@angular/core 13.0.0-next.7 → 13.0.0-rc.1

package/esm2020/src/metadata/di.mjs

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { InjectionToken } from '../di/injection_token';
+import { makePropDecorator } from '../util/decorators';
+/**
+ * A DI token that you can use to create a virtual [provider](guide/glossary#provider)
+ * that will populate the `entryComponents` field of components and NgModules
+ * based on its `useValue` property value.
+ * All components that are referenced in the `useValue` value (either directly
+ * or in a nested array or map) are added to the `entryComponents` property.
+ *
+ * @usageNotes
+ *
+ * The following example shows how the router can populate the `entryComponents`
+ * field of an NgModule based on a router configuration that refers
+ * to components.
+ *
+ * ```typescript
+ * // helper function inside the router
+ * function provideRoutes(routes) {
+ *   return [
+ *     {provide: ROUTES, useValue: routes},
+ *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}
+ *   ];
+ * }
+ *
+ * // user code
+ * let routes = [
+ *   {path: '/root', component: RootComp},
+ *   {path: '/teams', component: TeamsComp}
+ * ];
+ *
+ * @NgModule({
+ *   providers: [provideRoutes(routes)]
+ * })
+ * class ModuleWithRoutes {}
+ * ```
+ *
+ * @publicApi
+ * @deprecated Since 9.0.0. With Ivy, this property is no longer necessary.
+ */
+export const ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken('AnalyzeForEntryComponents');
+// Stores the default value of `emitDistinctChangesOnly` when the `emitDistinctChangesOnly` is not
+// explicitly set.
+export const emitDistinctChangesOnlyDefaultValue = true;
+/**
+ * Base class for query metadata.
+ *
+ * @see `ContentChildren`.
+ * @see `ContentChild`.
+ * @see `ViewChildren`.
+ * @see `ViewChild`.
+ *
+ * @publicApi
+ */
+export class Query {
+}
+/**
+ * ContentChildren decorator and metadata.
+ *
+ *
+ * @Annotation
+ * @publicApi
+ */
+export const ContentChildren = makePropDecorator('ContentChildren', (selector, data = {}) => ({
+    selector,
+    first: false,
+    isViewQuery: false,
+    descendants: false,
+    emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue,
+    ...data
+}), Query);
+/**
+ * ContentChild decorator and metadata.
+ *
+ *
+ * @Annotation
+ *
+ * @publicApi
+ */
+export const ContentChild = makePropDecorator('ContentChild', (selector, data = {}) => ({ selector, first: true, isViewQuery: false, descendants: true, ...data }), Query);
+/**
+ * ViewChildren decorator and metadata.
+ *
+ * @Annotation
+ * @publicApi
+ */
+export const ViewChildren = makePropDecorator('ViewChildren', (selector, data = {}) => ({
+    selector,
+    first: false,
+    isViewQuery: true,
+    descendants: true,
+    emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue,
+    ...data
+}), Query);
+/**
+ * ViewChild decorator and metadata.
+ *
+ * @Annotation
+ * @publicApi
+ */
+export const ViewChild = makePropDecorator('ViewChild', (selector, data) => ({ selector, first: true, isViewQuery: true, descendants: true, ...data }), Query);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"di.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/metadata/di.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAErD,OAAO,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,IAAI,cAAc,CAAM,2BAA2B,CAAC,CAAC;AA2DjG,kGAAkG;AAClG,kBAAkB;AAClB,MAAM,CAAC,MAAM,mCAAmC,GAAG,IAAI,CAAC;AAGxD;;;;;;;;;GASG;AACH,MAAM,OAAgB,KAAK;CAAG;AAwF9B;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAA6B,iBAAiB,CACtE,iBAAiB,EAAE,CAAC,QAAc,EAAE,OAAY,EAAE,EAAE,EAAE,CAAC,CAAC;IACnC,QAAQ;IACR,KAAK,EAAE,KAAK;IACZ,WAAW,EAAE,KAAK;IAClB,WAAW,EAAE,KAAK;IAClB,uBAAuB,EAAE,mCAAmC;IAC5D,GAAG,IAAI;CACR,CAAC,EACrB,KAAK,CAAC,CAAC;AAoEX;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,YAAY,GAA0B,iBAAiB,CAChE,cAAc,EACd,CAAC,QAAc,EAAE,OAAY,EAAE,EAAE,EAAE,CAC/B,CAAC,EAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,IAAI,EAAC,CAAC,EAC7E,KAAK,CAAC,CAAC;AA0EX;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAA0B,iBAAiB,CAChE,cAAc,EAAE,CAAC,QAAc,EAAE,OAAY,EAAE,EAAE,EAAE,CAAC,CAAC;IACnC,QAAQ;IACR,KAAK,EAAE,KAAK;IACZ,WAAW,EAAE,IAAI;IACjB,WAAW,EAAE,IAAI;IACjB,uBAAuB,EAAE,mCAAmC;IAC5D,GAAG,IAAI;CACR,CAAC,EAClB,KAAK,CAAC,CAAC;AAkEX;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAuB,iBAAiB,CAC1D,WAAW,EACX,CAAC,QAAa,EAAE,IAAS,EAAE,EAAE,CACzB,CAAC,EAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,IAAI,EAAC,CAAC,EAC5E,KAAK,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {InjectionToken} from '../di/injection_token';\nimport {ProviderToken} from '../di/provider_token';\nimport {makePropDecorator} from '../util/decorators';\n\n/**\n * A DI token that you can use to create a virtual [provider](guide/glossary#provider)\n * that will populate the `entryComponents` field of components and NgModules\n * based on its `useValue` property value.\n * All components that are referenced in the `useValue` value (either directly\n * or in a nested array or map) are added to the `entryComponents` property.\n *\n * @usageNotes\n *\n * The following example shows how the router can populate the `entryComponents`\n * field of an NgModule based on a router configuration that refers\n * to components.\n *\n * ```typescript\n * // helper function inside the router\n * function provideRoutes(routes) {\n *   return [\n *     {provide: ROUTES, useValue: routes},\n *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}\n *   ];\n * }\n *\n * // user code\n * let routes = [\n *   {path: '/root', component: RootComp},\n *   {path: '/teams', component: TeamsComp}\n * ];\n *\n * @NgModule({\n *   providers: [provideRoutes(routes)]\n * })\n * class ModuleWithRoutes {}\n * ```\n *\n * @publicApi\n * @deprecated Since 9.0.0. With Ivy, this property is no longer necessary.\n */\nexport const ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken<any>('AnalyzeForEntryComponents');\n\n/**\n * Type of the `Attribute` decorator / constructor function.\n *\n * @publicApi\n */\nexport interface AttributeDecorator {\n  /**\n   * Specifies that a constant attribute value should be injected.\n   *\n   * The directive can inject constant string literals of host element attributes.\n   *\n   * @usageNotes\n   *\n   * Suppose we have an `<input>` element and want to know its `type`.\n   *\n   * ```html\n   * <input type=\"text\">\n   * ```\n   *\n   * A decorator can inject string literal `text` as in the following example.\n   *\n   * {@example core/ts/metadata/metadata.ts region='attributeMetadata'}\n   *\n   * @publicApi\n   */\n  (name: string): any;\n  new(name: string): Attribute;\n}\n\n\n/**\n * Type of the Attribute metadata.\n *\n * @publicApi\n */\nexport interface Attribute {\n  /**\n   * The name of the attribute to be injected into the constructor.\n   */\n  attributeName?: string;\n}\n\n/**\n * Type of the Query metadata.\n *\n * @publicApi\n */\nexport interface Query {\n  descendants: boolean;\n  emitDistinctChangesOnly: boolean;\n  first: boolean;\n  read: any;\n  isViewQuery: boolean;\n  selector: any;\n  static?: boolean;\n}\n\n// Stores the default value of `emitDistinctChangesOnly` when the `emitDistinctChangesOnly` is not\n// explicitly set.\nexport const emitDistinctChangesOnlyDefaultValue = true;\n\n\n/**\n * Base class for query metadata.\n *\n * @see `ContentChildren`.\n * @see `ContentChild`.\n * @see `ViewChildren`.\n * @see `ViewChild`.\n *\n * @publicApi\n */\nexport abstract class Query {}\n\n/**\n * Type of the ContentChildren decorator / constructor function.\n *\n * @see `ContentChildren`.\n * @publicApi\n */\nexport interface ContentChildrenDecorator {\n  /**\n   * @description\n   * Property decorator that configures a content query.\n   *\n   * Use to get the `QueryList` of elements or directives from the content DOM.\n   * Any time a child element is added, removed, or moved, the query list will be\n   * updated, and the changes observable of the query list will emit a new value.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   *\n   * Does not retrieve elements or directives that are in other components' templates,\n   * since a component's template is always a black box to its ancestors.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - The directive type or the name used for querying.\n   * * **descendants** - If `true` include all descendants of the element. If `false` then only\n   * query direct children of the element.\n   * * **emitDistinctChangesOnly** - The ` QueryList#changes` observable will emit new values only\n   *   if the QueryList result has changed. When `false` the `changes` observable might emit even\n   *   if the QueryList has not changed.\n   *   ** Note: *** This config option is **deprecated**, it will be permanently set to `true` and\n   *   removed in future versions of Angular.\n   * * **read** - Used to read a different token from the queried elements.\n   *\n   * The following selectors are supported.\n   *   * Any class with the `@Component` or `@Directive` decorator\n   *   * A template reference variable as a string (e.g. query `<my-component #cmp></my-component>`\n   * with `@ContentChildren('cmp')`)\n   *   * Any provider defined in the child component tree of the current component (e.g.\n   * `@ContentChildren(SomeService) someService: SomeService`)\n   *   * Any provider defined through a string token (e.g. `@ContentChildren('someToken')\n   * someTokenVal: any`)\n   *   * A `TemplateRef` (e.g. query `<ng-template></ng-template>` with\n   * `@ContentChildren(TemplateRef) template;`)\n   *\n   * In addition, multiple string selectors can be separated with a comma (e.g.\n   * `@ContentChildren('cmp1,cmp2')`)\n   *\n   * The following values are supported by `read`:\n   *   * Any class with the `@Component` or `@Directive` decorator\n   *   * Any provider defined on the injector of the component that is matched by the `selector` of\n   * this query\n   *   * Any provider defined through a string token (e.g. `{provide: 'token', useValue: 'val'}`)\n   *   * `TemplateRef`, `ElementRef`, and `ViewContainerRef`\n   *\n   * @usageNotes\n   *\n   * Here is a simple demonstration of how the `ContentChildren` decorator can be used.\n   *\n   * {@example core/di/ts/contentChildren/content_children_howto.ts region='HowTo'}\n   *\n   * ### Tab-pane example\n   *\n   * Here is a slightly more realistic example that shows how `ContentChildren` decorators\n   * can be used to implement a tab pane component.\n   *\n   * {@example core/di/ts/contentChildren/content_children_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: ProviderToken<unknown>|Function|string, opts?: {\n    descendants?: boolean,\n    emitDistinctChangesOnly?: boolean,\n    read?: any,\n  }): any;\n  new(selector: ProviderToken<unknown>|Function|string,\n      opts?: {descendants?: boolean, emitDistinctChangesOnly?: boolean, read?: any}): Query;\n}\n\n/**\n * Type of the ContentChildren metadata.\n *\n *\n * @Annotation\n * @publicApi\n */\nexport type ContentChildren = Query;\n\n/**\n * ContentChildren decorator and metadata.\n *\n *\n * @Annotation\n * @publicApi\n */\nexport const ContentChildren: ContentChildrenDecorator = makePropDecorator(\n    'ContentChildren', (selector?: any, data: any = {}) => ({\n                         selector,\n                         first: false,\n                         isViewQuery: false,\n                         descendants: false,\n                         emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue,\n                         ...data\n                       }),\n    Query);\n\n/**\n * Type of the ContentChild decorator / constructor function.\n *\n * @publicApi\n */\nexport interface ContentChildDecorator {\n  /**\n   * @description\n   * Property decorator that configures a content query.\n   *\n   * Use to get the first element or the directive matching the selector from the content DOM.\n   * If the content DOM changes, and a new child matches the selector,\n   * the property will be updated.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   *\n   * Does not retrieve elements or directives that are in other components' templates,\n   * since a component's template is always a black box to its ancestors.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - The directive type or the name used for querying.\n   * * **read** - Used to read a different token from the queried element.\n   * * **static** - True to resolve query results before change detection runs,\n   * false to resolve after change detection. Defaults to false.\n   *\n   * The following selectors are supported.\n   *   * Any class with the `@Component` or `@Directive` decorator\n   *   * A template reference variable as a string (e.g. query `<my-component #cmp></my-component>`\n   * with `@ContentChild('cmp')`)\n   *   * Any provider defined in the child component tree of the current component (e.g.\n   * `@ContentChild(SomeService) someService: SomeService`)\n   *   * Any provider defined through a string token (e.g. `@ContentChild('someToken') someTokenVal:\n   * any`)\n   *   * A `TemplateRef` (e.g. query `<ng-template></ng-template>` with `@ContentChild(TemplateRef)\n   * template;`)\n   *\n   * The following values are supported by `read`:\n   *   * Any class with the `@Component` or `@Directive` decorator\n   *   * Any provider defined on the injector of the component that is matched by the `selector` of\n   * this query\n   *   * Any provider defined through a string token (e.g. `{provide: 'token', useValue: 'val'}`)\n   *   * `TemplateRef`, `ElementRef`, and `ViewContainerRef`\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/contentChild/content_child_howto.ts region='HowTo'}\n   *\n   * ### Example\n   *\n   * {@example core/di/ts/contentChild/content_child_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: ProviderToken<unknown>|Function|string, opts?: {read?: any, static?: boolean}): any;\n  new(selector: ProviderToken<unknown>|Function|string,\n      opts?: {read?: any, static?: boolean}): ContentChild;\n}\n\n/**\n * Type of the ContentChild metadata.\n *\n * @publicApi\n */\nexport type ContentChild = Query;\n\n/**\n * ContentChild decorator and metadata.\n *\n *\n * @Annotation\n *\n * @publicApi\n */\nexport const ContentChild: ContentChildDecorator = makePropDecorator(\n    'ContentChild',\n    (selector?: any, data: any = {}) =>\n        ({selector, first: true, isViewQuery: false, descendants: true, ...data}),\n    Query);\n\n/**\n * Type of the ViewChildren decorator / constructor function.\n *\n * @see `ViewChildren`.\n *\n * @publicApi\n */\nexport interface ViewChildrenDecorator {\n  /**\n   * @description\n   * Property decorator that configures a view query.\n   *\n   * Use to get the `QueryList` of elements or directives from the view DOM.\n   * Any time a child element is added, removed, or moved, the query list will be updated,\n   * and the changes observable of the query list will emit a new value.\n   *\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - The directive type or the name used for querying.\n   * * **read** - Used to read a different token from the queried elements.\n   * * **emitDistinctChangesOnly** - The ` QueryList#changes` observable will emit new values only\n   *   if the QueryList result has changed. When `false` the `changes` observable might emit even\n   *   if the QueryList has not changed.\n   *   ** Note: *** This config option is **deprecated**, it will be permanently set to `true` and\n   * removed in future versions of Angular.\n   *\n   * The following selectors are supported.\n   *   * Any class with the `@Component` or `@Directive` decorator\n   *   * A template reference variable as a string (e.g. query `<my-component #cmp></my-component>`\n   * with `@ViewChildren('cmp')`)\n   *   * Any provider defined in the child component tree of the current component (e.g.\n   * `@ViewChildren(SomeService) someService!: SomeService`)\n   *   * Any provider defined through a string token (e.g. `@ViewChildren('someToken')\n   * someTokenVal!: any`)\n   *   * A `TemplateRef` (e.g. query `<ng-template></ng-template>` with `@ViewChildren(TemplateRef)\n   * template;`)\n   *\n   * In addition, multiple string selectors can be separated with a comma (e.g.\n   * `@ViewChildren('cmp1,cmp2')`)\n   *\n   * The following values are supported by `read`:\n   *   * Any class with the `@Component` or `@Directive` decorator\n   *   * Any provider defined on the injector of the component that is matched by the `selector` of\n   * this query\n   *   * Any provider defined through a string token (e.g. `{provide: 'token', useValue: 'val'}`)\n   *   * `TemplateRef`, `ElementRef`, and `ViewContainerRef`\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/viewChildren/view_children_howto.ts region='HowTo'}\n   *\n   * ### Another example\n   *\n   * {@example core/di/ts/viewChildren/view_children_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: ProviderToken<unknown>|Function|string,\n   opts?: {read?: any, emitDistinctChangesOnly?: boolean}): any;\n  new(selector: ProviderToken<unknown>|Function|string,\n      opts?: {read?: any, emitDistinctChangesOnly?: boolean}): ViewChildren;\n}\n\n/**\n * Type of the ViewChildren metadata.\n *\n * @publicApi\n */\nexport type ViewChildren = Query;\n\n/**\n * ViewChildren decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nexport const ViewChildren: ViewChildrenDecorator = makePropDecorator(\n    'ViewChildren', (selector?: any, data: any = {}) => ({\n                      selector,\n                      first: false,\n                      isViewQuery: true,\n                      descendants: true,\n                      emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue,\n                      ...data\n                    }),\n    Query);\n\n/**\n * Type of the ViewChild decorator / constructor function.\n *\n * @see `ViewChild`.\n * @publicApi\n */\nexport interface ViewChildDecorator {\n  /**\n   * @description\n   * Property decorator that configures a view query.\n   * The change detector looks for the first element or the directive matching the selector\n   * in the view DOM. If the view DOM changes, and a new child matches the selector,\n   * the property is updated.\n   *\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - The directive type or the name used for querying.\n   * * **read** - Used to read a different token from the queried elements.\n   * * **static** - True to resolve query results before change detection runs,\n   * false to resolve after change detection. Defaults to false.\n   *\n   *\n   * The following selectors are supported.\n   *   * Any class with the `@Component` or `@Directive` decorator\n   *   * A template reference variable as a string (e.g. query `<my-component #cmp></my-component>`\n   * with `@ViewChild('cmp')`)\n   *   * Any provider defined in the child component tree of the current component (e.g.\n   * `@ViewChild(SomeService) someService: SomeService`)\n   *   * Any provider defined through a string token (e.g. `@ViewChild('someToken') someTokenVal:\n   * any`)\n   *   * A `TemplateRef` (e.g. query `<ng-template></ng-template>` with `@ViewChild(TemplateRef)\n   * template;`)\n   *\n   * The following values are supported by `read`:\n   *   * Any class with the `@Component` or `@Directive` decorator\n   *   * Any provider defined on the injector of the component that is matched by the `selector` of\n   * this query\n   *   * Any provider defined through a string token (e.g. `{provide: 'token', useValue: 'val'}`)\n   *   * `TemplateRef`, `ElementRef`, and `ViewContainerRef`\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/viewChild/view_child_example.ts region='Component'}\n   *\n   * ### Example 2\n   *\n   * {@example core/di/ts/viewChild/view_child_howto.ts region='HowTo'}\n   *\n   * @Annotation\n   */\n  (selector: ProviderToken<unknown>|Function|string, opts?: {read?: any, static?: boolean}): any;\n  new(selector: ProviderToken<unknown>|Function|string,\n      opts?: {read?: any, static?: boolean}): ViewChild;\n}\n\n/**\n * Type of the ViewChild metadata.\n *\n * @publicApi\n */\nexport type ViewChild = Query;\n\n/**\n * ViewChild decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nexport const ViewChild: ViewChildDecorator = makePropDecorator(\n    'ViewChild',\n    (selector: any, data: any) =>\n        ({selector, first: true, isViewQuery: true, descendants: true, ...data}),\n    Query);\n"]}

