/build/pojoviz.js

!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var o;"undefined"!=typeof window?o=window:"undefined"!=typeof global?o=global:"undefined"!=typeof self&&(o=self),o.pojoviz=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({"dagre":[function(_dereq_,module,exports){
module.exports=_dereq_('JWa/F1');
},{}],"lodash":[function(_dereq_,module,exports){
module.exports=_dereq_('K2RcUv');
},{}],"q":[function(_dereq_,module,exports){
module.exports=_dereq_('qLuPo1');
},{}],4:[function(_dereq_,module,exports){
var HashMap = _dereq_('./util/HashMap'),
  hashKey = _dereq_('./util/hashKey'),
  _ = _dereq_('lodash');

// utils
function eachObjectAndPrototype(obj, fn) {
  fn(obj);
  if (obj.hasOwnProperty('prototype')) {
    fn(obj.prototype);
  }
}

/**
 * Wraps a function with another
 * @param  {Function} fn
 * @param  {Function}   wrapper
 * @return {*}
 */
function wrapFn(fn, wrapper) {
  return function () {
    // NOTE: `this` will be the instance
    wrapper.call(this);
    var args = [].slice.call(arguments);
    return fn.apply(this, args);
  };
}

function isObjectOrFunction(v) {
  return !!(v && (typeof v === 'object' ||
    typeof v === 'function'));
}

/**
 * Properties forbidden in strict mode
 * @type {Array}
 */
var forbiddenInStrictMode = [
  'callee', 'caller', 'arguments'
];

/**
 * @constructor
 * Object analyz
 * @param {[type]} config [description]
 */
function Analyzer(config) {
  if (!(this instanceof Analyzer)) {
    return new Analyzer(config);
  }
  config = config || {};

  /**
   * Objects registered in this instance
   * @type {HashMap}
   */
  this.objects = config.objects || new HashMap();
  /**
   * Forbidden objects
   * @type {HashMap}
   */
  this.forbidden = config.forbidden || new HashMap();

  /**
   * Cache of properties
   * @type {Object}
   */
  this.__cacheObjects = {};

  /**
   * Cache of links
   * @type {Object}
   */
  this.__cacheLinks = {};

  /**
   * Dfs levels
   * @type {number}
   */
  this.levels = Infinity;
  /**
   * If the analyzer is dirty then it has some pending work
   * to do
   * @type {boolean}
   */
  this.dirty = true;

  /**
   * True to save the properties of the objects analyzed in an
   * internal cache
   * @type {Boolean}
   */
  this.cache =
    config.hasOwnProperty('cache') ?
    config.cache : true;
  /**
   * True to include function constructors in the analysis graph
   * i.e. the functions that have a prototype
   * @type {boolean}
   */
  this.functionConstructors =
    config.hasOwnProperty('functionConstructors') ?
    config.functionConstructors : false;
  /**
   * True to include all the functions in the analysis graph
   * @type {boolean}
   */
  this.allFunctions =
    config.hasOwnProperty('allFunctions') ?
    config.allFunctions : false;
  /**
   * True to allow HTML nodes
   * @type {boolean}
   */
  this.htmlNode =
    config.hasOwnProperty('htmlNode') ?
    config.htmlNode : false;
}

Analyzer.prototype = {
  constructor: Analyzer,

  /**
   * Checks if an object is in the forbidden hash
   * @param  {Object}  obj
   * @return {boolean}
   */
  isForbidden: function (obj) {
    return this.forbidden.get(obj);
  },

  isLinkable: function (key, obj) {
    if (!obj) {
      return false;
    }

    var v = typeof obj === 'object';

    // if (v) {
    //   if (!this.htmlNode && v instanceof Node) { return false; }
    //   return true;
    // }

    // if (!this.htmlNode) {
    //   v = v && !(v instanceof Node);
    // }fdeq1`

    // typeof obj === 'function' &&
    //   console.log(Object.getOwnPropertyNames(obj));
    if (!v && this.allFunctions) {
      // minimize the nodes created by considering functions
      // with more properties than the usual ones
      v = typeof obj === 'function';
      v = v && Object.getOwnPropertyNames(obj).length > 5;
    }
    if (!v && this.functionConstructors) {
      v = typeof obj === 'function';
      v = v && (
        obj.name &&
        obj.name[0].match(/^[A-Z]/) ||
        key[0].match(/^[A-Z]/)
      );
    }
    return v;
  },

  /**
   * Gets the enumerable properties an object discarding
   * forbidden ones
   *
   * @param  {Object} obj
   * @return {Array} Array of objects, each object has the following
   * properties:
   *
   * - name
   * - cls
   * - type
   * - linkeable (if it's an object this property is set to true)
   */
  getProperties: function (obj, linkableOnly) {
    var me = this,
      hk = hashKey(obj),
      properties;

    if (!obj) {
      throw 'this method needs an object to analyze';
    }

    if (this.cache) {
      if (!linkableOnly && this.__cacheObjects[hk]) {
        // console.log('objects from cache :)');
        return this.__cacheObjects[hk];
      }
    }

    properties = Object.getOwnPropertyNames(obj);

    function forbiddenKey(v) {
      // forbidden in strict mode
      return ~forbiddenInStrictMode.indexOf(v) ||
        v.match(/^__.*?__$/) ||
        v.match(/^\$\$.*?\$\$$/) ||
        v.match(/[:+~!><=//\[\]@\. ]/);
    }

    properties = _.filter(properties, function (v) {
      var good = typeof v === 'string' && !forbiddenKey(v),
          r;
      if (linkableOnly) {
        try {
          r = good && me.isLinkable(v, obj[v]);
        } catch (e) {
          r = false;
          // uncomment to see why obj[v] is not allowed
          // console.log(e);
        } finally {
          return r;
        }
      }
      return good;
    }).map(function (v) {
      var type,
        linkeable;
      try {
        // type = null|string|undefined|number|object
        type = typeof obj[v];
        linkeable = isObjectOrFunction(obj[v]);
      } catch(e) {
        type = 'undefined';
        linkeable = false;
      }

      return {
        // parent: hashKey(obj),
        name: v,
        type: type,
        linkeable: linkeable
      };
    });

    // special properties
    var proto = Object.getPrototypeOf(obj);
    if (proto) {
      properties.push({
        name: '[[Prototype]]',
        // cls: hashKey(obj),
        type: 'object',
        linkeable: true,
        hidden: true
      });
    }
    var constructor = obj.hasOwnProperty &&
      obj.hasOwnProperty('constructor') &&
      typeof obj.constructor === 'function';
    if (constructor &&
        _.findIndex(properties, { name: 'constructor' }) === -1) {
      properties.push({
        // cls: hashKey(obj),
        name: 'constructor',
        type: 'function',
        linkeable: true
      });
    }

    if (this.cache && !linkableOnly) {
      this.__cacheObjects[hk] = properties;
    }

    // console.log(properties);
    return properties;
  },

  /**
   * Analyzes a list of objects recursively
   * @param  {Array} objects      Array of objects
   * @param  {number} currentLevel Current dfs level
   */
  analyzeObjects: function (objects, currentLevel) {
    var me = this;
    objects.forEach(function (v) {
      if (currentLevel <= me.levels &&    // dfs level
          !me.objects.get(v) &&         // already registered
          !me.isForbidden(v)              // forbidden check
          ) {

        // add to the registered object pool
        me.objects.put(v);

        // dfs to the next level
        me.analyzeObjects(
          me.getOwnLinks(v).map(function (link) {
            return link.to;
          }),
          currentLevel + 1
        );
      }
    });
  },

  /**
   * Returns a list of links, each link is an object which has the
   * following properties:
   *
   * - from
   * - to
   * - property (string)
   *
   * @param  {Object} obj
   * @return {Array}
   */
  getOwnLinks: function (obj) {
    var me = this,
        links = [],
        properties,
        name = hashKey(obj);

    if (this.__cacheLinks[name]) {
      // console.log('links from cache :)');
      return this.__cacheLinks[name];
    }

    properties = me.getProperties(obj, true);

    function getAugmentedHash(obj, name) {
      if (!hashKey.has(obj) &&
          name !== 'prototype' &&
          name !== 'constructor') {
        hashKey.createHashKeysFor(obj, name);
      }
      return hashKey(obj);
    }

    if (!name) {
      throw 'the object needs to have a hashkey';
    }

    _.forEach(properties, function (v) {
      var ref = obj[v.name];
      // because of the levels a reference might not exist
      if (!ref) {
        return;
      }

      // if the object doesn't have a hashkey
      // let's give it a name equal to the property
      // being analyzed
      getAugmentedHash(ref, v.name);

      if (!me.isForbidden(ref)) {
        links.push({
          from: obj,
          fromHash: hashKey(obj),
          to: ref,
          toHash: hashKey(ref),
          property: v.name
        });
      }
    });

    var proto = Object.getPrototypeOf(obj);
    if (proto && !me.isForbidden(proto)) {
      links.push({
        from: obj,
        fromHash: hashKey(obj),
        to: proto,
        toHash: hashKey(proto),
        property: '[[Prototype]]'
      });
    }

    if (this.cache) {
      this.__cacheLinks[name] = links;
    }

    return links;
  },

  makeDirty: function () {
    this.dirty = true;
  },

  setLevels: function (l) {
    this.levels = l;
  },

  setDirty: function (d) {
    this.dirty = d;
  },

  setFunctionConstructors: function (v) {
    this.functionConstructors = v;
  },

  getObjects: function () {
    return this.objects;
  },

  /**
   * Stringifies an object properties
   * @param  obj
   * @param  toString
   * @return {Array}
   */
  stringifyObjectProperties: function (obj) {
    return this.getProperties(obj);
  },

  /**
   * Returns a representation of the links of
   * an object
   * @return {Array}
   */
  stringifyObjectLinks: function (obj) {
    var me = this;
    return me.getOwnLinks(obj).map(function (link) {
      // discarded: from, to
      return {
        from: link.fromHash,
        to: link.toHash,
        property: link.property
      };
    });
  },

  /**
   * Stringifies the objects saved in this analyzer
   * @return {Object}
   */
  stringify: function () {
    var me = this,
      nodes = {},
      edges = {};
    console.time('stringify');
    _(this.objects).forOwn(function (v) {
      nodes[hashKey(v)] = me.stringifyObjectProperties(v);
      edges[hashKey(v)] = me.stringifyObjectLinks(v);
    });
    console.timeEnd('stringify');
    return {
      nodes: nodes,
      edges: edges
    };
  }
};

// aditional objects that need the prototype to exist
var aProto = Analyzer.prototype;
_.merge(aProto, {

  /**
   * Adds a list of objects to analyze and make the analyzer dirty
   * @param  {Array<Objects>} objects
   * @return {this}
   */
  add: wrapFn(function (objects) {
    console.time('analyze');
    this.analyzeObjects(objects, 0);
    console.timeEnd('analyze');
    return this;
  }, aProto.makeDirty),

  /**
   * Removes a list of objects, if `withPrototype` is true then
   * also the prototype is removed
   * @param  {Array<Objects>} objects
   * @param  {boolean} withPrototype
   * @return {this}
   */
  remove: wrapFn(function (objects, withPrototype) {
    var me = this;
    objects.forEach(function (obj) {
      me.objects.remove(obj);
      if (withPrototype && obj.hasOwnProperty('prototype')) {
        me.objects.remove(obj.prototype);
      }
    });
    return me;
  }, aProto.makeDirty),

  /**
   * Forbids a list of objects, if `withPrototype` is true then
   * also the prototype is forbidden
   * @param  {Array<Objects>} objects
   * @param  {boolean} withPrototype
   * @return {this}
   */
  forbid: wrapFn(function (objects, withPrototype) {
    var me = this;
    me.remove(objects, withPrototype);
    objects.forEach(function (obj) {
      me.forbidden.put(obj);
      if (withPrototype && obj.hasOwnProperty('prototype')) {
        me.forbidden.put(obj.prototype);
      }
    });
  }, aProto.makeDirty),

  /**
   * Unforbids a list of objects, if `withPrototype` is true then
   * also the prototype is unforbidden
   * @param  {Array<Objects>} objects
   * @param  {boolean} withPrototype
   * @return {this}
   */
  unforbid: wrapFn(function (objects, withPrototype) {
    var me = this;
    objects.forEach(function (obj) {
      me.forbidden.remove(obj);
      if (withPrototype && obj.hasOwnProperty('prototype')) {
        me.forbidden.remove(obj.prototype);
      }
    });
  }, aProto.makeDirty)
});

module.exports = Analyzer;

},{"./util/HashMap":12,"./util/hashKey":13,"lodash":"K2RcUv"}],5:[function(_dereq_,module,exports){
'use strict';

var _ = _dereq_('lodash'),
  Generic = _dereq_('./analyzer/GenericAnalyzer'),
  Angular = _dereq_('./analyzer/Angular'),
  Window = _dereq_('./analyzer/Window'),
  PObject = _dereq_('./analyzer/Object'),
  BuiltIn = _dereq_('./analyzer/BuiltIn');

var libraries;

var proto = {
  createNew: function (global, options) {
    console.log('creating a generic container for: ' + global, options);
    return (libraries[global] = new Generic(options));
  },
  all: function (fn) {
    _.forOwn(libraries, fn);
  },
  markDirty: function () {
    proto.all(function (v) {
      v.markDirty();
    });
    return proto;
  },
  setFunctionConstructors: function (newValue) {
    proto.all(function (v) {
      // this only works on the generic analyzers
      if (!v._hasfc) {
        v.analyzer.setFunctionConstructors(newValue);
      }
    });
    return proto;
  }
};

libraries = Object.create(proto);
_.merge(libraries, {
  object: new PObject(),
  builtIn: new BuiltIn(),
  window: new Window(),
  // popular
  angular: new Angular(),
  // mine
  // t3: new Generic({ global: 't3' }),
  // huge
  three: new Generic({
    global: 'THREE',
    rendereachtime: true
  })
});

// console.log(libraries);

// win max level initially is 0
// libraries.win.preRender = function () {
//   libraries.win.getObjects().empty();
//   libraries.win.analyzeObjects([window], 0);
// };

// console.log(builtIn.getObjects());
// console.log(win.getObjects());
// console.log(user.getObjects());

module.exports = libraries;
},{"./analyzer/Angular":6,"./analyzer/BuiltIn":7,"./analyzer/GenericAnalyzer":8,"./analyzer/Object":9,"./analyzer/Window":10,"lodash":"K2RcUv"}],6:[function(_dereq_,module,exports){
'use strict';

var GenericAnalyzer = _dereq_('./GenericAnalyzer'),
  hashKey = _dereq_('../util/hashKey');

function Angular() {
  GenericAnalyzer.call(this, {
    global: 'angular',
    displayname: 'AngularJS',
    rendereachtime: true
  });

  this.services = [
    '$animate',
    '$cacheFactory',
    '$compile',
    '$controller',
    // '$document',
    '$exceptionHandler',
    '$filter',
    '$http',
    '$httpBackend',
    '$interpolate',
    '$interval',
    '$locale',
    '$log',
    '$parse',
    '$q',
    '$rootScope',
    '$sce',
    '$sceDelegate',
    '$templateCache',
    '$timeout',
    // '$window'
  ].map(function (v) {
    return { checked: true, name: v };
  });
}

Angular.prototype = Object.create(GenericAnalyzer.prototype);

Angular.prototype.getSelectedServices = function () {
  var me = this,
    toAnalyze = [];

  window.angular.module('app', ['ng']);
  this.injector = window.angular.injector(['app']);

  me.services.forEach(function (s) {
    if (s.checked) {
      var obj = me.injector.get(s.name);
      hashKey.createHashKeysFor(obj, s.name);
      toAnalyze.push(obj);
    }
  });
  return toAnalyze;
};

Angular.prototype.inspectSelf = function () {
  console.log('inspecting angular');
  hashKey.createHashKeysFor(window.angular, 'angular');
  this.analyzer.getObjects().empty();
  this.analyzer.add(
    [window.angular].concat(this.getSelectedServices())
  );
};

module.exports = Angular;
},{"../util/hashKey":13,"./GenericAnalyzer":8}],7:[function(_dereq_,module,exports){
'use strict';

var GenericAnalyzer = _dereq_('./GenericAnalyzer'),
  utils = _dereq_('../util');

var toInspect = [
  Object, Function,
  Array, Date, Boolean, Number, Math, String, RegExp, JSON,
  Error
];

function BuiltIn() {
  GenericAnalyzer.call(this);
}

BuiltIn.prototype = Object.create(GenericAnalyzer.prototype);

BuiltIn.prototype.inspectSelf = function () {
  console.log('inspecting builtIn objects');
  this.analyzer.add(this.getObjects());
};

BuiltIn.prototype.getObjects = function () {
  return toInspect;
};

BuiltIn.prototype.showSearch = function (nodeName, nodeProperty) {
  var url = 'https://developer.mozilla.org/en-US/search?' +
    utils.toQueryString({
      q: encodeURIComponent(nodeName + ' ' + nodeProperty),
    });
  window.open(url);
};

module.exports = BuiltIn;
},{"../util":14,"./GenericAnalyzer":8}],8:[function(_dereq_,module,exports){
'use strict';

var Q = _dereq_('q'),
  _ = _dereq_('lodash'),
  utils = _dereq_('../util/'),
  hashKey = _dereq_('../util/hashKey'),
  analyzer = _dereq_('../ObjectAnalyzer');

var searchEngine = 'https://duckduckgo.com/?q=';

function GenericAnalyzer(options) {
  options = options || {};
  // if (!name) {
  //   throw 'name needs to be defined';
  // }
  this.global = options.global;
  this.displayname = options.displayname;
  this.levels = options.hasOwnProperty('levels') ? options.levels : 10;
  this.forbidden = options.forbidden || [];
  this.src = options.src;
  this._hasfc = options.hasOwnProperty('functionconstructors');
  this.functionconstructors = this._hasfc ?
    options.functionconstructors : GenericAnalyzer.SHOW_FUNCTION_CONSTRUCTORS;
  this.rendereachtime = options.hasOwnProperty('rendereachtime') ?
    options.rendereachtime : false;
  this.allfunctions = options.hasOwnProperty('allfunctions') ?
    options.allfunctions : false;

  this.inspected = false;

  // parse forbid string to array
  this.parse();

  this.analyzer = analyzer({
    functionConstructors: this.functionconstructors,
    allFunctions: this.allfunctions
  });
}

GenericAnalyzer.SHOW_BUILTIN = false;
GenericAnalyzer.SHOW_FUNCTION_CONSTRUCTORS = true;
GenericAnalyzer.FORBIDDEN = 'pojoviz:window,pojoviz:builtIn,document';

GenericAnalyzer.prototype.init = function () {
  var me = this;
  console.log('%cPojoViz', 'font-size: 15px; color: ');
  return me.fetch()
    .then(function () {
      if (me.rendereachtime || !me.inspected) {
        me.inspect();
      }
      return me;
    });
};

GenericAnalyzer.prototype.parse = function () {
  if (typeof this.forbidden === 'string') {
    this.forbidden = this.forbidden.split(',');
  }
  if (typeof this.functionconstructors === 'string') {
    this.functionconstructors = this.functionconstructors === 'true';
  }
  if (typeof this.rendereachtime === 'string') {
    this.rendereachtime = this.rendereachtime === 'true';
  }
  if (typeof this.allfunctions === 'string') {
    this.allfunctions = this.allfunctions === 'true';
  }
};

GenericAnalyzer.prototype.markDirty = function () {
  this.inspected = false;
};

GenericAnalyzer.prototype.inspectSelf = function () {
  console.log('analyzing window.' + this.global);
  var me = this,
    analyzer = this.analyzer,
    forbidden = [].concat(this.forbidden);
  // set a predefied global
  hashKey.createHashKeysFor(window[this.global], this.global);
  // clean
  analyzer.getObjects().empty();
  analyzer.forbidden.empty();
  analyzer.setLevels(this.levels);

  // settings > show links to built in objects
  if (!GenericAnalyzer.SHOW_BUILTIN) {
    forbidden = forbidden.concat(
      GenericAnalyzer.FORBIDDEN.split(',')
    );
  }

  forbidden.forEach(function(f) {
    var arr,
      tokens;
    if (!f.indexOf('pojoviz:')) {
      tokens = f.split(':');
      arr = _dereq_('../ObjectHashes')[tokens[1]].getObjects();
    } else {
      arr = [window[f]];
    }
    console.log('forbidding: ', arr);
    analyzer.forbid(arr, true);
  });

  analyzer.add([window[this.global]]);

};

GenericAnalyzer.prototype.markInspected = function () {
  // mark this container as inspected
  this.inspected = true;
  return this;
};

GenericAnalyzer.prototype.inspect = function () {
  this
    .markInspected()
    .inspectSelf();
};

GenericAnalyzer.prototype.preRender = function () {
};

GenericAnalyzer.prototype.fetch = function () {
  var me = this,
    script;

  function getValue() {
    return window[me.global];
  }

  function promisify(v) {
    return function () {
      utils.notification('fetching script ' + v, true);
      var deferred = Q.defer();
      script = document.createElement('script');
      script.src = v;
      script.onload = function () {
        utils.notification('completed script ' + v, true);
        deferred.resolve(getValue());
      };
      document.head.appendChild(script);
      return deferred.promise;
    };
  }

  if (this.src) {
    if (getValue()) {
      console.log('resource already fetched ' + this.src);
    } else {
      var srcs = this.src.split('|');
      return srcs.reduce(function (prev, current) {
        return prev.then(promisify(current));
      }, Q('reduce'));
    }
  }

  return Q(true);
};

GenericAnalyzer.prototype.showSearch = function (nodeName, nodeProperty) {
  var me = this;
  window.open(
    _.template('${searchEngine}${lucky}${libraryName} ${nodeName} ${nodeProperty}', {
      searchEngine: searchEngine,
      lucky: GenericAnalyzer.lucky ? '!ducky' : '',
      libraryName: me.displayname || me.global,
      nodeName: nodeName,
      nodeProperty: nodeProperty
    })
  );
};

module.exports = GenericAnalyzer;
},{"../ObjectAnalyzer":4,"../ObjectHashes":5,"../util/":14,"../util/hashKey":13,"lodash":"K2RcUv","q":"qLuPo1"}],9:[function(_dereq_,module,exports){
'use strict';

var GenericAnalyzer = _dereq_('./GenericAnalyzer'),
  utils = _dereq_('../util');

function PObject() {
  GenericAnalyzer.call(this);
}

PObject.prototype = Object.create(GenericAnalyzer.prototype);

PObject.prototype.inspectSelf = function () {
  console.log('inspecting Object objects');
  this.analyzer.add(this.getObjects());
};

PObject.prototype.getObjects = function () {
  return [Object];
};

module.exports = PObject;
},{"../util":14,"./GenericAnalyzer":8}],10:[function(_dereq_,module,exports){
'use strict';

var _ = _dereq_('lodash'),
  hashKey = _dereq_('../util/hashKey'),
  GenericAnalyzer = _dereq_('./GenericAnalyzer');

var toInspect = [window];

function Window() {
  GenericAnalyzer.call(this, {
    levels: 1,
    rendereachtime: true,
    functionconstructors: false
  });
}

Window.prototype = Object.create(GenericAnalyzer.prototype);

Window.prototype.getObjects = function () {
  return toInspect;
};

Window.prototype.inspectSelf = function () {
  console.log('inspecting window');
  var me = this,
    hashes = _dereq_('../ObjectHashes');

  _.forOwn(hashes, function (v, k) {
    if (v.global && window[v.global]) {
      me.analyzer.forbid([window[v.global]], true);
    }
  });
  this.analyzer.getObjects().empty();
  this.analyzer.setLevels(this.levels);
  this.analyzer.add(me.getObjects());
};

module.exports = Window;
},{"../ObjectHashes":5,"../util/hashKey":13,"./GenericAnalyzer":8,"lodash":"K2RcUv"}],11:[function(_dereq_,module,exports){
var _ = _dereq_('lodash'),
  Q = _dereq_('q'),
  dagre = _dereq_('dagre'),
  utils = _dereq_('./util/'),
  ObjectHashes = _dereq_('./ObjectHashes');

// enable long stacks
Q.longStackSupport = true;

var container,
  oldContainer,
  oldRenderer,
  renderer,
  pojoviz;      // namespace

function process() {
  var g = new dagre.Digraph(),
      properties,
      node,
      library = container.analyzer,
      str = library.stringify(),
      libraryNodes = str.nodes,
      libraryEdges = str.edges;

  // create the graph
  // each element of the graph has
  // - label
  // - width
  // - height
  // - properties
  _.forOwn(libraryNodes, function (properties, k) {
    var label = k.match(/\S*?-(.*)/)[1];
    // console.log(k, label.length);
    node = {
      label: k,
      width: label.length * 10
    };
    // lines + header + padding bottom
    node.height = properties.length * 15 + 50;
    node.properties = properties;
    properties.forEach(function (v) {
      node.width = Math.max(node.width, v.name.length * 10);
    });
    g.addNode(k, node);
  });

  // build the edges from node to node
  _.forOwn(libraryEdges, function (links) {
    links.forEach(function (link) {
      if (g.hasNode(link.from) && g.hasNode(link.to)) {
        g.addEdge(null, link.from, link.to);
      }
    });
  });

  // layout of the graph
  var layout = dagre.layout()
    .nodeSep(30)
    // .rankSep(70)
    // .rankDir('TB')
    .run(g);

  var nodes = [],
      edges = [],
      center = {x: 0, y: 0},
      mn = {x: Infinity, y: Infinity},
      mx = {x: -Infinity, y: -Infinity},
      total = g.nodes().length;

  // update the node info of the node adding:
  // - x
  // - y
  // - predecessors
  // - successors
  layout.eachNode(function (k, layoutInfo) {
    var x = layoutInfo.x;
    var y = layoutInfo.y;

    node = g.node(k);
    node.x = x;
    node.y = y;
    node.predecessors = g.predecessors(k);
    node.successors = g.successors(k);
    nodes.push(node);

    // calculate the bbox of the graph to center the graph
    var mnx = x - node.width / 2;
    var mny = y - node.height / 2;
    var mxx = x + node.width / 2;
    var mxy = y + node.height / 2;

    center.x += x;
    center.y += y;
    mn.x = Math.min(mn.x, mnx);
    mn.y = Math.min(mn.y, mny);
    // console.log(x, y, ' dim ', node.width, node.height);
    mx.x = Math.max(mx.x, mxx);
    mx.y = Math.max(mx.y, mxy);
  });

  center.x /= (total || 1);
  center.y /= (total || 1);

  // create the edges from property to node
  _(libraryEdges).forOwn(function (links) {
    links.forEach(function (link) {
      if (g.hasNode(link.from) && g.hasNode(link.to)) {
        edges.push(link);
      }
    });
  });

  return {
    edges: edges,
    nodes: nodes,
    center: center,
    mn: mn,
    mx: mx
  };
}

// render
function render() {
  var data;

  if (container === oldContainer) {
    return;
  }

  utils.notification('processing ' + container.global);

  // pre render
  oldRenderer && oldRenderer.clean();
  renderer.clean();

  setTimeout(function () {
    container.preRender();
    console.log('process & render start: ', new Date());
    // data has
    // - edges (property -> node)
    // - nodes
    // - center
    //
    console.time('process');
    data = process();
    console.timeEnd('process');

    utils.notification('rendering ' + container.global);

    console.time('render');
    renderer.render(data);
    console.timeEnd('render');

    utils.notification('complete!');
  }, 0);
}

// public api
pojoviz = {
  renderers: {},
  addRenderers: function (newRenderers) {
    _.merge(pojoviz.renderers, newRenderers);
  },
  nullifyContainer: function () {
    oldContainer = container;
    container = null;
  },
  getContainer: function () {
    return container;
  },
  setContainer: function (containerName, options) {
    oldContainer = container;
    container = ObjectHashes[containerName];

    if (!container) {
      container = ObjectHashes.createNew(containerName, options);
    } else {
      // required to fetch external resources
      container.src = options.src;
    }

    return container.init();
  },
  setRenderer: function (r) {
    oldRenderer = renderer;
    renderer = pojoviz.renderers[r];
  },
  getRenderer: function () {
    return renderer;
  },
  render: render,

  // expose inner modules
  ObjectHashes: _dereq_('./ObjectHashes'),
  ObjectAnalyzer: _dereq_('./ObjectAnalyzer'),
  analyzer: {
    GenericAnalyzer: _dereq_('./analyzer/GenericAnalyzer')
  },
  utils: _dereq_('./util'),

  // user vars
  userVariables: []
};

// custom events
document.addEventListener('property-click', function (e) {
  var detail = e.detail;
  pojoviz
    .getContainer()
    .showSearch(detail.name, detail.property);
});

module.exports = pojoviz;
},{"./ObjectAnalyzer":4,"./ObjectHashes":5,"./analyzer/GenericAnalyzer":8,"./util":14,"./util/":14,"dagre":"JWa/F1","lodash":"K2RcUv","q":"qLuPo1"}],12:[function(_dereq_,module,exports){
'use strict';

var hashKey = _dereq_('./hashKey');

function HashMap() {
}

HashMap.prototype = {
  put: function (key, value) {
    this[hashKey(key)] = (value || key);
  },
  get: function (key) {
    return this[hashKey(key)];
  },
  remove: function (key) {
    var v = this[hashKey(key)];
    delete this[hashKey(key)];
    return v;
  },
  empty: function () {
    var p,
        me = this;
    for (p in me) {
      if (me.hasOwnProperty(p)) {
        delete this[p];
      }
    }
  }
};

module.exports = HashMap;
},{"./hashKey":13}],13:[function(_dereq_,module,exports){
'use strict';

var _ = _dereq_('lodash'),
  assert = _dereq_('./').assert,
  me, hashKey;

function isObjectOrFunction(v) {
  return v && (typeof v === 'object' || typeof v === 'function');
}

/**
 * Gets a store hashkey only if it's an object
 * @param  {[type]} obj
 * @return {[type]}
 */
function get(obj) {
  assert(isObjectOrFunction(obj), 'obj must be an object|function');
  return obj.hasOwnProperty &&
    obj.hasOwnProperty(me.hiddenKey) &&
    obj[me.hiddenKey];
}

/**
 * Sets a key on an object
 * @param {[type]} obj [description]
 * @param {[type]} key [description]
 */
function set(obj, key) {
  assert(isObjectOrFunction(obj), 'obj must be an object|function');
  assert(
    key && typeof key === 'string',
    'The key needs to be a valid string'
  );
  if (!get(obj)) {
    Object.defineProperty(obj, me.hiddenKey, {
      value: typeof obj + '-' + key
    });
  }
  return me;
}

me = hashKey = function (v) {
  var value = v,
      uid = v;

  if (isObjectOrFunction(v)) {
    if (!get(v)) {
      me.createHashKeysFor(v);
    }
    uid = get(v);
    if (!uid) {
      console.err('no hashkey :(', v);
    }
    assert(uid, 'error getting the key');
    return uid;
  }

  // v is a primitive
  return typeof v + '-' + uid;
};
me.hiddenKey = '__pojoVizKey__';

me.createHashKeysFor = function (obj, name) {

  function localToString(obj) {
    var match;
    try {
      match = {}.toString.call(obj).match(/^\[object (\S*?)\]/);
    } catch (e) {
      match = false;
    }
    return match && match[1];
  }

  /**
   * Analyze the internal property [[Class]] to guess the name
   * of this object, e.g. [object Date], [object Math]
   * Many object will give false positives (they will match [object Object])
   * so let's consider Object as the name only if it's equal to
   * Object.prototype
   * @param  {Object}  obj
   * @return {Boolean}
   */
  function hasAClassName(obj) {
    var match = localToString(obj);
    if (match === 'Object') {
      return obj === Object.prototype && 'Object';
    }
    return match;
  }

  function getName(obj) {
    var name, className;

    // return the already generated hashKey
    if (get(obj)) {
      return get(obj);
    }

    // generate a new key based on
    // - the name if it's a function
    // - a unique id
    name = typeof obj === 'function' &&
      typeof obj.name === 'string' &&
      obj.name;

    className = hasAClassName(obj);
    if (!name && className) {
      name = className;
    }

    name = name || _.uniqueId();
    return name;
  }

  // the name is equal to the passed name or the
  // generated name
  name = name || getName(obj);
  name = name.replace(/[\. ]/img, '-');

  // if the obj is a prototype then try to analyze
  // the constructor first so that the prototype becomes
  // [name].prototype
  // special case: object.constructor = object
  if (obj.hasOwnProperty &&
      obj.hasOwnProperty('constructor') &&
      typeof obj.constructor === 'function' &&
      obj.constructor !== obj) {
    me.createHashKeysFor(obj.constructor);
  }

  // set name on self
  set(obj, name);

  // set name on the prototype
  if (typeof obj === 'function' &&
      obj.hasOwnProperty('prototype')) {
    set(obj.prototype, name + '-prototype');
  }
};

me.has = function (v) {
  return v.hasOwnProperty &&
    v.hasOwnProperty(me.hiddenKey);
};

module.exports = me;
},{"./":14,"lodash":"K2RcUv"}],14:[function(_dereq_,module,exports){
'use strict';

var _ = _dereq_('lodash');

var propertiesTransformation = {
  '[[Prototype]]': '__proto__'
};

var utils = {
  assert: function (v, message) {
    if (!v) {
      throw message || 'error';
    }
  },
  translate: function (x, y) {
    return 'translate(' + (x || 0) + ', ' + (y || 0) + ')';
  },
  scale: function (s) {
    return 'scale(' + (s || 1) + ')';
  },
  transform: function (obj) {
    var t = [];
    _.forOwn(obj, function (v, k) {
      t.push(utils[k].apply(utils, v));
    });
    return t.join(' ');
  },
  prefixer: function () {
    var args = [].slice.call(arguments);
    args.unshift('pv');
    return args.join('-');
  },
  transformProperty: function (v) {
    if (propertiesTransformation.hasOwnProperty(v)) {
      return propertiesTransformation[v];
    }
    return v;
  },
  escapeCls: function(v) {
    return v.replace(/\$/g, '_');
  },
  toQueryString: function (obj) {
    var s = '',
        i = 0;
    _.forOwn(obj, function (v, k) {
      if (i) {
        s += '&';
      }
      s += k + '=' + v;
      i += 1;
    });
    return s;
  },
  createEvent: function (eventName, details) {
    return new CustomEvent(eventName, {
      detail: details
    });
  },
  notification: function (message, consoleToo) {
    var ev = utils.createEvent('pojoviz-notification', message);
    consoleToo && console.log(message);
    document.dispatchEvent(ev);
  },
  createJsonpCallback: function (url) {
    var script = document.createElement('script');
    script.src = url;
    document.head.appendChild(script);
  }
};

module.exports = utils;
},{"lodash":"K2RcUv"}]},{},[11])
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/mauricio/Documents/web/maurizzzio.me/pojoviz/node_modules/browserify/node_modules/browser-pack/_prelude.js","/Users/mauricio/Documents/web/maurizzzio.me/pojoviz/src/ObjectAnalyzer.js","/Users/mauricio/Documents/web/maurizzzio.me/pojoviz/src/ObjectHashes.js","/Users/mauricio/Documents/web/maurizzzio.me/pojoviz/src/analyzer/Angular.js","/Users/mauricio/Documents/web/maurizzzio.me/pojoviz/src/analyzer/BuiltIn.js","/Users/mauricio/Documents/web/maurizzzio.me/pojoviz/src/analyzer/GenericAnalyzer.js","/Users/mauricio/Documents/web/maurizzzio.me/pojoviz/src/analyzer/Object.js","/Users/mauricio/Documents/web/maurizzzio.me/pojoviz/src/analyzer/Window.js","/Users/mauricio/Documents/web/maurizzzio.me/pojoviz/src/index.js","/Users/mauricio/Documents/web/maurizzzio.me/pojoviz/src/util/HashMap.js","/Users/mauricio/Documents/web/maurizzzio.me/pojoviz/src/util/hashKey.js","/Users/mauricio/Documents/web/maurizzzio.me/pojoviz/src/util/index.js"],"names":[],"mappings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ngBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/KA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error(\"Cannot find module '\"+o+\"'\")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","var HashMap = require('./util/HashMap'),\n  hashKey = require('./util/hashKey'),\n  _ = require('lodash');\n\n// utils\nfunction eachObjectAndPrototype(obj, fn) {\n  fn(obj);\n  if (obj.hasOwnProperty('prototype')) {\n    fn(obj.prototype);\n  }\n}\n\n/**\n * Wraps a function with another\n * @param  {Function} fn\n * @param  {Function}   wrapper\n * @return {*}\n */\nfunction wrapFn(fn, wrapper) {\n  return function () {\n    // NOTE: `this` will be the instance\n    wrapper.call(this);\n    var args = [].slice.call(arguments);\n    return fn.apply(this, args);\n  };\n}\n\nfunction isObjectOrFunction(v) {\n  return !!(v && (typeof v === 'object' ||\n    typeof v === 'function'));\n}\n\n/**\n * Properties forbidden in strict mode\n * @type {Array}\n */\nvar forbiddenInStrictMode = [\n  'callee', 'caller', 'arguments'\n];\n\n/**\n * @constructor\n * Object analyz\n * @param {[type]} config [description]\n */\nfunction Analyzer(config) {\n  if (!(this instanceof Analyzer)) {\n    return new Analyzer(config);\n  }\n  config = config || {};\n\n  /**\n   * Objects registered in this instance\n   * @type {HashMap}\n   */\n  this.objects = config.objects || new HashMap();\n  /**\n   * Forbidden objects\n   * @type {HashMap}\n   */\n  this.forbidden = config.forbidden || new HashMap();\n\n  /**\n   * Cache of properties\n   * @type {Object}\n   */\n  this.__cacheObjects = {};\n\n  /**\n   * Cache of links\n   * @type {Object}\n   */\n  this.__cacheLinks = {};\n\n  /**\n   * Dfs levels\n   * @type {number}\n   */\n  this.levels = Infinity;\n  /**\n   * If the analyzer is dirty then it has some pending work\n   * to do\n   * @type {boolean}\n   */\n  this.dirty = true;\n\n  /**\n   * True to save the properties of the objects analyzed in an\n   * internal cache\n   * @type {Boolean}\n   */\n  this.cache =\n    config.hasOwnProperty('cache') ?\n    config.cache : true;\n  /**\n   * True to include function constructors in the analysis graph\n   * i.e. the functions that have a prototype\n   * @type {boolean}\n   */\n  this.functionConstructors =\n    config.hasOwnProperty('functionConstructors') ?\n    config.functionConstructors : false;\n  /**\n   * True to include all the functions in the analysis graph\n   * @type {boolean}\n   */\n  this.allFunctions =\n    config.hasOwnProperty('allFunctions') ?\n    config.allFunctions : false;\n  /**\n   * True to allow HTML nodes\n   * @type {boolean}\n   */\n  this.htmlNode =\n    config.hasOwnProperty('htmlNode') ?\n    config.htmlNode : false;\n}\n\nAnalyzer.prototype = {\n  constructor: Analyzer,\n\n  /**\n   * Checks if an object is in the forbidden hash\n   * @param  {Object}  obj\n   * @return {boolean}\n   */\n  isForbidden: function (obj) {\n    return this.forbidden.get(obj);\n  },\n\n  isLinkable: function (key, obj) {\n    if (!obj) {\n      return false;\n    }\n\n    var v = typeof obj === 'object';\n\n    // if (v) {\n    //   if (!this.htmlNode && v instanceof Node) { return false; }\n    //   return true;\n    // }\n\n    // if (!this.htmlNode) {\n    //   v = v && !(v instanceof Node);\n    // }fdeq1`\n\n    // typeof obj === 'function' &&\n    //   console.log(Object.getOwnPropertyNames(obj));\n    if (!v && this.allFunctions) {\n      // minimize the nodes created by considering functions\n      // with more properties than the usual ones\n      v = typeof obj === 'function';\n      v = v && Object.getOwnPropertyNames(obj).length > 5;\n    }\n    if (!v && this.functionConstructors) {\n      v = typeof obj === 'function';\n      v = v && (\n        obj.name &&\n        obj.name[0].match(/^[A-Z]/) ||\n        key[0].match(/^[A-Z]/)\n      );\n    }\n    return v;\n  },\n\n  /**\n   * Gets the enumerable properties an object discarding\n   * forbidden ones\n   *\n   * @param  {Object} obj\n   * @return {Array} Array of objects, each object has the following\n   * properties:\n   *\n   * - name\n   * - cls\n   * - type\n   * - linkeable (if it's an object this property is set to true)\n   */\n  getProperties: function (obj, linkableOnly) {\n    var me = this,\n      hk = hashKey(obj),\n      properties;\n\n    if (!obj) {\n      throw 'this method needs an object to analyze';\n    }\n\n    if (this.cache) {\n      if (!linkableOnly && this.__cacheObjects[hk]) {\n        // console.log('objects from cache :)');\n        return this.__cacheObjects[hk];\n      }\n    }\n\n    properties = Object.getOwnPropertyNames(obj);\n\n    function forbiddenKey(v) {\n      // forbidden in strict mode\n      return ~forbiddenInStrictMode.indexOf(v) ||\n        v.match(/^__.*?__$/) ||\n        v.match(/^\\$\\$.*?\\$\\$$/) ||\n        v.match(/[:+~!><=//\\[\\]@\\. ]/);\n    }\n\n    properties = _.filter(properties, function (v) {\n      var good = typeof v === 'string' && !forbiddenKey(v),\n          r;\n      if (linkableOnly) {\n        try {\n          r = good && me.isLinkable(v, obj[v]);\n        } catch (e) {\n          r = false;\n          // uncomment to see why obj[v] is not allowed\n          // console.log(e);\n        } finally {\n          return r;\n        }\n      }\n      return good;\n    }).map(function (v) {\n      var type,\n        linkeable;\n      try {\n        // type = null|string|undefined|number|object\n        type = typeof obj[v];\n        linkeable = isObjectOrFunction(obj[v]);\n      } catch(e) {\n        type = 'undefined';\n        linkeable = false;\n      }\n\n      return {\n        // parent: hashKey(obj),\n        name: v,\n        type: type,\n        linkeable: linkeable\n      };\n    });\n\n    // special properties\n    var proto = Object.getPrototypeOf(obj);\n    if (proto) {\n      properties.push({\n        name: '[[Prototype]]',\n        // cls: hashKey(obj),\n        type: 'object',\n        linkeable: true,\n        hidden: true\n      });\n    }\n    var constructor = obj.hasOwnProperty &&\n      obj.hasOwnProperty('constructor') &&\n      typeof obj.constructor === 'function';\n    if (constructor &&\n        _.findIndex(properties, { name: 'constructor' }) === -1) {\n      properties.push({\n        // cls: hashKey(obj),\n        name: 'constructor',\n        type: 'function',\n        linkeable: true\n      });\n    }\n\n    if (this.cache && !linkableOnly) {\n      this.__cacheObjects[hk] = properties;\n    }\n\n    // console.log(properties);\n    return properties;\n  },\n\n  /**\n   * Analyzes a list of objects recursively\n   * @param  {Array} objects      Array of objects\n   * @param  {number} currentLevel Current dfs level\n   */\n  analyzeObjects: function (objects, currentLevel) {\n    var me = this;\n    objects.forEach(function (v) {\n      if (currentLevel <= me.levels &&    // dfs level\n          !me.objects.get(v) &&         // already registered\n          !me.isForbidden(v)              // forbidden check\n          ) {\n\n        // add to the registered object pool\n        me.objects.put(v);\n\n        // dfs to the next level\n        me.analyzeObjects(\n          me.getOwnLinks(v).map(function (link) {\n            return link.to;\n          }),\n          currentLevel + 1\n        );\n      }\n    });\n  },\n\n  /**\n   * Returns a list of links, each link is an object which has the\n   * following properties:\n   *\n   * - from\n   * - to\n   * - property (string)\n   *\n   * @param  {Object} obj\n   * @return {Array}\n   */\n  getOwnLinks: function (obj) {\n    var me = this,\n        links = [],\n        properties,\n        name = hashKey(obj);\n\n    if (this.__cacheLinks[name]) {\n      // console.log('links from cache :)');\n      return this.__cacheLinks[name];\n    }\n\n    properties = me.getProperties(obj, true);\n\n    function getAugmentedHash(obj, name) {\n      if (!hashKey.has(obj) &&\n          name !== 'prototype' &&\n          name !== 'constructor') {\n        hashKey.createHashKeysFor(obj, name);\n      }\n      return hashKey(obj);\n    }\n\n    if (!name) {\n      throw 'the object needs to have a hashkey';\n    }\n\n    _.forEach(properties, function (v) {\n      var ref = obj[v.name];\n      // because of the levels a reference might not exist\n      if (!ref) {\n        return;\n      }\n\n      // if the object doesn't have a hashkey\n      // let's give it a name equal to the property\n      // being analyzed\n      getAugmentedHash(ref, v.name);\n\n      if (!me.isForbidden(ref)) {\n        links.push({\n          from: obj,\n          fromHash: hashKey(obj),\n          to: ref,\n          toHash: hashKey(ref),\n          property: v.name\n        });\n      }\n    });\n\n    var proto = Object.getPrototypeOf(obj);\n    if (proto && !me.isForbidden(proto)) {\n      links.push({\n        from: obj,\n        fromHash: hashKey(obj),\n        to: proto,\n        toHash: hashKey(proto),\n        property: '[[Prototype]]'\n      });\n    }\n\n    if (this.cache) {\n      this.__cacheLinks[name] = links;\n    }\n\n    return links;\n  },\n\n  makeDirty: function () {\n    this.dirty = true;\n  },\n\n  setLevels: function (l) {\n    this.levels = l;\n  },\n\n  setDirty: function (d) {\n    this.dirty = d;\n  },\n\n  setFunctionConstructors: function (v) {\n    this.functionConstructors = v;\n  },\n\n  getObjects: function () {\n    return this.objects;\n  },\n\n  /**\n   * Stringifies an object properties\n   * @param  obj\n   * @param  toString\n   * @return {Array}\n   */\n  stringifyObjectProperties: function (obj) {\n    return this.getProperties(obj);\n  },\n\n  /**\n   * Returns a representation of the links of\n   * an object\n   * @return {Array}\n   */\n  stringifyObjectLinks: function (obj) {\n    var me = this;\n    return me.getOwnLinks(obj).map(function (link) {\n      // discarded: from, to\n      return {\n        from: link.fromHash,\n        to: link.toHash,\n        property: link.property\n      };\n    });\n  },\n\n  /**\n   * Stringifies the objects saved in this analyzer\n   * @return {Object}\n   */\n  stringify: function () {\n    var me = this,\n      nodes = {},\n      edges = {};\n    console.time('stringify');\n    _(this.objects).forOwn(function (v) {\n      nodes[hashKey(v)] = me.stringifyObjectProperties(v);\n      edges[hashKey(v)] = me.stringifyObjectLinks(v);\n    });\n    console.timeEnd('stringify');\n    return {\n      nodes: nodes,\n      edges: edges\n    };\n  }\n};\n\n// aditional objects that need the prototype to exist\nvar aProto = Analyzer.prototype;\n_.merge(aProto, {\n\n  /**\n   * Adds a list of objects to analyze and make the analyzer dirty\n   * @param  {Array<Objects>} objects\n   * @return {this}\n   */\n  add: wrapFn(function (objects) {\n    console.time('analyze');\n    this.analyzeObjects(objects, 0);\n    console.timeEnd('analyze');\n    return this;\n  }, aProto.makeDirty),\n\n  /**\n   * Removes a list of objects, if `withPrototype` is true then\n   * also the prototype is removed\n   * @param  {Array<Objects>} objects\n   * @param  {boolean} withPrototype\n   * @return {this}\n   */\n  remove: wrapFn(function (objects, withPrototype) {\n    var me = this;\n    objects.forEach(function (obj) {\n      me.objects.remove(obj);\n      if (withPrototype && obj.hasOwnProperty('prototype')) {\n        me.objects.remove(obj.prototype);\n      }\n    });\n    return me;\n  }, aProto.makeDirty),\n\n  /**\n   * Forbids a list of objects, if `withPrototype` is true then\n   * also the prototype is forbidden\n   * @param  {Array<Objects>} objects\n   * @param  {boolean} withPrototype\n   * @return {this}\n   */\n  forbid: wrapFn(function (objects, withPrototype) {\n    var me = this;\n    me.remove(objects, withPrototype);\n    objects.forEach(function (obj) {\n      me.forbidden.put(obj);\n      if (withPrototype && obj.hasOwnProperty('prototype')) {\n        me.forbidden.put(obj.prototype);\n      }\n    });\n  }, aProto.makeDirty),\n\n  /**\n   * Unforbids a list of objects, if `withPrototype` is true then\n   * also the prototype is unforbidden\n   * @param  {Array<Objects>} objects\n   * @param  {boolean} withPrototype\n   * @return {this}\n   */\n  unforbid: wrapFn(function (objects, withPrototype) {\n    var me = this;\n    objects.forEach(function (obj) {\n      me.forbidden.remove(obj);\n      if (withPrototype && obj.hasOwnProperty('prototype')) {\n        me.forbidden.remove(obj.prototype);\n      }\n    });\n  }, aProto.makeDirty)\n});\n\nmodule.exports = Analyzer;\n","'use strict';\n\nvar _ = require('lodash'),\n  Generic = require('./analyzer/GenericAnalyzer'),\n  Angular = require('./analyzer/Angular'),\n  Window = require('./analyzer/Window'),\n  PObject = require('./analyzer/Object'),\n  BuiltIn = require('./analyzer/BuiltIn');\n\nvar libraries;\n\nvar proto = {\n  createNew: function (global, options) {\n    console.log('creating a generic container for: ' + global, options);\n    return (libraries[global] = new Generic(options));\n  },\n  all: function (fn) {\n    _.forOwn(libraries, fn);\n  },\n  markDirty: function () {\n    proto.all(function (v) {\n      v.markDirty();\n    });\n    return proto;\n  },\n  setFunctionConstructors: function (newValue) {\n    proto.all(function (v) {\n      // this only works on the generic analyzers\n      if (!v._hasfc) {\n        v.analyzer.setFunctionConstructors(newValue);\n      }\n    });\n    return proto;\n  }\n};\n\nlibraries = Object.create(proto);\n_.merge(libraries, {\n  object: new PObject(),\n  builtIn: new BuiltIn(),\n  window: new Window(),\n  // popular\n  angular: new Angular(),\n  // mine\n  // t3: new Generic({ global: 't3' }),\n  // huge\n  three: new Generic({\n    global: 'THREE',\n    rendereachtime: true\n  })\n});\n\n// console.log(libraries);\n\n// win max level initially is 0\n// libraries.win.preRender = function () {\n//   libraries.win.getObjects().empty();\n//   libraries.win.analyzeObjects([window], 0);\n// };\n\n// console.log(builtIn.getObjects());\n// console.log(win.getObjects());\n// console.log(user.getObjects());\n\nmodule.exports = libraries;","'use strict';\n\nvar GenericAnalyzer = require('./GenericAnalyzer'),\n  hashKey = require('../util/hashKey');\n\nfunction Angular() {\n  GenericAnalyzer.call(this, {\n    global: 'angular',\n    displayname: 'AngularJS',\n    rendereachtime: true\n  });\n\n  this.services = [\n    '$animate',\n    '$cacheFactory',\n    '$compile',\n    '$controller',\n    // '$document',\n    '$exceptionHandler',\n    '$filter',\n    '$http',\n    '$httpBackend',\n    '$interpolate',\n    '$interval',\n    '$locale',\n    '$log',\n    '$parse',\n    '$q',\n    '$rootScope',\n    '$sce',\n    '$sceDelegate',\n    '$templateCache',\n    '$timeout',\n    // '$window'\n  ].map(function (v) {\n    return { checked: true, name: v };\n  });\n}\n\nAngular.prototype = Object.create(GenericAnalyzer.prototype);\n\nAngular.prototype.getSelectedServices = function () {\n  var me = this,\n    toAnalyze = [];\n\n  window.angular.module('app', ['ng']);\n  this.injector = window.angular.injector(['app']);\n\n  me.services.forEach(function (s) {\n    if (s.checked) {\n      var obj = me.injector.get(s.name);\n      hashKey.createHashKeysFor(obj, s.name);\n      toAnalyze.push(obj);\n    }\n  });\n  return toAnalyze;\n};\n\nAngular.prototype.inspectSelf = function () {\n  console.log('inspecting angular');\n  hashKey.createHashKeysFor(window.angular, 'angular');\n  this.analyzer.getObjects().empty();\n  this.analyzer.add(\n    [window.angular].concat(this.getSelectedServices())\n  );\n};\n\nmodule.exports = Angular;","'use strict';\n\nvar GenericAnalyzer = require('./GenericAnalyzer'),\n  utils = require('../util');\n\nvar toInspect = [\n  Object, Function,\n  Array, Date, Boolean, Number, Math, String, RegExp, JSON,\n  Error\n];\n\nfunction BuiltIn() {\n  GenericAnalyzer.call(this);\n}\n\nBuiltIn.prototype = Object.create(GenericAnalyzer.prototype);\n\nBuiltIn.prototype.inspectSelf = function () {\n  console.log('inspecting builtIn objects');\n  this.analyzer.add(this.getObjects());\n};\n\nBuiltIn.prototype.getObjects = function () {\n  return toInspect;\n};\n\nBuiltIn.prototype.showSearch = function (nodeName, nodeProperty) {\n  var url = 'https://developer.mozilla.org/en-US/search?' +\n    utils.toQueryString({\n      q: encodeURIComponent(nodeName + ' ' + nodeProperty),\n    });\n  window.open(url);\n};\n\nmodule.exports = BuiltIn;","'use strict';\n\nvar Q = require('q'),\n  _ = require('lodash'),\n  utils = require('../util/'),\n  hashKey = require('../util/hashKey'),\n  analyzer = require('../ObjectAnalyzer');\n\nvar searchEngine = 'https://duckduckgo.com/?q=';\n\nfunction GenericAnalyzer(options) {\n  options = options || {};\n  // if (!name) {\n  //   throw 'name needs to be defined';\n  // }\n  this.global = options.global;\n  this.displayname = options.displayname;\n  this.levels = options.hasOwnProperty('levels') ? options.levels : 10;\n  this.forbidden = options.forbidden || [];\n  this.src = options.src;\n  this._hasfc = options.hasOwnProperty('functionconstructors');\n  this.functionconstructors = this._hasfc ?\n    options.functionconstructors : GenericAnalyzer.SHOW_FUNCTION_CONSTRUCTORS;\n  this.rendereachtime = options.hasOwnProperty('rendereachtime') ?\n    options.rendereachtime : false;\n  this.allfunctions = options.hasOwnProperty('allfunctions') ?\n    options.allfunctions : false;\n\n  this.inspected = false;\n\n  // parse forbid string to array\n  this.parse();\n\n  this.analyzer = analyzer({\n    functionConstructors: this.functionconstructors,\n    allFunctions: this.allfunctions\n  });\n}\n\nGenericAnalyzer.SHOW_BUILTIN = false;\nGenericAnalyzer.SHOW_FUNCTION_CONSTRUCTORS = true;\nGenericAnalyzer.FORBIDDEN = 'pojoviz:window,pojoviz:builtIn,document';\n\nGenericAnalyzer.prototype.init = function () {\n  var me = this;\n  console.log('%cPojoViz', 'font-size: 15px; color: ');\n  return me.fetch()\n    .then(function () {\n      if (me.rendereachtime || !me.inspected) {\n        me.inspect();\n      }\n      return me;\n    });\n};\n\nGenericAnalyzer.prototype.parse = function () {\n  if (typeof this.forbidden === 'string') {\n    this.forbidden = this.forbidden.split(',');\n  }\n  if (typeof this.functionconstructors === 'string') {\n    this.functionconstructors = this.functionconstructors === 'true';\n  }\n  if (typeof this.rendereachtime === 'string') {\n    this.rendereachtime = this.rendereachtime === 'true';\n  }\n  if (typeof this.allfunctions === 'string') {\n    this.allfunctions = this.allfunctions === 'true';\n  }\n};\n\nGenericAnalyzer.prototype.markDirty = function () {\n  this.inspected = false;\n};\n\nGenericAnalyzer.prototype.inspectSelf = function () {\n  console.log('analyzing window.' + this.global);\n  var me = this,\n    analyzer = this.analyzer,\n    forbidden = [].concat(this.forbidden);\n  // set a predefied global\n  hashKey.createHashKeysFor(window[this.global], this.global);\n  // clean\n  analyzer.getObjects().empty();\n  analyzer.forbidden.empty();\n  analyzer.setLevels(this.levels);\n\n  // settings > show links to built in objects\n  if (!GenericAnalyzer.SHOW_BUILTIN) {\n    forbidden = forbidden.concat(\n      GenericAnalyzer.FORBIDDEN.split(',')\n    );\n  }\n\n  forbidden.forEach(function(f) {\n    var arr,\n      tokens;\n    if (!f.indexOf('pojoviz:')) {\n      tokens = f.split(':');\n      arr = require('../ObjectHashes')[tokens[1]].getObjects();\n    } else {\n      arr = [window[f]];\n    }\n    console.log('forbidding: ', arr);\n    analyzer.forbid(arr, true);\n  });\n\n  analyzer.add([window[this.global]]);\n\n};\n\nGenericAnalyzer.prototype.markInspected = function () {\n  // mark this container as inspected\n  this.inspected = true;\n  return this;\n};\n\nGenericAnalyzer.prototype.inspect = function () {\n  this\n    .markInspected()\n    .inspectSelf();\n};\n\nGenericAnalyzer.prototype.preRender = function () {\n};\n\nGenericAnalyzer.prototype.fetch = function () {\n  var me = this,\n    script;\n\n  function getValue() {\n    return window[me.global];\n  }\n\n  function promisify(v) {\n    return function () {\n      utils.notification('fetching script ' + v, true);\n      var deferred = Q.defer();\n      script = document.createElement('script');\n      script.src = v;\n      script.onload = function () {\n        utils.notification('completed script ' + v, true);\n        deferred.resolve(getValue());\n      };\n      document.head.appendChild(script);\n      return deferred.promise;\n    };\n  }\n\n  if (this.src) {\n    if (getValue()) {\n      console.log('resource already fetched ' + this.src);\n    } else {\n      var srcs = this.src.split('|');\n      return srcs.reduce(function (prev, current) {\n        return prev.then(promisify(current));\n      }, Q('reduce'));\n    }\n  }\n\n  return Q(true);\n};\n\nGenericAnalyzer.prototype.showSearch = function (nodeName, nodeProperty) {\n  var me = this;\n  window.open(\n    _.template('${searchEngine}${lucky}${libraryName} ${nodeName} ${nodeProperty}', {\n      searchEngine: searchEngine,\n      lucky: GenericAnalyzer.lucky ? '!ducky' : '',\n      libraryName: me.displayname || me.global,\n      nodeName: nodeName,\n      nodeProperty: nodeProperty\n    })\n  );\n};\n\nmodule.exports = GenericAnalyzer;","'use strict';\n\nvar GenericAnalyzer = require('./GenericAnalyzer'),\n  utils = require('../util');\n\nfunction PObject() {\n  GenericAnalyzer.call(this);\n}\n\nPObject.prototype = Object.create(GenericAnalyzer.prototype);\n\nPObject.prototype.inspectSelf = function () {\n  console.log('inspecting Object objects');\n  this.analyzer.add(this.getObjects());\n};\n\nPObject.prototype.getObjects = function () {\n  return [Object];\n};\n\nmodule.exports = PObject;","'use strict';\n\nvar _ = require('lodash'),\n  hashKey = require('../util/hashKey'),\n  GenericAnalyzer = require('./GenericAnalyzer');\n\nvar toInspect = [window];\n\nfunction Window() {\n  GenericAnalyzer.call(this, {\n    levels: 1,\n    rendereachtime: true,\n    functionconstructors: false\n  });\n}\n\nWindow.prototype = Object.create(GenericAnalyzer.prototype);\n\nWindow.prototype.getObjects = function () {\n  return toInspect;\n};\n\nWindow.prototype.inspectSelf = function () {\n  console.log('inspecting window');\n  var me = this,\n    hashes = require('../ObjectHashes');\n\n  _.forOwn(hashes, function (v, k) {\n    if (v.global && window[v.global]) {\n      me.analyzer.forbid([window[v.global]], true);\n    }\n  });\n  this.analyzer.getObjects().empty();\n  this.analyzer.setLevels(this.levels);\n  this.analyzer.add(me.getObjects());\n};\n\nmodule.exports = Window;","var _ = require('lodash'),\n  Q = require('q'),\n  dagre = require('dagre'),\n  utils = require('./util/'),\n  ObjectHashes = require('./ObjectHashes');\n\n// enable long stacks\nQ.longStackSupport = true;\n\nvar container,\n  oldContainer,\n  oldRenderer,\n  renderer,\n  pojoviz;      // namespace\n\nfunction process() {\n  var g = new dagre.Digraph(),\n      properties,\n      node,\n      library = container.analyzer,\n      str = library.stringify(),\n      libraryNodes = str.nodes,\n      libraryEdges = str.edges;\n\n  // create the graph\n  // each element of the graph has\n  // - label\n  // - width\n  // - height\n  // - properties\n  _.forOwn(libraryNodes, function (properties, k) {\n    var label = k.match(/\\S*?-(.*)/)[1];\n    // console.log(k, label.length);\n    node = {\n      label: k,\n      width: label.length * 10\n    };\n    // lines + header + padding bottom\n    node.height = properties.length * 15 + 50;\n    node.properties = properties;\n    properties.forEach(function (v) {\n      node.width = Math.max(node.width, v.name.length * 10);\n    });\n    g.addNode(k, node);\n  });\n\n  // build the edges from node to node\n  _.forOwn(libraryEdges, function (links) {\n    links.forEach(function (link) {\n      if (g.hasNode(link.from) && g.hasNode(link.to)) {\n        g.addEdge(null, link.from, link.to);\n      }\n    });\n  });\n\n  // layout of the graph\n  var layout = dagre.layout()\n    .nodeSep(30)\n    // .rankSep(70)\n    // .rankDir('TB')\n    .run(g);\n\n  var nodes = [],\n      edges = [],\n      center = {x: 0, y: 0},\n      mn = {x: Infinity, y: Infinity},\n      mx = {x: -Infinity, y: -Infinity},\n      total = g.nodes().length;\n\n  // update the node info of the node adding:\n  // - x\n  // - y\n  // - predecessors\n  // - successors\n  layout.eachNode(function (k, layoutInfo) {\n    var x = layoutInfo.x;\n    var y = layoutInfo.y;\n\n    node = g.node(k);\n    node.x = x;\n    node.y = y;\n    node.predecessors = g.predecessors(k);\n    node.successors = g.successors(k);\n    nodes.push(node);\n\n    // calculate the bbox of the graph to center the graph\n    var mnx = x - node.width / 2;\n    var mny = y - node.height / 2;\n    var mxx = x + node.width / 2;\n    var mxy = y + node.height / 2;\n\n    center.x += x;\n    center.y += y;\n    mn.x = Math.min(mn.x, mnx);\n    mn.y = Math.min(mn.y, mny);\n    // console.log(x, y, ' dim ', node.width, node.height);\n    mx.x = Math.max(mx.x, mxx);\n    mx.y = Math.max(mx.y, mxy);\n  });\n\n  center.x /= (total || 1);\n  center.y /= (total || 1);\n\n  // create the edges from property to node\n  _(libraryEdges).forOwn(function (links) {\n    links.forEach(function (link) {\n      if (g.hasNode(link.from) && g.hasNode(link.to)) {\n        edges.push(link);\n      }\n    });\n  });\n\n  return {\n    edges: edges,\n    nodes: nodes,\n    center: center,\n    mn: mn,\n    mx: mx\n  };\n}\n\n// render\nfunction render() {\n  var data;\n\n  if (container === oldContainer) {\n    return;\n  }\n\n  utils.notification('processing ' + container.global);\n\n  // pre render\n  oldRenderer && oldRenderer.clean();\n  renderer.clean();\n\n  setTimeout(function () {\n    container.preRender();\n    console.log('process & render start: ', new Date());\n    // data has\n    // - edges (property -> node)\n    // - nodes\n    // - center\n    //\n    console.time('process');\n    data = process();\n    console.timeEnd('process');\n\n    utils.notification('rendering ' + container.global);\n\n    console.time('render');\n    renderer.render(data);\n    console.timeEnd('render');\n\n    utils.notification('complete!');\n  }, 0);\n}\n\n// public api\npojoviz = {\n  renderers: {},\n  addRenderers: function (newRenderers) {\n    _.merge(pojoviz.renderers, newRenderers);\n  },\n  nullifyContainer: function () {\n    oldContainer = container;\n    container = null;\n  },\n  getContainer: function () {\n    return container;\n  },\n  setContainer: function (containerName, options) {\n    oldContainer = container;\n    container = ObjectHashes[containerName];\n\n    if (!container) {\n      container = ObjectHashes.createNew(containerName, options);\n    } else {\n      // required to fetch external resources\n      container.src = options.src;\n    }\n\n    return container.init();\n  },\n  setRenderer: function (r) {\n    oldRenderer = renderer;\n    renderer = pojoviz.renderers[r];\n  },\n  getRenderer: function () {\n    return renderer;\n  },\n  render: render,\n\n  // expose inner modules\n  ObjectHashes: require('./ObjectHashes'),\n  ObjectAnalyzer: require('./ObjectAnalyzer'),\n  analyzer: {\n    GenericAnalyzer: require('./analyzer/GenericAnalyzer')\n  },\n  utils: require('./util'),\n\n  // user vars\n  userVariables: []\n};\n\n// custom events\ndocument.addEventListener('property-click', function (e) {\n  var detail = e.detail;\n  pojoviz\n    .getContainer()\n    .showSearch(detail.name, detail.property);\n});\n\nmodule.exports = pojoviz;","'use strict';\n\nvar hashKey = require('./hashKey');\n\nfunction HashMap() {\n}\n\nHashMap.prototype = {\n  put: function (key, value) {\n    this[hashKey(key)] = (value || key);\n  },\n  get: function (key) {\n    return this[hashKey(key)];\n  },\n  remove: function (key) {\n    var v = this[hashKey(key)];\n    delete this[hashKey(key)];\n    return v;\n  },\n  empty: function () {\n    var p,\n        me = this;\n    for (p in me) {\n      if (me.hasOwnProperty(p)) {\n        delete this[p];\n      }\n    }\n  }\n};\n\nmodule.exports = HashMap;","'use strict';\n\nvar _ = require('lodash'),\n  assert = require('./').assert,\n  me, hashKey;\n\nfunction isObjectOrFunction(v) {\n  return v && (typeof v === 'object' || typeof v === 'function');\n}\n\n/**\n * Gets a store hashkey only if it's an object\n * @param  {[type]} obj\n * @return {[type]}\n */\nfunction get(obj) {\n  assert(isObjectOrFunction(obj), 'obj must be an object|function');\n  return obj.hasOwnProperty &&\n    obj.hasOwnProperty(me.hiddenKey) &&\n    obj[me.hiddenKey];\n}\n\n/**\n * Sets a key on an object\n * @param {[type]} obj [description]\n * @param {[type]} key [description]\n */\nfunction set(obj, key) {\n  assert(isObjectOrFunction(obj), 'obj must be an object|function');\n  assert(\n    key && typeof key === 'string',\n    'The key needs to be a valid string'\n  );\n  if (!get(obj)) {\n    Object.defineProperty(obj, me.hiddenKey, {\n      value: typeof obj + '-' + key\n    });\n  }\n  return me;\n}\n\nme = hashKey = function (v) {\n  var value = v,\n      uid = v;\n\n  if (isObjectOrFunction(v)) {\n    if (!get(v)) {\n      me.createHashKeysFor(v);\n    }\n    uid = get(v);\n    if (!uid) {\n      console.err('no hashkey :(', v);\n    }\n    assert(uid, 'error getting the key');\n    return uid;\n  }\n\n  // v is a primitive\n  return typeof v + '-' + uid;\n};\nme.hiddenKey = '__pojoVizKey__';\n\nme.createHashKeysFor = function (obj, name) {\n\n  function localToString(obj) {\n    var match;\n    try {\n      match = {}.toString.call(obj).match(/^\\[object (\\S*?)\\]/);\n    } catch (e) {\n      match = false;\n    }\n    return match && match[1];\n  }\n\n  /**\n   * Analyze the internal property [[Class]] to guess the name\n   * of this object, e.g. [object Date], [object Math]\n   * Many object will give false positives (they will match [object Object])\n   * so let's consider Object as the name only if it's equal to\n   * Object.prototype\n   * @param  {Object}  obj\n   * @return {Boolean}\n   */\n  function hasAClassName(obj) {\n    var match = localToString(obj);\n    if (match === 'Object') {\n      return obj === Object.prototype && 'Object';\n    }\n    return match;\n  }\n\n  function getName(obj) {\n    var name, className;\n\n    // return the already generated hashKey\n    if (get(obj)) {\n      return get(obj);\n    }\n\n    // generate a new key based on\n    // - the name if it's a function\n    // - a unique id\n    name = typeof obj === 'function' &&\n      typeof obj.name === 'string' &&\n      obj.name;\n\n    className = hasAClassName(obj);\n    if (!name && className) {\n      name = className;\n    }\n\n    name = name || _.uniqueId();\n    return name;\n  }\n\n  // the name is equal to the passed name or the\n  // generated name\n  name = name || getName(obj);\n  name = name.replace(/[\\. ]/img, '-');\n\n  // if the obj is a prototype then try to analyze\n  // the constructor first so that the prototype becomes\n  // [name].prototype\n  // special case: object.constructor = object\n  if (obj.hasOwnProperty &&\n      obj.hasOwnProperty('constructor') &&\n      typeof obj.constructor === 'function' &&\n      obj.constructor !== obj) {\n    me.createHashKeysFor(obj.constructor);\n  }\n\n  // set name on self\n  set(obj, name);\n\n  // set name on the prototype\n  if (typeof obj === 'function' &&\n      obj.hasOwnProperty('prototype')) {\n    set(obj.prototype, name + '-prototype');\n  }\n};\n\nme.has = function (v) {\n  return v.hasOwnProperty &&\n    v.hasOwnProperty(me.hiddenKey);\n};\n\nmodule.exports = me;","'use strict';\n\nvar _ = require('lodash');\n\nvar propertiesTransformation = {\n  '[[Prototype]]': '__proto__'\n};\n\nvar utils = {\n  assert: function (v, message) {\n    if (!v) {\n      throw message || 'error';\n    }\n  },\n  translate: function (x, y) {\n    return 'translate(' + (x || 0) + ', ' + (y || 0) + ')';\n  },\n  scale: function (s) {\n    return 'scale(' + (s || 1) + ')';\n  },\n  transform: function (obj) {\n    var t = [];\n    _.forOwn(obj, function (v, k) {\n      t.push(utils[k].apply(utils, v));\n    });\n    return t.join(' ');\n  },\n  prefixer: function () {\n    var args = [].slice.call(arguments);\n    args.unshift('pv');\n    return args.join('-');\n  },\n  transformProperty: function (v) {\n    if (propertiesTransformation.hasOwnProperty(v)) {\n      return propertiesTransformation[v];\n    }\n    return v;\n  },\n  escapeCls: function(v) {\n    return v.replace(/\\$/g, '_');\n  },\n  toQueryString: function (obj) {\n    var s = '',\n        i = 0;\n    _.forOwn(obj, function (v, k) {\n      if (i) {\n        s += '&';\n      }\n      s += k + '=' + v;\n      i += 1;\n    });\n    return s;\n  },\n  createEvent: function (eventName, details) {\n    return new CustomEvent(eventName, {\n      detail: details\n    });\n  },\n  notification: function (message, consoleToo) {\n    var ev = utils.createEvent('pojoviz-notification', message);\n    consoleToo && console.log(message);\n    document.dispatchEvent(ev);\n  },\n  createJsonpCallback: function (url) {\n    var script = document.createElement('script');\n    script.src = url;\n    document.head.appendChild(script);\n  }\n};\n\nmodule.exports = utils;"]}
(11)
});