test($compile): check for memory leaks in nested transclusion
test($compile): check no memory leak with coexisting element transcludes

If an element contains two "element" transcludes then the initial clone
consists of only comment nodes.  The concern was that this meant that
the transclude scopes would not be cleaned up.

But it turns out that in the case that there are only comments then the
scope is never attached to anything so we don't need to worry about cleaning
it up.

Later if a concrete element is created as part of the transclude then these
elements will have destroy handlers.
fix(jqLite): don't attach event handlers to comments or text nodes

We were attaching handlers to comment nodes when setting up bound transclusion
functions. But we don't clean up comments and text nodes when deallocating so
there was a memory leak.

Closes #7913
Closes #7942
test(compile): check transclusion/scopes work with multi-element directives
fix(jqLite): never add to the cache for non-element/document nodes

Calling `jqLite.data()` on a disallowed node type caused an empty object to be added to the
cache. This could lead to memory leaks since we no longer clean up such node types when they are
removed from the DOM.

Closes #7966
fix($parse): handle constants as one-time binding expressions

Handle constant expressions as one-time binding expressions.
Avoids the infinite digest from
https://github.com/angular/angular.js/pull/7960/files#r14136938

Closes #7970
docs($location): hashPrefix, html5Mode are methods

Closes #7915
docs(srcset): fix mistake in example
docs(guide/introduction): use durandal as an example of a framework

To me knockout is a library that does data binding well.
Durandal is a framework that uses knockout as it's data binding component.
docs(guide/unit-testing): correct spelling
chore(ngMock): replace misplaced comma with semicolon
docs($q): remove unnecessary $scope.apply wrapping

As of Angular 1.2, this kind of thing is no longer necessary (thank goodness!)
fix(core): drop the toBoolean function

So far Angular have used the toBoolean function to decide if the parsed value
is truthy. The function made more values falsy than regular JavaScript would,
e.g. strings 'f' and 'no' were both treated as falsy. This creates suble bugs
when backend sends a non-empty string with one of these values and something
suddenly hides in the application

Thanks to lgalfaso for test ideas.

BREAKING CHANGE: values 'f', '0', 'false', 'no', 'n', '[]' are no longer
treated as falsy. Only JavaScript falsy values are now treated as falsy by the
expression parser; there are six of them: false, null, undefined, NaN, 0 and "".

Closes #3969
Closes #4277
Closes #7960
revert: chore($resource): refactor confusing case statement

This reverts commit d50829bcf74318a02bbfdbd3172a2bfb95b9283d.

This commit introduces a regression that results in urls with
parameters being incorrectly generated. We need to investigate
further why this is happening, for now I'm just reverting.
fix($http): add the PATCH shortcut back

The shortcut was dropped because it had a lot of unkowns about PATCH.
Since we already know that using PATCH is good
(http://www.mnot.net/blog/2012/09/05/patch), and only IE8 has issues with that,
let's add the shortcut back.

Closes #5894
fix($timeout/$interval): if invokeApply is false, do not use evalAsync

$evalAsync triggers a digest, and is unsuitable when it is expected that a digest should not occur.

BREAKING CHANGE

Previously, even if invokeApply was set to false, a $rootScope digest would occur during promise
resolution. This is no longer the case, as promises returned from $timeout and $interval will no
longer trigger $evalAsync (which in turn causes a $digest) if `invokeApply` is false.

Workarounds include manually triggering $scope.$apply(), or returning $q.defer().promise from a
promise callback, and resolving or rejecting it when appropriate.

    var interval = $interval(function() {
      if (someRequirementFulfilled) {
        $interval.cancel(interval);
        $scope.$apply();
      }
    }, 100, 0, false);

or:

    var interval = $interval(function (idx) {
      // make the magic happen
    }, 1000, 10, false);
    interval.then(function(idx) {
      var deferred = $q.defer();
      // do the asynchronous magic --- $evalAsync will cause a digest and cause
      // bindings to update.
      return deferred.promise;
    });

Closes #7999
Closes #7103
chore: use triple equals comparison with typeof operator.

It is common practice for typeof operator to be used with '==='.

Closes #8009
feat(jqLite): support isDefaultPrevented for triggerHandler dummies

triggerHandler sends dummy events to an element, but although the event includes the preventDefault method, there is no way to see if it was called for the event. This is sometimes important when testing directives that use preventDefault

Closes #8008
docs(input): fix a typo
fix($interval): when canceling, use clearInterval from $window instead of global scope.

In $interval.cancel, use clearInterval from the $window service instead of from global scope.
The variable clearInterval declared above isn't visible here.