zmdms-webui 1.9.3 → 1.9.4

package/dist/es/node_modules/readable-stream/lib/internal/streams/BufferList.js

@@ -0,0 +1,92 @@
+import { __module as BufferList } from '../../../../../_virtual/BufferList.js';
+import { __require as requireSafeBuffer } from '../../../node_modules/safe-buffer/index.js';
+import require$$0 from 'util';
+
+var hasRequiredBufferList;
+
+function requireBufferList () {
+	if (hasRequiredBufferList) return BufferList.exports;
+	hasRequiredBufferList = 1;
+	(function (module) {
+
+		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+		var Buffer = requireSafeBuffer().Buffer;
+		var util = require$$0;
+
+		function copyBuffer(src, target, offset) {
+		  src.copy(target, offset);
+		}
+
+		module.exports = function () {
+		  function BufferList() {
+		    _classCallCheck(this, BufferList);
+
+		    this.head = null;
+		    this.tail = null;
+		    this.length = 0;
+		  }
+
+		  BufferList.prototype.push = function push(v) {
+		    var entry = { data: v, next: null };
+		    if (this.length > 0) this.tail.next = entry;else this.head = entry;
+		    this.tail = entry;
+		    ++this.length;
+		  };
+
+		  BufferList.prototype.unshift = function unshift(v) {
+		    var entry = { data: v, next: this.head };
+		    if (this.length === 0) this.tail = entry;
+		    this.head = entry;
+		    ++this.length;
+		  };
+
+		  BufferList.prototype.shift = function shift() {
+		    if (this.length === 0) return;
+		    var ret = this.head.data;
+		    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
+		    --this.length;
+		    return ret;
+		  };
+
+		  BufferList.prototype.clear = function clear() {
+		    this.head = this.tail = null;
+		    this.length = 0;
+		  };
+
+		  BufferList.prototype.join = function join(s) {
+		    if (this.length === 0) return '';
+		    var p = this.head;
+		    var ret = '' + p.data;
+		    while (p = p.next) {
+		      ret += s + p.data;
+		    }return ret;
+		  };
+
+		  BufferList.prototype.concat = function concat(n) {
+		    if (this.length === 0) return Buffer.alloc(0);
+		    var ret = Buffer.allocUnsafe(n >>> 0);
+		    var p = this.head;
+		    var i = 0;
+		    while (p) {
+		      copyBuffer(p.data, ret, i);
+		      i += p.data.length;
+		      p = p.next;
+		    }
+		    return ret;
+		  };
+
+		  return BufferList;
+		}();
+
+		if (util && util.inspect && util.inspect.custom) {
+		  module.exports.prototype[util.inspect.custom] = function () {
+		    var obj = util.inspect({ length: this.length });
+		    return this.constructor.name + ' ' + obj;
+		  };
+		} 
+	} (BufferList));
+	return BufferList.exports;
+}
+
+export { requireBufferList as __require };

package/dist/es/node_modules/readable-stream/lib/internal/streams/destroy.js

