twitst4tz

debug.js (4889B)

---

 
 /**
  * This is the common logic for both the Node.js and web browser
  * implementations of `debug()`.
  *
  * Expose `debug()` as the module.
  */
 
 exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
 exports.coerce = coerce;
 exports.disable = disable;
 exports.enable = enable;
 exports.enabled = enabled;
 exports.humanize = require('ms');
 
 /**
  * Active `debug` instances.
  */
 exports.instances = [];
 
 /**
  * The currently active debug mode names, and names to skip.
  */
 
 exports.names = [];
 exports.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".
  */
 
 exports.formatters = {};
 
 /**
  * Select a color.
  * @param {String} namespace
  * @return {Number}
  * @api private
  */
 
 function selectColor(namespace) {
   var hash = 0, i;
 
   for (i in namespace) {
     hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);
     hash |= 0; // Convert to 32bit integer
   }
 
   return exports.colors[Math.abs(hash) % exports.colors.length];
 }
 
 /**
  * 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;
 
     var self = debug;
 
     // set `diff` timestamp
     var curr = +new Date();
     var ms = curr - (prevTime || curr);
     self.diff = ms;
     self.prev = prevTime;
     self.curr = curr;
     prevTime = curr;
 
     // turn the `arguments` into a proper Array
     var args = new Array(arguments.length);
     for (var i = 0; i < args.length; i++) {
       args[i] = arguments[i];
     }
 
     args[0] = exports.coerce(args[0]);
 
     if ('string' !== typeof args[0]) {
       // 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 = exports.formatters[format];
       if ('function' === typeof formatter) {
         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.)
     exports.formatArgs.call(self, args);
 
     var logFn = debug.log || exports.log || console.log.bind(console);
     logFn.apply(self, args);
   }
 
   debug.namespace = namespace;
   debug.enabled = exports.enabled(namespace);
   debug.useColors = exports.useColors();
   debug.color = selectColor(namespace);
   debug.destroy = destroy;
 
   // env-specific initialization logic for debug instances
   if ('function' === typeof exports.init) {
     exports.init(debug);
   }
 
   exports.instances.push(debug);
 
   return debug;
 }
 
 function destroy () {
   var index = exports.instances.indexOf(this);
   if (index !== -1) {
     exports.instances.splice(index, 1);
     return true;
   } else {
     return false;
   }
 }
 
 /**
  * Enables a debug mode by namespaces. This can include modes
  * separated by a colon and wildcards.
  *
  * @param {String} namespaces
  * @api public
  */
 
 function enable(namespaces) {
   exports.save(namespaces);
 
   exports.names = [];
   exports.skips = [];
 
   var i;
   var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
   var len = split.length;
 
   for (i = 0; i < len; i++) {
     if (!split[i]) continue; // ignore empty strings
     namespaces = split[i].replace(/\*/g, '.*?');
     if (namespaces[0] === '-') {
       exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
     } else {
       exports.names.push(new RegExp('^' + namespaces + '$'));
     }
   }
 
   for (i = 0; i < exports.instances.length; i++) {
     var instance = exports.instances[i];
     instance.enabled = exports.enabled(instance.namespace);
   }
 }
 
 /**
  * Disable debug output.
  *
  * @api public
  */
 
 function disable() {
   exports.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, len;
   for (i = 0, len = exports.skips.length; i < len; i++) {
     if (exports.skips[i].test(name)) {
       return false;
     }
   }
   for (i = 0, len = exports.names.length; i < len; i++) {
     if (exports.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;
 }