anchor.diff:        `Component` is a *decorator function* that takes a *metadata object* as argument.
         We apply this function to the component class by prefixing the function with the
         **@** symbol and invoking it with a metadata object, just above the class.
  +      
  +      `Component` est une *fonction décorateur* qui prend un *objet metadata* comme argument.
  +      Nous appliquons cette fonction à la classe du composant en préfixant cette fonction avec le symbole
  +      **@** et l'invoquons avec l'objet metadata, juste au-dessus de la classe.
     :marked
       `@Component` is #{_a} *#{_decorator}* that allows us to associate *metadata* with the
       component class.
       The metadata tells Angular how to create and use this component.
  +    
  +    `@Component` est un *#{_decorator}* qui nous autorise à associer des *metadata* avec la classe du composant.
  +    Les metadata indiquent à Angular comment créer et utiliser ce composant.
   
     +makeExcerpt('app/app.component.ts', 'metadata')
   
     block annotation-fields
       :marked
         This particular metadata object has two fields, a `selector` and a `template`.
  +      
  +      Cet objet metadata a deux champs, un `selector` et un `template`.
     :marked
       The **selector** specifies a simple CSS selector for an HTML element that represents the component.
  +    
  +    Ce **selector** définit un simple selecteru CSS pour un élément HTML qui représente notre composant.
   
       >The element for this component is named `my-app`.
       Angular creates and displays an instance of our `AppComponent`
       wherever it encounters a `my-app` element in the host HTML.
   
  +    >L'élément pour ce composant est appelé `my-app`.
  +    Angular crée et affiche une instance de notre `AppComponent`
  +    à chaque fois qu'il rencontre un élément `my-app` dans le HTML hôte.
  +
       The **template** specifies the component's companion template,
       written in an enhanced form of HTML that tells Angular how to render this component's view.
  +    
  +    Le **template** définit le template associé à notre composant,
  +    écrit dans une forme améliorée de HTML qui indique à Angular comment afficher la vue associée à ce composant.
   
       >Our template is a single line of HTML announcing "*My First Angular 2 App*".
  +    
  +    >Notre template est une ligne de HTML annonçant "*My First Angular 2 App*".
   
       >A more advanced template could contain data bindings to component properties
       and might identify other application components which have their own templates.
       These templates might identify yet other components.
       In this way an Angular application becomes a tree of components.
  +    
  +    >Un template plus avancé peut contenir des associations de données aux propriétés du composant et pourrait utiliser
  +    d'autres composants qui possèdent leur propre template. Ces templates pourraient utiliser encore d'autres composants.
  +    C'est de cette façon qu'une application Angular devient un arbre de composants.
   
     :marked
       ### Component class
  +    
  +    ### La classe Composant
  +    
       At the bottom of the file is an empty, do-nothing class named `AppComponent`.
  +    
  +    A la fin de ce fichier il y a une classe vide appelée `AppComponent`.
  +    
     +makeExcerpt('app/app.component.ts', 'class')
     :marked
       When we're ready to build a substantive application,
       we can expand this class with properties and application logic.
       Our `AppComponent` class is empty because we don't need it to do anything in this QuickStart.
  +    
  +    Quand nous serons prêts à construire une application substantielle,
  +    nous pourrons étendre cette classe avec des propriétés et une logique applicative.
  +    Notre classe `AppComponent` est vide car nous n'avons pas besoin qu'elle fasse quoique ce soit dans ce démarrage rapide.
     +ifDocsFor('ts')
       :marked
         We **export** `AppComponent` so that we can **import** it elsewhere in our application,
         as we'll see when we create `main.ts`.
  +      
  +      Nous **exportons** `AppComponent` de manière à pouvoir **l'importer** ailleurs dans notre application,
  +      comme nous le verrons lorsque nous créerons le fichier `main.ts`.
   
   .l-main-section
   h2#main Step 3: Add #[code #[+adjExPath('main.ts')]]
  +
  +h2#main Étape 3: Ajoutons le fichier #[code #[+adjExPath('main.ts')]]
   
   block create-main
     p.
       Now we need something to tell Angular to load the root component.
       Create the file #[code #[+adjExPath('app/main.ts')]] with the following content:
  +  
  +  p.
  +    Maintenant nous avons besoin de dire à Angular de charger notre composant racine.
  +    Créons le fichier #[code #[+adjExPath('app/main.ts')]] avec le contenu suivant:
   
   +makeExample('app/main.ts')
   
   .l-verbose-section
     :marked
       We import the two things we need to launch the application:
  +    
  +    Nous importons les deux choses dont nous avons besoin pour lancer l'application:
   
       1. Angular's browser `bootstrap` function
  +    
  +    1. La fonction `bootstrap` d'Angular 
  +    
       1. The application root component, `AppComponent`.
  +    
  +    1. Le composant racine de notre application, `AppComponent`.
   
       Then we call `bootstrap` with `AppComponent`.
  +    
  +    Ensuite, nous appelons `bootstrap` avec notre `AppComponent`.
   
       ### Bootstrapping is platform-specific
  +    
  +    ### Le bootstrapping est spécifique à la plateforme
       Notice that we import the `bootstrap` function from `#{_angular_browser_uri}`,
       not `#{_angular_core_uri}`.
       Bootstrapping isn't core because there isn't a single way to bootstrap the app.
       True, most applications that run in a browser call the bootstrap function from
       this library.
  +    
  +    Notez que nous importons la fonction `bootstrap` depuis `#{_angular_browser_uri}`,
  +    et non depuis `#{_angular_core_uri}`.
  +    Le lancement ne fait pas partie du coeur car il n'y a pas de façon simple de lancer notre application.
  +    Il est vrai que la plupart des applications qui s'exécutent dans un navigateur appelle la fonction bootstrap depuis
  +    cette librairie.
   
       But it is possible to load a component in a different environment.
       We might load it on a mobile device with [Apache Cordova](https://cordova.apache.org/) or [NativeScript](https://www.nativescript.org/).
  
positive.code:       First, we create a map to tell SystemJS where to look when we import some module.
        Then, we register all our packages to SystemJS:
        all the project dependencies and our application package, `app`.
  
      .l-sub-section
        :marked
          Our QuickStart doesn't use all of the listed packages
          but any substantial application will want many of them
          and all of the listed packages are required by at least one of the documentation samples.
  
          There is no runtime harm in listing packages that we don't need as they will only be loaded when requested.
      :marked
        The `app` package tells SystemJS what to do when it sees a request for a
        module from the `app/` folder.
  
        Our QuickStart makes such requests when one of its
        application TypeScript files has an import statement like this:
      +makeExcerpt('app/main.ts', 'import')
      :marked
        Notice that the module name (after `from`) does not mention a filename extension.
        In the configuration we tell SystemJS to default the extension to `js`, a JavaScript file.
  
        That makes sense because we transpile TypeScript to JavaScript
        *before* running the application.
  
      .l-sub-section
        :marked
          #### Transpiling in the browser
          In the live example on plunker we transpile (AKA compile) to JavaScript in the browser
          on the fly. _That's fine for a demo_.
  
          **Do not transpile in the browser during development or for production**.
  
          We strongly recommend transpiling (AKA compiling) to JavaScript during a build phase
          before running the application for several reasons including:
  
          * We see compiler warnings and errors that are hidden from us in the browser.
  
          * Precompilation simplifies the module loading process and
          it's much easier to diagnose problems when this is a separate, external step.
  
          * Precompilation means a faster user experience because the browser doesn't waste time compiling.
  
          * We iterate development faster because we only recompile changed files.
          We notice the difference as soon as the app grows beyond a handful of files.
  
          * Precompilation fits into a continuous integration process of build, test, deploy.
  
      :marked
        The `System.import` call tells SystemJS to import the `main` file
        (`main.js` ... after transpiling `main.ts`, remember?);
        `main` is where we tell Angular to launch the application.
        We also catch and log launch errors to the console.
  
        All other modules are loaded upon request
        either by an import statement or by Angular itself.
  
        ### *&lt;my-app&gt;*
  
  
negative.code:   .l-sub-section
      :marked
        The `typings` folder could not show up after `npm install`. If so, please install them manually.
        
        Le dossier `typings` peut ne pas avoir été créé après l'exécution de la commande `npm install`. Le cas échéant, 
        installez les manuellement.
  
      code-example(language="sh").
        npm run typings install
  