zmdms-webui 1.9.3 → 1.9.5

package/dist/es/node_modules/tar-stream/extract.js

@@ -0,0 +1,265 @@
+import require$$0 from 'util';
+import { b as blExports } from '../bl/bl.js';
+import './headers.js';
+import { r as readableExports } from './node_modules/readable-stream/readable.js';
+import { __exports as headers$1 } from '../../_virtual/headers.js';
+
+var util = require$$0;
+var bl = blExports;
+var headers = headers$1;
+
+var Writable = readableExports.Writable;
+var PassThrough = readableExports.PassThrough;
+
+var noop = function () {};
+
+var overflow = function (size) {
+  size &= 511;
+  return size && 512 - size
+};
+
+var emptyStream = function (self, offset) {
+  var s = new Source(self, offset);
+  s.end();
+  return s
+};
+
+var mixinPax = function (header, pax) {
+  if (pax.path) header.name = pax.path;
+  if (pax.linkpath) header.linkname = pax.linkpath;
+  if (pax.size) header.size = parseInt(pax.size, 10);
+  header.pax = pax;
+  return header
+};
+
+var Source = function (self, offset) {
+  this._parent = self;
+  this.offset = offset;
+  PassThrough.call(this, { autoDestroy: false });
+};
+
+util.inherits(Source, PassThrough);
+
+Source.prototype.destroy = function (err) {
+  this._parent.destroy(err);
+};
+
+var Extract = function (opts) {
+  if (!(this instanceof Extract)) return new Extract(opts)
+  Writable.call(this, opts);
+
+  opts = opts || {};
+
+  this._offset = 0;
+  this._buffer = bl();
+  this._missing = 0;
+  this._partial = false;
+  this._onparse = noop;
+  this._header = null;
+  this._stream = null;
+  this._overflow = null;
+  this._cb = null;
+  this._locked = false;
+  this._destroyed = false;
+  this._pax = null;
+  this._paxGlobal = null;
+  this._gnuLongPath = null;
+  this._gnuLongLinkPath = null;
+
+  var self = this;
+  var b = self._buffer;
+
+  var oncontinue = function () {
+    self._continue();
+  };
+
+  var onunlock = function (err) {
+    self._locked = false;
+    if (err) return self.destroy(err)
+    if (!self._stream) oncontinue();
+  };
+
+  var onstreamend = function () {
+    self._stream = null;
+    var drain = overflow(self._header.size);
+    if (drain) self._parse(drain, ondrain);
+    else self._parse(512, onheader);
+    if (!self._locked) oncontinue();
+  };
+
+  var ondrain = function () {
+    self._buffer.consume(overflow(self._header.size));
+    self._parse(512, onheader);
+    oncontinue();
+  };
+
+  var onpaxglobalheader = function () {
+    var size = self._header.size;
+    self._paxGlobal = headers.decodePax(b.slice(0, size));
+    b.consume(size);
+    onstreamend();
+  };
+
+  var onpaxheader = function () {
+    var size = self._header.size;
+    self._pax = headers.decodePax(b.slice(0, size));
+    if (self._paxGlobal) self._pax = Object.assign({}, self._paxGlobal, self._pax);
+    b.consume(size);
+    onstreamend();
+  };
+
+  var ongnulongpath = function () {
+    var size = self._header.size;
+    this._gnuLongPath = headers.decodeLongPath(b.slice(0, size), opts.filenameEncoding);
+    b.consume(size);
+    onstreamend();
+  };
+
+  var ongnulonglinkpath = function () {
+    var size = self._header.size;
+    this._gnuLongLinkPath = headers.decodeLongPath(b.slice(0, size), opts.filenameEncoding);
+    b.consume(size);
+    onstreamend();
+  };
+
+  var onheader = function () {
+    var offset = self._offset;
+    var header;
+    try {
+      header = self._header = headers.decode(b.slice(0, 512), opts.filenameEncoding, opts.allowUnknownFormat);
+    } catch (err) {
+      self.emit('error', err);
+    }
+    b.consume(512);
+
+    if (!header) {
+      self._parse(512, onheader);
+      oncontinue();
+      return
+    }
+    if (header.type === 'gnu-long-path') {
+      self._parse(header.size, ongnulongpath);
+      oncontinue();
+      return
+    }
+    if (header.type === 'gnu-long-link-path') {
+      self._parse(header.size, ongnulonglinkpath);
+      oncontinue();
+      return
+    }
+    if (header.type === 'pax-global-header') {
+      self._parse(header.size, onpaxglobalheader);
+      oncontinue();
+      return
+    }
+    if (header.type === 'pax-header') {
+      self._parse(header.size, onpaxheader);
+      oncontinue();
+      return
+    }
+
+    if (self._gnuLongPath) {
+      header.name = self._gnuLongPath;
+      self._gnuLongPath = null;
+    }
+
+    if (self._gnuLongLinkPath) {
+      header.linkname = self._gnuLongLinkPath;
+      self._gnuLongLinkPath = null;
+    }
+
+    if (self._pax) {
+      self._header = header = mixinPax(header, self._pax);
+      self._pax = null;
+    }
+
+    self._locked = true;
+
+    if (!header.size || header.type === 'directory') {
+      self._parse(512, onheader);
+      self.emit('entry', header, emptyStream(self, offset), onunlock);
+      return
+    }
+
+    self._stream = new Source(self, offset);
+
+    self.emit('entry', header, self._stream, onunlock);
+    self._parse(header.size, onstreamend);
+    oncontinue();
+  };
+
+  this._onheader = onheader;
+  this._parse(512, onheader);
+};
+
+util.inherits(Extract, Writable);
+
+Extract.prototype.destroy = function (err) {
+  if (this._destroyed) return
+  this._destroyed = true;
+
+  if (err) this.emit('error', err);
+  this.emit('close');
+  if (this._stream) this._stream.emit('close');
+};
+
+Extract.prototype._parse = function (size, onparse) {
+  if (this._destroyed) return
+  this._offset += size;
+  this._missing = size;
+  if (onparse === this._onheader) this._partial = false;
+  this._onparse = onparse;
+};
+
+Extract.prototype._continue = function () {
+  if (this._destroyed) return
+  var cb = this._cb;
+  this._cb = noop;
+  if (this._overflow) this._write(this._overflow, undefined, cb);
+  else cb();
+};
+
+Extract.prototype._write = function (data, enc, cb) {
+  if (this._destroyed) return
+
+  var s = this._stream;
+  var b = this._buffer;
+  var missing = this._missing;
+  if (data.length) this._partial = true;
+
+  // we do not reach end-of-chunk now. just forward it
+
+  if (data.length < missing) {
+    this._missing -= data.length;
+    this._overflow = null;
+    if (s) return s.write(data, cb)
+    b.append(data);
+    return cb()
+  }
+
+  // end-of-chunk. the parser should call cb.
+
+  this._cb = cb;
+  this._missing = 0;
+
+  var overflow = null;
+  if (data.length > missing) {
+    overflow = data.slice(missing);
+    data = data.slice(0, missing);
+  }
+
+  if (s) s.end(data);
+  else b.append(data);
+
+  this._overflow = overflow;
+  this._onparse();
+};
+
+Extract.prototype._final = function (cb) {
+  if (this._partial) return this.destroy(new Error('Unexpected end of data'))
+  cb();
+};
+
+var extract = Extract;
+
+export { extract as e };

