function decorator(name, func) {
    /*jshint validthis: true */
    if (isString(name) && !isDefined(func)) {
      return stateBuilder[name];
    }
    if (!isFunction(func) || !isString(name)) {
      return this;
    }
    if (stateBuilder[name] && !stateBuilder.$delegates[name]) {
      stateBuilder.$delegates[name] = stateBuilder[name];
    }
    stateBuilder[name] = func;
    return this;
  }
@ngdoc function
@name ui.router.state.$stateProvider#decorator
@methodOf ui.router.state.$stateProvider

@description
Allows you to extend (carefully) or override (at your own peril) the 
`stateBuilder` object used internally by `$stateProvider`. This can be used 
to add custom functionality to ui-router, for example inferring templateUrl 
based on the state name.

When passing only a name, it returns the current (original or decorated) builder
function that matches `name`.

The builder functions that can be decorated are listed below. Though not all
necessarily have a good use case for decoration, that is up to you to decide.

In addition, users can attach custom decorators, which will generate new 
properties within the state's internal definition. There is currently no clear 
use-case for this beyond accessing internal states (i.e. $state.$current), 
however, expect this to become increasingly relevant as we introduce additional 
meta-programming features.

**Warning**: Decorators should not be interdependent because the order of 
execution of the builder functions in non-deterministic. Builder functions 
should only be dependent on the state definition object and super function.


Existing builder functions and current return values:

- **parent** `{object}` - returns the parent state object.
- **data** `{object}` - returns state data, including any inherited data that is not
  overridden by own values (if any).
- **url** `{object}` - returns a {@link ui.router.util.type:UrlMatcher UrlMatcher}
  or `null`.
- **navigable** `{object}` - returns closest ancestor state that has a URL (aka is 
  navigable).
- **params** `{object}` - returns an array of state params that are ensured to 
  be a super-set of parent's params.
- **views** `{object}` - returns a views object where each key is an absolute view 
  name (i.e. "viewName@stateName") and each value is the config object 
  (template, controller) for the view. Even when you don't use the views object 
  explicitly on a state config, one is still created for you internally.
  So by decorating this builder function you have access to decorating template 
  and controller properties.
- **ownParams** `{object}` - returns an array of params that belong to the state, 
  not including any params defined by ancestor states.
- **path** `{string}` - returns the full path from the root down to this state. 
  Needed for state activation.
- **includes** `{object}` - returns an object that includes every state that 
  would pass a `$state.includes()` test.

@example
<pre>
// Override the internal 'views' builder with a function that takes the state
// definition, and a reference to the internal function being overridden:
$stateProvider.decorator('views', function (state, parent) {
  var result = {},
      views = parent(state);

  angular.forEach(views, function (config, name) {
    var autoName = (state.name + '.' + name).replace('.', '/');
    config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';
    result[name] = config;
  });
  return result;
});

$stateProvider.state('home', {
  views: {
    'contact.list': { controller: 'ListController' },
    'contact.item': { controller: 'ItemController' }
  }
});

// ...

$state.go('home');
// Auto-populates list and item views with /partials/home/contact/list.html,
// and /partials/home/contact/item.html, respectively.
</pre>

@param {string} name The name of the builder function to decorate. 
@param {object} func A function that is responsible for decorating the original 
builder function. The function receives two parameters:

  - `{object}` - state - The state config object.
  - `{object}` - super - The original builder function.

@return {object} $stateProvider - $stateProvider instance