zmdms-utils 0.0.80 → 0.0.81

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

@@ -0,0 +1,172 @@
+/**
+ * Helpers.
+ */
+
+var ms;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms;
+	hasRequiredMs = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms = function (val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isFinite(val)) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
+
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'weeks':
+	    case 'week':
+	    case 'w':
+	      return n * w;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
+
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (msAbs >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (msAbs >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (msAbs >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
+
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return plural(ms, msAbs, d, 'day');
+	  }
+	  if (msAbs >= h) {
+	    return plural(ms, msAbs, h, 'hour');
+	  }
+	  if (msAbs >= m) {
+	    return plural(ms, msAbs, m, 'minute');
+	  }
+	  if (msAbs >= s) {
+	    return plural(ms, msAbs, s, 'second');
+	  }
+	  return ms + ' ms';
+	}
+
+	/**
+	 * Pluralization helper.
+	 */
+
+	function plural(ms, msAbs, n, name) {
+	  var isPlural = msAbs >= n * 1.5;
+	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	}
+	return ms;
+}
+
+export { requireMs as __require };

package/dist/es/node_modules/node-gyp-build/index.js

@@ -0,0 +1,21 @@
+import { commonjsRequire } from '../../_virtual/_commonjs-dynamic-modules.js';
+import { __module as nodeGypBuild, exports as nodeGypBuildExports } from '../../_virtual/index6.js';
+import { __require as requireNodeGypBuild$1 } from './node-gyp-build.js';
+
+var hasRequiredNodeGypBuild;
+
+function requireNodeGypBuild () {
+	if (hasRequiredNodeGypBuild) return nodeGypBuildExports;
+	hasRequiredNodeGypBuild = 1;
+	(function (module) {
+		const runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : commonjsRequire; // eslint-disable-line
+		if (typeof runtimeRequire.addon === 'function') { // if the platform supports native resolving prefer that
+		  module.exports = runtimeRequire.addon.bind(runtimeRequire);
+		} else { // else use the runtime version here
+		  module.exports = requireNodeGypBuild$1();
+		}
+} (nodeGypBuild));
+	return nodeGypBuildExports;
+}
+
+export { requireNodeGypBuild as __require };

package/dist/es/node_modules/node-gyp-build/node-gyp-build.js