package/dist/es/node_modules/tar-stream/headers.js

@@ -0,0 +1,296 @@
+import { __exports as headers } from '../../_virtual/headers.js';
+
+var alloc = Buffer.alloc;
+
+var ZEROS = '0000000000000000000';
+var SEVENS = '7777777777777777777';
+var ZERO_OFFSET = '0'.charCodeAt(0);
+var USTAR_MAGIC = Buffer.from('ustar\x00', 'binary');
+var USTAR_VER = Buffer.from('00', 'binary');
+var GNU_MAGIC = Buffer.from('ustar\x20', 'binary');
+var GNU_VER = Buffer.from('\x20\x00', 'binary');
+var MASK = parseInt('7777', 8);
+var MAGIC_OFFSET = 257;
+var VERSION_OFFSET = 263;
+
+var clamp = function (index, len, defaultValue) {
+  if (typeof index !== 'number') return defaultValue
+  index = ~~index; // Coerce to integer.
+  if (index >= len) return len
+  if (index >= 0) return index
+  index += len;
+  if (index >= 0) return index
+  return 0
+};
+
+var toType = function (flag) {
+  switch (flag) {
+    case 0:
+      return 'file'
+    case 1:
+      return 'link'
+    case 2:
+      return 'symlink'
+    case 3:
+      return 'character-device'
+    case 4:
+      return 'block-device'
+    case 5:
+      return 'directory'
+    case 6:
+      return 'fifo'
+    case 7:
+      return 'contiguous-file'
+    case 72:
+      return 'pax-header'
+    case 55:
+      return 'pax-global-header'
+    case 27:
+      return 'gnu-long-link-path'
+    case 28:
+    case 30:
+      return 'gnu-long-path'
+  }
+
+  return null
+};
+
+var toTypeflag = function (flag) {
+  switch (flag) {
+    case 'file':
+      return 0
+    case 'link':
+      return 1
+    case 'symlink':
+      return 2
+    case 'character-device':
+      return 3
+    case 'block-device':
+      return 4
+    case 'directory':
+      return 5
+    case 'fifo':
+      return 6
+    case 'contiguous-file':
+      return 7
+    case 'pax-header':
+      return 72
+  }
+
+  return 0
+};
+
+var indexOf = function (block, num, offset, end) {
+  for (; offset < end; offset++) {
+    if (block[offset] === num) return offset
+  }
+  return end
+};
+
+var cksum = function (block) {
+  var sum = 8 * 32;
+  for (var i = 0; i < 148; i++) sum += block[i];
+  for (var j = 156; j < 512; j++) sum += block[j];
+  return sum
+};
+
+var encodeOct = function (val, n) {
+  val = val.toString(8);
+  if (val.length > n) return SEVENS.slice(0, n) + ' '
+  else return ZEROS.slice(0, n - val.length) + val + ' '
+};
+
+/* Copied from the node-tar repo and modified to meet
+ * tar-stream coding standard.
+ *
+ * Source: https://github.com/npm/node-tar/blob/51b6627a1f357d2eb433e7378e5f05e83b7aa6cd/lib/header.js#L349
+ */
+function parse256 (buf) {
+  // first byte MUST be either 80 or FF
+  // 80 for positive, FF for 2's comp
+  var positive;
+  if (buf[0] === 0x80) positive = true;
+  else if (buf[0] === 0xFF) positive = false;
+  else return null
+
+  // build up a base-256 tuple from the least sig to the highest
+  var tuple = [];
+  for (var i = buf.length - 1; i > 0; i--) {
+    var byte = buf[i];
+    if (positive) tuple.push(byte);
+    else tuple.push(0xFF - byte);
+  }
+
+  var sum = 0;
+  var l = tuple.length;
+  for (i = 0; i < l; i++) {
+    sum += tuple[i] * Math.pow(256, i);
+  }
+
+  return positive ? sum : -1 * sum
+}
+
+var decodeOct = function (val, offset, length) {
+  val = val.slice(offset, offset + length);
+  offset = 0;
+
+  // If prefixed with 0x80 then parse as a base-256 integer
+  if (val[offset] & 0x80) {
+    return parse256(val)
+  } else {
+    // Older versions of tar can prefix with spaces
+    while (offset < val.length && val[offset] === 32) offset++;
+    var end = clamp(indexOf(val, 32, offset, val.length), val.length, val.length);
+    while (offset < end && val[offset] === 0) offset++;
+    if (end === offset) return 0
+    return parseInt(val.slice(offset, end).toString(), 8)
+  }
+};
+
+var decodeStr = function (val, offset, length, encoding) {
+  return val.slice(offset, indexOf(val, 0, offset, offset + length)).toString(encoding)
+};
+
+var addLength = function (str) {
+  var len = Buffer.byteLength(str);
+  var digits = Math.floor(Math.log(len) / Math.log(10)) + 1;
+  if (len + digits >= Math.pow(10, digits)) digits++;
+
+  return (len + digits) + str
+};
+
+headers.decodeLongPath = function (buf, encoding) {
+  return decodeStr(buf, 0, buf.length, encoding)
+};
+
+headers.encodePax = function (opts) { // TODO: encode more stuff in pax
+  var result = '';
+  if (opts.name) result += addLength(' path=' + opts.name + '\n');
+  if (opts.linkname) result += addLength(' linkpath=' + opts.linkname + '\n');
+  var pax = opts.pax;
+  if (pax) {
+    for (var key in pax) {
+      result += addLength(' ' + key + '=' + pax[key] + '\n');
+    }
+  }
+  return Buffer.from(result)
+};
+
+headers.decodePax = function (buf) {
+  var result = {};
+
+  while (buf.length) {
+    var i = 0;
+    while (i < buf.length && buf[i] !== 32) i++;
+    var len = parseInt(buf.slice(0, i).toString(), 10);
+    if (!len) return result
+
+    var b = buf.slice(i + 1, len - 1).toString();
+    var keyIndex = b.indexOf('=');
+    if (keyIndex === -1) return result
+    result[b.slice(0, keyIndex)] = b.slice(keyIndex + 1);
+
+    buf = buf.slice(len);
+  }
+
+  return result
+};
+
+headers.encode = function (opts) {
+  var buf = alloc(512);
+  var name = opts.name;
+  var prefix = '';
+
+  if (opts.typeflag === 5 && name[name.length - 1] !== '/') name += '/';
+  if (Buffer.byteLength(name) !== name.length) return null // utf-8
+
+  while (Buffer.byteLength(name) > 100) {
+    var i = name.indexOf('/');
+    if (i === -1) return null
+    prefix += prefix ? '/' + name.slice(0, i) : name.slice(0, i);
+    name = name.slice(i + 1);
+  }
+
+  if (Buffer.byteLength(name) > 100 || Buffer.byteLength(prefix) > 155) return null
+  if (opts.linkname && Buffer.byteLength(opts.linkname) > 100) return null
+
+  buf.write(name);
+  buf.write(encodeOct(opts.mode & MASK, 6), 100);
+  buf.write(encodeOct(opts.uid, 6), 108);
+  buf.write(encodeOct(opts.gid, 6), 116);
+  buf.write(encodeOct(opts.size, 11), 124);
+  buf.write(encodeOct((opts.mtime.getTime() / 1000) | 0, 11), 136);
+
+  buf[156] = ZERO_OFFSET + toTypeflag(opts.type);
+
+  if (opts.linkname) buf.write(opts.linkname, 157);
+
+  USTAR_MAGIC.copy(buf, MAGIC_OFFSET);
+  USTAR_VER.copy(buf, VERSION_OFFSET);
+  if (opts.uname) buf.write(opts.uname, 265);
+  if (opts.gname) buf.write(opts.gname, 297);
+  buf.write(encodeOct(opts.devmajor || 0, 6), 329);
+  buf.write(encodeOct(opts.devminor || 0, 6), 337);
+
+  if (prefix) buf.write(prefix, 345);
+
+  buf.write(encodeOct(cksum(buf), 6), 148);
+
+  return buf
+};
+
+headers.decode = function (buf, filenameEncoding, allowUnknownFormat) {
+  var typeflag = buf[156] === 0 ? 0 : buf[156] - ZERO_OFFSET;
+
+  var name = decodeStr(buf, 0, 100, filenameEncoding);
+  var mode = decodeOct(buf, 100, 8);
+  var uid = decodeOct(buf, 108, 8);
+  var gid = decodeOct(buf, 116, 8);
+  var size = decodeOct(buf, 124, 12);
+  var mtime = decodeOct(buf, 136, 12);
+  var type = toType(typeflag);
+  var linkname = buf[157] === 0 ? null : decodeStr(buf, 157, 100, filenameEncoding);
+  var uname = decodeStr(buf, 265, 32);
+  var gname = decodeStr(buf, 297, 32);
+  var devmajor = decodeOct(buf, 329, 8);
+  var devminor = decodeOct(buf, 337, 8);
+
+  var c = cksum(buf);
+
+  // checksum is still initial value if header was null.
+  if (c === 8 * 32) return null
+
+  // valid checksum
+  if (c !== decodeOct(buf, 148, 8)) throw new Error('Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?')
+
+  if (USTAR_MAGIC.compare(buf, MAGIC_OFFSET, MAGIC_OFFSET + 6) === 0) {
+    // ustar (posix) format.
+    // prepend prefix, if present.
+    if (buf[345]) name = decodeStr(buf, 345, 155, filenameEncoding) + '/' + name;
+  } else if (GNU_MAGIC.compare(buf, MAGIC_OFFSET, MAGIC_OFFSET + 6) === 0 &&
+             GNU_VER.compare(buf, VERSION_OFFSET, VERSION_OFFSET + 2) === 0) ; else {
+    if (!allowUnknownFormat) {
+      throw new Error('Invalid tar header: unknown format.')
+    }
+  }
+
+  // to support old tar versions that use trailing / to indicate dirs
+  if (typeflag === 0 && name && name[name.length - 1] === '/') typeflag = 5;
+
+  return {
+    name,
+    mode,
+    uid,
+    gid,
+    size,
+    mtime: new Date(1000 * mtime),
+    type,
+    linkname,
+    uname,
+    gname,
+    devmajor,
+    devminor
+  }
+};
+
+export { headers as default };