@@ -0,0 +1,95 @@
+import { __require as requireProcessNextickArgs } from '../../../../process-nextick-args/index.js';
+
+var destroy_1;
+var hasRequiredDestroy;
+
+function requireDestroy () {
+	if (hasRequiredDestroy) return destroy_1;
+	hasRequiredDestroy = 1;
+
+	/*<replacement>*/
+
+	var pna = requireProcessNextickArgs();
+	/*</replacement>*/
+
+	// undocumented cb() API, needed for core, not for public API
+	function destroy(err, cb) {
+	  var _this = this;
+
+	  var readableDestroyed = this._readableState && this._readableState.destroyed;
+	  var writableDestroyed = this._writableState && this._writableState.destroyed;
+
+	  if (readableDestroyed || writableDestroyed) {
+	    if (cb) {
+	      cb(err);
+	    } else if (err) {
+	      if (!this._writableState) {
+	        pna.nextTick(emitErrorNT, this, err);
+	      } else if (!this._writableState.errorEmitted) {
+	        this._writableState.errorEmitted = true;
+	        pna.nextTick(emitErrorNT, this, err);
+	      }
+	    }
+
+	    return this;
+	  }
+
+	  // we set destroyed to true before firing error callbacks in order
+	  // to make it re-entrance safe in case destroy() is called within callbacks
+
+	  if (this._readableState) {
+	    this._readableState.destroyed = true;
+	  }
+
+	  // if this is a duplex stream mark the writable part as destroyed as well
+	  if (this._writableState) {
+	    this._writableState.destroyed = true;
+	  }
+
+	  this._destroy(err || null, function (err) {
+	    if (!cb && err) {
+	      if (!_this._writableState) {
+	        pna.nextTick(emitErrorNT, _this, err);
+	      } else if (!_this._writableState.errorEmitted) {
+	        _this._writableState.errorEmitted = true;
+	        pna.nextTick(emitErrorNT, _this, err);
+	      }
+	    } else if (cb) {
+	      cb(err);
+	    }
+	  });
+
+	  return this;
+	}
+
+	function undestroy() {
+	  if (this._readableState) {
+	    this._readableState.destroyed = false;
+	    this._readableState.reading = false;
+	    this._readableState.ended = false;
+	    this._readableState.endEmitted = false;
+	  }
+
+	  if (this._writableState) {
+	    this._writableState.destroyed = false;
+	    this._writableState.ended = false;
+	    this._writableState.ending = false;
+	    this._writableState.finalCalled = false;
+	    this._writableState.prefinished = false;
+	    this._writableState.finished = false;
+	    this._writableState.errorEmitted = false;
+	  }
+	}
+
+	function emitErrorNT(self, err) {
+	  self.emit('error', err);
+	}
+
+	destroy_1 = {
+	  destroy: destroy,
+	  undestroy: undestroy
+	};
+	return destroy_1;
+}
+
+export { requireDestroy as __require };

package/dist/es/node_modules/readable-stream/lib/internal/streams/stream.js

@@ -0,0 +1,13 @@
+import require$$0 from 'stream';
+
+var stream;
+var hasRequiredStream;
+
+function requireStream () {
+	if (hasRequiredStream) return stream;
+	hasRequiredStream = 1;
+	stream = require$$0;
+	return stream;
+}
+
+export { requireStream as __require };

package/dist/es/node_modules/readable-stream/node_modules/isarray/index.js

@@ -0,0 +1,15 @@
+var isarray;
+var hasRequiredIsarray;
+
+function requireIsarray () {
+	if (hasRequiredIsarray) return isarray;
+	hasRequiredIsarray = 1;
+	var toString = {}.toString;
+
+	isarray = Array.isArray || function (arr) {
+	  return toString.call(arr) == '[object Array]';
+	};
+	return isarray;
+}
+
+export { requireIsarray as __require };

package/dist/es/node_modules/readable-stream/node_modules/safe-buffer/index.js

