anchor.diff:    of registering a controller, we register a `pcPhoneList` directive.
     The directive is a downgraded version of our component, and the `UpgradeAdapter`
     handles the bridging between the two:
  -  
  +
   +makeExample('upgrade-phonecat/ts/ng2_components/app/js/phone_list/phone_list.module.ts', null, 'app/js/phone_list/phone_list.module.ts')
   
   :marked
     The `<angular.IDirectiveFactory>` type annotation here is to let the TypeScript compiler
     know that the return value of the downgrade method call will be something that can be
     used as a directive factory.
  -  
  +
     To complete the switch, we should change our route configuration in `app.module.ts`.
     Instead of using the controller and template, it can just instantiate our component.
     We can do that by using a simple template that uses the directive
  
positive.code:   the custom Jasmine matcher `toEqualData` in both of them. Because this is something
    we define ourselves, it isn't included in the Jasmine type definitions that we
    installed using Typings.
    
    We can add our own little type definition file for that extension, which extends
    the `jasmine.Matchers` interface and adds our custom matcher to it. This will
    satisfy the compiler and let us use our custom matcher while retaining the nice
    type safety features of TypeScript:
    
  +makeExample('upgrade-phonecat/ts/typescript-conversion/test/jasmine_matchers.d.ts', null, 'test/jasmine_matchers.d.ts')
  
  :marked
    And now we have a fully functional test suite for our TypeScript-enabled
    application as well.
    
  :marked
    ## Enjoying The Benefits of TypeScript
    
    Now that we have TypeScript, we can start benefiting from some of its
    other features in addition to the imports and exports that we're already using.
    There's a lot of value the language can provide in Angular 1 applications.
    
    For one thing, TypeScript is a superset of ES2015. Any app that has previously
    been written in ES5 - like the PhoneCat example has - can with TypeScript
    start incorporating all of the JavaScript features that are new to ES2015.
    These include things like `let`s and `const`s, default function parameters,
    and destructuring assignments.
    
    Another thing we can do is start adding *type safety* to our code, by
    adding type annotations. For instance, we can annotate the checkmark
    filter so that it expects booleans as arguments and returns strings.
    This makes it clearer what the filter is supposed to do, and makes it
    possible for the TypeScript compiler to notify us when we're trying to
    use it with incompatible types.
    
  +makeExample('upgrade-phonecat/ts/classes/app/js/core/checkmark.filter.ts', null, 'app/js/core/checkmark.filter.ts', {otl: /(:\w+)/g})
    
  .l-sub-section
    :marked
      The [Angular 1.x type definitions](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/angularjs)
  
negative.code:   to the class, letting Angular 2 know about its dependencies. As described
    by our [Dependency Injection Guide](../guide/dependency-injection.html),
    this is a marker decorator we need to use for classes that have no other
    Angular 2 decorators but still need to have their dependencies injected.
  
    In its constructor the class expects to get the `Http` service. It will
    be injected to it and it is stored as a private field. The service is then
    used in the two instance methods, one of which loads the list of all phones,
  