@@ -0,0 +1,222 @@
+import { commonjsRequire } from '../../_virtual/_commonjs-dynamic-modules.js';
+import require$$3 from 'fs';
+import require$$1 from 'path';
+import require$$2 from 'os';
+
+var nodeGypBuild;
+var hasRequiredNodeGypBuild;
+
+function requireNodeGypBuild () {
+	if (hasRequiredNodeGypBuild) return nodeGypBuild;
+	hasRequiredNodeGypBuild = 1;
+	var fs = require$$3;
+	var path = require$$1;
+	var os = require$$2;
+
+	// Workaround to fix webpack's build warnings: 'the request of a dependency is an expression'
+	var runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : commonjsRequire; // eslint-disable-line
+
+	var vars = (process.config && process.config.variables) || {};
+	var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
+	var abi = process.versions.modules; // TODO: support old node where this is undef
+	var runtime = isElectron() ? 'electron' : (isNwjs() ? 'node-webkit' : 'node');
+
+	var arch = process.env.npm_config_arch || os.arch();
+	var platform = process.env.npm_config_platform || os.platform();
+	var libc = process.env.LIBC || (isAlpine(platform) ? 'musl' : 'glibc');
+	var armv = process.env.ARM_VERSION || (arch === 'arm64' ? '8' : vars.arm_version) || '';
+	var uv = (process.versions.uv || '').split('.')[0];
+
+	nodeGypBuild = load;
+
+	function load (dir) {
+	  return runtimeRequire(load.resolve(dir))
+	}
+
+	load.resolve = load.path = function (dir) {
+	  dir = path.resolve(dir || '.');
+
+	  try {
+	    var name = runtimeRequire(path.join(dir, 'package.json')).name.toUpperCase().replace(/-/g, '_');
+	    if (process.env[name + '_PREBUILD']) dir = process.env[name + '_PREBUILD'];
+	  } catch (err) {}
+
+	  if (!prebuildsOnly) {
+	    var release = getFirst(path.join(dir, 'build/Release'), matchBuild);
+	    if (release) return release
+
+	    var debug = getFirst(path.join(dir, 'build/Debug'), matchBuild);
+	    if (debug) return debug
+	  }
+
+	  var prebuild = resolve(dir);
+	  if (prebuild) return prebuild
+
+	  var nearby = resolve(path.dirname(process.execPath));
+	  if (nearby) return nearby
+
+	  var target = [
+	    'platform=' + platform,
+	    'arch=' + arch,
+	    'runtime=' + runtime,
+	    'abi=' + abi,
+	    'uv=' + uv,
+	    armv ? 'armv=' + armv : '',
+	    'libc=' + libc,
+	    'node=' + process.versions.node,
+	    process.versions.electron ? 'electron=' + process.versions.electron : '',
+	    typeof __webpack_require__ === 'function' ? 'webpack=true' : '' // eslint-disable-line
+	  ].filter(Boolean).join(' ');
+
+	  throw new Error('No native build was found for ' + target + '\n    loaded from: ' + dir + '\n')
+
+	  function resolve (dir) {
+	    // Find matching "prebuilds/<platform>-<arch>" directory
+	    var tuples = readdirSync(path.join(dir, 'prebuilds')).map(parseTuple);
+	    var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
+	    if (!tuple) return
+
+	    // Find most specific flavor first
+	    var prebuilds = path.join(dir, 'prebuilds', tuple.name);
+	    var parsed = readdirSync(prebuilds).map(parseTags);
+	    var candidates = parsed.filter(matchTags(runtime, abi));
+	    var winner = candidates.sort(compareTags(runtime))[0];
+	    if (winner) return path.join(prebuilds, winner.file)
+	  }
+	};
+
+	function readdirSync (dir) {
+	  try {
+	    return fs.readdirSync(dir)
+	  } catch (err) {
+	    return []
+	  }
+	}
+
+	function getFirst (dir, filter) {
+	  var files = readdirSync(dir).filter(filter);
+	  return files[0] && path.join(dir, files[0])
+	}
+
+	function matchBuild (name) {
+	  return /\.node$/.test(name)
+	}
+
+	function parseTuple (name) {
+	  // Example: darwin-x64+arm64
+	  var arr = name.split('-');
+	  if (arr.length !== 2) return
+
+	  var platform = arr[0];
+	  var architectures = arr[1].split('+');
+
+	  if (!platform) return
+	  if (!architectures.length) return
+	  if (!architectures.every(Boolean)) return
+
+	  return { name, platform, architectures }
+	}
+
+	function matchTuple (platform, arch) {
+	  return function (tuple) {
+	    if (tuple == null) return false
+	    if (tuple.platform !== platform) return false
+	    return tuple.architectures.includes(arch)
+	  }
+	}
+
+	function compareTuples (a, b) {
+	  // Prefer single-arch prebuilds over multi-arch
+	  return a.architectures.length - b.architectures.length
+	}
+
+	function parseTags (file) {
+	  var arr = file.split('.');
+	  var extension = arr.pop();
+	  var tags = { file: file, specificity: 0 };
+
+	  if (extension !== 'node') return
+
+	  for (var i = 0; i < arr.length; i++) {
+	    var tag = arr[i];
+
+	    if (tag === 'node' || tag === 'electron' || tag === 'node-webkit') {
+	      tags.runtime = tag;
+	    } else if (tag === 'napi') {
+	      tags.napi = true;
+	    } else if (tag.slice(0, 3) === 'abi') {
+	      tags.abi = tag.slice(3);
+	    } else if (tag.slice(0, 2) === 'uv') {
+	      tags.uv = tag.slice(2);
+	    } else if (tag.slice(0, 4) === 'armv') {
+	      tags.armv = tag.slice(4);
+	    } else if (tag === 'glibc' || tag === 'musl') {
+	      tags.libc = tag;
+	    } else {
+	      continue
+	    }
+
+	    tags.specificity++;
+	  }
+
+	  return tags
+	}
+
+	function matchTags (runtime, abi) {
+	  return function (tags) {
+	    if (tags == null) return false
+	    if (tags.runtime && tags.runtime !== runtime && !runtimeAgnostic(tags)) return false
+	    if (tags.abi && tags.abi !== abi && !tags.napi) return false
+	    if (tags.uv && tags.uv !== uv) return false
+	    if (tags.armv && tags.armv !== armv) return false
+	    if (tags.libc && tags.libc !== libc) return false
+
+	    return true
+	  }
+	}
+
+	function runtimeAgnostic (tags) {
+	  return tags.runtime === 'node' && tags.napi
+	}
+
+	function compareTags (runtime) {
+	  // Precedence: non-agnostic runtime, abi over napi, then by specificity.
+	  return function (a, b) {
+	    if (a.runtime !== b.runtime) {
+	      return a.runtime === runtime ? -1 : 1
+	    } else if (a.abi !== b.abi) {
+	      return a.abi ? -1 : 1
+	    } else if (a.specificity !== b.specificity) {
+	      return a.specificity > b.specificity ? -1 : 1
+	    } else {
+	      return 0
+	    }
+	  }
+	}
+
+	function isNwjs () {
+	  return !!(process.versions && process.versions.nw)
+	}
+
+	function isElectron () {
+	  if (process.versions && process.versions.electron) return true
+	  if (process.env.ELECTRON_RUN_AS_NODE) return true
+	  return typeof window !== 'undefined' && window.process && window.process.type === 'renderer'
+	}
+
+	function isAlpine (platform) {
+	  return platform === 'linux' && fs.existsSync('/etc/alpine-release')
+	}
+
+	// Exposed for unit tests
+	// TODO: move to lib
+	load.parseTags = parseTags;
+	load.matchTags = matchTags;
+	load.compareTags = compareTags;
+	load.parseTuple = parseTuple;
+	load.matchTuple = matchTuple;
+	load.compareTuples = compareTuples;
+	return nodeGypBuild;
+}
+
+export { requireNodeGypBuild as __require };

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