@@ -0,0 +1,77 @@
+import { __module as safeBuffer } from '../../../../_virtual/index19.js';
+import require$$0 from 'buffer';
+
+/* eslint-disable node/no-deprecated-api */
+
+var hasRequiredSafeBuffer;
+
+function requireSafeBuffer () {
+	if (hasRequiredSafeBuffer) return safeBuffer.exports;
+	hasRequiredSafeBuffer = 1;
+	(function (module, exports) {
+		var buffer = require$$0;
+		var Buffer = buffer.Buffer;
+
+		// alternative to using Object.keys for old browsers
+		function copyProps (src, dst) {
+		  for (var key in src) {
+		    dst[key] = src[key];
+		  }
+		}
+		if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+		  module.exports = buffer;
+		} else {
+		  // Copy properties from require('buffer')
+		  copyProps(buffer, exports);
+		  exports.Buffer = SafeBuffer;
+		}
+
+		function SafeBuffer (arg, encodingOrOffset, length) {
+		  return Buffer(arg, encodingOrOffset, length)
+		}
+
+		// Copy static methods from Buffer
+		copyProps(Buffer, SafeBuffer);
+
+		SafeBuffer.from = function (arg, encodingOrOffset, length) {
+		  if (typeof arg === 'number') {
+		    throw new TypeError('Argument must not be a number')
+		  }
+		  return Buffer(arg, encodingOrOffset, length)
+		};
+
+		SafeBuffer.alloc = function (size, fill, encoding) {
+		  if (typeof size !== 'number') {
+		    throw new TypeError('Argument must be a number')
+		  }
+		  var buf = Buffer(size);
+		  if (fill !== undefined) {
+		    if (typeof encoding === 'string') {
+		      buf.fill(fill, encoding);
+		    } else {
+		      buf.fill(fill);
+		    }
+		  } else {
+		    buf.fill(0);
+		  }
+		  return buf
+		};
+
+		SafeBuffer.allocUnsafe = function (size) {
+		  if (typeof size !== 'number') {
+		    throw new TypeError('Argument must be a number')
+		  }
+		  return Buffer(size)
+		};
+
+		SafeBuffer.allocUnsafeSlow = function (size) {
+		  if (typeof size !== 'number') {
+		    throw new TypeError('Argument must be a number')
+		  }
+		  return buffer.SlowBuffer(size)
+		}; 
+	} (safeBuffer, safeBuffer.exports));
+	return safeBuffer.exports;
+}
+
+export { requireSafeBuffer as __require };

package/dist/es/node_modules/readable-stream/passthrough.js

@@ -0,0 +1,5 @@
+import { __require as requireReadable } from './readable.js';
+
+var passthrough = requireReadable().PassThrough;
+
+export { passthrough as p };

package/dist/es/node_modules/readable-stream/readable.js

@@ -0,0 +1,38 @@
+import { __module as readable } from '../../_virtual/readable3.js';
+import require$$0 from 'stream';
+import { __require as require_stream_readable } from './lib/_stream_readable.js';
+import { __require as require_stream_writable } from './lib/_stream_writable.js';
+import { __require as require_stream_duplex } from './lib/_stream_duplex.js';
+import { __require as require_stream_transform } from './lib/_stream_transform.js';
+import { __require as require_stream_passthrough } from './lib/_stream_passthrough.js';
+
+var hasRequiredReadable;
+
+function requireReadable () {
+	if (hasRequiredReadable) return readable.exports;
+	hasRequiredReadable = 1;
+	(function (module, exports) {
+		var Stream = require$$0;
+		if (process.env.READABLE_STREAM === 'disable' && Stream) {
+		  module.exports = Stream;
+		  exports = module.exports = Stream.Readable;
+		  exports.Readable = Stream.Readable;
+		  exports.Writable = Stream.Writable;
+		  exports.Duplex = Stream.Duplex;
+		  exports.Transform = Stream.Transform;
+		  exports.PassThrough = Stream.PassThrough;
+		  exports.Stream = Stream;
+		} else {
+		  exports = module.exports = require_stream_readable();
+		  exports.Stream = Stream || exports;
+		  exports.Readable = exports;
+		  exports.Writable = require_stream_writable();
+		  exports.Duplex = require_stream_duplex();
+		  exports.Transform = require_stream_transform();
+		  exports.PassThrough = require_stream_passthrough();
+		} 
+	} (readable, readable.exports));
+	return readable.exports;
+}
+
+export { requireReadable as __require };

package/dist/es/node_modules/readdir-glob/index.js