package/esm2020/src/metadata/directives.mjs

@@ -0,0 +1,112 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ChangeDetectionStrategy } from '../change_detection/constants';
+import { compileComponent as render3CompileComponent, compileDirective as render3CompileDirective } from '../render3/jit/directive';
+import { compilePipe as render3CompilePipe } from '../render3/jit/pipe';
+import { makeDecorator, makePropDecorator } from '../util/decorators';
+import { noop } from '../util/noop';
+/**
+ * Type of the Directive metadata.
+ *
+ * @publicApi
+ */
+export const Directive = makeDecorator('Directive', (dir = {}) => dir, undefined, undefined, (type, meta) => SWITCH_COMPILE_DIRECTIVE(type, meta));
+/**
+ * Component decorator and metadata.
+ *
+ * @Annotation
+ * @publicApi
+ */
+export const Component = makeDecorator('Component', (c = {}) => ({ changeDetection: ChangeDetectionStrategy.Default, ...c }), Directive, undefined, (type, meta) => SWITCH_COMPILE_COMPONENT(type, meta));
+/**
+ * @Annotation
+ * @publicApi
+ */
+export const Pipe = makeDecorator('Pipe', (p) => ({ pure: true, ...p }), undefined, undefined, (type, meta) => SWITCH_COMPILE_PIPE(type, meta));
+/**
+ * @Annotation
+ * @publicApi
+ */
+export const Input = makePropDecorator('Input', (bindingPropertyName) => ({ bindingPropertyName }));
+/**
+ * @Annotation
+ * @publicApi
+ */
+export const Output = makePropDecorator('Output', (bindingPropertyName) => ({ bindingPropertyName }));
+/**
+ * @Annotation
+ * @publicApi
+ */
+export const HostBinding = makePropDecorator('HostBinding', (hostPropertyName) => ({ hostPropertyName }));
+/**
+ * Decorator that binds a DOM 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.
+ *
+ * ```ts
+ * @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 {}
+ *
+ * ```
+ *
+ * The following example registers another DOM event handler that listens for key-press events.
+ * ``` ts
+ * import { HostListener, Component } from "@angular/core";
+ *
+ * @Component({
+ *   selector: 'app',
+ *   template: `<h1>Hello, you have pressed keys {{counter}} number of times!</h1> Press any key to
+ * increment the counter.
+ *   <button (click)="resetCounter()">Reset Counter</button>`
+ * })
+ * class AppComponent {
+ *   counter = 0;
+ *   @HostListener('window:keydown', ['$event'])
+ *   handleKeyDown(event: KeyboardEvent) {
+ *     this.counter++;
+ *   }
+ *   resetCounter() {
+ *     this.counter = 0;
+ *   }
+ * }
+ * ```
+ *
+ * @Annotation
+ * @publicApi
+ */
+export const HostListener = makePropDecorator('HostListener', (eventName, args) => ({ eventName, args }));
+export const SWITCH_COMPILE_COMPONENT__POST_R3__ = render3CompileComponent;
+export const SWITCH_COMPILE_DIRECTIVE__POST_R3__ = render3CompileDirective;
+export const SWITCH_COMPILE_PIPE__POST_R3__ = render3CompilePipe;
+const SWITCH_COMPILE_COMPONENT__PRE_R3__ = noop;
+const SWITCH_COMPILE_DIRECTIVE__PRE_R3__ = noop;
+const SWITCH_COMPILE_PIPE__PRE_R3__ = noop;
+const SWITCH_COMPILE_COMPONENT = SWITCH_COMPILE_COMPONENT__POST_R3__;
+const SWITCH_COMPILE_DIRECTIVE = SWITCH_COMPILE_DIRECTIVE__POST_R3__;
+const SWITCH_COMPILE_PIPE = SWITCH_COMPILE_PIPE__POST_R3__;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directives.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/metadata/directives.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,uBAAuB,EAAC,MAAM,+BAA+B,CAAC;AAGtE,OAAO,EAAC,gBAAgB,IAAI,uBAAuB,EAAE,gBAAgB,IAAI,uBAAuB,EAAC,MAAM,0BAA0B,CAAC;AAClI,OAAO,EAAC,WAAW,IAAI,kBAAkB,EAAC,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAAC,aAAa,EAAE,iBAAiB,EAAgB,MAAM,oBAAoB,CAAC;AACnF,OAAO,EAAC,IAAI,EAAC,MAAM,cAAc,CAAC;AAsRlC;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAuB,aAAa,CACtD,WAAW,EAAE,CAAC,MAAiB,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,SAAS,EAAE,SAAS,EAC/D,CAAC,IAAe,EAAE,IAAe,EAAE,EAAE,CAAC,wBAAwB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAkQhF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAuB,aAAa,CACtD,WAAW,EAAE,CAAC,IAAe,EAAE,EAAE,EAAE,CAAC,CAAC,EAAC,eAAe,EAAE,uBAAuB,CAAC,OAAO,EAAE,GAAG,CAAC,EAAC,CAAC,EAC9F,SAAS,EAAE,SAAS,EACpB,CAAC,IAAe,EAAE,IAAe,EAAE,EAAE,CAAC,wBAAwB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AA+DhF;;;GAGG;AACH,MAAM,CAAC,MAAM,IAAI,GAAkB,aAAa,CAC5C,MAAM,EAAE,CAAC,CAAO,EAAE,EAAE,CAAC,CAAC,EAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,EAAC,CAAC,EAAE,SAAS,EAAE,SAAS,EAC/D,CAAC,IAAe,EAAE,IAAU,EAAE,EAAE,CAAC,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAoEtE;;;GAGG;AACH,MAAM,CAAC,MAAM,KAAK,GACd,iBAAiB,CAAC,OAAO,EAAE,CAAC,mBAA4B,EAAE,EAAE,CAAC,CAAC,EAAC,mBAAmB,EAAC,CAAC,CAAC,CAAC;AAwC1F;;;GAGG;AACH,MAAM,CAAC,MAAM,MAAM,GACf,iBAAiB,CAAC,QAAQ,EAAE,CAAC,mBAA4B,EAAE,EAAE,CAAC,CAAC,EAAC,mBAAmB,EAAC,CAAC,CAAC,CAAC;AAuD3F;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GACpB,iBAAiB,CAAC,aAAa,EAAE,CAAC,gBAAyB,EAAE,EAAE,CAAC,CAAC,EAAC,gBAAgB,EAAC,CAAC,CAAC,CAAC;AAsC1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,MAAM,CAAC,MAAM,YAAY,GACrB,iBAAiB,CAAC,cAAc,EAAE,CAAC,SAAkB,EAAE,IAAe,EAAE,EAAE,CAAC,CAAC,EAAC,SAAS,EAAE,IAAI,EAAC,CAAC,CAAC,CAAC;AAIpG,MAAM,CAAC,MAAM,mCAAmC,GAAG,uBAAuB,CAAC;AAC3E,MAAM,CAAC,MAAM,mCAAmC,GAAG,uBAAuB,CAAC;AAC3E,MAAM,CAAC,MAAM,8BAA8B,GAAG,kBAAkB,CAAC;AAEjE,MAAM,kCAAkC,GAAG,IAAI,CAAC;AAChD,MAAM,kCAAkC,GAAG,IAAI,CAAC;AAChD,MAAM,6BAA6B,GAAG,IAAI,CAAC;AAE3C,MAAM,wBAAwB,GARjB,mCAQsF,CAAC;AACpG,MAAM,wBAAwB,GARjB,mCAQsF,CAAC;AACpG,MAAM,mBAAmB,GARZ,8BAQuE,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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/interface/provider';\nimport {Type} from '../interface/type';\nimport {compileComponent as render3CompileComponent, compileDirective as render3CompileDirective} from '../render3/jit/directive';\nimport {compilePipe as render3CompilePipe} from '../render3/jit/pipe';\nimport {makeDecorator, makePropDecorator, TypeDecorator} from '../util/decorators';\nimport {noop} from '../util/noop';\n\nimport {ViewEncapsulation} from './view';\n\n\n\n/**\n * Type of the Directive decorator / constructor function.\n * @publicApi\n */\nexport interface DirectiveDecorator {\n  /**\n   * Decorator that marks a class as an Angular directive.\n   * You can define your own directives to attach custom behavior to elements in the DOM.\n   *\n   * The options provide configuration metadata that determines\n   * how the directive should be processed, instantiated and used at\n   * runtime.\n   *\n   * Directive classes, like component classes, can implement\n   * [life-cycle hooks](guide/lifecycle-hooks) to influence their configuration and behavior.\n   *\n   *\n   * @usageNotes\n   * To define a directive, mark the class with the decorator and provide metadata.\n   *\n   * ```ts\n   * import {Directive} from '@angular/core';\n   *\n   * @Directive({\n   *   selector: 'my-directive',\n   * })\n   * export class MyDirective {\n   * ...\n   * }\n   * ```\n   *\n   * ### Declaring directives\n   *\n   * Directives are [declarables](guide/glossary#declarable).\n   * They must be declared by an NgModule\n   * in order to be usable in an app.\n   *\n   * A directive must belong to exactly one NgModule. Do not re-declare\n   * a directive imported from another module.\n   * List the directive class in the `declarations` field of an NgModule.\n   *\n   * ```ts\n   * declarations: [\n   *  AppComponent,\n   *  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\n/**\n * Directive decorator and metadata.\n *\n * @Annotation\n * @publicApi\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   * Enumerates the set of data-bound input properties for a directive\n   *\n   * Angular automatically updates input properties during change detection.\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   *\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   */\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   * in 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   *\n   * ```typescript\n   * @Component({\n   *   selector: 'child-dir',\n   *   outputs: [ 'bankNameChange' ]\n   *   template: `<input (input)=\"bankNameChange.emit($event.target.value)\" />`\n   * })\n   * class ChildDir {\n   *  bankNameChange: EventEmitter<string> = new EventEmitter<string>();\n   * }\n   *\n   * @Component({\n   *   selector: 'main',\n   *   template: `\n   *     {{ bankName }} <child-dir (bankNameChange)=\"onBankNameChange($event)\"></child-dir>\n   *   `\n   * })\n   * class MainComponent {\n   *  bankName: string;\n   *\n   *   onBankNameChange(bankName: string) {\n   *     this.bankName = bankName;\n   *   }\n   * }\n   * ```\n   *\n   */\n  outputs?: string[];\n\n  /**\n   * Configures the [injector](guide/glossary#injector) of this\n   * directive or component with a [token](guide/glossary#di-token)\n   * that maps to a [provider](guide/glossary#provider) of a dependency.\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   *\n   * ```ts\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   *\n   * The following example shows how queries are defined\n   * and when their results are available in lifecycle hooks:\n   *\n   * ```ts\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   * 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 evaluates 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   * When present, this directive/component is ignored by the AOT compiler.\n   * It remains in distributed code, and the JIT compiler attempts to compile it\n   * at run time, in the browser.\n   * To ensure the correct behavior, the app must import `@angular/compiler`.\n   */\n  jit?: true;\n}\n\n/**\n * Type of the Directive metadata.\n *\n * @publicApi\n */\nexport const Directive: DirectiveDecorator = makeDecorator(\n    'Directive', (dir: Directive = {}) => dir, undefined, undefined,\n    (type: Type<any>, meta: Directive) => SWITCH_COMPILE_DIRECTIVE(type, meta));\n\n/**\n * Component decorator interface\n *\n * @publicApi\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 for a given element in a\n   * 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\"></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   * ```ts\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   * ### Preserving whitespace\n   *\n   * Removing whitespace can greatly reduce AOT-generated code size and speed up view creation.\n   * As of Angular 6, the 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   * By default, the AOT compiler 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   *\n   * ```html\n   * <button>Action 1</button>  <button>Action 2</button>\n   * ```\n   *\n   * becomes:\n   *\n   * ```html\n   * <button>Action 1</button><button>Action 2</button>\n   * ```\n   *\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>before</a> <a>after</a> -->\n   * ```\n   *\n   * To preserve sequences of whitespace characters, use the\n   * `ngPreserveWhitespaces` attribute.\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 *\n * @publicApi\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 relative path or absolute URL of a template file for an Angular component.\n   * If provided, 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 relative paths or absolute 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.Emulated`: Use shimmed CSS that\n   * emulates the native behavior.\n   * - `ViewEncapsulation.None`: Use global CSS without any\n   * encapsulation.\n   * - `ViewEncapsulation.ShadowDom`: Use Shadow DOM v1 to encapsulate styles.\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 interpolation 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   * @deprecated Since 9.0.0. With Ivy, this property is no longer necessary.\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 * @Annotation\n * @publicApi\n */\nexport const Component: ComponentDecorator = makeDecorator(\n    'Component', (c: Component = {}) => ({changeDetection: ChangeDetectionStrategy.Default, ...c}),\n    Directive, undefined,\n    (type: Type<any>, meta: Component) => SWITCH_COMPILE_COMPONENT(type, meta));\n\n/**\n * Type of the Pipe decorator / constructor function.\n *\n * @publicApi\n */\nexport interface PipeDecorator {\n  /**\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   * @see [Style Guide: Pipe Names](guide/styleguide#02-09)\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 *\n * @publicApi\n */\nexport interface Pipe {\n  /**\n   * The pipe name to use in template bindings.\n   * Typically uses [lowerCamelCase](guide/glossary#case-types)\n   * because the name cannot contain hyphens.\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 * @Annotation\n * @publicApi\n */\nexport const Pipe: PipeDecorator = makeDecorator(\n    'Pipe', (p: Pipe) => ({pure: true, ...p}), undefined, undefined,\n    (type: Type<any>, meta: Pipe) => SWITCH_COMPILE_PIPE(type, meta));\n\n\n/**\n * @publicApi\n */\nexport interface InputDecorator {\n  /**\n   * Decorator that marks a class field as an input property and supplies configuration metadata.\n   * The input property is bound to a DOM property in the template. During change detection,\n   * Angular automatically updates the data property with the DOM property's value.\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   * class App {}\n   * ```\n   *\n   * @see [Input and Output properties](guide/inputs-outputs)\n   */\n  (bindingPropertyName?: string): any;\n  new(bindingPropertyName?: string): any;\n}\n\n/**\n * Type of metadata for an `Input` property.\n *\n * @publicApi\n */\nexport interface Input {\n  /**\n   * The name of the DOM property to which the input property is bound.\n   */\n  bindingPropertyName?: string;\n}\n\n/**\n * @Annotation\n * @publicApi\n */\nexport const Input: InputDecorator =\n    makePropDecorator('Input', (bindingPropertyName?: string) => ({bindingPropertyName}));\n\n/**\n * Type of the Output decorator / constructor function.\n *\n * @publicApi\n */\nexport interface OutputDecorator {\n  /**\n   * Decorator that marks a class field as an output property and supplies configuration metadata.\n   * The DOM property bound to the output property is automatically updated 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   * @see [Input and Output properties](guide/inputs-outputs)\n   *\n   */\n  (bindingPropertyName?: string): any;\n  new(bindingPropertyName?: string): any;\n}\n\n/**\n * Type of the Output metadata.\n *\n * @publicApi\n */\nexport interface Output {\n  /**\n   * The name of the DOM property to which the output property is bound.\n   */\n  bindingPropertyName?: string;\n}\n\n/**\n * @Annotation\n * @publicApi\n */\nexport const Output: OutputDecorator =\n    makePropDecorator('Output', (bindingPropertyName?: string) => ({bindingPropertyName}));\n\n\n\n/**\n * Type of the HostBinding decorator / constructor function.\n *\n * @publicApi\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   */\n  (hostPropertyName?: string): any;\n  new(hostPropertyName?: string): any;\n}\n\n/**\n * Type of the HostBinding metadata.\n *\n * @publicApi\n */\nexport interface HostBinding {\n  /**\n   * The DOM property that is bound to a data property.\n   */\n  hostPropertyName?: string;\n}\n\n/**\n * @Annotation\n * @publicApi\n */\nexport const HostBinding: HostBindingDecorator =\n    makePropDecorator('HostBinding', (hostPropertyName?: string) => ({hostPropertyName}));\n\n\n/**\n * Type of the HostListener decorator / constructor function.\n *\n * @publicApi\n */\nexport interface HostListenerDecorator {\n  /**\n   * Decorator that declares a DOM event to listen for,\n   * and provides a handler method to run when that event occurs.\n   *\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   *\n   * If the handler method returns false, applies `preventDefault` on the bound element.\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 * @publicApi\n */\nexport interface HostListener {\n  /**\n   * The DOM 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 * Decorator that binds a DOM 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 *\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 * ```ts\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 *\n * The following example registers another DOM event handler that listens for key-press events.\n * ``` ts\n * import { HostListener, Component } from \"@angular/core\";\n *\n * @Component({\n *   selector: 'app',\n *   template: `<h1>Hello, you have pressed keys {{counter}} number of times!</h1> Press any key to\n * increment the counter.\n *   <button (click)=\"resetCounter()\">Reset Counter</button>`\n * })\n * class AppComponent {\n *   counter = 0;\n *   @HostListener('window:keydown', ['$event'])\n *   handleKeyDown(event: KeyboardEvent) {\n *     this.counter++;\n *   }\n *   resetCounter() {\n *     this.counter = 0;\n *   }\n * }\n * ```\n *\n * @Annotation\n * @publicApi\n */\nexport const HostListener: HostListenerDecorator =\n    makePropDecorator('HostListener', (eventName?: string, args?: string[]) => ({eventName, args}));\n\n\n\nexport const SWITCH_COMPILE_COMPONENT__POST_R3__ = render3CompileComponent;\nexport const SWITCH_COMPILE_DIRECTIVE__POST_R3__ = render3CompileDirective;\nexport const SWITCH_COMPILE_PIPE__POST_R3__ = render3CompilePipe;\n\nconst SWITCH_COMPILE_COMPONENT__PRE_R3__ = noop;\nconst SWITCH_COMPILE_DIRECTIVE__PRE_R3__ = noop;\nconst SWITCH_COMPILE_PIPE__PRE_R3__ = noop;\n\nconst SWITCH_COMPILE_COMPONENT: typeof render3CompileComponent = SWITCH_COMPILE_COMPONENT__PRE_R3__;\nconst SWITCH_COMPILE_DIRECTIVE: typeof render3CompileDirective = SWITCH_COMPILE_DIRECTIVE__PRE_R3__;\nconst SWITCH_COMPILE_PIPE: typeof render3CompilePipe = SWITCH_COMPILE_PIPE__PRE_R3__;\n"]}

