source: trip-planner-front/node_modules/debug/src/common.js@ eed0bf8

/**
 * 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 = require('ms');
        createDebug.destroy = destroy;

        Object.keys(env).forEach(key => {
                createDebug[key] = env[key];
        });

        /**
        * 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) {
                let hash = 0;

                for (let 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) {
                let prevTime;
                let enableOverride = null;
                let namespacesCache;
                let enabledCache;

                function debug(...args) {
                        // Disabled?
                        if (!debug.enabled) {
                                return;
                        }

                        const self = debug;

                        // Set `diff` timestamp
                        const curr = Number(new Date());
                        const 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
                        let index = 0;
                        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
                                // If we encounter an escaped % then don't increase the array index
                                if (match === '%%') {
                                        return '%';
                                }
                                index++;
                                const formatter = createDebug.formatters[format];
                                if (typeof formatter === 'function') {
                                        const 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);

                        const logFn = self.log || createDebug.log;
                        logFn.apply(self, args);
                }

                debug.namespace = namespace;
                debug.useColors = createDebug.useColors();
                debug.color = createDebug.selectColor(namespace);
                debug.extend = extend;
                debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.

                Object.defineProperty(debug, 'enabled', {
                        enumerable: true,
                        configurable: false,
                        get: () => {
                                if (enableOverride !== null) {
                                        return enableOverride;
                                }
                                if (namespacesCache !== createDebug.namespaces) {
                                        namespacesCache = createDebug.namespaces;
                                        enabledCache = createDebug.enabled(namespace);
                                }

                                return enabledCache;
                        },
                        set: v => {
                                enableOverride = v;
                        }
                });

                // Env-specific initialization logic for debug instances
                if (typeof createDebug.init === 'function') {
                        createDebug.init(debug);
                }

                return debug;
        }

        function extend(namespace, delimiter) {
                const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
                newDebug.log = this.log;
                return newDebug;
        }

        /**
        * 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.namespaces = namespaces;

                createDebug.names = [];
                createDebug.skips = [];

                let i;
                const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
                const 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 + '$'));
                        }
                }
        }

        /**
        * Disable debug output.
        *
        * @return {String} namespaces
        * @api public
        */
        function disable() {
                const namespaces = [
                        ...createDebug.names.map(toNamespace),
                        ...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
                ].join(',');
                createDebug.enable('');
                return namespaces;
        }

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

                let i;
                let 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;
        }

        /**
        * Convert regexp to namespace
        *
        * @param {RegExp} regxep
        * @return {String} namespace
        * @api private
        */
        function toNamespace(regexp) {
                return regexp.toString()
                        .substring(2, regexp.toString().length - 2)
                        .replace(/\.\*\?$/, '*');
        }

        /**
        * Coerce `val`.
        *
        * @param {Mixed} val
        * @return {Mixed}
        * @api private
        */
        function coerce(val) {
                if (val instanceof Error) {
                        return val.stack || val.message;
                }
                return val;
        }

        /**
        * XXX DO NOT USE. This is a temporary stub function.
        * XXX It WILL be removed in the next major release.
        */
        function destroy() {
                console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
        }

        createDebug.enable(createDebug.load());

        return createDebug;
}

module.exports = setup;