text: 'use strict';
  
  /**
   * Cache results of the first function call to ensure only calling once.
   *
   * ```js
   * var utils = require('lazy-cache')(require);
   * // cache the call to `require('ansi-yellow')`
   * utils('ansi-yellow', 'yellow');
   * // use `ansi-yellow`
   * console.log(utils.yellow('this is yellow'));
   * ```
   *
   * @param  {Function} `fn` Function that will be called only once.
   * @return {Function} Function that can be called to get the cached function
   * @api public
   */
  
  function lazyCache(fn) {
    var cache = {};
    var proxy = function(mod, name) {
      name = name || camelcase(mod);
  
      // check both boolean and string in case `process.env` cases to string
      if (process.env.UNLAZY === 'true' || process.env.UNLAZY === true || process.env.TRAVIS) {
        cache[name] = fn(mod);
      }
  
      Object.defineProperty(proxy, name, {
        enumerable: true,
        configurable: true,
        get: getter
      });
  
      function getter() {
        if (cache.hasOwnProperty(name)) {
          return cache[name];
        }
        return (cache[name] = fn(mod));
      }
      return getter;
    };
    return proxy;
  }
  
  /**
   * Used to camelcase the name to be stored on the `lazy` object.
   *
   * @param  {String} `str` String containing `_`, `.`, `-` or whitespace that will be camelcased.
   * @return {String} camelcased string.
   */
  
  function camelcase(str) {
    if (str.length === 1) {
      return str.toLowerCase();
    }
    str = str.replace(/^[\W_]+|[\W_]+$/g, '').toLowerCase();
    return str.replace(/[\W_]+(\w|$)/g, function(_, ch) {
      return ch.toUpperCase();
    });
  }
  
  /**
   * Expose `lazyCache`
   */
  
  module.exports = lazyCache;
  