package/esm2020/src/metadata/ng_module.mjs

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ɵɵdefineInjector } from '../di/interface/defs';
+import { convertInjectableProviderToFactory } from '../di/util';
+import { compileNgModule as render3CompileNgModule } from '../render3/jit/module';
+import { makeDecorator } from '../util/decorators';
+/**
+ * @Annotation
+ * @publicApi
+ */
+export const NgModule = makeDecorator('NgModule', (ngModule) => ngModule, undefined, undefined, 
+/**
+ * Decorator that marks the following class as an NgModule, and supplies
+ * configuration metadata for it.
+ *
+ * * The `declarations` and `entryComponents` options configure the compiler
+ * with information about what belongs to the NgModule.
+ * * The `providers` options configures the NgModule's injector to provide
+ * dependencies the NgModule members.
+ * * The `imports` and `exports` options bring in members from other modules, and make
+ * this module's members available to others.
+ */
+(type, meta) => SWITCH_COMPILE_NGMODULE(type, meta));
+function preR3NgModuleCompile(moduleType, metadata) {
+    let imports = (metadata && metadata.imports) || [];
+    if (metadata && metadata.exports) {
+        imports = [...imports, metadata.exports];
+    }
+    const moduleInjectorType = moduleType;
+    moduleInjectorType.ɵfac = convertInjectableProviderToFactory(moduleType, { useClass: moduleType });
+    moduleInjectorType.ɵinj =
+        ɵɵdefineInjector({ providers: metadata && metadata.providers, imports: imports });
+}
+export const SWITCH_COMPILE_NGMODULE__POST_R3__ = render3CompileNgModule;
+const SWITCH_COMPILE_NGMODULE__PRE_R3__ = preR3NgModuleCompile;
+const SWITCH_COMPILE_NGMODULE = SWITCH_COMPILE_NGMODULE__POST_R3__;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng_module.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/metadata/ng_module.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAe,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AAEpE,OAAO,EAAC,kCAAkC,EAAC,MAAM,YAAY,CAAC;AAG9D,OAAO,EAAC,eAAe,IAAI,sBAAsB,EAAC,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAC,aAAa,EAAgB,MAAM,oBAAoB,CAAC;AAoOhE;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAsB,aAAa,CACpD,UAAU,EAAE,CAAC,QAAkB,EAAE,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS;AAClE;;;;;;;;;;GAUG;AACH,CAAC,IAAe,EAAE,IAAc,EAAE,EAAE,CAAC,uBAAuB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAG9E,SAAS,oBAAoB,CAAC,UAAqB,EAAE,QAAmB;IACtE,IAAI,OAAO,GAAG,CAAC,QAAQ,IAAI,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;IACnD,IAAI,QAAQ,IAAI,QAAQ,CAAC,OAAO,EAAE;QAChC,OAAO,GAAG,CAAC,GAAG,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;KAC1C;IAED,MAAM,kBAAkB,GAAG,UAA+B,CAAC;IAC3D,kBAAkB,CAAC,IAAI,GAAG,kCAAkC,CAAC,UAAU,EAAE,EAAC,QAAQ,EAAE,UAAU,EAAC,CAAC,CAAC;IACjG,kBAAkB,CAAC,IAAI;QACnB,gBAAgB,CAAC,EAAC,SAAS,EAAE,QAAQ,IAAI,QAAQ,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAC,CAAC,CAAC;AACtF,CAAC;AAGD,MAAM,CAAC,MAAM,kCAAkC,GAAG,sBAAsB,CAAC;AACzE,MAAM,iCAAiC,GAAG,oBAAoB,CAAC;AAC/D,MAAM,uBAAuB,GAFhB,kCAEmF,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {InjectorType, ɵɵdefineInjector} from '../di/interface/defs';\nimport {Provider} from '../di/interface/provider';\nimport {convertInjectableProviderToFactory} from '../di/util';\nimport {Type} from '../interface/type';\nimport {SchemaMetadata} from '../metadata/schema';\nimport {compileNgModule as render3CompileNgModule} from '../render3/jit/module';\nimport {makeDecorator, TypeDecorator} from '../util/decorators';\n\n\n/**\n * A wrapper around an NgModule that associates it with [providers](guide/glossary#provider\n * \"Definition\"). Usage without a generic type is deprecated.\n *\n * @see [Deprecations](guide/deprecations#modulewithproviders-type-without-a-generic)\n *\n * @publicApi\n */\nexport interface ModuleWithProviders<T> {\n  ngModule: Type<T>;\n  providers?: Provider[];\n}\n\n\n/**\n * Type of the NgModule decorator / constructor function.\n *\n * @publicApi\n */\nexport interface NgModuleDecorator {\n  /**\n   * Decorator that marks a class as an NgModule and supplies configuration metadata.\n   */\n  (obj?: NgModule): TypeDecorator;\n  new(obj?: NgModule): NgModule;\n}\n\n/**\n * Type of the NgModule metadata.\n *\n * @publicApi\n */\nexport interface NgModule {\n  /**\n   * The set of injectable objects that are available in the injector\n   * of this module.\n   *\n   * @see [Dependency Injection guide](guide/dependency-injection)\n   * @see [NgModule guide](guide/providers)\n   *\n   * @usageNotes\n   *\n   * Dependencies whose providers are listed here become available for injection\n   * into any component, directive, pipe or service that is a child of this injector.\n   * The NgModule used for bootstrapping uses the root injector, and can provide dependencies\n   * to any part of the app.\n   *\n   * A lazy-loaded module has its own injector, typically a child of the app root injector.\n   * Lazy-loaded services are scoped to the lazy-loaded module's injector.\n   * If a lazy-loaded module also provides the `UserService`, any component created\n   * within that module's context (such as by router navigation) gets the local instance\n   * of the service, not the instance in the root injector.\n   * Components in external modules continue to receive the instance provided by their injectors.\n   *\n   * ### Example\n   *\n   * The following example defines a class that is injected in\n   * the HelloWorld NgModule:\n   *\n   * ```\n   * class Greeter {\n   *    greet(name:string) {\n   *      return 'Hello ' + name + '!';\n   *    }\n   * }\n   *\n   * @NgModule({\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   * The set of components, directives, and pipes ([declarables](guide/glossary#declarable))\n   * that belong to this module.\n   *\n   * @usageNotes\n   *\n   * The set of selectors that are available to a template include those declared here, and\n   * those that are exported from imported NgModules.\n   *\n   * Declarables must belong to exactly one module.\n   * The compiler emits an error if you try to declare the same class in more than one module.\n   * Be careful not to declare a class that is imported from another module.\n   *\n   * ### Example\n   *\n   * The following example allows the CommonModule to use the `NgFor`\n   * directive.\n   *\n   * ```javascript\n   * @NgModule({\n   *   declarations: [NgFor]\n   * })\n   * class CommonModule {\n   * }\n   * ```\n   */\n  declarations?: Array<Type<any>|any[]>;\n\n  /**\n   * The set of NgModules whose exported [declarables](guide/glossary#declarable)\n   * are available to templates in this module.\n   *\n   * @usageNotes\n   *\n   * A template can use exported declarables from any\n   * imported module, including those from modules that are imported indirectly\n   * and re-exported.\n   * For example, `ModuleA` imports `ModuleB`, and also exports\n   * it, which makes the declarables from `ModuleB` available\n   * wherever `ModuleA` is imported.\n   *\n   * ### Example\n   *\n   * The following example allows MainModule to use anything exported by\n   * `CommonModule`:\n   *\n   * ```javascript\n   * @NgModule({\n   *   imports: [CommonModule]\n   * })\n   * class MainModule {\n   * }\n   * ```\n   *\n   */\n  imports?: Array<Type<any>|ModuleWithProviders<{}>|any[]>;\n\n  /**\n   * The set of components, directives, and pipes declared in this\n   * NgModule that can be used in the template of any component that is part of an\n   * NgModule that imports this NgModule. Exported declarations are the module's public API.\n   *\n   * A declarable belongs to one and only one NgModule.\n   * A module can list another module among its exports, in which case all of that module's\n   * public declaration are exported.\n   *\n   * @usageNotes\n   *\n   * Declarations are private by default.\n   * If this ModuleA does not export UserComponent, then only the components within this\n   * ModuleA can use UserComponent.\n   *\n   * ModuleA can import ModuleB and also export it, making exports from ModuleB\n   * available to an NgModule that imports ModuleA.\n   *\n   * ### Example\n   *\n   * The following example exports the `NgFor` directive from CommonModule.\n   *\n   * ```javascript\n   * @NgModule({\n   *   exports: [NgFor]\n   * })\n   * class CommonModule {\n   * }\n   * ```\n   */\n  exports?: Array<Type<any>|any[]>;\n\n  /**\n   * The set of components to compile when this NgModule is defined,\n   * so that they can be dynamically loaded into the view.\n   *\n   * For each component listed here, Angular creates a `ComponentFactory`\n   * and stores it in the `ComponentFactoryResolver`.\n   *\n   * Angular automatically adds components in the module's bootstrap\n   * and route definitions into the `entryComponents` list. Use this\n   * option to add components that are bootstrapped\n   * using one of the imperative techniques, such as `ViewContainerRef.createComponent()`.\n   *\n   * @see [Entry Components](guide/entry-components)\n   * @deprecated\n   * Since 9.0.0. With Ivy, this property is no longer necessary.\n   * (You may need to keep these if building a library that will be consumed by a View Engine\n   * application.)\n   */\n  entryComponents?: Array<Type<any>|any[]>;\n\n  /**\n   * The set of components that are bootstrapped when\n   * this module is bootstrapped. The components listed here\n   * are automatically added to `entryComponents`.\n   */\n  bootstrap?: Array<Type<any>|any[]>;\n\n  /**\n   * The set of schemas that declare elements to be allowed in the NgModule.\n   * Elements and properties that are neither Angular components nor directives\n   * must be declared in a schema.\n   *\n   * Allowed value are `NO_ERRORS_SCHEMA` and `CUSTOM_ELEMENTS_SCHEMA`.\n   *\n   * @security When using one of `NO_ERRORS_SCHEMA` or `CUSTOM_ELEMENTS_SCHEMA`\n   * you must ensure that allowed elements and properties securely escape inputs.\n   */\n  schemas?: Array<SchemaMetadata|any[]>;\n\n  /**\n   * A name or path that uniquely identifies this NgModule in `getNgModuleById`.\n   * If left `undefined`, the NgModule is not registered with `getNgModuleById`.\n   */\n  id?: string;\n\n  /**\n   * When present, this module is ignored by the AOT compiler.\n   * It remains in distributed code, and the JIT compiler attempts to compile it\n   * at run time, in the browser.\n   * To ensure the correct behavior, the app must import `@angular/compiler`.\n   */\n  jit?: true;\n}\n\n/**\n * @Annotation\n * @publicApi\n */\nexport const NgModule: NgModuleDecorator = makeDecorator(\n    'NgModule', (ngModule: NgModule) => ngModule, undefined, undefined,\n    /**\n     * Decorator that marks the following class as an NgModule, and supplies\n     * configuration metadata for it.\n     *\n     * * The `declarations` and `entryComponents` options configure the compiler\n     * with information about what belongs to the NgModule.\n     * * The `providers` options configures the NgModule's injector to provide\n     * dependencies the NgModule members.\n     * * The `imports` and `exports` options bring in members from other modules, and make\n     * this module's members available to others.\n     */\n    (type: Type<any>, meta: NgModule) => SWITCH_COMPILE_NGMODULE(type, meta));\n\n\nfunction preR3NgModuleCompile(moduleType: Type<any>, metadata?: NgModule): void {\n  let imports = (metadata && metadata.imports) || [];\n  if (metadata && metadata.exports) {\n    imports = [...imports, metadata.exports];\n  }\n\n  const moduleInjectorType = moduleType as InjectorType<any>;\n  moduleInjectorType.ɵfac = convertInjectableProviderToFactory(moduleType, {useClass: moduleType});\n  moduleInjectorType.ɵinj =\n      ɵɵdefineInjector({providers: metadata && metadata.providers, imports: imports});\n}\n\n\nexport const SWITCH_COMPILE_NGMODULE__POST_R3__ = render3CompileNgModule;\nconst SWITCH_COMPILE_NGMODULE__PRE_R3__ = preR3NgModuleCompile;\nconst SWITCH_COMPILE_NGMODULE: typeof render3CompileNgModule = SWITCH_COMPILE_NGMODULE__PRE_R3__;\n"]}

