zmdms-webui 1.9.3 → 1.9.5

package/dist/es/node_modules/traverse/index.js

@@ -0,0 +1,322 @@
+var traverse = Traverse;
+function Traverse (obj) {
+    if (!(this instanceof Traverse)) return new Traverse(obj);
+    this.value = obj;
+}
+
+Traverse.prototype.get = function (ps) {
+    var node = this.value;
+    for (var i = 0; i < ps.length; i ++) {
+        var key = ps[i];
+        if (!Object.hasOwnProperty.call(node, key)) {
+            node = undefined;
+            break;
+        }
+        node = node[key];
+    }
+    return node;
+};
+
+Traverse.prototype.set = function (ps, value) {
+    var node = this.value;
+    for (var i = 0; i < ps.length - 1; i ++) {
+        var key = ps[i];
+        if (!Object.hasOwnProperty.call(node, key)) node[key] = {};
+        node = node[key];
+    }
+    node[ps[i]] = value;
+    return value;
+};
+
+Traverse.prototype.map = function (cb) {
+    return walk(this.value, cb, true);
+};
+
+Traverse.prototype.forEach = function (cb) {
+    this.value = walk(this.value, cb, false);
+    return this.value;
+};
+
+Traverse.prototype.reduce = function (cb, init) {
+    var skip = arguments.length === 1;
+    var acc = skip ? this.value : init;
+    this.forEach(function (x) {
+        if (!this.isRoot || !skip) {
+            acc = cb.call(this, acc, x);
+        }
+    });
+    return acc;
+};
+
+Traverse.prototype.deepEqual = function (obj) {
+    if (arguments.length !== 1) {
+        throw new Error(
+            'deepEqual requires exactly one object to compare against'
+        );
+    }
+    
+    var equal = true;
+    var node = obj;
+    
+    this.forEach(function (y) {
+        var notEqual = (function () {
+            equal = false;
+            //this.stop();
+            return undefined;
+        }).bind(this);
+        
+        //if (node === undefined || node === null) return notEqual();
+        
+        if (!this.isRoot) {
+        /*
+            if (!Object.hasOwnProperty.call(node, this.key)) {
+                return notEqual();
+            }
+        */
+            if (typeof node !== 'object') return notEqual();
+            node = node[this.key];
+        }
+        
+        var x = node;
+        
+        this.post(function () {
+            node = x;
+        });
+        
+        var toS = function (o) {
+            return Object.prototype.toString.call(o);
+        };
+        
+        if (this.circular) {
+            if (Traverse(obj).get(this.circular.path) !== x) notEqual();
+        }
+        else if (typeof x !== typeof y) {
+            notEqual();
+        }
+        else if (x === null || y === null || x === undefined || y === undefined) {
+            if (x !== y) notEqual();
+        }
+        else if (x.__proto__ !== y.__proto__) {
+            notEqual();
+        }
+        else if (x === y) ;
+        else if (typeof x === 'function') {
+            if (x instanceof RegExp) {
+                // both regexps on account of the __proto__ check
+                if (x.toString() != y.toString()) notEqual();
+            }
+            else if (x !== y) notEqual();
+        }
+        else if (typeof x === 'object') {
+            if (toS(y) === '[object Arguments]'
+            || toS(x) === '[object Arguments]') {
+                if (toS(x) !== toS(y)) {
+                    notEqual();
+                }
+            }
+            else if (x instanceof Date || y instanceof Date) {
+                if (!(x instanceof Date) || !(y instanceof Date)
+                || x.getTime() !== y.getTime()) {
+                    notEqual();
+                }
+            }
+            else {
+                var kx = Object.keys(x);
+                var ky = Object.keys(y);
+                if (kx.length !== ky.length) return notEqual();
+                for (var i = 0; i < kx.length; i++) {
+                    var k = kx[i];
+                    if (!Object.hasOwnProperty.call(y, k)) {
+                        notEqual();
+                    }
+                }
+            }
+        }
+    });
+    
+    return equal;
+};
+
+Traverse.prototype.paths = function () {
+    var acc = [];
+    this.forEach(function (x) {
+        acc.push(this.path); 
+    });
+    return acc;
+};
+
+Traverse.prototype.nodes = function () {
+    var acc = [];
+    this.forEach(function (x) {
+        acc.push(this.node);
+    });
+    return acc;
+};
+
+Traverse.prototype.clone = function () {
+    var parents = [], nodes = [];
+    
+    return (function clone (src) {
+        for (var i = 0; i < parents.length; i++) {
+            if (parents[i] === src) {
+                return nodes[i];
+            }
+        }
+        
+        if (typeof src === 'object' && src !== null) {
+            var dst = copy(src);
+            
+            parents.push(src);
+            nodes.push(dst);
+            
+            Object.keys(src).forEach(function (key) {
+                dst[key] = clone(src[key]);
+            });
+            
+            parents.pop();
+            nodes.pop();
+            return dst;
+        }
+        else {
+            return src;
+        }
+    })(this.value);
+};
+
+function walk (root, cb, immutable) {
+    var path = [];
+    var parents = [];
+    var alive = true;
+    
+    return (function walker (node_) {
+        var node = immutable ? copy(node_) : node_;
+        var modifiers = {};
+        
+        var state = {
+            node : node,
+            node_ : node_,
+            path : [].concat(path),
+            parent : parents.slice(-1)[0],
+            key : path.slice(-1)[0],
+            isRoot : path.length === 0,
+            level : path.length,
+            circular : null,
+            update : function (x) {
+                if (!state.isRoot) {
+                    state.parent.node[state.key] = x;
+                }
+                state.node = x;
+            },
+            'delete' : function () {
+                delete state.parent.node[state.key];
+            },
+            remove : function () {
+                if (Array.isArray(state.parent.node)) {
+                    state.parent.node.splice(state.key, 1);
+                }
+                else {
+                    delete state.parent.node[state.key];
+                }
+            },
+            before : function (f) { modifiers.before = f; },
+            after : function (f) { modifiers.after = f; },
+            pre : function (f) { modifiers.pre = f; },
+            post : function (f) { modifiers.post = f; },
+            stop : function () { alive = false; }
+        };
+        
+        if (!alive) return state;
+        
+        if (typeof node === 'object' && node !== null) {
+            state.isLeaf = Object.keys(node).length == 0;
+            
+            for (var i = 0; i < parents.length; i++) {
+                if (parents[i].node_ === node_) {
+                    state.circular = parents[i];
+                    break;
+                }
+            }
+        }
+        else {
+            state.isLeaf = true;
+        }
+        
+        state.notLeaf = !state.isLeaf;
+        state.notRoot = !state.isRoot;
+        
+        // use return values to update if defined
+        var ret = cb.call(state, state.node);
+        if (ret !== undefined && state.update) state.update(ret);
+        if (modifiers.before) modifiers.before.call(state, state.node);
+        
+        if (typeof state.node == 'object'
+        && state.node !== null && !state.circular) {
+            parents.push(state);
+            
+            var keys = Object.keys(state.node);
+            keys.forEach(function (key, i) {
+                path.push(key);
+                
+                if (modifiers.pre) modifiers.pre.call(state, state.node[key], key);
+                
+                var child = walker(state.node[key]);
+                if (immutable && Object.hasOwnProperty.call(state.node, key)) {
+                    state.node[key] = child.node;
+                }
+                
+                child.isLast = i == keys.length - 1;
+                child.isFirst = i == 0;
+                
+                if (modifiers.post) modifiers.post.call(state, child);
+                
+                path.pop();
+            });
+            parents.pop();
+        }
+        
+        if (modifiers.after) modifiers.after.call(state, state.node);
+        
+        return state;
+    })(root).node;
+}
+
+Object.keys(Traverse.prototype).forEach(function (key) {
+    Traverse[key] = function (obj) {
+        var args = [].slice.call(arguments, 1);
+        var t = Traverse(obj);
+        return t[key].apply(t, args);
+    };
+});
+
+function copy (src) {
+    if (typeof src === 'object' && src !== null) {
+        var dst;
+        
+        if (Array.isArray(src)) {
+            dst = [];
+        }
+        else if (src instanceof Date) {
+            dst = new Date(src);
+        }
+        else if (src instanceof Boolean) {
+            dst = new Boolean(src);
+        }
+        else if (src instanceof Number) {
+            dst = new Number(src);
+        }
+        else if (src instanceof String) {
+            dst = new String(src);
+        }
+        else {
+            dst = Object.create(Object.getPrototypeOf(src));
+        }
+        
+        Object.keys(src).forEach(function (key) {
+            dst[key] = src[key];
+        });
+        return dst;
+    }
+    else return src;
+}
+
+export { traverse as t };