@@ -0,0 +1,250 @@
+import require$$0$1 from 'fs';
+import require$$0 from 'events';
+import { m as minimatch_1 } from './node_modules/minimatch/minimatch.js';
+import require$$1 from 'path';
+
+var readdirGlob_1 = readdirGlob;
+
+const fs = require$$0$1;
+const { EventEmitter } = require$$0;
+const { Minimatch } = minimatch_1;
+const { resolve } = require$$1;
+
+function readdir(dir, strict) {
+  return new Promise((resolve, reject) => {
+    fs.readdir(dir, {withFileTypes: true} ,(err, files) => {
+      if(err) {
+        switch (err.code) {
+          case 'ENOTDIR':      // Not a directory
+            if(strict) {
+              reject(err);
+            } else {
+              resolve([]);
+            }
+            break;
+          case 'ENOTSUP':      // Operation not supported
+          case 'ENOENT':       // No such file or directory
+          case 'ENAMETOOLONG': // Filename too long
+          case 'UNKNOWN':
+            resolve([]);
+            break;
+          case 'ELOOP':        // Too many levels of symbolic links
+          default:
+            reject(err);
+            break;
+        }
+      } else {
+        resolve(files);
+      }
+    });
+  });
+}
+function stat(file, followSymlinks) {
+  return new Promise((resolve, reject) => {
+    const statFunc = followSymlinks ? fs.stat : fs.lstat;
+    statFunc(file, (err, stats) => {
+      if(err) {
+        switch (err.code) {
+          case 'ENOENT':
+            if(followSymlinks) {
+              // Fallback to lstat to handle broken links as files
+              resolve(stat(file, false)); 
+            } else {
+              resolve(null);
+            }
+            break;
+          default:
+            resolve(null);
+            break;
+        }
+      } else {
+        resolve(stats);
+      }
+    });
+  });
+}
+
+async function* exploreWalkAsync(dir, path, followSymlinks, useStat, shouldSkip, strict) {
+  let files = await readdir(path + dir, strict);
+  for(const file of files) {
+    let name = file.name;
+    if(name === undefined) {
+      // undefined file.name means the `withFileTypes` options is not supported by node
+      // we have to call the stat function to know if file is directory or not.
+      name = file;
+      useStat = true;
+    }
+    const filename = dir + '/' + name;
+    const relative = filename.slice(1); // Remove the leading /
+    const absolute = path + '/' + relative;
+    let stats = null;
+    if(useStat || followSymlinks) {
+      stats = await stat(absolute, followSymlinks);
+    }
+    if(!stats && file.name !== undefined) {
+      stats = file;
+    }
+    if(stats === null) {
+      stats = { isDirectory: () => false };
+    }
+
+    if(stats.isDirectory()) {
+      if(!shouldSkip(relative)) {
+        yield {relative, absolute, stats};
+        yield* exploreWalkAsync(filename, path, followSymlinks, useStat, shouldSkip, false);
+      }
+    } else {
+      yield {relative, absolute, stats};
+    }
+  }
+}
+async function* explore(path, followSymlinks, useStat, shouldSkip) {
+  yield* exploreWalkAsync('', path, followSymlinks, useStat, shouldSkip, true);
+}
+
+
+function readOptions(options) {
+  return {
+    pattern: options.pattern,
+    dot: !!options.dot,
+    noglobstar: !!options.noglobstar,
+    matchBase: !!options.matchBase,
+    nocase: !!options.nocase,
+    ignore: options.ignore,
+    skip: options.skip,
+
+    follow: !!options.follow,
+    stat: !!options.stat,
+    nodir: !!options.nodir,
+    mark: !!options.mark,
+    silent: !!options.silent,
+    absolute: !!options.absolute
+  };
+}
+
+class ReaddirGlob extends EventEmitter {
+  constructor(cwd, options, cb) {
+    super();
+    if(typeof options === 'function') {
+      cb = options;
+      options = null;
+    }
+
+    this.options = readOptions(options || {});
+  
+    this.matchers = [];
+    if(this.options.pattern) {
+      const matchers = Array.isArray(this.options.pattern) ? this.options.pattern : [this.options.pattern];
+      this.matchers = matchers.map( m =>
+        new Minimatch(m, {
+          dot: this.options.dot,
+          noglobstar:this.options.noglobstar,
+          matchBase:this.options.matchBase,
+          nocase:this.options.nocase
+        })
+      );
+    }
+  
+    this.ignoreMatchers = [];
+    if(this.options.ignore) {
+      const ignorePatterns = Array.isArray(this.options.ignore) ? this.options.ignore : [this.options.ignore];
+      this.ignoreMatchers = ignorePatterns.map( ignore =>
+        new Minimatch(ignore, {dot: true})
+      );
+    }
+  
+    this.skipMatchers = [];
+    if(this.options.skip) {
+      const skipPatterns = Array.isArray(this.options.skip) ? this.options.skip : [this.options.skip];
+      this.skipMatchers = skipPatterns.map( skip =>
+        new Minimatch(skip, {dot: true})
+      );
+    }
+
+    this.iterator = explore(resolve(cwd || '.'), this.options.follow, this.options.stat, this._shouldSkipDirectory.bind(this));
+    this.paused = false;
+    this.inactive = false;
+    this.aborted = false;
+  
+    if(cb) {
+      this._matches = []; 
+      this.on('match', match => this._matches.push(this.options.absolute ? match.absolute : match.relative));
+      this.on('error', err => cb(err));
+      this.on('end', () => cb(null, this._matches));
+    }
+
+    setTimeout( () => this._next(), 0);
+  }
+
+  _shouldSkipDirectory(relative) {
+    //console.log(relative, this.skipMatchers.some(m => m.match(relative)));
+    return this.skipMatchers.some(m => m.match(relative));
+  }
+
+  _fileMatches(relative, isDirectory) {
+    const file = relative + (isDirectory ? '/' : '');
+    return (this.matchers.length === 0 || this.matchers.some(m => m.match(file)))
+      && !this.ignoreMatchers.some(m => m.match(file))
+      && (!this.options.nodir || !isDirectory);
+  }
+
+  _next() {
+    if(!this.paused && !this.aborted) {
+      this.iterator.next()
+      .then((obj)=> {
+        if(!obj.done) {
+          const isDirectory = obj.value.stats.isDirectory();
+          if(this._fileMatches(obj.value.relative, isDirectory )) {
+            let relative = obj.value.relative;
+            let absolute = obj.value.absolute;
+            if(this.options.mark && isDirectory) {
+              relative += '/';
+              absolute += '/';
+            }
+            if(this.options.stat) {
+              this.emit('match', {relative, absolute, stat:obj.value.stats});
+            } else {
+              this.emit('match', {relative, absolute});
+            }
+          }
+          this._next(this.iterator);
+        } else {
+          this.emit('end');
+        }
+      })
+      .catch((err) => {
+        this.abort();
+        this.emit('error', err);
+        if(!err.code && !this.options.silent) {
+          console.error(err);
+        }
+      });
+    } else {
+      this.inactive = true;
+    }
+  }
+
+  abort() {
+    this.aborted = true;
+  }
+
+  pause() {
+    this.paused = true;
+  }
+
+  resume() {
+    this.paused = false;
+    if(this.inactive) {
+      this.inactive = false;
+      this._next();
+    }
+  }
+}
+
+
+function readdirGlob(pattern, options, cb) {
+  return new ReaddirGlob(pattern, options, cb);
+}
+readdirGlob.ReaddirGlob = ReaddirGlob;
+
+export { readdirGlob_1 as r };

package/dist/es/node_modules/readdir-glob/node_modules/minimatch/lib/path.js

@@ -0,0 +1,6 @@
+const isWindows = typeof process === 'object' &&
+  process &&
+  process.platform === 'win32';
+var path = isWindows ? { sep: '\\' } : { sep: '/' };
+
+export { path as p };