anchor.diff:    after injecting an `AlexComponent` into her constructor:
   +makeExample('cb-dependency-injection/ts/src/app/parent-finder.component.ts','cathy','parent-finder.component.ts (CathyComponent)')(format='.')
   :marked
  -  We added the [@Optional](#optional) qualifier for safety but
  +  Notice that even though the [@Optional](#optional) qualifier 
  +  is there for safety,
     the <live-example name="cb-dependency-injection"></live-example>
     confirms that the `alex` parameter is set.
   
     <a id="base-parent"></a>
     ### Cannot find a parent by its base class
   
  -  What if we do *not* know the concrete parent component class?
  +  What if you *don't* know the concrete parent component class?
   
     A re-usable component might be a child of multiple components.
     Imagine a component for rendering breaking news about a financial instrument.
  -  For sound (cough) business reasons, this news component makes frequent calls
  -  directly into its parent instrument as changing market data stream by.
  +  For business reasons, this news component makes frequent calls
  +  directly into its parent instrument as changing market data streams by.
   
     The app probably defines more than a dozen financial instrument components.
  -  If we're lucky, they all implement the same base class
  -  whose API our `NewsComponent` understands.
  +  If you're lucky, they all implement the same base class
  +  whose API your `NewsComponent` understands.
   
   .l-sub-section
     :marked
       Looking for components that implement an interface would be better.
  -    That's not possible because TypeScript interfaces disappear from the transpiled JavaScript
  -    which doesn't support interfaces. There's no artifact we could look for.
  -:marked
  -  We're not claiming this is good design.
  -  We are asking *can a component inject its parent via the parent's base class*?
  -
  -  The sample's `CraigComponent` explores this question. [Looking back](#alex)
  -  we see that the `Alex` component *extends* (*inherits*) from a class named `Base`.
  +    That's not possible because TypeScript interfaces disappear 
  +    from the transpiled JavaScript, which doesn't support interfaces. 
  +    There's no artifact to look for.
  +:marked
  +  This isn't necessarily good design.
  +  This example is examining *whether a component can 
  +  inject its parent via the parent's base class*.
  +
  +  The sample's `CraigComponent` explores this question. [Looking back](#alex),
  +  you see that the `Alex` component *extends* (*inherits*) from a class named `Base`.
   +makeExample('cb-dependency-injection/ts/src/app/parent-finder.component.ts','alex-class-signature','parent-finder.component.ts (Alex class signature)')(format='.')
   :marked
     The `CraigComponent` tries to inject `Base` into its `alex` constructor parameter and reports if it succeeded.
  
positive.code:   :marked
      If the injector doesn't have a provider for the requested *token*, it delegates the request
      to its parent injector, where the process repeats until there are no more injectors.
      If the search is futile, the injector throws an error ... unless the request was [optional](#optional).
  
      Let's return our attention to providers themselves.
  :marked
    A new injector has no providers.
    Angular initializes the injectors it creates with some providers it cares about.
    We have to register our _own_ application providers manually,
    usually in the `providers` array of the `Component` or `Directive` metadata:
  +makeExample('cb-dependency-injection/ts/src/app/app.component.ts','providers','src/app/app.component.ts (providers)')
  :marked
    ### Defining providers
  
    The simple class provider is the most typical by far.
    We mention the class in the `providers` array and we're done.
  +makeExample('cb-dependency-injection/ts/src/app/hero-bios.component.ts','class-provider','src/app/hero-bios.component.ts (class provider)')(format='.')
  :marked
    It's that simple because the most common injected service is an instance of a class.
    But not every dependency can be satisfied by creating a new instance of a class.
    We need other ways to deliver dependency values and that means we need other ways to specify a provider.
  
    The `HeroOfTheMonthComponent` example demonstrates many of the alternatives and why we need them.
  
  figure.image-display
    img(src="/resources/images/cookbooks/dependency-injection/hero-of-month.png" alt="Hero of the month" width="300px")
  :marked
    It's visually simple: a few properties and the output of a logger. The code behind it gives us plenty to talk about.
  +makeExample('cb-dependency-injection/ts/src/app/hero-of-the-month.component.ts','hero-of-the-month','hero-of-the-month.component.ts')
  
  .l-main-section
  
negative.code:   1. It tells the injector to start its search for a `Parent` dependency in a component *above* itself,
    which *is* what parent means.
  
    2. Angular throws a cyclic dependency error if you omit the `@SkipSelf` decorator.
  
      `Cannot instantiate cyclic dependency! (BethComponent -> Parent -> BethComponent)`
  
  