text:   /**
     * @ngdoc module
     * @name material.core.componentRegistry
     *
     * @description
     * A component instance registration service.
     * Note: currently this as a private service in the SideNav component.
     */
    angular.module('material.core')
      .factory('$mdComponentRegistry', ComponentRegistry);
  
    /*
     * @private
     * @ngdoc factory
     * @name ComponentRegistry
     * @module material.core.componentRegistry
     *
     */
    function ComponentRegistry($log, $q) {
  
      var self;
      var instances = [ ];
      var pendings = { };
  
      return self = {
        /**
         * Used to print an error when an instance for a handle isn't found.
         */
        notFoundError: function(handle, msgContext) {
          $log.error( (msgContext || "") + 'No instance found for handle', handle);
        },
        /**
         * Return all registered instances as an array.
         */
        getInstances: function() {
          return instances;
        },
  
        /**
         * Get a registered instance.
         * @param handle the String handle to look up for a registered instance.
         */
        get: function(handle) {
          if ( !isValidID(handle) ) return null;
  
          var i, j, instance;
          for(i = 0, j = instances.length; i < j; i++) {
            instance = instances[i];
            if(instance.$$mdHandle === handle) {
              return instance;
            }
          }
          return null;
        },
  
        /**
         * Register an instance.
         * @param instance the instance to register
         * @param handle the handle to identify the instance under.
         */
        register: function(instance, handle) {
          if ( !handle ) return angular.noop;
  
          instance.$$mdHandle = handle;
          instances.push(instance);
          resolveWhen();
  
          return deregister;
  
          /**
           * Remove registration for an instance
           */
          function deregister() {
            var index = instances.indexOf(instance);
            if (index !== -1) {
              instances.splice(index, 1);
            }
          }
  
          /**
           * Resolve any pending promises for this instance
           */
          function resolveWhen() {
            var dfd = pendings[handle];
            if ( dfd ) {
              dfd.forEach(function (promise) {
                promise.resolve(instance);
              });
              delete pendings[handle];
            }
          }
        },
  
        /**
         * Async accessor to registered component instance
         * If not available then a promise is created to notify
         * all listeners when the instance is registered.
         */
        when : function(handle) {
          if ( isValidID(handle) ) {
            var deferred = $q.defer();
            var instance = self.get(handle);
  
            if ( instance )  {
              deferred.resolve( instance );
            } else {
              if (pendings[handle] === undefined) {
                pendings[handle] = [];
              }
              pendings[handle].push(deferred);
            }
  
            return deferred.promise;
          }
          return $q.reject("Invalid `md-component-id` value.");
        }
  
      };
  
      function isValidID(handle){
        return handle && (handle !== "");
      }
  
    }
  