zmdms-utils 0.0.80 → 0.0.81

package/dist/es/node_modules/debug/src/common.js

@@ -0,0 +1,259 @@
+import { __require as requireMs } from '../../ms/index.js';
+
+var common;
+var hasRequiredCommon;
+
+function requireCommon () {
+	if (hasRequiredCommon) return common;
+	hasRequiredCommon = 1;
+
+	/**
+	 * This is the common logic for both the Node.js and web browser
+	 * implementations of `debug()`.
+	 */
+	function setup(env) {
+	  createDebug.debug = createDebug;
+	  createDebug.default = createDebug;
+	  createDebug.coerce = coerce;
+	  createDebug.disable = disable;
+	  createDebug.enable = enable;
+	  createDebug.enabled = enabled;
+	  createDebug.humanize = requireMs();
+	  Object.keys(env).forEach(function (key) {
+	    createDebug[key] = env[key];
+	  });
+	  /**
+	  * Active `debug` instances.
+	  */
+
+	  createDebug.instances = [];
+	  /**
+	  * The currently active debug mode names, and names to skip.
+	  */
+
+	  createDebug.names = [];
+	  createDebug.skips = [];
+	  /**
+	  * Map of special "%n" handling functions, for the debug "format" argument.
+	  *
+	  * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+	  */
+
+	  createDebug.formatters = {};
+	  /**
+	  * Selects a color for a debug namespace
+	  * @param {String} namespace The namespace string for the for the debug instance to be colored
+	  * @return {Number|String} An ANSI color code for the given namespace
+	  * @api private
+	  */
+
+	  function selectColor(namespace) {
+	    var hash = 0;
+
+	    for (var i = 0; i < namespace.length; i++) {
+	      hash = (hash << 5) - hash + namespace.charCodeAt(i);
+	      hash |= 0; // Convert to 32bit integer
+	    }
+
+	    return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+	  }
+
+	  createDebug.selectColor = selectColor;
+	  /**
+	  * Create a debugger with the given `namespace`.
+	  *
+	  * @param {String} namespace
+	  * @return {Function}
+	  * @api public
+	  */
+
+	  function createDebug(namespace) {
+	    var prevTime;
+
+	    function debug() {
+	      // Disabled?
+	      if (!debug.enabled) {
+	        return;
+	      }
+
+	      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+	        args[_key] = arguments[_key];
+	      }
+
+	      var self = debug; // Set `diff` timestamp
+
+	      var curr = Number(new Date());
+	      var ms = curr - (prevTime || curr);
+	      self.diff = ms;
+	      self.prev = prevTime;
+	      self.curr = curr;
+	      prevTime = curr;
+	      args[0] = createDebug.coerce(args[0]);
+
+	      if (typeof args[0] !== 'string') {
+	        // Anything else let's inspect with %O
+	        args.unshift('%O');
+	      } // Apply any `formatters` transformations
+
+
+	      var index = 0;
+	      args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) {
+	        // If we encounter an escaped % then don't increase the array index
+	        if (match === '%%') {
+	          return match;
+	        }
+
+	        index++;
+	        var formatter = createDebug.formatters[format];
+
+	        if (typeof formatter === 'function') {
+	          var val = args[index];
+	          match = formatter.call(self, val); // Now we need to remove `args[index]` since it's inlined in the `format`
+
+	          args.splice(index, 1);
+	          index--;
+	        }
+
+	        return match;
+	      }); // Apply env-specific formatting (colors, etc.)
+
+	      createDebug.formatArgs.call(self, args);
+	      var logFn = self.log || createDebug.log;
+	      logFn.apply(self, args);
+	    }
+
+	    debug.namespace = namespace;
+	    debug.enabled = createDebug.enabled(namespace);
+	    debug.useColors = createDebug.useColors();
+	    debug.color = selectColor(namespace);
+	    debug.destroy = destroy;
+	    debug.extend = extend; // Debug.formatArgs = formatArgs;
+	    // debug.rawLog = rawLog;
+	    // env-specific initialization logic for debug instances
+
+	    if (typeof createDebug.init === 'function') {
+	      createDebug.init(debug);
+	    }
+
+	    createDebug.instances.push(debug);
+	    return debug;
+	  }
+
+	  function destroy() {
+	    var index = createDebug.instances.indexOf(this);
+
+	    if (index !== -1) {
+	      createDebug.instances.splice(index, 1);
+	      return true;
+	    }
+
+	    return false;
+	  }
+
+	  function extend(namespace, delimiter) {
+	    return createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+	  }
+	  /**
+	  * Enables a debug mode by namespaces. This can include modes
+	  * separated by a colon and wildcards.
+	  *
+	  * @param {String} namespaces
+	  * @api public
+	  */
+
+
+	  function enable(namespaces) {
+	    createDebug.save(namespaces);
+	    createDebug.names = [];
+	    createDebug.skips = [];
+	    var i;
+	    var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+	    var len = split.length;
+
+	    for (i = 0; i < len; i++) {
+	      if (!split[i]) {
+	        // ignore empty strings
+	        continue;
+	      }
+
+	      namespaces = split[i].replace(/\*/g, '.*?');
+
+	      if (namespaces[0] === '-') {
+	        createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+	      } else {
+	        createDebug.names.push(new RegExp('^' + namespaces + '$'));
+	      }
+	    }
+
+	    for (i = 0; i < createDebug.instances.length; i++) {
+	      var instance = createDebug.instances[i];
+	      instance.enabled = createDebug.enabled(instance.namespace);
+	    }
+	  }
+	  /**
+	  * Disable debug output.
+	  *
+	  * @api public
+	  */
+
+
+	  function disable() {
+	    createDebug.enable('');
+	  }
+	  /**
+	  * Returns true if the given mode name is enabled, false otherwise.
+	  *
+	  * @param {String} name
+	  * @return {Boolean}
+	  * @api public
+	  */
+
+
+	  function enabled(name) {
+	    if (name[name.length - 1] === '*') {
+	      return true;
+	    }
+
+	    var i;
+	    var len;
+
+	    for (i = 0, len = createDebug.skips.length; i < len; i++) {
+	      if (createDebug.skips[i].test(name)) {
+	        return false;
+	      }
+	    }
+
+	    for (i = 0, len = createDebug.names.length; i < len; i++) {
+	      if (createDebug.names[i].test(name)) {
+	        return true;
+	      }
+	    }
+
+	    return false;
+	  }
+	  /**
+	  * Coerce `val`.
+	  *
+	  * @param {Mixed} val
+	  * @return {Mixed}
+	  * @api private
+	  */
+
+
+	  function coerce(val) {
+	    if (val instanceof Error) {
+	      return val.stack || val.message;
+	    }
+
+	    return val;
+	  }
+
+	  createDebug.enable(createDebug.load());
+	  return createDebug;
+	}
+
+	common = setup;
+	return common;
+}
+
+export { requireCommon as __require };