package/{esm2015/src/reflection/reflection_capabilities.js → esm2020/src/reflection/reflection_capabilities.mjs}

@@ -35,12 +35,12 @@ import { stringify } from '../util/stringify';
  * or downleveled to ES5 with `downlevelIteration` for TypeScript >= 4.2:
  * ```
  *   function MyClass() {
- *     var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+ *     var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
  * ```
  *
  * More details can be found in: https://github.com/angular/angular/issues/38453.
  */
-export const ES5_DELEGATE_CTOR = /^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*(arguments|(?:[^()]+\(\[\],)?[^()]+\(arguments\))\)/;
+export const ES5_DELEGATE_CTOR = /^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*(arguments|(?:[^()]+\(\[\],)?[^()]+\(arguments\).*)\)/;
 /** Regular expression that detects ES2015 classes which extend from other classes. */
 export const ES2015_INHERITED_CLASS = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/;
 /**
@@ -295,4 +295,4 @@ function getParentCtor(ctor) {
     // to simplify checking later on.
     return parentCtor || Object;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reflection_capabilities.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/reflection/reflection_capabilities.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {isType, Type} from '../interface/type';\nimport {newArray} from '../util/array_utils';\nimport {ANNOTATIONS, PARAMETERS, PROP_METADATA} from '../util/decorators';\nimport {global} from '../util/global';\nimport {stringify} from '../util/stringify';\n\nimport {PlatformReflectionCapabilities} from './platform_reflection_capabilities';\nimport {GetterFn, MethodFn, SetterFn} from './types';\n\n\n\n/*\n * #########################\n * Attention: These Regular expressions have to hold even if the code is minified!\n * ##########################\n */\n\n/**\n * Regular expression that detects pass-through constructors for ES5 output. This Regex\n * intends to capture the common delegation pattern emitted by TypeScript and Babel. Also\n * it intends to capture the pattern where existing constructors have been downleveled from\n * ES2015 to ES5 using TypeScript w/ downlevel iteration. e.g.\n *\n * ```\n *   function MyClass() {\n *     var _this = _super.apply(this, arguments) || this;\n * ```\n *\n * downleveled to ES5 with `downlevelIteration` for TypeScript < 4.2:\n * ```\n *   function MyClass() {\n *     var _this = _super.apply(this, __spread(arguments)) || this;\n * ```\n *\n * or downleveled to ES5 with `downlevelIteration` for TypeScript >= 4.2:\n * ```\n *   function MyClass() {\n *     var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;\n * ```\n *\n * More details can be found in: https://github.com/angular/angular/issues/38453.\n */\nexport const ES5_DELEGATE_CTOR =\n    /^function\\s+\\S+\\(\\)\\s*{[\\s\\S]+\\.apply\\(this,\\s*(arguments|(?:[^()]+\\(\\[\\],)?[^()]+\\(arguments\\))\\)/;\n/** Regular expression that detects ES2015 classes which extend from other classes. */\nexport const ES2015_INHERITED_CLASS = /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[^{]+{/;\n/**\n * Regular expression that detects ES2015 classes which extend from other classes and\n * have an explicit constructor defined.\n */\nexport const ES2015_INHERITED_CLASS_WITH_CTOR =\n    /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[^{]+{[\\s\\S]*constructor\\s*\\(/;\n/**\n * Regular expression that detects ES2015 classes which extend from other classes\n * and inherit a constructor.\n */\nexport const ES2015_INHERITED_CLASS_WITH_DELEGATE_CTOR =\n    /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[^{]+{[\\s\\S]*constructor\\s*\\(\\)\\s*{\\s*super\\(\\.\\.\\.arguments\\)/;\n\n/**\n * Determine whether a stringified type is a class which delegates its constructor\n * to its parent.\n *\n * This is not trivial since compiled code can actually contain a constructor function\n * even if the original source code did not. For instance, when the child class contains\n * an initialized instance property.\n */\nexport function isDelegateCtor(typeStr: string): boolean {\n  return ES5_DELEGATE_CTOR.test(typeStr) ||\n      ES2015_INHERITED_CLASS_WITH_DELEGATE_CTOR.test(typeStr) ||\n      (ES2015_INHERITED_CLASS.test(typeStr) && !ES2015_INHERITED_CLASS_WITH_CTOR.test(typeStr));\n}\n\nexport class ReflectionCapabilities implements PlatformReflectionCapabilities {\n  private _reflect: any;\n\n  constructor(reflect?: any) {\n    this._reflect = reflect || global['Reflect'];\n  }\n\n  isReflectionEnabled(): boolean {\n    return true;\n  }\n\n  factory<T>(t: Type<T>): (args: any[]) => T {\n    return (...args: any[]) => new t(...args);\n  }\n\n  /** @internal */\n  _zipTypesAndAnnotations(paramTypes: any[], paramAnnotations: any[]): any[][] {\n    let result: any[][];\n\n    if (typeof paramTypes === 'undefined') {\n      result = newArray(paramAnnotations.length);\n    } else {\n      result = newArray(paramTypes.length);\n    }\n\n    for (let i = 0; i < result.length; i++) {\n      // TS outputs Object for parameters without types, while Traceur omits\n      // the annotations. For now we preserve the Traceur behavior to aid\n      // migration, but this can be revisited.\n      if (typeof paramTypes === 'undefined') {\n        result[i] = [];\n      } else if (paramTypes[i] && paramTypes[i] != Object) {\n        result[i] = [paramTypes[i]];\n      } else {\n        result[i] = [];\n      }\n      if (paramAnnotations && paramAnnotations[i] != null) {\n        result[i] = result[i].concat(paramAnnotations[i]);\n      }\n    }\n    return result;\n  }\n\n  private _ownParameters(type: Type<any>, parentCtor: any): any[][]|null {\n    const typeStr = type.toString();\n    // If we have no decorators, we only have function.length as metadata.\n    // In that case, to detect whether a child class declared an own constructor or not,\n    // we need to look inside of that constructor to check whether it is\n    // just calling the parent.\n    // This also helps to work around for https://github.com/Microsoft/TypeScript/issues/12439\n    // that sets 'design:paramtypes' to []\n    // if a class inherits from another class but has no ctor declared itself.\n    if (isDelegateCtor(typeStr)) {\n      return null;\n    }\n\n    // Prefer the direct API.\n    if ((<any>type).parameters && (<any>type).parameters !== parentCtor.parameters) {\n      return (<any>type).parameters;\n    }\n\n    // API of tsickle for lowering decorators to properties on the class.\n    const tsickleCtorParams = (<any>type).ctorParameters;\n    if (tsickleCtorParams && tsickleCtorParams !== parentCtor.ctorParameters) {\n      // Newer tsickle uses a function closure\n      // Retain the non-function case for compatibility with older tsickle\n      const ctorParameters =\n          typeof tsickleCtorParams === 'function' ? tsickleCtorParams() : tsickleCtorParams;\n      const paramTypes = ctorParameters.map((ctorParam: any) => ctorParam && ctorParam.type);\n      const paramAnnotations = ctorParameters.map(\n          (ctorParam: any) =>\n              ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators));\n      return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);\n    }\n\n    // API for metadata created by invoking the decorators.\n    const paramAnnotations = type.hasOwnProperty(PARAMETERS) && (type as any)[PARAMETERS];\n    const paramTypes = this._reflect && this._reflect.getOwnMetadata &&\n        this._reflect.getOwnMetadata('design:paramtypes', type);\n    if (paramTypes || paramAnnotations) {\n      return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);\n    }\n\n    // If a class has no decorators, at least create metadata\n    // based on function.length.\n    // Note: We know that this is a real constructor as we checked\n    // the content of the constructor above.\n    return newArray<any[]>(type.length);\n  }\n\n  parameters(type: Type<any>): any[][] {\n    // Note: only report metadata if we have at least one class decorator\n    // to stay in sync with the static reflector.\n    if (!isType(type)) {\n      return [];\n    }\n    const parentCtor = getParentCtor(type);\n    let parameters = this._ownParameters(type, parentCtor);\n    if (!parameters && parentCtor !== Object) {\n      parameters = this.parameters(parentCtor);\n    }\n    return parameters || [];\n  }\n\n  private _ownAnnotations(typeOrFunc: Type<any>, parentCtor: any): any[]|null {\n    // Prefer the direct API.\n    if ((<any>typeOrFunc).annotations && (<any>typeOrFunc).annotations !== parentCtor.annotations) {\n      let annotations = (<any>typeOrFunc).annotations;\n      if (typeof annotations === 'function' && annotations.annotations) {\n        annotations = annotations.annotations;\n      }\n      return annotations;\n    }\n\n    // API of tsickle for lowering decorators to properties on the class.\n    if ((<any>typeOrFunc).decorators && (<any>typeOrFunc).decorators !== parentCtor.decorators) {\n      return convertTsickleDecoratorIntoMetadata((<any>typeOrFunc).decorators);\n    }\n\n    // API for metadata created by invoking the decorators.\n    if (typeOrFunc.hasOwnProperty(ANNOTATIONS)) {\n      return (typeOrFunc as any)[ANNOTATIONS];\n    }\n    return null;\n  }\n\n  annotations(typeOrFunc: Type<any>): any[] {\n    if (!isType(typeOrFunc)) {\n      return [];\n    }\n    const parentCtor = getParentCtor(typeOrFunc);\n    const ownAnnotations = this._ownAnnotations(typeOrFunc, parentCtor) || [];\n    const parentAnnotations = parentCtor !== Object ? this.annotations(parentCtor) : [];\n    return parentAnnotations.concat(ownAnnotations);\n  }\n\n  private _ownPropMetadata(typeOrFunc: any, parentCtor: any): {[key: string]: any[]}|null {\n    // Prefer the direct API.\n    if ((<any>typeOrFunc).propMetadata &&\n        (<any>typeOrFunc).propMetadata !== parentCtor.propMetadata) {\n      let propMetadata = (<any>typeOrFunc).propMetadata;\n      if (typeof propMetadata === 'function' && propMetadata.propMetadata) {\n        propMetadata = propMetadata.propMetadata;\n      }\n      return propMetadata;\n    }\n\n    // API of tsickle for lowering decorators to properties on the class.\n    if ((<any>typeOrFunc).propDecorators &&\n        (<any>typeOrFunc).propDecorators !== parentCtor.propDecorators) {\n      const propDecorators = (<any>typeOrFunc).propDecorators;\n      const propMetadata = <{[key: string]: any[]}>{};\n      Object.keys(propDecorators).forEach(prop => {\n        propMetadata[prop] = convertTsickleDecoratorIntoMetadata(propDecorators[prop]);\n      });\n      return propMetadata;\n    }\n\n    // API for metadata created by invoking the decorators.\n    if (typeOrFunc.hasOwnProperty(PROP_METADATA)) {\n      return (typeOrFunc as any)[PROP_METADATA];\n    }\n    return null;\n  }\n\n  propMetadata(typeOrFunc: any): {[key: string]: any[]} {\n    if (!isType(typeOrFunc)) {\n      return {};\n    }\n    const parentCtor = getParentCtor(typeOrFunc);\n    const propMetadata: {[key: string]: any[]} = {};\n    if (parentCtor !== Object) {\n      const parentPropMetadata = this.propMetadata(parentCtor);\n      Object.keys(parentPropMetadata).forEach((propName) => {\n        propMetadata[propName] = parentPropMetadata[propName];\n      });\n    }\n    const ownPropMetadata = this._ownPropMetadata(typeOrFunc, parentCtor);\n    if (ownPropMetadata) {\n      Object.keys(ownPropMetadata).forEach((propName) => {\n        const decorators: any[] = [];\n        if (propMetadata.hasOwnProperty(propName)) {\n          decorators.push(...propMetadata[propName]);\n        }\n        decorators.push(...ownPropMetadata[propName]);\n        propMetadata[propName] = decorators;\n      });\n    }\n    return propMetadata;\n  }\n\n  ownPropMetadata(typeOrFunc: any): {[key: string]: any[]} {\n    if (!isType(typeOrFunc)) {\n      return {};\n    }\n    return this._ownPropMetadata(typeOrFunc, getParentCtor(typeOrFunc)) || {};\n  }\n\n  hasLifecycleHook(type: any, lcProperty: string): boolean {\n    return type instanceof Type && lcProperty in type.prototype;\n  }\n\n  guards(type: any): {[key: string]: any} {\n    return {};\n  }\n\n  getter(name: string): GetterFn {\n    return <GetterFn>new Function('o', 'return o.' + name + ';');\n  }\n\n  setter(name: string): SetterFn {\n    return <SetterFn>new Function('o', 'v', 'return o.' + name + ' = v;');\n  }\n\n  method(name: string): MethodFn {\n    const functionBody = `if (!o.${name}) throw new Error('\"${name}\" is undefined');\n        return o.${name}.apply(o, args);`;\n    return <MethodFn>new Function('o', 'args', functionBody);\n  }\n\n  // There is not a concept of import uri in Js, but this is useful in developing Dart applications.\n  importUri(type: any): string {\n    // StaticSymbol\n    if (typeof type === 'object' && type['filePath']) {\n      return type['filePath'];\n    }\n    // Runtime type\n    return `./${stringify(type)}`;\n  }\n\n  resourceUri(type: any): string {\n    return `./${stringify(type)}`;\n  }\n\n  resolveIdentifier(name: string, moduleUrl: string, members: string[], runtime: any): any {\n    return runtime;\n  }\n  resolveEnum(enumIdentifier: any, name: string): any {\n    return enumIdentifier[name];\n  }\n}\n\nfunction convertTsickleDecoratorIntoMetadata(decoratorInvocations: any[]): any[] {\n  if (!decoratorInvocations) {\n    return [];\n  }\n  return decoratorInvocations.map(decoratorInvocation => {\n    const decoratorType = decoratorInvocation.type;\n    const annotationCls = decoratorType.annotationCls;\n    const annotationArgs = decoratorInvocation.args ? decoratorInvocation.args : [];\n    return new annotationCls(...annotationArgs);\n  });\n}\n\nfunction getParentCtor(ctor: Function): Type<any> {\n  const parentProto = ctor.prototype ? Object.getPrototypeOf(ctor.prototype) : null;\n  const parentCtor = parentProto ? parentProto.constructor : null;\n  // Note: We always use `Object` as the null value\n  // to simplify checking later on.\n  return parentCtor || Object;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reflection_capabilities.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/reflection/reflection_capabilities.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {isType, Type} from '../interface/type';\nimport {newArray} from '../util/array_utils';\nimport {ANNOTATIONS, PARAMETERS, PROP_METADATA} from '../util/decorators';\nimport {global} from '../util/global';\nimport {stringify} from '../util/stringify';\n\nimport {PlatformReflectionCapabilities} from './platform_reflection_capabilities';\nimport {GetterFn, MethodFn, SetterFn} from './types';\n\n\n\n/*\n * #########################\n * Attention: These Regular expressions have to hold even if the code is minified!\n * ##########################\n */\n\n/**\n * Regular expression that detects pass-through constructors for ES5 output. This Regex\n * intends to capture the common delegation pattern emitted by TypeScript and Babel. Also\n * it intends to capture the pattern where existing constructors have been downleveled from\n * ES2015 to ES5 using TypeScript w/ downlevel iteration. e.g.\n *\n * ```\n *   function MyClass() {\n *     var _this = _super.apply(this, arguments) || this;\n * ```\n *\n * downleveled to ES5 with `downlevelIteration` for TypeScript < 4.2:\n * ```\n *   function MyClass() {\n *     var _this = _super.apply(this, __spread(arguments)) || this;\n * ```\n *\n * or downleveled to ES5 with `downlevelIteration` for TypeScript >= 4.2:\n * ```\n *   function MyClass() {\n *     var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;\n * ```\n *\n * More details can be found in: https://github.com/angular/angular/issues/38453.\n */\nexport const ES5_DELEGATE_CTOR =\n    /^function\\s+\\S+\\(\\)\\s*{[\\s\\S]+\\.apply\\(this,\\s*(arguments|(?:[^()]+\\(\\[\\],)?[^()]+\\(arguments\\).*)\\)/;\n/** Regular expression that detects ES2015 classes which extend from other classes. */\nexport const ES2015_INHERITED_CLASS = /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[^{]+{/;\n/**\n * Regular expression that detects ES2015 classes which extend from other classes and\n * have an explicit constructor defined.\n */\nexport const ES2015_INHERITED_CLASS_WITH_CTOR =\n    /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[^{]+{[\\s\\S]*constructor\\s*\\(/;\n/**\n * Regular expression that detects ES2015 classes which extend from other classes\n * and inherit a constructor.\n */\nexport const ES2015_INHERITED_CLASS_WITH_DELEGATE_CTOR =\n    /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[^{]+{[\\s\\S]*constructor\\s*\\(\\)\\s*{\\s*super\\(\\.\\.\\.arguments\\)/;\n\n/**\n * Determine whether a stringified type is a class which delegates its constructor\n * to its parent.\n *\n * This is not trivial since compiled code can actually contain a constructor function\n * even if the original source code did not. For instance, when the child class contains\n * an initialized instance property.\n */\nexport function isDelegateCtor(typeStr: string): boolean {\n  return ES5_DELEGATE_CTOR.test(typeStr) ||\n      ES2015_INHERITED_CLASS_WITH_DELEGATE_CTOR.test(typeStr) ||\n      (ES2015_INHERITED_CLASS.test(typeStr) && !ES2015_INHERITED_CLASS_WITH_CTOR.test(typeStr));\n}\n\nexport class ReflectionCapabilities implements PlatformReflectionCapabilities {\n  private _reflect: any;\n\n  constructor(reflect?: any) {\n    this._reflect = reflect || global['Reflect'];\n  }\n\n  isReflectionEnabled(): boolean {\n    return true;\n  }\n\n  factory<T>(t: Type<T>): (args: any[]) => T {\n    return (...args: any[]) => new t(...args);\n  }\n\n  /** @internal */\n  _zipTypesAndAnnotations(paramTypes: any[], paramAnnotations: any[]): any[][] {\n    let result: any[][];\n\n    if (typeof paramTypes === 'undefined') {\n      result = newArray(paramAnnotations.length);\n    } else {\n      result = newArray(paramTypes.length);\n    }\n\n    for (let i = 0; i < result.length; i++) {\n      // TS outputs Object for parameters without types, while Traceur omits\n      // the annotations. For now we preserve the Traceur behavior to aid\n      // migration, but this can be revisited.\n      if (typeof paramTypes === 'undefined') {\n        result[i] = [];\n      } else if (paramTypes[i] && paramTypes[i] != Object) {\n        result[i] = [paramTypes[i]];\n      } else {\n        result[i] = [];\n      }\n      if (paramAnnotations && paramAnnotations[i] != null) {\n        result[i] = result[i].concat(paramAnnotations[i]);\n      }\n    }\n    return result;\n  }\n\n  private _ownParameters(type: Type<any>, parentCtor: any): any[][]|null {\n    const typeStr = type.toString();\n    // If we have no decorators, we only have function.length as metadata.\n    // In that case, to detect whether a child class declared an own constructor or not,\n    // we need to look inside of that constructor to check whether it is\n    // just calling the parent.\n    // This also helps to work around for https://github.com/Microsoft/TypeScript/issues/12439\n    // that sets 'design:paramtypes' to []\n    // if a class inherits from another class but has no ctor declared itself.\n    if (isDelegateCtor(typeStr)) {\n      return null;\n    }\n\n    // Prefer the direct API.\n    if ((<any>type).parameters && (<any>type).parameters !== parentCtor.parameters) {\n      return (<any>type).parameters;\n    }\n\n    // API of tsickle for lowering decorators to properties on the class.\n    const tsickleCtorParams = (<any>type).ctorParameters;\n    if (tsickleCtorParams && tsickleCtorParams !== parentCtor.ctorParameters) {\n      // Newer tsickle uses a function closure\n      // Retain the non-function case for compatibility with older tsickle\n      const ctorParameters =\n          typeof tsickleCtorParams === 'function' ? tsickleCtorParams() : tsickleCtorParams;\n      const paramTypes = ctorParameters.map((ctorParam: any) => ctorParam && ctorParam.type);\n      const paramAnnotations = ctorParameters.map(\n          (ctorParam: any) =>\n              ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators));\n      return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);\n    }\n\n    // API for metadata created by invoking the decorators.\n    const paramAnnotations = type.hasOwnProperty(PARAMETERS) && (type as any)[PARAMETERS];\n    const paramTypes = this._reflect && this._reflect.getOwnMetadata &&\n        this._reflect.getOwnMetadata('design:paramtypes', type);\n    if (paramTypes || paramAnnotations) {\n      return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);\n    }\n\n    // If a class has no decorators, at least create metadata\n    // based on function.length.\n    // Note: We know that this is a real constructor as we checked\n    // the content of the constructor above.\n    return newArray<any[]>(type.length);\n  }\n\n  parameters(type: Type<any>): any[][] {\n    // Note: only report metadata if we have at least one class decorator\n    // to stay in sync with the static reflector.\n    if (!isType(type)) {\n      return [];\n    }\n    const parentCtor = getParentCtor(type);\n    let parameters = this._ownParameters(type, parentCtor);\n    if (!parameters && parentCtor !== Object) {\n      parameters = this.parameters(parentCtor);\n    }\n    return parameters || [];\n  }\n\n  private _ownAnnotations(typeOrFunc: Type<any>, parentCtor: any): any[]|null {\n    // Prefer the direct API.\n    if ((<any>typeOrFunc).annotations && (<any>typeOrFunc).annotations !== parentCtor.annotations) {\n      let annotations = (<any>typeOrFunc).annotations;\n      if (typeof annotations === 'function' && annotations.annotations) {\n        annotations = annotations.annotations;\n      }\n      return annotations;\n    }\n\n    // API of tsickle for lowering decorators to properties on the class.\n    if ((<any>typeOrFunc).decorators && (<any>typeOrFunc).decorators !== parentCtor.decorators) {\n      return convertTsickleDecoratorIntoMetadata((<any>typeOrFunc).decorators);\n    }\n\n    // API for metadata created by invoking the decorators.\n    if (typeOrFunc.hasOwnProperty(ANNOTATIONS)) {\n      return (typeOrFunc as any)[ANNOTATIONS];\n    }\n    return null;\n  }\n\n  annotations(typeOrFunc: Type<any>): any[] {\n    if (!isType(typeOrFunc)) {\n      return [];\n    }\n    const parentCtor = getParentCtor(typeOrFunc);\n    const ownAnnotations = this._ownAnnotations(typeOrFunc, parentCtor) || [];\n    const parentAnnotations = parentCtor !== Object ? this.annotations(parentCtor) : [];\n    return parentAnnotations.concat(ownAnnotations);\n  }\n\n  private _ownPropMetadata(typeOrFunc: any, parentCtor: any): {[key: string]: any[]}|null {\n    // Prefer the direct API.\n    if ((<any>typeOrFunc).propMetadata &&\n        (<any>typeOrFunc).propMetadata !== parentCtor.propMetadata) {\n      let propMetadata = (<any>typeOrFunc).propMetadata;\n      if (typeof propMetadata === 'function' && propMetadata.propMetadata) {\n        propMetadata = propMetadata.propMetadata;\n      }\n      return propMetadata;\n    }\n\n    // API of tsickle for lowering decorators to properties on the class.\n    if ((<any>typeOrFunc).propDecorators &&\n        (<any>typeOrFunc).propDecorators !== parentCtor.propDecorators) {\n      const propDecorators = (<any>typeOrFunc).propDecorators;\n      const propMetadata = <{[key: string]: any[]}>{};\n      Object.keys(propDecorators).forEach(prop => {\n        propMetadata[prop] = convertTsickleDecoratorIntoMetadata(propDecorators[prop]);\n      });\n      return propMetadata;\n    }\n\n    // API for metadata created by invoking the decorators.\n    if (typeOrFunc.hasOwnProperty(PROP_METADATA)) {\n      return (typeOrFunc as any)[PROP_METADATA];\n    }\n    return null;\n  }\n\n  propMetadata(typeOrFunc: any): {[key: string]: any[]} {\n    if (!isType(typeOrFunc)) {\n      return {};\n    }\n    const parentCtor = getParentCtor(typeOrFunc);\n    const propMetadata: {[key: string]: any[]} = {};\n    if (parentCtor !== Object) {\n      const parentPropMetadata = this.propMetadata(parentCtor);\n      Object.keys(parentPropMetadata).forEach((propName) => {\n        propMetadata[propName] = parentPropMetadata[propName];\n      });\n    }\n    const ownPropMetadata = this._ownPropMetadata(typeOrFunc, parentCtor);\n    if (ownPropMetadata) {\n      Object.keys(ownPropMetadata).forEach((propName) => {\n        const decorators: any[] = [];\n        if (propMetadata.hasOwnProperty(propName)) {\n          decorators.push(...propMetadata[propName]);\n        }\n        decorators.push(...ownPropMetadata[propName]);\n        propMetadata[propName] = decorators;\n      });\n    }\n    return propMetadata;\n  }\n\n  ownPropMetadata(typeOrFunc: any): {[key: string]: any[]} {\n    if (!isType(typeOrFunc)) {\n      return {};\n    }\n    return this._ownPropMetadata(typeOrFunc, getParentCtor(typeOrFunc)) || {};\n  }\n\n  hasLifecycleHook(type: any, lcProperty: string): boolean {\n    return type instanceof Type && lcProperty in type.prototype;\n  }\n\n  guards(type: any): {[key: string]: any} {\n    return {};\n  }\n\n  getter(name: string): GetterFn {\n    return <GetterFn>new Function('o', 'return o.' + name + ';');\n  }\n\n  setter(name: string): SetterFn {\n    return <SetterFn>new Function('o', 'v', 'return o.' + name + ' = v;');\n  }\n\n  method(name: string): MethodFn {\n    const functionBody = `if (!o.${name}) throw new Error('\"${name}\" is undefined');\n        return o.${name}.apply(o, args);`;\n    return <MethodFn>new Function('o', 'args', functionBody);\n  }\n\n  // There is not a concept of import uri in Js, but this is useful in developing Dart applications.\n  importUri(type: any): string {\n    // StaticSymbol\n    if (typeof type === 'object' && type['filePath']) {\n      return type['filePath'];\n    }\n    // Runtime type\n    return `./${stringify(type)}`;\n  }\n\n  resourceUri(type: any): string {\n    return `./${stringify(type)}`;\n  }\n\n  resolveIdentifier(name: string, moduleUrl: string, members: string[], runtime: any): any {\n    return runtime;\n  }\n  resolveEnum(enumIdentifier: any, name: string): any {\n    return enumIdentifier[name];\n  }\n}\n\nfunction convertTsickleDecoratorIntoMetadata(decoratorInvocations: any[]): any[] {\n  if (!decoratorInvocations) {\n    return [];\n  }\n  return decoratorInvocations.map(decoratorInvocation => {\n    const decoratorType = decoratorInvocation.type;\n    const annotationCls = decoratorType.annotationCls;\n    const annotationArgs = decoratorInvocation.args ? decoratorInvocation.args : [];\n    return new annotationCls(...annotationArgs);\n  });\n}\n\nfunction getParentCtor(ctor: Function): Type<any> {\n  const parentProto = ctor.prototype ? Object.getPrototypeOf(ctor.prototype) : null;\n  const parentCtor = parentProto ? parentProto.constructor : null;\n  // Note: We always use `Object` as the null value\n  // to simplify checking later on.\n  return parentCtor || Object;\n}\n"]}