| |
| /** |
| * 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; |
| } |