package/dist/es/node_modules/tar-stream/index.js

@@ -0,0 +1,8 @@
+import { __exports as tarStream } from '../../_virtual/index7.js';
+import { e as extract } from './extract.js';
+import { p as pack } from './pack.js';
+
+tarStream.extract = extract;
+tarStream.pack = pack;
+
+export { tarStream as default };

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

@@ -0,0 +1,126 @@
+import { __exports as errors } from '../../../../_virtual/errors3.js';
+
+var hasRequiredErrors;
+
+function requireErrors () {
+	if (hasRequiredErrors) return errors;
+	hasRequiredErrors = 1;
+
+	const codes = {};
+
+	function createErrorType(code, message, Base) {
+	  if (!Base) {
+	    Base = Error;
+	  }
+
+	  function getMessage (arg1, arg2, arg3) {
+	    if (typeof message === 'string') {
+	      return message
+	    } else {
+	      return message(arg1, arg2, arg3)
+	    }
+	  }
+
+	  class NodeError extends Base {
+	    constructor (arg1, arg2, arg3) {
+	      super(getMessage(arg1, arg2, arg3));
+	    }
+	  }
+
+	  NodeError.prototype.name = Base.name;
+	  NodeError.prototype.code = code;
+
+	  codes[code] = NodeError;
+	}
+
+	// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
+	function oneOf(expected, thing) {
+	  if (Array.isArray(expected)) {
+	    const len = expected.length;
+	    expected = expected.map((i) => String(i));
+	    if (len > 2) {
+	      return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +
+	             expected[len - 1];
+	    } else if (len === 2) {
+	      return `one of ${thing} ${expected[0]} or ${expected[1]}`;
+	    } else {
+	      return `of ${thing} ${expected[0]}`;
+	    }
+	  } else {
+	    return `of ${thing} ${String(expected)}`;
+	  }
+	}
+
+	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+	function startsWith(str, search, pos) {
+		return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+	}
+
+	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
+	function endsWith(str, search, this_len) {
+		if (this_len === undefined || this_len > str.length) {
+			this_len = str.length;
+		}
+		return str.substring(this_len - search.length, this_len) === search;
+	}
+
+	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
+	function includes(str, search, start) {
+	  if (typeof start !== 'number') {
+	    start = 0;
+	  }
+
+	  if (start + search.length > str.length) {
+	    return false;
+	  } else {
+	    return str.indexOf(search, start) !== -1;
+	  }
+	}
+
+	createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
+	  return 'The value "' + value + '" is invalid for option "' + name + '"'
+	}, TypeError);
+	createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
+	  // determiner: 'must be' or 'must not be'
+	  let determiner;
+	  if (typeof expected === 'string' && startsWith(expected, 'not ')) {
+	    determiner = 'must not be';
+	    expected = expected.replace(/^not /, '');
+	  } else {
+	    determiner = 'must be';
+	  }
+
+	  let msg;
+	  if (endsWith(name, ' argument')) {
+	    // For cases like 'first argument'
+	    msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
+	  } else {
+	    const type = includes(name, '.') ? 'property' : 'argument';
+	    msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
+	  }
+
+	  msg += `. Received type ${typeof actual}`;
+	  return msg;
+	}, TypeError);
+	createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
+	createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
+	  return 'The ' + name + ' method is not implemented'
+	});
+	createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
+	createErrorType('ERR_STREAM_DESTROYED', function (name) {
+	  return 'Cannot call ' + name + ' after a stream was destroyed';
+	});
+	createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
+	createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
+	createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
+	createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
+	createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
+	  return 'Unknown encoding: ' + arg
+	}, TypeError);
+	createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
+
+	errors.codes = codes;
+	return errors;
+}
+
+export { requireErrors as __require };