@angular/core 6.0.3 → 6.0.7

package/esm2015/src/metadata/directives.js

@@ -13,8 +13,6 @@ import { ChangeDetectionStrategy } from '../change_detection/constants';
 import { makeDecorator, makePropDecorator } from '../util/decorators';
 /**
  * Type of the Directive decorator / constructor function.
- *
- *
  * @record
  */
 export function DirectiveDecorator() { }
@@ -27,15 +25,11 @@ function DirectiveDecorator_tsickle_Closure_declarations() {
     */
 }
 /**
- * Directive decorator and metadata.
- *
- *
- * \@Annotation
+ * Type of the Component metadata.
  */
 export const /** @type {?} */ Directive = makeDecorator('Directive', (dir = {}) => dir);
 /**
- * Type of the Component decorator / constructor function.
- *
+ * Component decorator interface
  *
  * @record
  */
@@ -51,14 +45,94 @@ function ComponentDecorator_tsickle_Closure_declarations() {
 /**
  * Component decorator and metadata.
  *
+ * \@usageNotes
+ *
+ * ### Using animations
+ *
+ * The following snippet shows an animation trigger in a component's
+ * metadata. The trigger is attached to an element in the component's
+ * template, using "\@_trigger_name_", and a state expression that is evaluated
+ * at run time to determine whether the animation should start.
+ *
+ * ```typescript
+ * \@Component({
+ *   selector: 'animation-cmp',
+ *   templateUrl: 'animation-cmp.html',
+ *   animations: [
+ *     trigger('myTriggerName', [
+ *       state('on', style({ opacity: 1 }),
+ *       state('off', style({ opacity: 0 }),
+ *       transition('on => off', [
+ *         animate("1s")
+ *       ])
+ *     ])
+ *   ]
+ * })
+ * ```
+ *
+ * ```html
+ * <!-- animation-cmp.html -->
+ * <div \@myTriggerName="expression">...</div>
+ * ```
+ *
+ * ### Preserving whitespace
+ *
+ * Removing whitespace can greatly reduce AOT-generated code size, and speed up view creation.
+ * As of Angular 6, default for `preserveWhitespaces` is false (whitespace is removed).
+ * To change the default setting for all components in your application, set
+ * the `preserveWhitespaces` option of the AOT compiler.
+ *
+ * Current implementation removes whitespace characters as follows:
+ * - Trims all whitespaces at the beginning and the end of a template.
+ * - Removes whitespace-only text nodes. For example,
+ * `<button>Action 1</button>  <button>Action 2</button>` becomes
+ * `<button>Action 1</button><button>Action 2</button>`.
+ * - Replaces a series of whitespace characters in text nodes with a single space.
+ * For example, `<span>\n some text\n</span>` becomes `<span> some text </span>`.
+ * - Does NOT alter text nodes inside HTML tags such as `<pre>` or `<textarea>`,
+ * where whitespace characters are significant.
+ *
+ * Note that these transformations can influence DOM nodes layout, although impact
+ * should be minimal.
+ *
+ * You can override the default behavior to preserve whitespace characters
+ * in certain fragments of a template. For example, you can exclude an entire
+ * DOM sub-tree by using the `ngPreserveWhitespaces` attribute:
+ *
+ * ```html
+ * <div ngPreserveWhitespaces>
+ *     whitespaces are preserved here
+ *     <span>    and here </span>
+ * </div>
+ * ```
+ *
+ * You can force a single space to be preserved in a text node by using `&ngsp;`,
+ * which is replaced with a space character by Angular's template
+ * compiler:
+ *
+ * ```html
+ * <a>Spaces</a>&ngsp;<a>between</a>&ngsp;<a>links.</a>
+ * <!-->compiled to be equivalent to:</>
+ *  <a>Spaces</a> <a>between</a> <a>links.</a>
+ * ```
+ *
+ * Note that sequences of `&ngsp;` are still collapsed to just one space character when
+ * the `preserveWhitespaces` option is set to `false`.
+ *
+ * ```html
+ * <a>before</a>&ngsp;&ngsp;&ngsp;<a>after</a>
+ * <!-->compiled to be equivalent to:</>
+ *  <a>Spaces</a> <a>between</a> <a>links.</a>
+ * ```
+ *
+ * To preserve sequences of whitespace characters, use the
+ * `ngPreserveWhitespaces` attribute.
  *
  * \@Annotation
  */
 export const /** @type {?} */ Component = makeDecorator('Component', (c = {}) => (Object.assign({ changeDetection: ChangeDetectionStrategy.Default }, c)), Directive);
 /**
  * Type of the Pipe decorator / constructor function.
- *
- *
  * @record
  */
 export function PipeDecorator() { }
@@ -71,21 +145,12 @@ function PipeDecorator_tsickle_Closure_declarations() {
     */
 }
 /**
- * Pipe decorator and metadata.
- *
- * Use the `\@Pipe` annotation to declare that a given class is a pipe. A pipe
- * class must also implement {\@link PipeTransform} interface.
- *
- * To use the pipe include a reference to the pipe class in
- * {\@link NgModule#declarations}.
  *
  *
  * \@Annotation
  */
 export const /** @type {?} */ Pipe = makeDecorator('Pipe', (p) => (Object.assign({ pure: true }, p)));
 /**
- * Type of the Input decorator / constructor function.
- *
  *
  * @record
  */
@@ -99,16 +164,12 @@ function InputDecorator_tsickle_Closure_declarations() {
     */
 }
 /**
- * Input decorator and metadata.
- *
  *
  * \@Annotation
  */
 export const /** @type {?} */ Input = makePropDecorator('Input', (bindingPropertyName) => ({ bindingPropertyName }));
 /**
  * Type of the Output decorator / constructor function.
- *
- *
  * @record
  */
 export function OutputDecorator() { }
@@ -121,16 +182,12 @@ function OutputDecorator_tsickle_Closure_declarations() {
     */
 }
 /**
- * Output decorator and metadata.
- *
  *
  * \@Annotation
  */
 export const /** @type {?} */ Output = makePropDecorator('Output', (bindingPropertyName) => ({ bindingPropertyName }));
 /**
  * Type of the HostBinding decorator / constructor function.
- *
- *
  * @record
  */
 export function HostBindingDecorator() { }
@@ -143,16 +200,12 @@ function HostBindingDecorator_tsickle_Closure_declarations() {
     */
 }
 /**
- * HostBinding decorator and metadata.
- *
  *
  * \@Annotation
  */
 export const /** @type {?} */ HostBinding = makePropDecorator('HostBinding', (hostPropertyName) => ({ hostPropertyName }));
 /**
  * Type of the HostListener decorator / constructor function.
- *
- *
  * @record
  */
 export function HostListenerDecorator() { }
@@ -165,11 +218,36 @@ function HostListenerDecorator_tsickle_Closure_declarations() {
     */
 }
 /**
- * HostListener decorator and metadata.
+ * Binds a CSS event to a host listener and supplies configuration metadata.
+ * Angular invokes the supplied handler method when the host element emits the specified event,
+ * and updates the bound element with the result.
+ * If the handler method returns false, applies `preventDefault` on the bound element.
+ *
+ * \@usageNotes
+ *
+ * The following example declares a directive
+ * that attaches a click listener to a button and counts clicks.
+ *
+ * ```
+ * \@Directive({selector: 'button[counting]'})
+ * class CountClicks {
+ *   numberOfClicks = 0;
+ *
+ * \@HostListener('click', ['$event.target'])
+ *   onClick(btn) {
+ *     console.log('button', btn, 'number of clicks:', this.numberOfClicks++);
+ *  }
+ * }
  *
+ * \@Component({
+ *   selector: 'app',
+ *   template: '<button counting>Increment</button>',
+ * })
+ * class App {}
+ * ```
  *
  * \@Annotation
  */
 export const /** @type {?} */ HostListener = makePropDecorator('HostListener', (eventName, args) => ({ eventName, args }));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directives.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/metadata/directives.ts"],"names":[],"mappings":";;;;;;;;;;;AAQA,OAAO,EAAC,uBAAuB,EAAC,MAAM,+BAA+B,CAAC;AAGtE,OAAO,EAAgB,aAAa,EAAE,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;AAuYnF,MAAM,CAAC,uBAAM,SAAS,GAClB,aAAa,CAAC,WAAW,EAAE,CAAC,MAAiB,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;AA+V7D,MAAM,CAAC,uBAAM,SAAS,GAAuB,aAAa,CACtD,WAAW,EAAE,CAAC,IAAe,EAAE,EAAE,EAAE,CAAC,iBAAE,eAAe,EAAE,uBAAuB,CAAC,OAAO,IAAK,CAAC,EAAE,EAC9F,SAAS,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8Df,MAAM,CAAC,uBAAM,IAAI,GAAkB,aAAa,CAAC,MAAM,EAAE,CAAC,CAAO,EAAE,EAAE,CAAC,iBAAE,IAAI,EAAE,IAAI,IAAK,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;AAuE5F,MAAM,CAAC,uBAAM,KAAK,GACd,iBAAiB,CAAC,OAAO,EAAE,CAAC,mBAA4B,EAAE,EAAE,CAAC,CAAC,EAAC,mBAAmB,EAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;AAiE1F,MAAM,CAAC,uBAAM,MAAM,GACf,iBAAiB,CAAC,QAAQ,EAAE,CAAC,mBAA4B,EAAE,EAAE,CAAC,CAAC,EAAC,mBAAmB,EAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;AA2D3F,MAAM,CAAC,uBAAM,WAAW,GACpB,iBAAiB,CAAC,aAAa,EAAE,CAAC,gBAAyB,EAAE,EAAE,CAAC,CAAC,EAAC,gBAAgB,EAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;AA6D1F,MAAM,CAAC,uBAAM,YAAY,GACrB,iBAAiB,CAAC,cAAc,EAAE,CAAC,SAAkB,EAAE,IAAe,EAAE,EAAE,CAAC,CAAC,EAAC,SAAS,EAAE,IAAI,EAAC,CAAC,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ChangeDetectionStrategy} from '../change_detection/constants';\nimport {Provider} from '../di';\nimport {Type} from '../type';\nimport {TypeDecorator, makeDecorator, makePropDecorator} from '../util/decorators';\n\nimport {ViewEncapsulation} from './view';\n\n\n/**\n * Type of the Directive decorator / constructor function.\n *\n *\n */\nexport interface DirectiveDecorator {\n  /**\n   * @usageNotes\n   *\n   * ```\n   * import {Directive} from '@angular/core';\n   *\n   * @Directive({\n   *   selector: 'my-directive',\n   * })\n   * export class MyDirective {\n   * }\n   * ```\n   *\n   * @description\n   *\n   * Marks a class as an Angular directive and collects directive configuration\n   * metadata.\n   *\n   * Directive decorator allows you to mark a class as an Angular directive and provide additional\n   * metadata that determines how the directive should be processed, instantiated and used at\n   * runtime.\n   *\n   * Directives allow you to attach behavior to elements in the DOM..\n   *\n   * A directive must belong to an NgModule in order for it to be usable\n   * by another directive, component, or application. To specify that a directive is a member of an\n   * NgModule,\n   * you should list it in the `declarations` field of that NgModule.\n   *\n   * In addition to the metadata configuration specified via the Directive decorator,\n   * directives can control their runtime behavior by implementing various Life-Cycle hooks.\n   *\n   * **Metadata Properties:**\n   *\n   * * **exportAs** - name under which the component instance is exported in a template. Can be\n   * given a single name or a comma-delimited list of names.\n   * * **host** - map of class property to host element bindings for events, properties and\n   * attributes\n   * * **inputs** - list of class property names to data-bind as component inputs\n   * * **outputs** - list of class property names that expose output events that others can\n   * subscribe to\n   * * **providers** - list of providers available to this component and its children\n   * * **queries** -  configure queries that can be injected into the component\n   * * **selector** - css selector that identifies this component in a template\n   *\n   *\n   * @Annotation\n   */\n  (obj: Directive): TypeDecorator;\n\n  /**\n   * See the {@link Directive} decorator.\n   */\n  new (obj: Directive): Directive;\n}\n\nexport interface Directive {\n  /**\n   * The CSS selector that triggers the instantiation of a directive.\n   *\n   * Angular only allows directives to trigger on CSS selectors that do not cross element\n   * boundaries.\n   *\n   * `selector` may be declared as one of the following:\n   *\n   * - `element-name`: select by element name.\n   * - `.class`: select by class name.\n   * - `[attribute]`: select by attribute name.\n   * - `[attribute=value]`: select by attribute name and value.\n   * - `:not(sub_selector)`: select only if the element does not match the `sub_selector`.\n   * - `selector1, selector2`: select if either `selector1` or `selector2` matches.\n   *\n   *\n   * ### Example\n   *\n   * Suppose we have a directive with an `input[type=text]` selector.\n   *\n   * And the following HTML:\n   *\n   * ```html\n   * <form>\n   *   <input type=\"text\">\n   *   <input type=\"radio\">\n   * <form>\n   * ```\n   *\n   * The directive would only be instantiated on the `<input type=\"text\">` element.\n   *\n   */\n  selector?: string;\n\n  /**\n   * Enumerates the set of data-bound input properties for a directive\n   *\n   * Angular automatically updates input properties during change detection.\n   *\n   * The `inputs` property defines a set of `directiveProperty` to `bindingProperty`\n   * configuration:\n   *\n   * - `directiveProperty` specifies the component property where the value is written.\n   * - `bindingProperty` specifies the DOM property where the value is read from.\n   *\n   * When `bindingProperty` is not provided, it is assumed to be equal to `directiveProperty`.\n   *\n   * ### Example ([live demo](http://plnkr.co/edit/ivhfXY?p=preview))\n   *\n   * The following example creates a component with two data-bound properties.\n   *\n   * ```typescript\n   * @Component({\n   *   selector: 'bank-account',\n   *   inputs: ['bankName', 'id: account-id'],\n   *   template: `\n   *     Bank Name: {{bankName}}\n   *     Account Id: {{id}}\n   *   `\n   * })\n   * class BankAccount {\n   *   bankName: string;\n   *   id: string;\n   *\n   *   // this property is not bound, and won't be automatically updated by Angular\n   *   normalizedBankName: string;\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `\n   *     <bank-account bankName=\"RBC\" account-id=\"4747\"></bank-account>\n   *   `\n   * })\n   * class App {}\n   * ```\n   *\n   */\n  inputs?: string[];\n\n  /**\n   * Enumerates the set of event-bound output properties.\n   *\n   * When an output property emits an event, an event handler attached to that event\n   * the template is invoked.\n   *\n   * The `outputs` property defines a set of `directiveProperty` to `bindingProperty`\n   * configuration:\n   *\n   * - `directiveProperty` specifies the component property that emits events.\n   * - `bindingProperty` specifies the DOM property the event handler is attached to.\n   *\n   * ### Example ([live demo](http://plnkr.co/edit/d5CNq7?p=preview))\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: 'interval-dir',\n   *   outputs: ['everySecond', 'five5Secs: everyFiveSeconds']\n   * })\n   * class IntervalDir {\n   *   everySecond = new EventEmitter();\n   *   five5Secs = new EventEmitter();\n   *\n   *   constructor() {\n   *     setInterval(() => this.everySecond.emit(\"event\"), 1000);\n   *     setInterval(() => this.five5Secs.emit(\"event\"), 5000);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `\n   *     <interval-dir (everySecond)=\"everySecond()\" (everyFiveSeconds)=\"everyFiveSeconds()\">\n   *     </interval-dir>\n   *   `\n   * })\n   * class App {\n   *   everySecond() { console.log('second'); }\n   *   everyFiveSeconds() { console.log('five seconds'); }\n   * }\n   * ```\n   *\n   */\n  outputs?: string[];\n\n  /**\n   * Specify the events, actions, properties and attributes related to the host element.\n   *\n   * ## Host Listeners\n   *\n   * Specifies which DOM events a directive listens to via a set of `(event)` to `method`\n   * key-value pairs:\n   *\n   * - `event`: the DOM event that the directive listens to.\n   * - `statement`: the statement to execute when the event occurs.\n   * If the evaluation of the statement returns `false`, then `preventDefault`is applied on the DOM\n   * event.\n   *\n   * To listen to global events, a target must be added to the event name.\n   * The target can be `window`, `document` or `body`.\n   *\n   * When writing a directive event binding, you can also refer to the $event local variable.\n   *\n   * ### Example ([live demo](http://plnkr.co/edit/DlA5KU?p=preview))\n   *\n   * The following example declares a directive that attaches a click listener to the button and\n   * counts clicks.\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: 'button[counting]',\n   *   host: {\n   *     '(click)': 'onClick($event.target)'\n   *   }\n   * })\n   * class CountClicks {\n   *   numberOfClicks = 0;\n   *\n   *   onClick(btn) {\n   *     console.log(\"button\", btn, \"number of clicks:\", this.numberOfClicks++);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `<button counting>Increment</button>`\n   * })\n   * class App {}\n   * ```\n   *\n   * ## Host Property Bindings\n   *\n   * Specifies which DOM properties a directive updates.\n   *\n   * Angular automatically checks host property bindings during change detection.\n   * If a binding changes, it will update the host element of the directive.\n   *\n   * ### Example ([live demo](http://plnkr.co/edit/gNg0ED?p=preview))\n   *\n   * The following example creates a directive that sets the `valid` and `invalid` classes\n   * on the DOM element that has ngModel directive on it.\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: '[ngModel]',\n   *   host: {\n   *     '[class.valid]': 'valid',\n   *     '[class.invalid]': 'invalid'\n   *   }\n   * })\n   * class NgModelStatus {\n   *   constructor(public control:NgModel) {}\n   *   get valid { return this.control.valid; }\n   *   get invalid { return this.control.invalid; }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `<input [(ngModel)]=\"prop\">`\n   * })\n   * class App {\n   *   prop;\n   * }\n   * ```\n   *\n   * ## Attributes\n   *\n   * Specifies static attributes that should be propagated to a host element.\n   *\n   * ### Example\n   *\n   * In this example using `my-button` directive (ex.: `<div my-button></div>`) on a host element\n   * (here: `<div>` ) will ensure that this element will get the \"button\" role.\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: '[my-button]',\n   *   host: {\n   *     'role': 'button'\n   *   }\n   * })\n   * class MyButton {\n   * }\n   * ```\n   */\n  host?: {[key: string]: string};\n\n  /**\n   * Defines the set of injectable objects that are visible to a Directive and its light DOM\n   * children.\n   *\n   * ## Simple Example\n   *\n   * Here is an example of a class that can be injected:\n   *\n   * ```\n   * class Greeter {\n   *    greet(name:string) {\n   *      return 'Hello ' + name + '!';\n   *    }\n   * }\n   *\n   * @Directive({\n   *   selector: 'greet',\n   *   providers: [\n   *     Greeter\n   *   ]\n   * })\n   * class HelloWorld {\n   *   greeter:Greeter;\n   *\n   *   constructor(greeter:Greeter) {\n   *     this.greeter = greeter;\n   *   }\n   * }\n   * ```\n   */\n  providers?: Provider[];\n\n  /**\n   * Defines the name that can be used in the template to assign this directive to a variable.\n   *\n   * ## Simple Example\n   *\n   * ```\n   * @Directive({\n   *   selector: 'child-dir',\n   *   exportAs: 'child'\n   * })\n   * class ChildDir {\n   * }\n   *\n   * @Component({\n   *   selector: 'main',\n   *   template: `<child-dir #c=\"child\"></child-dir>`\n   * })\n   * class MainComponent {\n   * }\n   *\n   * ```\n   */\n  exportAs?: string;\n\n  /**\n   * Configures the queries that will be injected into the directive.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * ### Example\n   *\n   * ```\n   * @Component({\n   *   selector: 'someDir',\n   *   queries: {\n   *     contentChildren: new ContentChildren(ChildDirective),\n   *     viewChildren: new ViewChildren(ChildDirective)\n   *   },\n   *   template: '<child-directive></child-directive>'\n   * })\n   * class SomeDir {\n   *   contentChildren: QueryList<ChildDirective>,\n   *   viewChildren: QueryList<ChildDirective>\n   *\n   *   ngAfterContentInit() {\n   *     // contentChildren is set\n   *   }\n   *\n   *   ngAfterViewInit() {\n   *     // viewChildren is set\n   *   }\n   * }\n   * ```\n   */\n  queries?: {[key: string]: any};\n}\n\n/**\n * Directive decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const Directive: DirectiveDecorator =\n    makeDecorator('Directive', (dir: Directive = {}) => dir);\n\n/**\n * Type of the Component decorator / constructor function.\n *\n *\n */\nexport interface ComponentDecorator {\n  /**\n   * @usageNotes\n   *\n   * {@example core/ts/metadata/metadata.ts region='component'}\n   *\n   * @description\n   * Marks a class as an Angular component and collects component configuration\n   * metadata.\n   *\n   * Component decorator allows you to mark a class as an Angular component and provide additional\n   * metadata that determines how the component should be processed, instantiated and used at\n   * runtime.\n   *\n   * Components are the most basic building block of an UI in an Angular application.\n   * An Angular application is a tree of Angular components.\n   * Angular components are a subset of directives. Unlike directives, components always have\n   * a template and only one component can be instantiated per an element in a template.\n   *\n   * A component must belong to an NgModule in order for it to be usable\n   * by another component or application. To specify that a component is a member of an NgModule,\n   * you should list it in the `declarations` field of that NgModule.\n   *\n   * In addition to the metadata configuration specified via the Component decorator,\n   * components can control their runtime behavior by implementing various Life-Cycle hooks.\n   *\n   * **Metadata Properties:**\n   *\n   * * **animations** - list of animations of this component\n   * * **changeDetection** - change detection strategy used by this component\n   * * **encapsulation** - style encapsulation strategy used by this component\n   * * **entryComponents** - list of components that are dynamically inserted into the view of this\n   *   component\n   * * **exportAs** - name under which the component instance is exported in a template\n   * * **host** - map of class property to host element bindings for events, properties and\n   *   attributes\n   * * **inputs** - list of class property names to data-bind as component inputs\n   * * **interpolation** - custom interpolation markers used in this component's template\n   * * **moduleId** - ES/CommonJS module id of the file in which this component is defined\n   * * **outputs** - list of class property names that expose output events that others can\n   *   subscribe to\n   * * **providers** - list of providers available to this component and its children\n   * * **queries** -  configure queries that can be injected into the component\n   * * **selector** - css selector that identifies this component in a template\n   * * **styleUrls** - list of urls to stylesheets to be applied to this component's view\n   * * **styles** - inline-defined styles to be applied to this component's view\n   * * **template** - inline-defined template for the view\n   * * **templateUrl** - url to an external file containing a template for the view\n   * * **viewProviders** - list of providers available to this component and its view children\n   *\n   * ### Example\n   *\n   * {@example core/ts/metadata/metadata.ts region='component'}\n   *\n   *\n   * @Annotation\n   */\n  (obj: Component): TypeDecorator;\n  /**\n   * See the {@link Component} decorator.\n   */\n  new (obj: Component): Component;\n}\n\n/**\n * Type of the Component metadata.\n *\n *\n */\nexport interface Component extends Directive {\n  /**\n   * Defines the used change detection strategy.\n   *\n   * When a component is instantiated, Angular creates a change detector, which is responsible for\n   * propagating the component's bindings.\n   *\n   * The `changeDetection` property defines, whether the change detection will be checked every time\n   * or only when the component tells it to do so.\n   */\n  changeDetection?: ChangeDetectionStrategy;\n\n  /**\n   * Defines the set of injectable objects that are visible to its view DOM children.\n   *\n   * ## Simple Example\n   *\n   * Here is an example of a class that can be injected:\n   *\n   * ```\n   * class Greeter {\n   *    greet(name:string) {\n   *      return 'Hello ' + name + '!';\n   *    }\n   * }\n   *\n   * @Directive({\n   *   selector: 'needs-greeter'\n   * })\n   * class NeedsGreeter {\n   *   greeter:Greeter;\n   *\n   *   constructor(greeter:Greeter) {\n   *     this.greeter = greeter;\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'greet',\n   *   viewProviders: [\n   *     Greeter\n   *   ],\n   *   template: `<needs-greeter></needs-greeter>`\n   * })\n   * class HelloWorld {\n   * }\n   *\n   * ```\n   */\n  viewProviders?: Provider[];\n\n  /**\n   * The module id of the module that contains the component.\n   * Needed to be able to resolve relative urls for templates and styles.\n   * In CommonJS, this can always be set to `module.id`, similarly SystemJS exposes `__moduleName`\n   * variable within each module.\n   *\n   *\n   * ## Simple Example\n   *\n   * ```\n   * @Directive({\n   *   selector: 'someDir',\n   *   moduleId: module.id\n   * })\n   * class SomeDir {\n   * }\n   *\n   * ```\n   */\n  moduleId?: string;\n\n  /**\n   * Specifies a template URL for an Angular component.\n   *\n   *Only one of `templateUrl` or `template` can be defined per View.\n   */\n  templateUrl?: string;\n\n  /**\n   * Specifies an inline template for an Angular component.\n   *\n   * Only one of `templateUrl` or `template` can be defined per Component.\n   */\n  template?: string;\n\n  /**\n   * Specifies stylesheet URLs for an Angular component.\n   */\n  styleUrls?: string[];\n\n  /**\n   * Specifies inline stylesheets for an Angular component.\n   */\n  styles?: string[];\n\n  /**\n   * Animations are defined on components via an animation-like DSL. This DSL approach to describing\n   * animations allows for a flexibility that both benefits developers and the framework.\n   *\n   * Animations work by listening on state changes that occur on an element within\n   * the template. When a state change occurs, Angular can then take advantage and animate the\n   * arc in between. This works similar to how CSS transitions work, however, by having a\n   * programmatic DSL, animations are not limited to environments that are DOM-specific.\n   * (Angular can also perform optimizations behind the scenes to make animations more performant.)\n   *\n   * For animations to be available for use, animation state changes are placed within\n   * {@link trigger animation triggers} which are housed inside of the `animations` annotation\n   * metadata. Within a trigger both {@link state state} and {@link transition transition} entries\n   * can be placed.\n   *\n   * ```typescript\n   * @Component({\n   *   selector: 'animation-cmp',\n   *   templateUrl: 'animation-cmp.html',\n   *   animations: [\n   *     // this here is our animation trigger that\n   *     // will contain our state change animations.\n   *     trigger('myTriggerName', [\n   *       // the styles defined for the `on` and `off`\n   *       // states declared below are persisted on the\n   *       // element once the animation completes.\n   *       state('on', style({ opacity: 1 }),\n   *       state('off', style({ opacity: 0 }),\n   *\n   *       // this here is our animation that kicks off when\n   *       // this state change jump is true\n   *       transition('on => off', [\n   *         animate(\"1s\")\n   *       ])\n   *     ])\n   *   ]\n   * })\n   * ```\n   *\n   * As depicted in the code above, a group of related animation states are all contained within\n   * an animation `trigger` (the code example above called the trigger `myTriggerName`).\n   * When a trigger is created then it can be bound onto an element within the component's\n   * template via a property prefixed by an `@` symbol followed by trigger name and an expression\n   * that\n   * is used to determine the state value for that trigger.\n   *\n   * ```html\n   * <!-- animation-cmp.html -->\n   * <div @myTriggerName=\"expression\">...</div>\n   * ```\n   *\n   * For state changes to be executed, the `expression` value must change value from its existing\n   * value\n   * to something that we have set an animation to animate on (in the example above we are listening\n   * to a change of state between `on` and `off`). The `expression` value attached to the trigger\n   * must be something that can be evaluated with the template/component context.\n   *\n   * ### DSL Animation Functions\n   *\n   * Please visit each of the animation DSL functions listed below to gain a better understanding\n   * of how and why they are used for crafting animations in Angular:\n   *\n   * - {@link trigger trigger()}\n   * - {@link state state()}\n   * - {@link transition transition()}\n   * - {@link group group()}\n   * - {@link sequence sequence()}\n   * - {@link style style()}\n   * - {@link animate animate()}\n   * - {@link keyframes keyframes()}\n   */\n  animations?: any[];\n\n  /**\n   * Specifies how the template and the styles should be encapsulated:\n   * - {@link ViewEncapsulation#Native `ViewEncapsulation.Native`} to use shadow roots - only works\n   *   if natively available on the platform,\n   * - {@link ViewEncapsulation#Emulated `ViewEncapsulation.Emulated`} to use shimmed CSS that\n   *   emulates the native behavior,\n   * - {@link ViewEncapsulation#None `ViewEncapsulation.None`} to use global CSS without any\n   *   encapsulation.\n   *\n   * When no `encapsulation` is defined for the component, the default value from the\n   * {@link CompilerOptions} is used. The default is `ViewEncapsulation.Emulated`}. Provide a new\n   * `CompilerOptions` to override this value.\n   *\n   * If the encapsulation is set to `ViewEncapsulation.Emulated` and the component has no `styles`\n   * nor `styleUrls` the encapsulation will automatically be switched to `ViewEncapsulation.None`.\n   */\n  encapsulation?: ViewEncapsulation;\n\n  /**\n   * Overrides the default encapsulation start and end delimiters (respectively `{{` and `}}`)\n   */\n  interpolation?: [string, string];\n\n  /**\n   * Defines the components that should be compiled as well when\n   * this component is defined. For each components listed here,\n   * Angular will create a {@link ComponentFactory} and store it in the\n   * {@link ComponentFactoryResolver}.\n   */\n  entryComponents?: Array<Type<any>|any[]>;\n\n  /**\n   * If {@link Component#preserveWhitespaces Component.preserveWhitespaces} is set to `false`\n   * potentially superfluous whitespace characters (ones matching the `\\s` character class in\n   * JavaScript regular expressions) will be removed from a compiled template. This can greatly\n   * reduce AOT-generated code size as well as speed up view creation.\n   *\n   * Current implementation works according to the following rules:\n   * - all whitespaces at the beginning and the end of a template are removed (trimmed);\n   * - text nodes consisting of whitespaces only are removed (ex.:\n   *   `<button>Action 1</button>  <button>Action 2</button>` will be converted to\n   *   `<button>Action 1</button><button>Action 2</button>` (no whitespaces between buttons);\n   * - series of whitespaces in text nodes are replaced with one space (ex.:\n   *   `<span>\\n some text\\n</span>` will be converted to `<span> some text </span>`);\n   * - text nodes are left as-is inside HTML tags where whitespaces are significant (ex. `<pre>`,\n   *   `<textarea>`).\n   *\n   * Described transformations may (potentially) influence DOM nodes layout. However, the impact\n   * should so be minimal. That's why starting from Angular 6, the\n   * `preserveWhitespaces` option is `false` by default (whitespace removal).\n   * If you want to change the default setting for all components in your application you can use\n   * the `preserveWhitespaces` option of the AOT compiler.\n   *\n   * Even with the default behavior of whitespace removal, there are ways of preserving whitespaces\n   * in certain fragments of a template. You can either exclude entire DOM sub-tree by using the\n   * `ngPreserveWhitespaces` attribute, ex.:\n   *\n   * ```html\n   * <div ngPreserveWhitespaces>\n   *     whitespaces are preserved here\n   *     <span>    and here </span>\n   * </div>\n   * ```\n   *\n   * Alternatively you can force a space to be preserved in a text node by using the `&ngsp;`\n   * pseudo-entity. `&ngsp;` will be replaced with a space character by Angular's template\n   * compiler, ex.:\n   *\n   * ```html\n   * <a>Spaces</a>&ngsp;<a>between</a>&ngsp;<a>links.</a>\n   * ```\n   *\n   * will be compiled to the equivalent of:\n   *\n   * ```html\n   * <a>Spaces</a> <a>between</a> <a>links.</a>\n   * ```\n   *\n   * Please note that sequences of `&ngsp;` are still collapsed to just one space character when\n   * the `preserveWhitespaces` option is set to `false`. Ex.:\n   *\n   * ```html\n   * <a>before</a>&ngsp;&ngsp;&ngsp;<a>after</a>\n   * ```\n   *\n   * would be equivalent to:\n   *\n   * ```html\n   * <a>before</a> <a>after</a>\n   * ```\n   *\n   * The `&ngsp;` pseudo-entity is useful for forcing presence of\n   * one space (a text node having `&ngsp;` pseudo-entities will never be removed), but it is not\n   * meant to mark sequences of whitespace characters. The previously described\n   * `ngPreserveWhitespaces` attribute is more useful for preserving sequences of whitespace\n   * characters.\n   */\n  preserveWhitespaces?: boolean;\n}\n\n/**\n * Component decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const Component: ComponentDecorator = makeDecorator(\n    'Component', (c: Component = {}) => ({changeDetection: ChangeDetectionStrategy.Default, ...c}),\n    Directive);\n\n/**\n * Type of the Pipe decorator / constructor function.\n *\n *\n */\nexport interface PipeDecorator {\n  /**\n   * Declare reusable pipe function.\n   *\n   * A \"pure\" pipe is only re-evaluated when either the input or any of the arguments change.\n   *\n   * When not specified, pipes default to being pure.\n   */\n  (obj: Pipe): TypeDecorator;\n\n  /**\n   * See the {@link Pipe} decorator.\n   */\n  new (obj: Pipe): Pipe;\n}\n\n/**\n * Type of the Pipe metadata.\n *\n *\n */\nexport interface Pipe {\n  /**\n   * Name of the pipe.\n   *\n   * The pipe name is used in template bindings. For example if a pipe is named\n   * `myPipe` then it would be used in the template binding expression like\n   * so:  `{{ exp | myPipe }}`.\n   */\n  name: string;\n\n  /**\n   * If Pipe is pure (its output depends only on its input.)\n   *\n   * Normally pipe's `transform` method is only invoked when the inputs to pipe`s\n   * `transform` method change. If the pipe has internal state (it's result are\n   * dependent on state other than its arguments) than set `pure` to `false` so\n   * that the pipe is invoked on each change-detection even if the arguments to the\n   * pipe do not change.\n   */\n  pure?: boolean;\n}\n\n/**\n * Pipe decorator and metadata.\n *\n * Use the `@Pipe` annotation to declare that a given class is a pipe. A pipe\n * class must also implement {@link PipeTransform} interface.\n *\n * To use the pipe include a reference to the pipe class in\n * {@link NgModule#declarations}.\n *\n *\n * @Annotation\n */\nexport const Pipe: PipeDecorator = makeDecorator('Pipe', (p: Pipe) => ({pure: true, ...p}));\n\n\n/**\n * Type of the Input decorator / constructor function.\n *\n *\n */\nexport interface InputDecorator {\n  /**\n   * Declares a data-bound input property.\n   *\n   * Angular automatically updates data-bound properties during change detection.\n   *\n   * `Input` takes an optional parameter that specifies the name\n   * used when instantiating a component in the template. When not provided,\n   * the name of the decorated property is used.\n   *\n   * ### Example\n   *\n   * The following example creates a component with two input properties.\n   *\n   * ```typescript\n   * @Component({\n   *   selector: 'bank-account',\n   *   template: `\n   *     Bank Name: {{bankName}}\n   *     Account Id: {{id}}\n   *   `\n   * })\n   * class BankAccount {\n   *   @Input() bankName: string;\n   *   @Input('account-id') id: string;\n   *\n   *   // this property is not bound, and won't be automatically updated by Angular\n   *   normalizedBankName: string;\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `\n   *     <bank-account bankName=\"RBC\" account-id=\"4747\"></bank-account>\n   *   `\n   * })\n   *\n   * class App {}\n   * ```\n   *\n   */\n  (bindingPropertyName?: string): any;\n  new (bindingPropertyName?: string): any;\n}\n\n/**\n * Type of the Input metadata.\n *\n *\n */\nexport interface Input {\n  /**\n   * Name used when instantiating a component in the template.\n   */\n  bindingPropertyName?: string;\n}\n\n/**\n * Input decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const Input: InputDecorator =\n    makePropDecorator('Input', (bindingPropertyName?: string) => ({bindingPropertyName}));\n\n/**\n * Type of the Output decorator / constructor function.\n *\n *\n */\nexport interface OutputDecorator {\n  /**\n   * Declares an event-bound output property.\n   *\n   * When an output property emits an event, an event handler attached to that event\n   * the template is invoked.\n   *\n   * `Output` takes an optional parameter that specifies the name\n   * used when instantiating a component in the template. When not provided,\n   * the name of the decorated property is used.\n   *\n   * ### Example\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: 'interval-dir',\n   * })\n   * class IntervalDir {\n   *   @Output() everySecond = new EventEmitter();\n   *   @Output('everyFiveSeconds') five5Secs = new EventEmitter();\n   *\n   *   constructor() {\n   *     setInterval(() => this.everySecond.emit(\"event\"), 1000);\n   *     setInterval(() => this.five5Secs.emit(\"event\"), 5000);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `\n   *     <interval-dir (everySecond)=\"everySecond()\" (everyFiveSeconds)=\"everyFiveSeconds()\">\n   *     </interval-dir>\n   *   `\n   * })\n   * class App {\n   *   everySecond() { console.log('second'); }\n   *   everyFiveSeconds() { console.log('five seconds'); }\n   * }\n   * ```\n   *\n   */\n  (bindingPropertyName?: string): any;\n  new (bindingPropertyName?: string): any;\n}\n\n/**\n * Type of the Output metadata.\n *\n *\n */\nexport interface Output { bindingPropertyName?: string; }\n\n/**\n * Output decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const Output: OutputDecorator =\n    makePropDecorator('Output', (bindingPropertyName?: string) => ({bindingPropertyName}));\n\n\n/**\n * Type of the HostBinding decorator / constructor function.\n *\n *\n */\nexport interface HostBindingDecorator {\n  /**\n   * Declares a host property binding.\n   *\n   * Angular automatically checks host property bindings during change detection.\n   * If a binding changes, it will update the host element of the directive.\n   *\n   * `HostBinding` takes an optional parameter that specifies the property\n   * name of the host element that will be updated. When not provided,\n   * the class property name is used.\n   *\n   * ### Example\n   *\n   * The following example creates a directive that sets the `valid` and `invalid` classes\n   * on the DOM element that has ngModel directive on it.\n   *\n   * ```typescript\n   * @Directive({selector: '[ngModel]'})\n   * class NgModelStatus {\n   *   constructor(public control:NgModel) {}\n   *   @HostBinding('class.valid') get valid() { return this.control.valid; }\n   *   @HostBinding('class.invalid') get invalid() { return this.control.invalid; }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `<input [(ngModel)]=\"prop\">`,\n   * })\n   * class App {\n   *   prop;\n   * }\n   * ```\n   *\n   */\n  (hostPropertyName?: string): any;\n  new (hostPropertyName?: string): any;\n}\n\n/**\n * Type of the HostBinding metadata.\n *\n *\n */\nexport interface HostBinding { hostPropertyName?: string; }\n\n/**\n * HostBinding decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const HostBinding: HostBindingDecorator =\n    makePropDecorator('HostBinding', (hostPropertyName?: string) => ({hostPropertyName}));\n\n\n/**\n * Type of the HostListener decorator / constructor function.\n *\n *\n */\nexport interface HostListenerDecorator {\n  /**\n   * Declares a host listener.\n   *\n   * Angular will invoke the decorated method when the host element emits the specified event.\n   *\n   * If the decorated method returns `false`, then `preventDefault` is applied on the DOM event.\n   *\n   * ### Example\n   *\n   * The following example declares a directive that attaches a click listener to the button and\n   * counts clicks.\n   *\n   * ```typescript\n   * @Directive({selector: 'button[counting]'})\n   * class CountClicks {\n   *   numberOfClicks = 0;\n   *\n   *   @HostListener('click', ['$event.target'])\n   *   onClick(btn) {\n   *     console.log('button', btn, 'number of clicks:', this.numberOfClicks++);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: '<button counting>Increment</button>',\n   * })\n   * class App {}\n   * ```\n   *\n   * @Annotation\n   */\n  (eventName: string, args?: string[]): any;\n  new (eventName: string, args?: string[]): any;\n}\n\n/**\n * Type of the HostListener metadata.\n *\n *\n */\nexport interface HostListener {\n  eventName?: string;\n  args?: string[];\n}\n\n/**\n * HostListener decorator and metadata.\n *\n *\n * @Annotation\n */\nexport const HostListener: HostListenerDecorator =\n    makePropDecorator('HostListener', (eventName?: string, args?: string[]) => ({eventName, args}));\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directives.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/metadata/directives.ts"],"names":[],"mappings":";;;;;;;;;;;AAQA,OAAO,EAAC,uBAAuB,EAAC,MAAM,+BAA+B,CAAC;AAGtE,OAAO,EAAgB,aAAa,EAAE,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;;;;;;;;;;;;;;;;;AA4cnF,MAAM,CAAC,uBAAM,SAAS,GAClB,aAAa,CAAC,WAAW,EAAE,CAAC,MAAiB,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyR7D,MAAM,CAAC,uBAAM,SAAS,GAAuB,aAAa,CACtD,WAAW,EAAE,CAAC,IAAe,EAAE,EAAE,EAAE,CAAC,iBAAE,eAAe,EAAE,uBAAuB,CAAC,OAAO,IAAK,CAAC,EAAE,EAC9F,SAAS,CAAC,CAAC;;;;;;;;;;;;;;;;;;;AA8Cf,MAAM,CAAC,uBAAM,IAAI,GAAkB,aAAa,CAAC,MAAM,EAAE,CAAC,CAAO,EAAE,EAAE,CAAC,iBAAE,IAAI,EAAE,IAAI,IAAK,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;;AAsF5F,MAAM,CAAC,uBAAM,KAAK,GACd,iBAAiB,CAAC,OAAO,EAAE,CAAC,mBAA4B,EAAE,EAAE,CAAC,CAAC,EAAC,mBAAmB,EAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;AAkC1F,MAAM,CAAC,uBAAM,MAAM,GACf,iBAAiB,CAAC,QAAQ,EAAE,CAAC,mBAA4B,EAAE,EAAE,CAAC,CAAC,EAAC,mBAAmB,EAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;AAiD3F,MAAM,CAAC,uBAAM,WAAW,GACpB,iBAAiB,CAAC,aAAa,EAAE,CAAC,gBAAyB,EAAE,EAAE,CAAC,CAAC,EAAC,gBAAgB,EAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwD1F,MAAM,CAAC,uBAAM,YAAY,GACrB,iBAAiB,CAAC,cAAc,EAAE,CAAC,SAAkB,EAAE,IAAe,EAAE,EAAE,CAAC,CAAC,EAAC,SAAS,EAAE,IAAI,EAAC,CAAC,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ChangeDetectionStrategy} from '../change_detection/constants';\nimport {Provider} from '../di';\nimport {Type} from '../type';\nimport {TypeDecorator, makeDecorator, makePropDecorator} from '../util/decorators';\n\nimport {ViewEncapsulation} from './view';\n\n\n/**\n * Type of the Directive decorator / constructor function.\n */\nexport interface DirectiveDecorator {\n  /**\n   * Marks a class as an Angular directive and collects directive configuration\n   * metadata.\n   *\n   * Directive decorator allows you to mark a class as an Angular directive and provide additional\n   * metadata that determines how the directive should be processed, instantiated and used at\n   * runtime.\n   *\n   * Directives allow you to attach behavior to elements in the DOM..\n   *\n   * A directive must belong to an NgModule in order for it to be usable\n   * by another directive, component, or application. To specify that a directive is a member of an\n   * NgModule,\n   * you should list it in the `declarations` field of that NgModule.\n   *\n   * In addition to the metadata configuration specified via the Directive decorator,\n   * directives can control their runtime behavior by implementing various Life-Cycle hooks.\n   *\n   * **Metadata Properties:**\n   *\n   * * **exportAs** - name under which the component instance is exported in a template. Can be\n   * given a single name or a comma-delimited list of names.\n   * * **host** - map of class property to host element bindings for events, properties and\n   * attributes\n   * * **inputs** - list of class property names to data-bind as component inputs\n   * * **outputs** - list of class property names that expose output events that others can\n   * subscribe to\n   * * **providers** - list of providers available to this component and its children\n   * * **queries** -  configure queries that can be injected into the component\n   * * **selector** - css selector that identifies this component in a template\n   *\n   * @usageNotes\n   *\n   * ```\n   * import {Directive} from '@angular/core';\n   *\n   * @Directive({\n   *   selector: 'my-directive',\n   * })\n   * export class MyDirective {\n   * }\n   * ```\n   *\n   * @Annotation\n   */\n  (obj: Directive): TypeDecorator;\n\n  /**\n   * See the `Directive` decorator.\n   */\n  new (obj: Directive): Directive;\n}\n\nexport interface Directive {\n  /**\n   * The CSS selector that triggers the instantiation of a directive.\n   *\n   * Angular only allows directives to trigger on CSS selectors that do not cross element\n   * boundaries.\n   *\n   * `selector` may be declared as one of the following:\n   *\n   * - `element-name`: select by element name.\n   * - `.class`: select by class name.\n   * - `[attribute]`: select by attribute name.\n   * - `[attribute=value]`: select by attribute name and value.\n   * - `:not(sub_selector)`: select only if the element does not match the `sub_selector`.\n   * - `selector1, selector2`: select if either `selector1` or `selector2` matches.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * Suppose we have a directive with an `input[type=text]` selector.\n   *\n   * And the following HTML:\n   *\n   * ```html\n   * <form>\n   *   <input type=\"text\">\n   *   <input type=\"radio\">\n   * <form>\n   * ```\n   *\n   * The directive would only be instantiated on the `<input type=\"text\">` element.\n   *\n   */\n  selector?: string;\n\n  /**\n   * Enumerates the set of data-bound input properties for a directive\n   *\n   * Angular automatically updates input properties during change detection.\n   *\n   * The `inputs` property defines a set of `directiveProperty` to `bindingProperty`\n   * configuration:\n   *\n   * - `directiveProperty` specifies the component property where the value is written.\n   * - `bindingProperty` specifies the DOM property where the value is read from.\n   *\n   * When `bindingProperty` is not provided, it is assumed to be equal to `directiveProperty`.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * The following example creates a component with two data-bound properties.\n   *\n   * ```typescript\n   * @Component({\n   *   selector: 'bank-account',\n   *   inputs: ['bankName', 'id: account-id'],\n   *   template: `\n   *     Bank Name: {{bankName}}\n   *     Account Id: {{id}}\n   *   `\n   * })\n   * class BankAccount {\n   *   bankName: string;\n   *   id: string;\n   *\n   * ```\n   */\n  inputs?: string[];\n\n  /**\n   * Enumerates the set of event-bound output properties.\n   *\n   * When an output property emits an event, an event handler attached to that event\n   * the template is invoked.\n   *\n   * The `outputs` property defines a set of `directiveProperty` to `bindingProperty`\n   * configuration:\n   *\n   * - `directiveProperty` specifies the component property that emits events.\n   * - `bindingProperty` specifies the DOM property the event handler is attached to.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: 'child-dir',\n   *   exportAs: 'child'\n   * })\n   * class ChildDir {\n   * }\n   *\n   * @Component({\n   *   selector: 'main',\n   *   template: `<child-dir #c=\"child\"></child-dir>`\n   * })\n   * class MainComponent {\n   * }\n   * ```\n   */\n  outputs?: string[];\n\n  /**\n   * Specify the events, actions, properties and attributes related to the host element.\n   *\n   * @usageNotes\n   * The key corresponds to the name of the event, property or attribute on the host to\n   * bind. The value is formatted differently depending upon the type of the binding.\n   *\n   * ### Host Listeners\n   *\n   * Specifies which DOM events a directive listens to via a set of `(event)` to `method`\n   * key-value pairs:\n   *\n   * - `event`: the DOM event that the directive listens to.\n   * - `statement`: the statement to execute when the event occurs.\n   * If the evaluation of the statement returns `false`, then `preventDefault`is applied on the DOM\n   * event.\n   *\n   * To listen to global events, a target must be added to the event name.\n   * The target can be `window`, `document` or `body`.\n   *\n   * When writing a directive event binding, you can also refer to the $event local variable.\n   *\n   * The following example declares a directive that attaches a click listener to the button and\n   * counts clicks.\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: 'button[counting]',\n   *   host: {\n   *     '(click)': 'onClick($event.target)'\n   *   }\n   * })\n   * class CountClicks {\n   *   numberOfClicks = 0;\n   *\n   *   onClick(btn) {\n   *     console.log(\"button\", btn, \"number of clicks:\", this.numberOfClicks++);\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `<button counting>Increment</button>`\n   * })\n   * class App {}\n   * ```\n   * See [live demo](http://plnkr.co/edit/DlA5KU?p=preview)\n   *\n   * ### Host Property Bindings\n   *\n   * Specifies which DOM properties a directive updates.\n   *\n   * Angular automatically checks host property bindings during change detection.\n   * If a binding changes, it will update the host element of the directive.\n   *\n   * The following example creates a directive that sets the `valid` and `invalid` classes\n   * on the DOM element that has ngModel directive on it.\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: '[ngModel]',\n   *   host: {\n   *     '[class.valid]': 'valid',\n   *     '[class.invalid]': 'invalid'\n   *   }\n   * })\n   * class NgModelStatus {\n   *   constructor(public control:NgModel) {}\n   *   get valid { return this.control.valid; }\n   *   get invalid { return this.control.invalid; }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `<input [(ngModel)]=\"prop\">`\n   * })\n   * class App {\n   *   prop;\n   * }\n   * ```\n   * See [live demo](http://plnkr.co/edit/gNg0ED?p=preview).\n   *\n   * ### Attributes\n   *\n   * Specifies static attributes that should be propagated to a host element.\n   *\n   * In this example using `my-button` directive (ex.: `<div my-button></div>`) on a host element\n   * (here: `<div>` ) will ensure that this element will get the \"button\" role.\n   *\n   * ```typescript\n   * @Directive({\n   *   selector: '[my-button]',\n   *   host: {\n   *     'role': 'button'\n   *   }\n   * })\n   * class MyButton {\n   * }\n   * ```\n   * Attaching the `my-button` directive to the host `<div>` element\n   * ensures that this element gets the \"button\" role.\n   *\n   * ```html\n   * <div my-button></div>\n   * ```\n   *\n   * @usageNotes\n   * ### Simple Example\n   *\n   * The following simple example shows how a class is injected,\n   * using a provider specified in the directive metadata:\n   *\n   * ```\n   * class Greeter {\n   *    greet(name:string) {\n   *      return 'Hello ' + name + '!';\n   *    }\n   * }\n   *\n   * @Directive({\n   *   selector: 'greet',\n   *   providers: [\n   *     Greeter\n   *   ]\n   * })\n   * class HelloWorld {\n   *   greeter:Greeter;\n   *\n   *   constructor(greeter:Greeter) {\n   *     this.greeter = greeter;\n   *   }\n   * }\n   * ```\n   */\n  providers?: Provider[];\n\n  /**\n   * Defines the name that can be used in the template to assign this directive to a variable.\n   *\n   * @usageNotes\n   * ### Simple Example\n   *\n   * ```\n   * @Directive({\n   *   selector: 'child-dir',\n   *   exportAs: 'child'\n   * })\n   * class ChildDir {\n   * }\n   *\n   * @Component({\n   *   selector: 'main',\n   *   template: `<child-dir #c=\"child\"></child-dir>`\n   * })\n   * class MainComponent {\n   * }\n   *\n   * ```\n   */\n  exportAs?: string;\n\n  /**\n   * Configures the queries that will be injected into the directive.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * The followoing example (shows what??)\n   * ```\n   * @Component({\n   *   selector: 'someDir',\n   *   queries: {\n   *     contentChildren: new ContentChildren(ChildDirective),\n   *     viewChildren: new ViewChildren(ChildDirective)\n   *   },\n   *   template: '<child-directive></child-directive>'\n   * })\n   * class SomeDir {\n   *   contentChildren: QueryList<ChildDirective>,\n   *   viewChildren: QueryList<ChildDirective>\n   *\n   *   ngAfterContentInit() {\n   *     // contentChildren is set\n   *   }\n   *\n   *   ngAfterViewInit() {\n   *     // viewChildren is set\n   *   }\n   * }\n   * ```\n   *\n   * @Annotation\n   */\n  queries?: {[key: string]: any};\n}\n\n/**\n * Directive decorator and metadata.\n *\n * @Annotation\n */\nexport interface Directive {\n  /**\n   * The CSS selector that identifies this directive in a template\n   * and triggers instantiation of the directive.\n   *\n   * Declare as one of the following:\n   *\n   * - `element-name`: Select by element name.\n   * - `.class`: Select by class name.\n   * - `[attribute]`: Select by attribute name.\n   * - `[attribute=value]`: Select by attribute name and value.\n   * - `:not(sub_selector)`: Select only if the element does not match the `sub_selector`.\n   * - `selector1, selector2`: Select if either `selector1` or `selector2` matches.\n   *\n   * Angular only allows directives to apply on CSS selectors that do not cross\n   * element boundaries.\n   *\n   * For the following template HTML, a directive with an `input[type=text]` selector,\n   * would be instantiated only on the `<input type=\"text\">` element.\n   *\n   * ```html\n   * <form>\n   *   <input type=\"text\">\n   *   <input type=\"radio\">\n   * <form>\n   * ```\n   *\n   */\n  selector?: string;\n\n  /**\n   * The set of event-bound output properties.\n   * When an output property emits an event, an event handler attached\n   * to that event in the template is invoked.\n   *\n   * Each output property maps a `directiveProperty` to a `bindingProperty`:\n   * - `directiveProperty` specifies the component property that emits events.\n   * - `bindingProperty` specifies the HTML attribute the event handler is attached to.\n   *\n   */\n  outputs?: string[];\n\n  /**\n   * Maps class properties to host element bindings for properties,\n   * attributes, and events, using a set of key-value pairs.\n   *\n   * Angular automatically checks host property bindings during change detection.\n   * If a binding changes, Angular updates the directive's host element.\n   *\n   * When the key is a property of the host element, the property value is\n   * the propagated to the specified DOM property.\n   *\n   * When the key is a static attribute in the DOM, the attribute value\n   * is propagated to the specified property in the host element.\n   *\n   * For event handling:\n   * - The key is the DOM event that the directive listens to.\n   * To listen to global events, add the target to the event name.\n   * The target can be `window`, `document` or `body`.\n   * - The value is the statement to execute when the event occurs. If the\n   * statement evalueates to `false`, then `preventDefault` is applied on the DOM\n   * event. A handler method can refer to the `$event` local variable.\n   *\n   */\n  host?: {[key: string]: string};\n\n  /**\n   * See the `Component` decorator.\n   */\n  providers?: Provider[];\n\n  /**\n   * The name or names that can be used in the template to assign this directive to a variable.\n   * For multiple names, use a comma-separated string.\n   *\n   */\n  exportAs?: string;\n\n  /**\n   * Configures the queries that will be injected into the directive.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   */\n  queries?: {[key: string]: any};\n}\n\n/**\n * Type of the Component metadata.\n */\nexport const Directive: DirectiveDecorator =\n    makeDecorator('Directive', (dir: Directive = {}) => dir);\n/**\n * Component decorator interface\n *\n */\nexport interface ComponentDecorator {\n  /**\n   * Decorator that marks a class as an Angular component and provides configuration\n   * metadata that determines how the component should be processed,\n   * instantiated, and used at runtime.\n   *\n   * Components are the most basic UI building block of an Angular app.\n   * An Angular app contains a tree of Angular components.\n   *\n   * Angular components are a subset of directives, always associated with a template.\n   * Unlike other directives, only one component can be instantiated per an element in a template.\n   *\n   * A component must belong to an NgModule in order for it to be available\n   * to another component or application. To make it a member of an NgModule,\n   * list it in the `declarations` field of the `@NgModule` metadata.\n   *\n   * Note that, in addition to these options for configuring a directive,\n   * you can control a component's runtime behavior by implementing\n   * life-cycle hooks. For more information, see the\n   * [Lifecycle Hooks](guide/lifecycle-hooks) guide.\n   *\n   * @usageNotes\n   *\n   * ### Setting component inputs\n   *\n   * The following example creates a component with two data-bound properties,\n   * specified by the `inputs` value.\n   *\n   * <code-example path=\"core/ts/metadata/directives.ts\" region=\"component-input\">\n   * </code-example>\n   *\n   *\n   * ### Setting component outputs\n   *\n   * The following example shows two event emitters that emit on an interval. One\n   * emits an output every second, while the other emits every five seconds.\n   *\n   * {@example core/ts/metadata/directives.ts region='component-output-interval'}\n   *\n   * ### Injecting a class with a view provider\n   *\n   * The following simple example injects a class into a component\n   * using the view provider specified in component metadata:\n   *\n   * ```\n   * class Greeter {\n   *    greet(name:string) {\n   *      return 'Hello ' + name + '!';\n   *    }\n   * }\n   *\n   * @Directive({\n   *   selector: 'needs-greeter'\n   * })\n   * class NeedsGreeter {\n   *   greeter:Greeter;\n   *\n   *   constructor(greeter:Greeter) {\n   *     this.greeter = greeter;\n   *   }\n   * }\n   *\n   * @Component({\n   *   selector: 'greet',\n   *   viewProviders: [\n   *     Greeter\n   *   ],\n   *   template: `<needs-greeter></needs-greeter>`\n   * })\n   * class HelloWorld {\n   * }\n   *\n   * ```\n   *\n   *\n   * @Annotation\n   */\n  (obj: Component): TypeDecorator;\n  /**\n   * See the `@Component` decorator.\n   */\n  new (obj: Component): Component;\n}\n\n/**\n * Supplies configuration metadata for an Angular component.\n */\nexport interface Component extends Directive {\n  /**\n   * The change-detection strategy to use for this component.\n   *\n   * When a component is instantiated, Angular creates a change detector,\n   * which is responsible for propagating the component's bindings.\n   * The strategy is one of:\n   * - `ChangeDetectionStrategy#OnPush` sets the strategy to `CheckOnce` (on demand).\n   * - `ChangeDetectionStrategy#Default` sets the strategy to `CheckAlways`.\n   */\n  changeDetection?: ChangeDetectionStrategy;\n\n  /**\n   * Defines the set of injectable objects that are visible to its view DOM children.\n   * See [example](#injecting-a-class-with-a-view-provider).\n   *\n   */\n  viewProviders?: Provider[];\n\n  /**\n   * The module ID of the module that contains the component.\n   * The component must be able to resolve relative URLs for templates and styles.\n   * SystemJS exposes the `__moduleName` variable within each module.\n   * In CommonJS, this can  be set to `module.id`.\n   *\n   */\n  moduleId?: string;\n\n  /**\n   * The URL of a template file for an Angular component. If provided,\n   * do not supply an inline template using `template`.\n   *\n   */\n  templateUrl?: string;\n\n  /**\n   * An inline template for an Angular component. If provided,\n   * do not supply a template file using `templateUrl`.\n   *\n   */\n  template?: string;\n\n  /**\n   * One or more URLs for files containing CSS stylesheets to use\n   * in this component.\n   */\n  styleUrls?: string[];\n\n  /**\n   * One or more inline CSS stylesheets to use\n   * in this component.\n   */\n  styles?: string[];\n\n  /**\n   * One or more animation `trigger()` calls, containing\n   * `state()` and `transition()` definitions.\n   * See the [Animations guide](/guide/animations) and animations API documentation.\n   *\n   */\n  animations?: any[];\n\n  /**\n   * An encapsulation policy for the template and CSS styles. One of:\n   * - `ViewEncapsulation.Native`: Use shadow roots. This works\n   * only if natively available on the platform.\n   * - `ViewEncapsulation.Emulated`: Use shimmed CSS that\n   * emulates the native behavior.\n   * - `ViewEncapsulation.None`: Use global CSS without any\n   * encapsulation.\n   *\n   * If not supplied, the value is taken from `CompilerOptions`. The default compiler option is\n   * `ViewEncapsulation.Emulated`.\n   *\n   * If the policy is set to `ViewEncapsulation.Emulated` and the component has no `styles`\n   * or `styleUrls` specified, the policy is automatically switched to `ViewEncapsulation.None`.\n   */\n  encapsulation?: ViewEncapsulation;\n\n  /**\n   * Overrides the default encapsulation start and end delimiters (`{{` and `}}`)\n   */\n  interpolation?: [string, string];\n\n  /**\n   * A set of components that should be compiled along with\n   * this component. For each component listed here,\n   * Angular creates a {@link ComponentFactory} and stores it in the\n   * {@link ComponentFactoryResolver}.\n   */\n  entryComponents?: Array<Type<any>|any[]>;\n\n  /**\n   * True to preserve or false to remove potentially superfluous whitespace characters\n   * from the compiled template. Whitespace characters are those matching the `\\s`\n   * character class in JavaScript regular expressions. Default is false, unless\n   * overridden in compiler options.\n   */\n  preserveWhitespaces?: boolean;\n}\n\n/**\n * Component decorator and metadata.\n *\n * @usageNotes\n *\n * ### Using animations\n *\n * The following snippet shows an animation trigger in a component's\n * metadata. The trigger is attached to an element in the component's\n * template, using \"@_trigger_name_\", and a state expression that is evaluated\n * at run time to determine whether the animation should start.\n *\n * ```typescript\n * @Component({\n *   selector: 'animation-cmp',\n *   templateUrl: 'animation-cmp.html',\n *   animations: [\n *     trigger('myTriggerName', [\n *       state('on', style({ opacity: 1 }),\n *       state('off', style({ opacity: 0 }),\n *       transition('on => off', [\n *         animate(\"1s\")\n *       ])\n *     ])\n *   ]\n * })\n * ```\n *\n * ```html\n * <!-- animation-cmp.html -->\n * <div @myTriggerName=\"expression\">...</div>\n * ```\n *\n * ### Preserving whitespace\n *\n * Removing whitespace can greatly reduce AOT-generated code size, and speed up view creation.\n * As of Angular 6, default for `preserveWhitespaces` is false (whitespace is removed).\n * To change the default setting for all components in your application, set\n * the `preserveWhitespaces` option of the AOT compiler.\n *\n * Current implementation removes whitespace characters as follows:\n * - Trims all whitespaces at the beginning and the end of a template.\n * - Removes whitespace-only text nodes. For example,\n * `<button>Action 1</button>  <button>Action 2</button>` becomes\n * `<button>Action 1</button><button>Action 2</button>`.\n * - Replaces a series of whitespace characters in text nodes with a single space.\n * For example, `<span>\\n some text\\n</span>` becomes `<span> some text </span>`.\n * - Does NOT alter text nodes inside HTML tags such as `<pre>` or `<textarea>`,\n * where whitespace characters are significant.\n *\n * Note that these transformations can influence DOM nodes layout, although impact\n * should be minimal.\n *\n * You can override the default behavior to preserve whitespace characters\n * in certain fragments of a template. For example, you can exclude an entire\n * DOM sub-tree by using the `ngPreserveWhitespaces` attribute:\n *\n * ```html\n * <div ngPreserveWhitespaces>\n *     whitespaces are preserved here\n *     <span>    and here </span>\n * </div>\n * ```\n *\n * You can force a single space to be preserved in a text node by using `&ngsp;`,\n * which is replaced with a space character by Angular's template\n * compiler:\n *\n * ```html\n * <a>Spaces</a>&ngsp;<a>between</a>&ngsp;<a>links.</a>\n * <!-->compiled to be equivalent to:</>\n *  <a>Spaces</a> <a>between</a> <a>links.</a>\n * ```\n *\n * Note that sequences of `&ngsp;` are still collapsed to just one space character when\n * the `preserveWhitespaces` option is set to `false`.\n *\n * ```html\n * <a>before</a>&ngsp;&ngsp;&ngsp;<a>after</a>\n * <!-->compiled to be equivalent to:</>\n *  <a>Spaces</a> <a>between</a> <a>links.</a>\n * ```\n *\n * To preserve sequences of whitespace characters, use the\n * `ngPreserveWhitespaces` attribute.\n *\n * @Annotation\n */\nexport const Component: ComponentDecorator = makeDecorator(\n    'Component', (c: Component = {}) => ({changeDetection: ChangeDetectionStrategy.Default, ...c}),\n    Directive);\n\n/**\n * Type of the Pipe decorator / constructor function.\n */\nexport interface PipeDecorator {\n  /**\n   * Declares a reusable pipe function, and supplies configuration metadata.\n   *\n   */\n  (obj: Pipe): TypeDecorator;\n\n  /**\n   * See the `Pipe` decorator.\n   */\n  new (obj: Pipe): Pipe;\n}\n\n/**\n * Type of the Pipe metadata.\n */\nexport interface Pipe {\n  /**\n   * The pipe name to use in template bindings.\n   *\n   */\n  name: string;\n\n  /**\n   * When true, the pipe is pure, meaning that the\n   * `transform()` method is invoked only when its input arguments\n   * change. Pipes are pure by default.\n   *\n   * If the pipe has internal state (that is, the result\n   * depends on state other than its arguments), set `pure` to false.\n   * In this case, the pipe is invoked on each change-detection cycle,\n   * even if the arguments have not changed.\n   */\n  pure?: boolean;\n}\n\n/**\n *\n *\n * @Annotation\n */\nexport const Pipe: PipeDecorator = makeDecorator('Pipe', (p: Pipe) => ({pure: true, ...p}));\n\n\n/**\n *\n */\nexport interface InputDecorator {\n  /**\n   * Decorator that marks a class as pipe and supplies configuration metadata.\n   *\n   * A pipe class must implement the `PipeTransform` interface.\n   * For example, if the name is \"myPipe\", use a template binding expression\n   * such as the following:\n   *\n   * ```\n   * {{ exp | myPipe }}\n   * ```\n   *\n   * The result of the expression is passed to the pipe's `transform()` method.\n   *\n   * A pipe must belong to an NgModule in order for it to be available\n   * to a template. To make it a member of an NgModule,\n   * list it in the `declarations` field of the `@NgModule` metadata.\n   *\n   */\n  (bindingPropertyName?: string): any;\n  new (bindingPropertyName?: string): any;\n}\n\n/**\n * Type of metadata for an `Input` property.\n *\n *\n */\nexport interface Input {\n  /**\n   * Decorator that marks a class field as an input property and supplies configuration metadata.\n   * Declares a data-bound input property, which Angular automatically updates\n   * during change detection.\n   *\n   * @usageNotes\n   *\n   * You can supply an optional name to use in templates when the\n   * component is instantiated, that maps to the\n   * name of the bound property. By default, the original\n   * name of the bound property is used for input binding.\n   *\n   * The following example creates a component with two input properties,\n   * one of which is given a special binding name.\n   *\n   * ```typescript\n   * @Component({\n   *   selector: 'bank-account',\n   *   template: `\n   *     Bank Name: {{bankName}}\n  *      Account Id: {{id}}\n   *   `\n   * })\n   * class BankAccount {\n   *   // This property is bound using its original name.\n   *   @Input() bankName: string;\n   *   // this property value is bound to a different property name\n   *   // when this component is instantiated in a template.\n   *   @Input('account-id') id: string;\n   *\n   *   // this property is not bound, and is not automatically updated by Angular\n   *   normalizedBankName: string;\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `\n   *     <bank-account bankName=\"RBC\" account-id=\"4747\"></bank-account>\n   *   `\n   * })\n   *\n   * class App {}\n   * ```\n   */\n  bindingPropertyName?: string;\n}\n\n/**\n *\n * @Annotation\n */\nexport const Input: InputDecorator =\n    makePropDecorator('Input', (bindingPropertyName?: string) => ({bindingPropertyName}));\n\n/**\n * Type of the Output decorator / constructor function.\n */\nexport interface OutputDecorator {\n  /**\n  * Decorator that marks a class field as an output property and supplies configuration metadata.\n  * Declares a data-bound output property, which Angular automatically updates\n  * during change detection.\n  *\n  * @usageNotes\n  *\n  * You can supply an optional name to use in templates when the\n  * component is instantiated, that maps to the\n  * name of the bound property. By default, the original\n  * name of the bound property is used for output binding.\n  *\n  * See `@Input` decorator for an example of providing a binding name.\n  *\n  */\n  (bindingPropertyName?: string): any;\n  new (bindingPropertyName?: string): any;\n}\n\n/**\n * Type of the Output metadata.\n */\nexport interface Output { bindingPropertyName?: string; }\n\n/**\n *\n * @Annotation\n */\nexport const Output: OutputDecorator =\n    makePropDecorator('Output', (bindingPropertyName?: string) => ({bindingPropertyName}));\n\n\n/**\n * Type of the HostBinding decorator / constructor function.\n */\nexport interface HostBindingDecorator {\n  /**\n   * Decorator that marks a DOM property as a host-binding property and supplies configuration\n   * metadata.\n   * Angular automatically checks host property bindings during change detection, and\n   * if a binding changes it updates the host element of the directive.\n   *\n   * @usageNotes\n   *\n   * The following example creates a directive that sets the `valid` and `invalid`\n   * properties on the DOM element that has an `ngModel` directive on it.\n   *\n   * ```typescript\n   * @Directive({selector: '[ngModel]'})\n   * class NgModelStatus {\n   *   constructor(public control: NgModel) {}\n   *   @HostBinding('class.valid') get valid() { return this.control.valid; }\n   *   @HostBinding('class.invalid') get invalid() { return this.control.invalid; }\n   * }\n   *\n   * @Component({\n   *   selector: 'app',\n   *   template: `<input [(ngModel)]=\"prop\">`,\n   * })\n   * class App {\n   *   prop;\n   * }\n   * ```\n   */\n  (hostPropertyName?: string): any;\n  new (hostPropertyName?: string): any;\n}\n\n/**\n * Type of the HostBinding metadata.\n *\n */\nexport interface HostBinding { hostPropertyName?: string; }\n\n/**\n *\n * @Annotation\n */\nexport const HostBinding: HostBindingDecorator =\n    makePropDecorator('HostBinding', (hostPropertyName?: string) => ({hostPropertyName}));\n\n\n/**\n * Type of the HostListener decorator / constructor function.\n */\nexport interface HostListenerDecorator {\n  (eventName: string, args?: string[]): any;\n  new (eventName: string, args?: string[]): any;\n}\n\n/**\n * Type of the HostListener metadata.\n */\nexport interface HostListener {\n  /**\n   * The CSS event to listen for.\n   */\n  eventName?: string;\n  /**\n   * A set of arguments to pass to the handler method when the event occurs.\n   */\n  args?: string[];\n}\n\n/**\n * Binds a CSS event to a host listener and supplies configuration metadata.\n * Angular invokes the supplied handler method when the host element emits the specified event,\n * and updates the bound element with the result.\n * If the handler method returns false, applies `preventDefault` on the bound element.\n *\n * @usageNotes\n *\n * The following example declares a directive\n * that attaches a click listener to a button and counts clicks.\n *\n * ```\n * @Directive({selector: 'button[counting]'})\n * class CountClicks {\n *   numberOfClicks = 0;\n *\n *   @HostListener('click', ['$event.target'])\n *   onClick(btn) {\n *     console.log('button', btn, 'number of clicks:', this.numberOfClicks++);\n *  }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: '<button counting>Increment</button>',\n * })\n * class App {}\n * ```\n *\n * @Annotation\n */\nexport const HostListener: HostListenerDecorator =\n    makePropDecorator('HostListener', (eventName?: string, args?: string[]) => ({eventName, args}));\n"]}