package/dist/es/node_modules/debug/src/index.js

@@ -0,0 +1,25 @@
+import { exports as srcExports, __module as src } from '../../../_virtual/index8.js';
+import { __require as requireBrowser } from './browser.js';
+import { __require as requireNode } from './node.js';
+
+var hasRequiredSrc;
+
+function requireSrc () {
+	if (hasRequiredSrc) return srcExports;
+	hasRequiredSrc = 1;
+	(function (module) {
+
+		/**
+		 * Detect Electron renderer / nwjs process, which is node, but we should
+		 * treat as a browser.
+		 */
+		if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+		  module.exports = requireBrowser();
+		} else {
+		  module.exports = requireNode();
+		}
+} (src));
+	return srcExports;
+}
+
+export { requireSrc as __require };

package/dist/es/node_modules/debug/src/node.js

@@ -0,0 +1,192 @@
+import { exports as nodeExports, __module as node } from '../../../_virtual/node2.js';
+import require$$0 from 'tty';
+import require$$1 from 'util';
+import { __require as requireSupportsColor } from '../../supports-color/index.js';
+import { __require as requireCommon } from './common.js';
+
+var hasRequiredNode;
+
+function requireNode () {
+	if (hasRequiredNode) return nodeExports;
+	hasRequiredNode = 1;
+	(function (module, exports) {
+
+		/**
+		 * Module dependencies.
+		 */
+		var tty = require$$0;
+
+		var util = require$$1;
+		/**
+		 * This is the Node.js implementation of `debug()`.
+		 */
+
+
+		exports.init = init;
+		exports.log = log;
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [6, 2, 3, 4, 5, 1];
+
+		try {
+		  // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+		  // eslint-disable-next-line import/no-extraneous-dependencies
+		  var supportsColor = requireSupportsColor();
+
+		  if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+		    exports.colors = [20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62, 63, 68, 69, 74, 75, 76, 77, 78, 79, 80, 81, 92, 93, 98, 99, 112, 113, 128, 129, 134, 135, 148, 149, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 178, 179, 184, 185, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 214, 215, 220, 221];
+		  }
+		} catch (error) {} // Swallow - we only care if `supports-color` is available; it doesn't have to be.
+
+		/**
+		 * Build up the default `inspectOpts` object from the environment variables.
+		 *
+		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+		 */
+
+
+		exports.inspectOpts = Object.keys(process.env).filter(function (key) {
+		  return /^debug_/i.test(key);
+		}).reduce(function (obj, key) {
+		  // Camel-case
+		  var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function (_, k) {
+		    return k.toUpperCase();
+		  }); // Coerce string value into JS value
+
+		  var val = process.env[key];
+
+		  if (/^(yes|on|true|enabled)$/i.test(val)) {
+		    val = true;
+		  } else if (/^(no|off|false|disabled)$/i.test(val)) {
+		    val = false;
+		  } else if (val === 'null') {
+		    val = null;
+		  } else {
+		    val = Number(val);
+		  }
+
+		  obj[prop] = val;
+		  return obj;
+		}, {});
+		/**
+		 * Is stdout a TTY? Colored output is enabled when `true`.
+		 */
+
+		function useColors() {
+		  return 'colors' in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+		}
+		/**
+		 * Adds ANSI color escape codes if enabled.
+		 *
+		 * @api public
+		 */
+
+
+		function formatArgs(args) {
+		  var name = this.namespace,
+		      useColors = this.useColors;
+
+		  if (useColors) {
+		    var c = this.color;
+		    var colorCode = "\x1B[3" + (c < 8 ? c : '8;5;' + c);
+		    var prefix = "  ".concat(colorCode, ";1m").concat(name, " \x1B[0m");
+		    args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+		    args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + "\x1B[0m");
+		  } else {
+		    args[0] = getDate() + name + ' ' + args[0];
+		  }
+		}
+
+		function getDate() {
+		  if (exports.inspectOpts.hideDate) {
+		    return '';
+		  }
+
+		  return new Date().toISOString() + ' ';
+		}
+		/**
+		 * Invokes `util.format()` with the specified arguments and writes to stderr.
+		 */
+
+
+		function log() {
+		  return process.stderr.write(util.format.apply(util, arguments) + '\n');
+		}
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+
+
+		function save(namespaces) {
+		  if (namespaces) {
+		    process.env.DEBUG = namespaces;
+		  } else {
+		    // If you set a process.env field to null or undefined, it gets cast to the
+		    // string 'null' or 'undefined'. Just delete instead.
+		    delete process.env.DEBUG;
+		  }
+		}
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+
+
+		function load() {
+		  return process.env.DEBUG;
+		}
+		/**
+		 * Init logic for `debug` instances.
+		 *
+		 * Create a new `inspectOpts` object in case `useColors` is set
+		 * differently for a particular `debug` instance.
+		 */
+
+
+		function init(debug) {
+		  debug.inspectOpts = {};
+		  var keys = Object.keys(exports.inspectOpts);
+
+		  for (var i = 0; i < keys.length; i++) {
+		    debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+		  }
+		}
+
+		module.exports = requireCommon()(exports);
+		var formatters = module.exports.formatters;
+		/**
+		 * Map %o to `util.inspect()`, all on a single line.
+		 */
+
+		formatters.o = function (v) {
+		  this.inspectOpts.colors = this.useColors;
+		  return util.inspect(v, this.inspectOpts)
+		    .split('\n')
+		    .map(function (str) { return str.trim(); })
+		    .join(' ');
+		};
+		/**
+		 * Map %O to `util.inspect()`, allowing multiple lines if needed.
+		 */
+
+
+		formatters.O = function (v) {
+		  this.inspectOpts.colors = this.useColors;
+		  return util.inspect(v, this.inspectOpts);
+		};
+} (node, nodeExports));
+	return nodeExports;
+}
+
+export { requireNode as __require };