package/dist/es/node_modules/unzipper/lib/Buffer.js

@@ -0,0 +1,16 @@
+import require$$0 from 'buffer';
+
+var Buffer = require$$0.Buffer;
+
+// Backwards compatibility for node versions < 8
+if (Buffer.from === undefined) {
+  Buffer.from = function (a, b, c) {
+    return new Buffer(a, b, c)
+  };
+
+  Buffer.alloc = Buffer.from;
+}
+
+var Buffer_1 = Buffer;
+
+export { Buffer_1 as B };

package/dist/es/node_modules/unzipper/lib/BufferStream.js

@@ -0,0 +1,32 @@
+import { b as bluebird_1 } from '../node_modules/bluebird/js/release/bluebird.js';
+import require$$0 from 'stream';
+import { B as Buffer_1 } from './Buffer.js';
+import { __require as requireReadable } from '../../readable-stream/readable.js';
+
+var Promise$1 = bluebird_1;
+var Stream = require$$0;
+var Buffer = Buffer_1;
+
+// Backwards compatibility for node versions < 8
+if (!Stream.Writable || !Stream.Writable.prototype.destroy)
+  Stream = requireReadable();
+
+var BufferStream = function(entry) {
+  return new Promise$1(function(resolve,reject) {
+    var chunks = [];
+    var bufferStream = Stream.Transform()
+      .on('finish',function() {
+        resolve(Buffer.concat(chunks));
+      })
+      .on('error',reject);
+        
+    bufferStream._transform = function(d,e,cb) {
+      chunks.push(d);
+      cb();
+    };
+    entry.on('error',reject)
+      .pipe(bufferStream);
+  });
+};
+
+export { BufferStream as B };