package/esm2015/src/metadata/lifecycle_hooks.js

@@ -32,7 +32,7 @@ function SimpleChanges_tsickle_Closure_declarations() {
  * and content children are checked if at least one of them has changed.
  * The `changes` parameter contains the changed properties.
  *
- * See {\@linkDocs guide/lifecycle-hooks#onchanges "Lifecycle Hooks Guide"}.
+ * See ["Lifecycle Hooks Guide"](guide/lifecycle-hooks#onchanges).
  *
  *
  * @record
@@ -54,7 +54,7 @@ function OnChanges_tsickle_Closure_declarations() {
  * first time, and before any of its children have been checked. It is invoked only once when the
  * directive is instantiated.
  *
- * See {\@linkDocs guide/lifecycle-hooks "Lifecycle Hooks Guide"}.
+ * See ["Lifecycle Hooks Guide"](guide/lifecycle-hooks).
  *
  *
  * @record
@@ -82,7 +82,7 @@ function OnInit_tsickle_Closure_declarations() {
  * See {\@link KeyValueDiffers} and {\@link IterableDiffers} for implementing custom dirty checking
  * for collections.
  *
- * See {\@linkDocs guide/lifecycle-hooks#docheck "Lifecycle Hooks Guide"}.
+ * See ["Lifecycle Hooks Guide"](guide/lifecycle-hooks#docheck).
  *
  *
  * @record
@@ -102,7 +102,7 @@ function DoCheck_tsickle_Closure_declarations() {
  * `ngOnDestroy` callback is typically used for any custom cleanup that needs to occur when the
  * instance is destroyed.
  *
- * See {\@linkDocs guide/lifecycle-hooks "Lifecycle Hooks Guide"}.
+ * See ["Lifecycle Hooks Guide"](guide/lifecycle-hooks).
  *
  *
  * @record
@@ -121,7 +121,7 @@ function OnDestroy_tsickle_Closure_declarations() {
  * Lifecycle hook that is called after a directive's content has been fully
  * initialized.
  *
- * See {\@linkDocs guide/lifecycle-hooks#aftercontent "Lifecycle Hooks Guide"}.
+ * See ["Lifecycle Hooks Guide"](guide/lifecycle-hooks#aftercontent).
  *
  *
  * @record
@@ -138,7 +138,7 @@ function AfterContentInit_tsickle_Closure_declarations() {
  * \@description
  * Lifecycle hook that is called after every check of a directive's content.
  *
- * See {\@linkDocs guide/lifecycle-hooks#aftercontent "Lifecycle Hooks Guide"}.
+ * See ["Lifecycle Hooks Guide"](guide/lifecycle-hooks#aftercontent).
  *
  *
  * @record
@@ -156,7 +156,7 @@ function AfterContentChecked_tsickle_Closure_declarations() {
  * Lifecycle hook that is called after a component's view has been fully
  * initialized.
  *
- * See {\@linkDocs guide/lifecycle-hooks#afterview "Lifecycle Hooks Guide"}.
+ * See ["Lifecycle Hooks Guide"](guide/lifecycle-hooks#afterview).
  *
  *
  * @record
@@ -173,7 +173,7 @@ function AfterViewInit_tsickle_Closure_declarations() {
  * \@description
  * Lifecycle hook that is called after every check of a component's view.
  *
- * See {\@linkDocs guide/lifecycle-hooks#afterview "Lifecycle Hooks Guide"}.
+ * See ["Lifecycle Hooks Guide"](guide/lifecycle-hooks#afterview).
  *
  *
  * @record
@@ -184,4 +184,4 @@ function AfterViewChecked_tsickle_Closure_declarations() {
     AfterViewChecked.prototype.ngAfterViewChecked;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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