@@ -0,0 +1,120 @@
+import { __exports as querystringify$1 } from '../../_virtual/index7.js';
+
+var has = Object.prototype.hasOwnProperty
+  , undef;
+
+/**
+ * Decode a URI encoded string.
+ *
+ * @param {String} input The URI encoded string.
+ * @returns {String|Null} The decoded string.
+ * @api private
+ */
+function decode(input) {
+  try {
+    return decodeURIComponent(input.replace(/\+/g, ' '));
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Attempts to encode a given input.
+ *
+ * @param {String} input The string that needs to be encoded.
+ * @returns {String|Null} The encoded string.
+ * @api private
+ */
+function encode(input) {
+  try {
+    return encodeURIComponent(input);
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Simple query string parser.
+ *
+ * @param {String} query The query string that needs to be parsed.
+ * @returns {Object}
+ * @api public
+ */
+function querystring(query) {
+  var parser = /([^=?#&]+)=?([^&]*)/g
+    , result = {}
+    , part;
+
+  while (part = parser.exec(query)) {
+    var key = decode(part[1])
+      , value = decode(part[2]);
+
+    //
+    // Prevent overriding of existing properties. This ensures that build-in
+    // methods like `toString` or __proto__ are not overriden by malicious
+    // querystrings.
+    //
+    // In the case if failed decoding, we want to omit the key/value pairs
+    // from the result.
+    //
+    if (key === null || value === null || key in result) continue;
+    result[key] = value;
+  }
+
+  return result;
+}
+
+/**
+ * Transform a query string to an object.
+ *
+ * @param {Object} obj Object that should be transformed.
+ * @param {String} prefix Optional prefix.
+ * @returns {String}
+ * @api public
+ */
+function querystringify(obj, prefix) {
+  prefix = prefix || '';
+
+  var pairs = []
+    , value
+    , key;
+
+  //
+  // Optionally prefix with a '?' if needed
+  //
+  if ('string' !== typeof prefix) prefix = '?';
+
+  for (key in obj) {
+    if (has.call(obj, key)) {
+      value = obj[key];
+
+      //
+      // Edge cases where we actually want to encode the value to an empty
+      // string instead of the stringified value.
+      //
+      if (!value && (value === null || value === undef || isNaN(value))) {
+        value = '';
+      }
+
+      key = encode(key);
+      value = encode(value);
+
+      //
+      // If we failed to encode the strings, we should bail out as we don't
+      // want to add invalid strings to the query.
+      //
+      if (key === null || value === null) continue;
+      pairs.push(key +'='+ value);
+    }
+  }
+
+  return pairs.length ? prefix + pairs.join('&') : '';
+}
+
+//
+// Expose the module.
+//
+querystringify$1.stringify = querystringify;
+querystringify$1.parse = querystring;
+
+export { querystringify$1 as default };

package/dist/es/node_modules/requires-port/index.js

@@ -0,0 +1,38 @@
+/**
+ * Check if we're required to add a port number.
+ *
+ * @see https://url.spec.whatwg.org/#default-port
+ * @param {Number|String} port Port number we need to check
+ * @param {String} protocol Protocol we need to check against.
+ * @returns {Boolean} Is it a default port for the given protocol
+ * @api private
+ */
+var requiresPort = function required(port, protocol) {
+  protocol = protocol.split(':')[0];
+  port = +port;
+
+  if (!port) return false;
+
+  switch (protocol) {
+    case 'http':
+    case 'ws':
+    return port !== 80;
+
+    case 'https':
+    case 'wss':
+    return port !== 443;
+
+    case 'ftp':
+    return port !== 21;
+
+    case 'gopher':
+    return port !== 70;
+
+    case 'file':
+    return false;
+  }
+
+  return port !== 0;
+};
+
+export { requiresPort as default };

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

@@ -0,0 +1,71 @@
+import { exports as safeBufferExports, __module as safeBuffer } from '../../_virtual/index9.js';
+import require$$0 from 'buffer';
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+(function (module, exports) {
+	/* eslint-disable node/no-deprecated-api */
+	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)
+	}
+
+	SafeBuffer.prototype = Object.create(Buffer.prototype);
+
+	// 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, safeBufferExports));