package/dist/es/node_modules/unzipper/lib/Decrypt.js

@@ -0,0 +1,78 @@
+import { B as BigIntegerExports } from '../../big-integer/BigInteger.js';
+import require$$0 from 'stream';
+import { __require as requireReadable } from '../../readable-stream/readable.js';
+
+var bigInt = BigIntegerExports;
+var Stream = require$$0;
+
+// Backwards compatibility for node versions < 8
+if (!Stream.Writable || !Stream.Writable.prototype.destroy)
+  Stream = requireReadable();
+
+var table;
+
+function generateTable() {
+  var poly = 0xEDB88320,c,n,k;
+  table = [];
+  for (n = 0; n < 256; n++) {
+    c = n;
+    for (k = 0; k < 8; k++)
+      c = (c & 1) ? poly ^ (c >>> 1) :  c = c >>> 1;
+    table[n] = c >>> 0;
+  }
+}
+
+function crc(ch,crc) {
+  if (!table)
+    generateTable();
+
+  if (ch.charCodeAt)
+    ch = ch.charCodeAt(0);        
+
+  return (bigInt(crc).shiftRight(8).and(0xffffff)).xor(table[bigInt(crc).xor(ch).and(0xff)]).value;
+}
+
+function Decrypt() {
+  if (!(this instanceof Decrypt))
+    return new Decrypt();
+
+  this.key0 = 305419896;
+  this.key1 = 591751049;
+  this.key2 = 878082192;
+}
+
+Decrypt.prototype.update = function(h) {            
+  this.key0 = crc(h,this.key0);
+  this.key1 = bigInt(this.key0).and(255).and(4294967295).add(this.key1);
+  this.key1 = bigInt(this.key1).multiply(134775813).add(1).and(4294967295).value;
+  this.key2 = crc(bigInt(this.key1).shiftRight(24).and(255), this.key2);
+};
+
+
+Decrypt.prototype.decryptByte = function(c) {
+  var k = bigInt(this.key2).or(2);
+  c = c ^ bigInt(k).multiply(bigInt(k^1)).shiftRight(8).and(255);
+  this.update(c);
+  return c;
+};
+
+ Decrypt.prototype.stream = function() {
+  var stream = Stream.Transform(),
+      self = this;
+
+  stream._transform = function(d,e,cb) {
+    for (var i = 0; i<d.length;i++) {
+      d[i] = self.decryptByte(d[i]);
+    }
+    this.push(d);
+    cb();
+  };
+  return stream;
+};
+
+
+
+
+var Decrypt_1 = Decrypt;
+
+export { Decrypt_1 as D };

package/dist/es/node_modules/unzipper/lib/NoopStream.js

@@ -0,0 +1,25 @@
+import require$$0 from 'stream';
+import require$$0$1 from 'util';
+import { __require as requireReadable } from '../../readable-stream/readable.js';
+
+var Stream = require$$0;
+var util = require$$0$1;
+
+// Backwards compatibility for node versions < 8
+if (!Stream.Writable || !Stream.Writable.prototype.destroy)
+  Stream = requireReadable();
+
+function NoopStream() {
+  if (!(this instanceof NoopStream)) {
+    return new NoopStream();
+  }
+  Stream.Transform.call(this);
+}
+
+util.inherits(NoopStream,Stream.Transform);
+
+NoopStream.prototype._transform = function(d,e,cb) { cb() ;};
+  
+var NoopStream_1 = NoopStream;
+
+export { NoopStream_1 as N };