@angular/core 17.0.0-next.6 → 17.0.0-next.7

package/esm2022/src/render3/instructions/defer_events.mjs

@@ -33,8 +33,9 @@ class DeferEventEntry {
  * Registers an interaction trigger.
  * @param trigger Element that is the trigger.
  * @param callback Callback to be invoked when the trigger is interacted with.
+ * @param injector Injector that can be used by the trigger to resolve DI tokens.
  */
-export function onInteraction(trigger, callback) {
+export function onInteraction(trigger, callback, injector) {
     let entry = interactionTriggers.get(trigger);
     // If this is the first entry for this element, add the listeners.
     if (!entry) {
@@ -51,9 +52,13 @@ export function onInteraction(trigger, callback) {
         // are referencing it.
         entry = new DeferEventEntry();
         interactionTriggers.set(trigger, entry);
-        for (const name of interactionEventNames) {
-            trigger.addEventListener(name, entry.listener, eventListenerOptions);
-        }
+        // Ensure that the handler runs in the NgZone since it gets
+        // registered in `afterRender` which runs outside.
+        injector.get(NgZone).run(() => {
+            for (const name of interactionEventNames) {
+                trigger.addEventListener(name, entry.listener, eventListenerOptions);
+            }
+        });
     }
     entry.callbacks.add(callback);
     return () => {
@@ -71,14 +76,19 @@ export function onInteraction(trigger, callback) {
  * Registers a hover trigger.
  * @param trigger Element that is the trigger.
  * @param callback Callback to be invoked when the trigger is hovered over.
+ * @param injector Injector that can be used by the trigger to resolve DI tokens.
  */
-export function onHover(trigger, callback) {
+export function onHover(trigger, callback, injector) {
     let entry = hoverTriggers.get(trigger);
     // If this is the first entry for this element, add the listener.
     if (!entry) {
         entry = new DeferEventEntry();
-        trigger.addEventListener('mouseenter', entry.listener, eventListenerOptions);
         hoverTriggers.set(trigger, entry);
+        // Ensure that the handler runs in the NgZone since it gets
+        // registered in `afterRender` which runs outside.
+        injector.get(NgZone).run(() => {
+            trigger.addEventListener('mouseenter', entry.listener, eventListenerOptions);
+        });
     }
     entry.callbacks.add(callback);
     return () => {
@@ -151,4 +161,4 @@ class DeferIntersectionManager {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defer_events.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/defer_events.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 {inject, Injector, ɵɵdefineInjectable} from '../../di';\nimport {NgZone} from '../../zone';\n\n/** Configuration object used to register passive and capturing events. */\nconst eventListenerOptions: AddEventListenerOptions = {\n  passive: true,\n  capture: true\n};\n\n/** Keeps track of the currently-registered `on hover` triggers. */\nconst hoverTriggers = new WeakMap<Element, DeferEventEntry>();\n\n/** Keeps track of the currently-registered `on interaction` triggers. */\nconst interactionTriggers = new WeakMap<Element, DeferEventEntry>();\n\n/** Names of the events considered as interaction events. */\nconst interactionEventNames = ['click', 'keydown'] as const;\n\n/** Object keeping track of registered callbacks for a deferred block trigger. */\nclass DeferEventEntry {\n  callbacks = new Set<() => void>();\n\n  listener = () => {\n    for (const callback of this.callbacks) {\n      callback();\n    }\n  }\n}\n\n/**\n * Registers an interaction trigger.\n * @param trigger Element that is the trigger.\n * @param callback Callback to be invoked when the trigger is interacted with.\n */\nexport function onInteraction(trigger: Element, callback: VoidFunction) {\n  let entry = interactionTriggers.get(trigger);\n\n  // If this is the first entry for this element, add the listeners.\n  if (!entry) {\n    // Note that using managing events centrally like this lends itself well to using global\n    // event delegation. It currently does delegation at the element level, rather than the\n    // document level, because:\n    // 1. Global delegation is the most effective when there are a lot of events being registered\n    // at the same time. Deferred blocks are unlikely to be used in such a way.\n    // 2. Matching events to their target isn't free. For each `click` and `keydown` event we\n    // would have look through all the triggers and check if the target either is the element\n    // itself or it's contained within the element. Given that `click` and `keydown` are some\n    // of the most common events, this may end up introducing a lot of runtime overhead.\n    // 3. We're still registering only two events per element, no matter how many deferred blocks\n    // are referencing it.\n    entry = new DeferEventEntry();\n    interactionTriggers.set(trigger, entry);\n\n    for (const name of interactionEventNames) {\n      trigger.addEventListener(name, entry.listener, eventListenerOptions);\n    }\n  }\n\n  entry.callbacks.add(callback);\n\n  return () => {\n    const {callbacks, listener} = entry!;\n    callbacks.delete(callback);\n\n    if (callbacks.size === 0) {\n      interactionTriggers.delete(trigger);\n\n      for (const name of interactionEventNames) {\n        trigger.removeEventListener(name, listener, eventListenerOptions);\n      }\n    }\n  };\n}\n\n/**\n * Registers a hover trigger.\n * @param trigger Element that is the trigger.\n * @param callback Callback to be invoked when the trigger is hovered over.\n */\nexport function onHover(trigger: Element, callback: VoidFunction): VoidFunction {\n  let entry = hoverTriggers.get(trigger);\n\n  // If this is the first entry for this element, add the listener.\n  if (!entry) {\n    entry = new DeferEventEntry();\n    trigger.addEventListener('mouseenter', entry.listener, eventListenerOptions);\n    hoverTriggers.set(trigger, entry);\n  }\n\n  entry.callbacks.add(callback);\n\n  return () => {\n    const {callbacks, listener} = entry!;\n    callbacks.delete(callback);\n\n    if (callbacks.size === 0) {\n      trigger.removeEventListener('mouseenter', listener, eventListenerOptions);\n      hoverTriggers.delete(trigger);\n    }\n  };\n}\n\n/**\n * Registers a viewport trigger.\n * @param trigger Element that is the trigger.\n * @param callback Callback to be invoked when the trigger comes into the viewport.\n * @param injector Injector that can be used by the trigger to resolve DI tokens.\n */\nexport function onViewport(\n    trigger: Element, callback: VoidFunction, injector: Injector): VoidFunction {\n  return injector.get(DeferIntersectionManager).register(trigger, callback);\n}\n\n/** Keeps track of the registered `viewport` triggers. */\nclass DeferIntersectionManager {\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: DeferIntersectionManager,\n    providedIn: 'root',\n    factory: () => new DeferIntersectionManager(inject(NgZone)),\n  });\n\n  /** `IntersectionObserver` used to observe `viewport` triggers. */\n  private intersectionObserver: IntersectionObserver|null = null;\n\n  /** Number of elements currently observed with `viewport` triggers. */\n  private observedViewportElements = 0;\n\n  /** Currently-registered `viewport` triggers. */\n  private viewportTriggers = new WeakMap<Element, DeferEventEntry>();\n\n  constructor(private ngZone: NgZone) {}\n\n  register(trigger: Element, callback: VoidFunction): VoidFunction {\n    let entry = this.viewportTriggers.get(trigger);\n\n    if (!this.intersectionObserver) {\n      this.intersectionObserver =\n          this.ngZone.runOutsideAngular(() => new IntersectionObserver(this.intersectionCallback));\n    }\n\n    if (!entry) {\n      entry = new DeferEventEntry();\n      this.ngZone.runOutsideAngular(() => this.intersectionObserver!.observe(trigger));\n      this.viewportTriggers.set(trigger, entry);\n      this.observedViewportElements++;\n    }\n\n    entry.callbacks.add(callback);\n\n    return () => {\n      entry!.callbacks.delete(callback);\n\n      if (entry!.callbacks.size === 0) {\n        this.intersectionObserver?.unobserve(trigger);\n        this.viewportTriggers.delete(trigger);\n        this.observedViewportElements--;\n      }\n\n      if (this.observedViewportElements === 0) {\n        this.intersectionObserver?.disconnect();\n        this.intersectionObserver = null;\n      }\n    };\n  }\n\n  private intersectionCallback: IntersectionObserverCallback = entries => {\n    for (const current of entries) {\n      // Only invoke the callbacks if the specific element is intersecting.\n      if (current.isIntersecting && this.viewportTriggers.has(current.target)) {\n        this.ngZone.run(this.viewportTriggers.get(current.target)!.listener);\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defer_events.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/defer_events.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 {inject, Injector, ɵɵdefineInjectable} from '../../di';\nimport {NgZone} from '../../zone';\n\n/** Configuration object used to register passive and capturing events. */\nconst eventListenerOptions: AddEventListenerOptions = {\n  passive: true,\n  capture: true\n};\n\n/** Keeps track of the currently-registered `on hover` triggers. */\nconst hoverTriggers = new WeakMap<Element, DeferEventEntry>();\n\n/** Keeps track of the currently-registered `on interaction` triggers. */\nconst interactionTriggers = new WeakMap<Element, DeferEventEntry>();\n\n/** Names of the events considered as interaction events. */\nconst interactionEventNames = ['click', 'keydown'] as const;\n\n/** Object keeping track of registered callbacks for a deferred block trigger. */\nclass DeferEventEntry {\n  callbacks = new Set<() => void>();\n\n  listener = () => {\n    for (const callback of this.callbacks) {\n      callback();\n    }\n  }\n}\n\n/**\n * Registers an interaction trigger.\n * @param trigger Element that is the trigger.\n * @param callback Callback to be invoked when the trigger is interacted with.\n * @param injector Injector that can be used by the trigger to resolve DI tokens.\n */\nexport function onInteraction(\n    trigger: Element, callback: VoidFunction, injector: Injector): VoidFunction {\n  let entry = interactionTriggers.get(trigger);\n\n  // If this is the first entry for this element, add the listeners.\n  if (!entry) {\n    // Note that using managing events centrally like this lends itself well to using global\n    // event delegation. It currently does delegation at the element level, rather than the\n    // document level, because:\n    // 1. Global delegation is the most effective when there are a lot of events being registered\n    // at the same time. Deferred blocks are unlikely to be used in such a way.\n    // 2. Matching events to their target isn't free. For each `click` and `keydown` event we\n    // would have look through all the triggers and check if the target either is the element\n    // itself or it's contained within the element. Given that `click` and `keydown` are some\n    // of the most common events, this may end up introducing a lot of runtime overhead.\n    // 3. We're still registering only two events per element, no matter how many deferred blocks\n    // are referencing it.\n    entry = new DeferEventEntry();\n    interactionTriggers.set(trigger, entry);\n\n    // Ensure that the handler runs in the NgZone since it gets\n    // registered in `afterRender` which runs outside.\n    injector.get(NgZone).run(() => {\n      for (const name of interactionEventNames) {\n        trigger.addEventListener(name, entry!.listener, eventListenerOptions);\n      }\n    });\n  }\n\n  entry.callbacks.add(callback);\n\n  return () => {\n    const {callbacks, listener} = entry!;\n    callbacks.delete(callback);\n\n    if (callbacks.size === 0) {\n      interactionTriggers.delete(trigger);\n\n      for (const name of interactionEventNames) {\n        trigger.removeEventListener(name, listener, eventListenerOptions);\n      }\n    }\n  };\n}\n\n/**\n * Registers a hover trigger.\n * @param trigger Element that is the trigger.\n * @param callback Callback to be invoked when the trigger is hovered over.\n * @param injector Injector that can be used by the trigger to resolve DI tokens.\n */\nexport function onHover(\n    trigger: Element, callback: VoidFunction, injector: Injector): VoidFunction {\n  let entry = hoverTriggers.get(trigger);\n\n  // If this is the first entry for this element, add the listener.\n  if (!entry) {\n    entry = new DeferEventEntry();\n    hoverTriggers.set(trigger, entry);\n    // Ensure that the handler runs in the NgZone since it gets\n    // registered in `afterRender` which runs outside.\n    injector.get(NgZone).run(() => {\n      trigger.addEventListener('mouseenter', entry!.listener, eventListenerOptions);\n    });\n  }\n\n  entry.callbacks.add(callback);\n\n  return () => {\n    const {callbacks, listener} = entry!;\n    callbacks.delete(callback);\n\n    if (callbacks.size === 0) {\n      trigger.removeEventListener('mouseenter', listener, eventListenerOptions);\n      hoverTriggers.delete(trigger);\n    }\n  };\n}\n\n/**\n * Registers a viewport trigger.\n * @param trigger Element that is the trigger.\n * @param callback Callback to be invoked when the trigger comes into the viewport.\n * @param injector Injector that can be used by the trigger to resolve DI tokens.\n */\nexport function onViewport(\n    trigger: Element, callback: VoidFunction, injector: Injector): VoidFunction {\n  return injector.get(DeferIntersectionManager).register(trigger, callback);\n}\n\n/** Keeps track of the registered `viewport` triggers. */\nclass DeferIntersectionManager {\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: DeferIntersectionManager,\n    providedIn: 'root',\n    factory: () => new DeferIntersectionManager(inject(NgZone)),\n  });\n\n  /** `IntersectionObserver` used to observe `viewport` triggers. */\n  private intersectionObserver: IntersectionObserver|null = null;\n\n  /** Number of elements currently observed with `viewport` triggers. */\n  private observedViewportElements = 0;\n\n  /** Currently-registered `viewport` triggers. */\n  private viewportTriggers = new WeakMap<Element, DeferEventEntry>();\n\n  constructor(private ngZone: NgZone) {}\n\n  register(trigger: Element, callback: VoidFunction): VoidFunction {\n    let entry = this.viewportTriggers.get(trigger);\n\n    if (!this.intersectionObserver) {\n      this.intersectionObserver =\n          this.ngZone.runOutsideAngular(() => new IntersectionObserver(this.intersectionCallback));\n    }\n\n    if (!entry) {\n      entry = new DeferEventEntry();\n      this.ngZone.runOutsideAngular(() => this.intersectionObserver!.observe(trigger));\n      this.viewportTriggers.set(trigger, entry);\n      this.observedViewportElements++;\n    }\n\n    entry.callbacks.add(callback);\n\n    return () => {\n      entry!.callbacks.delete(callback);\n\n      if (entry!.callbacks.size === 0) {\n        this.intersectionObserver?.unobserve(trigger);\n        this.viewportTriggers.delete(trigger);\n        this.observedViewportElements--;\n      }\n\n      if (this.observedViewportElements === 0) {\n        this.intersectionObserver?.disconnect();\n        this.intersectionObserver = null;\n      }\n    };\n  }\n\n  private intersectionCallback: IntersectionObserverCallback = entries => {\n    for (const current of entries) {\n      // Only invoke the callbacks if the specific element is intersecting.\n      if (current.isIntersecting && this.viewportTriggers.has(current.target)) {\n        this.ngZone.run(this.viewportTriggers.get(current.target)!.listener);\n      }\n    }\n  }\n}\n"]}

package/esm2022/src/render3/interfaces/definition.mjs

@@ -8,4 +8,4 @@
 // Note: This hack is necessary so we don't erroneously get a circular dependency
 // failure based on types.
 export const unusedValueExportToPlacateAjd = 1;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/definition.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAigBH,iFAAiF;AACjF,0BAA0B;AAC1B,MAAM,CAAC,MAAM,6BAA6B,GAAG,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 {ModuleWithProviders, ProcessProvidersFunction} from '../../di/interface/provider';\nimport {EnvironmentInjector} from '../../di/r3_injector';\nimport {Type} from '../../interface/type';\nimport {SchemaMetadata} from '../../metadata/schema';\nimport {ViewEncapsulation} from '../../metadata/view';\nimport {FactoryFn} from '../definition_factory';\n\nimport {TAttributes, TConstantsOrFactory} from './node';\nimport {CssSelectorList} from './projection';\nimport {TView} from './view';\n\n\n/**\n * Definition of what a template rendering function should look like for a component.\n */\nexport type ComponentTemplate<T> = {\n  // Note: the ctx parameter is typed as T|U, as using only U would prevent a template with\n  // e.g. ctx: {} from being assigned to ComponentTemplate<any> as TypeScript won't infer U = any\n  // in that scenario. By including T this incompatibility is resolved.\n  <U extends T>(rf: RenderFlags, ctx: T|U): void;\n};\n\n/**\n * Definition of what a view queries function should look like.\n */\nexport type ViewQueriesFunction<T> = <U extends T>(rf: RenderFlags, ctx: U) => void;\n\n/**\n * Definition of what a content queries function should look like.\n */\nexport type ContentQueriesFunction<T> =\n    <U extends T>(rf: RenderFlags, ctx: U, directiveIndex: number) => void;\n\n/**\n * Flags passed into template functions to determine which blocks (i.e. creation, update)\n * should be executed.\n *\n * Typically, a template runs both the creation block and the update block on initialization and\n * subsequent runs only execute the update block. However, dynamically created views require that\n * the creation block be executed separately from the update block (for backwards compat).\n */\nexport const enum RenderFlags {\n  /* Whether to run the creation block (e.g. create elements and directives) */\n  Create = 0b01,\n\n  /* Whether to run the update block (e.g. refresh bindings) */\n  Update = 0b10\n}\n\n/**\n * A subclass of `Type` which has a static `ɵcmp`:`ComponentDef` field making it\n * consumable for rendering.\n */\nexport interface ComponentType<T> extends Type<T> {\n  ɵcmp: unknown;\n}\n\n/**\n * A subclass of `Type` which has a static `ɵdir`:`DirectiveDef` field making it\n * consumable for rendering.\n */\nexport interface DirectiveType<T> extends Type<T> {\n  ɵdir: unknown;\n  ɵfac: unknown;\n}\n\n/**\n * A subclass of `Type` which has a static `ɵpipe`:`PipeDef` field making it\n * consumable for rendering.\n */\nexport interface PipeType<T> extends Type<T> {\n  ɵpipe: unknown;\n}\n\n\n\n/**\n * Runtime link information for Directives.\n *\n * This is an internal data structure used by the render to link\n * directives into templates.\n *\n * NOTE: Always use `defineDirective` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * @param Selector type metadata specifying the selector of the directive or component\n *\n * See: {@link defineDirective}\n */\nexport interface DirectiveDef<T> {\n  /**\n   * A dictionary mapping the inputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Input('alias') propertyName: any;`).\n   */\n  readonly inputs: {[P in keyof T]: string};\n\n  /**\n   * A dictionary mapping the private names of inputs to their transformation functions.\n   * Note: the private names are used for the keys, rather than the public ones, because public\n   * names can be re-aliased in host directives which would invalidate the lookup.\n   */\n  readonly inputTransforms: {[classPropertyName: string]: InputTransformFunction}|null;\n\n  /**\n   * Contains the raw input information produced by the compiler. Can be\n   * used to do further processing after the `inputs` have been inverted.\n   */\n  readonly inputConfig:\n      {[classPropertyName: string]: string|[string, string, InputTransformFunction?]};\n\n  /**\n   * @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of\n   * public or minified name.\n   */\n  readonly declaredInputs: {[P in keyof T]: string};\n\n  /**\n   * A dictionary mapping the outputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Output('alias') propertyName: any;`).\n   */\n  readonly outputs: {[P in keyof T]: string};\n\n  /**\n   * Function to create and refresh content queries associated with a given directive.\n   */\n  contentQueries: ContentQueriesFunction<T>|null;\n\n  /**\n   * Query-related instructions for a directive. Note that while directives don't have a\n   * view and as such view queries won't necessarily do anything, there might be\n   * components that extend the directive.\n   */\n  viewQuery: ViewQueriesFunction<T>|null;\n\n  /**\n   * Refreshes host bindings on the associated directive.\n   */\n  readonly hostBindings: HostBindingsFunction<T>|null;\n\n  /**\n   * The number of bindings in this directive `hostBindings` (including pure fn bindings).\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the host binding start index.\n   */\n  readonly hostVars: number;\n\n  /**\n   * Assign static attribute values to a host element.\n   *\n   * This property will assign static attribute values as well as class and style\n   * values to a host element. Since attribute values can consist of different types of values, the\n   * `hostAttrs` array must include the values in the following format:\n   *\n   * attrs = [\n   *   // static attributes (like `title`, `name`, `id`...)\n   *   attr1, value1, attr2, value,\n   *\n   *   // a single namespace value (like `x:id`)\n   *   NAMESPACE_MARKER, namespaceUri1, name1, value1,\n   *\n   *   // another single namespace value (like `x:name`)\n   *   NAMESPACE_MARKER, namespaceUri2, name2, value2,\n   *\n   *   // a series of CSS classes that will be applied to the element (no spaces)\n   *   CLASSES_MARKER, class1, class2, class3,\n   *\n   *   // a series of CSS styles (property + value) that will be applied to the element\n   *   STYLES_MARKER, prop1, value1, prop2, value2\n   * ]\n   *\n   * All non-class and non-style attributes must be defined at the start of the list\n   * first before all class and style values are set. When there is a change in value\n   * type (like when classes and styles are introduced) a marker must be used to separate\n   * the entries. The marker values themselves are set via entries found in the\n   * [AttributeMarker] enum.\n   */\n  readonly hostAttrs: TAttributes|null;\n\n  /** Token representing the directive. Used by DI. */\n  readonly type: Type<T>;\n\n  /** Function that resolves providers and publishes them into the DI system. */\n  providersResolver:\n      (<U extends T>(def: DirectiveDef<U>, processProvidersFn?: ProcessProvidersFunction) =>\n           void)|null;\n\n  /** The selectors that will be used to match nodes to this directive. */\n  readonly selectors: CssSelectorList;\n\n  /**\n   * Name under which the directive is exported (for use with local references in template)\n   */\n  readonly exportAs: string[]|null;\n\n  /**\n   * Whether this directive (or component) is standalone.\n   */\n  readonly standalone: boolean;\n\n  /**\n   * Whether this directive (or component) uses the signals authoring experience.\n   */\n  readonly signals: boolean;\n\n  /**\n   * Factory function used to create a new directive instance. Will be null initially.\n   * Populated when the factory is first requested by directive instantiation logic.\n   */\n  readonly factory: FactoryFn<T>|null;\n\n  /**\n   * The features applied to this directive\n   */\n  readonly features: DirectiveDefFeature[]|null;\n\n  /**\n   * Function that will add the host directives to the list of matches during directive matching.\n   * Patched onto the definition by the `HostDirectivesFeature`.\n   * @param currentDef Definition that has been matched.\n   * @param matchedDefs List of all matches for a specified node. Will be mutated to include the\n   * host directives.\n   * @param hostDirectiveDefs Mapping of directive definitions to their host directive\n   * configuration. Host directives will be added to the map as they're being matched to the node.\n   */\n  findHostDirectiveDefs:\n      ((currentDef: DirectiveDef<unknown>, matchedDefs: DirectiveDef<unknown>[],\n        hostDirectiveDefs: HostDirectiveDefs) => void)|null;\n\n  /** Additional directives to be applied whenever the directive has been matched. */\n  hostDirectives: HostDirectiveDef[]|null;\n\n  setInput:\n      (<U extends T>(\n           this: DirectiveDef<U>, instance: U, value: any, publicName: string,\n           privateName: string) => void)|null;\n}\n\n/**\n * Runtime link information for Components.\n *\n * This is an internal data structure used by the render to link\n * components into templates.\n *\n * NOTE: Always use `defineComponent` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link defineComponent}\n */\nexport interface ComponentDef<T> extends DirectiveDef<T> {\n  /**\n   * Unique ID for the component. Used in view encapsulation and\n   * to keep track of the injector in standalone components.\n   */\n  readonly id: string;\n\n  /**\n   * The View template of the component.\n   */\n  readonly template: ComponentTemplate<T>;\n\n  /** Constants associated with the component's view. */\n  readonly consts: TConstantsOrFactory|null;\n\n  /**\n   * An array of `ngContent[selector]` values that were found in the template.\n   */\n  readonly ngContentSelectors?: string[];\n\n  /**\n   * A set of styles that the component needs to be present for component to render correctly.\n   */\n  readonly styles: string[];\n\n  /**\n   * The number of nodes, local refs, and pipes in this component template.\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the binding start index.\n   */\n  // TODO(kara): remove queries from this count\n  readonly decls: number;\n\n  /**\n   * The number of bindings in this component template (including pure fn bindings).\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the host binding start index.\n   */\n  readonly vars: number;\n\n  /**\n   * Query-related instructions for a component.\n   */\n  viewQuery: ViewQueriesFunction<T>|null;\n\n  /**\n   * The view encapsulation type, which determines how styles are applied to\n   * DOM elements. One of\n   * - `Emulated` (default): Emulate native scoping of styles.\n   * - `Native`: Use the native encapsulation mechanism of the renderer.\n   * - `ShadowDom`: Use modern [ShadowDOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n   *   create a ShadowRoot for component's host element.\n   * - `None`: Do not provide any template or style encapsulation.\n   */\n  readonly encapsulation: ViewEncapsulation;\n\n  /**\n   * Defines arbitrary developer-defined data to be stored on a renderer instance.\n   * This is useful for renderers that delegate to other renderers.\n   */\n  readonly data: {\n    [kind: string]: any,\n    animation?: any[],\n  };\n\n  /** Whether or not this component's ChangeDetectionStrategy is OnPush */\n  readonly onPush: boolean;\n\n  /** Whether or not this component is signal-based. */\n  readonly signals: boolean;\n\n  /**\n   * Registry of directives and components that may be found in this view.\n   *\n   * The property is either an array of `DirectiveDef`s or a function which returns the array of\n   * `DirectiveDef`s. The function is necessary to be able to support forward declarations.\n   */\n  directiveDefs: DirectiveDefListOrFactory|null;\n\n  /**\n   * Registry of pipes that may be found in this view.\n   *\n   * The property is either an array of `PipeDefs`s or a function which returns the array of\n   * `PipeDefs`s. The function is necessary to be able to support forward declarations.\n   */\n  pipeDefs: PipeDefListOrFactory|null;\n\n  /**\n   * Unfiltered list of all dependencies of a component, or `null` if none.\n   */\n  dependencies: TypeOrFactory<DependencyTypeList>|null;\n\n  /**\n   * The set of schemas that declare elements to be allowed in the component's template.\n   */\n  schemas: SchemaMetadata[]|null;\n\n  /**\n   * Ivy runtime uses this place to store the computed tView for the component. This gets filled on\n   * the first run of component.\n   */\n  tView: TView|null;\n\n  /**\n   * A function added by the {@link ɵɵStandaloneFeature} and used by the framework to create\n   * standalone injectors.\n   */\n  getStandaloneInjector: ((parentInjector: EnvironmentInjector) => EnvironmentInjector | null)|null;\n\n  /**\n   * Used to store the result of `noSideEffects` function so that it is not removed by closure\n   * compiler. The property should never be read.\n   */\n  readonly _?: unknown;\n}\n\n/**\n * Runtime link information for Pipes.\n *\n * This is an internal data structure used by the renderer to link\n * pipes into templates.\n *\n * NOTE: Always use `definePipe` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link definePipe}\n */\nexport interface PipeDef<T> {\n  /** Token representing the pipe. */\n  type: Type<T>;\n\n  /**\n   * Pipe name.\n   *\n   * Used to resolve pipe in templates.\n   */\n  readonly name: string;\n\n  /**\n   * Factory function used to create a new pipe instance. Will be null initially.\n   * Populated when the factory is first requested by pipe instantiation logic.\n   */\n  factory: FactoryFn<T>|null;\n\n  /**\n   * Whether or not the pipe is pure.\n   *\n   * Pure pipes result only depends on the pipe input and not on internal\n   * state of the pipe.\n   */\n  readonly pure: boolean;\n\n  /**\n   * Whether this pipe is standalone.\n   */\n  readonly standalone: boolean;\n\n  /* The following are lifecycle hooks for this pipe */\n  onDestroy: (() => void)|null;\n}\n\nexport interface DirectiveDefFeature {\n  <T>(directiveDef: DirectiveDef<T>): void;\n  /**\n   * Marks a feature as something that {@link InheritDefinitionFeature} will execute\n   * during inheritance.\n   *\n   * NOTE: DO NOT SET IN ROOT OF MODULE! Doing so will result in tree-shakers/bundlers\n   * identifying the change as a side effect, and the feature will be included in\n   * every bundle.\n   */\n  ngInherit?: true;\n}\n\n/** Runtime information used to configure a host directive. */\nexport interface HostDirectiveDef<T = unknown> {\n  /** Class representing the host directive. */\n  directive: Type<T>;\n\n  /** Directive inputs that have been exposed. */\n  inputs: HostDirectiveBindingMap;\n\n  /** Directive outputs that have been exposed. */\n  outputs: HostDirectiveBindingMap;\n}\n\n/**\n * Mapping between the public aliases of directive bindings and the underlying inputs/outputs that\n * they represent. Also serves as an allowlist of the inputs/outputs from the host directive that\n * the author has decided to expose.\n */\nexport type HostDirectiveBindingMap = {\n  [publicName: string]: string\n};\n\n/**\n * Mapping between a directive that was used as a host directive\n * and the configuration that was used to define it as such.\n */\nexport type HostDirectiveDefs = Map<DirectiveDef<unknown>, HostDirectiveDef>;\n\nexport interface ComponentDefFeature {\n  <T>(componentDef: ComponentDef<T>): void;\n  /**\n   * Marks a feature as something that {@link InheritDefinitionFeature} will execute\n   * during inheritance.\n   *\n   * NOTE: DO NOT SET IN ROOT OF MODULE! Doing so will result in tree-shakers/bundlers\n   * identifying the change as a side effect, and the feature will be included in\n   * every bundle.\n   */\n  ngInherit?: true;\n}\n\n/** Function that can be used to transform incoming input values. */\nexport type InputTransformFunction = (value: any) => any;\n\n/**\n * Type used for directiveDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type DirectiveDefListOrFactory = (() => DirectiveDefList)|DirectiveDefList;\n\nexport type DirectiveDefList = (DirectiveDef<any>|ComponentDef<any>)[];\n\nexport type DirectiveTypesOrFactory = (() => DirectiveTypeList)|DirectiveTypeList;\n\nexport type DirectiveTypeList =\n    (DirectiveType<any>|ComponentType<any>|\n     Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\nexport type DependencyType = DirectiveType<any>|ComponentType<any>|PipeType<any>|Type<any>;\n\nexport type DependencyTypeList = Array<DependencyType>;\n\nexport type TypeOrFactory<T> = T|(() => T);\n\nexport type HostBindingsFunction<T> = <U extends T>(rf: RenderFlags, ctx: U) => void;\n\n/**\n * Type used for PipeDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type PipeDefListOrFactory = (() => PipeDefList)|PipeDefList;\n\nexport type PipeDefList = PipeDef<any>[];\n\nexport type PipeTypesOrFactory = (() => PipeTypeList)|PipeTypeList;\n\nexport type PipeTypeList =\n    (PipeType<any>|Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n\n/**\n * NgModule scope info as provided by AoT compiler\n *\n * In full compilation Ivy resolved all the \"module with providers\" and forward refs the whole array\n * if at least one element is forward refed. So we end up with type `Type<any>[]|(() =>\n * Type<any>[])`.\n *\n * In local mode the compiler passes the raw info as they are to the runtime functions as it is not\n * possible to resolve them any further due to limited info at compile time. So we end up with type\n * `RawScopeInfoFromDecorator[]`.\n */\nexport interface NgModuleScopeInfoFromDecorator {\n  /** List of components, directives, and pipes declared by this module. */\n  declarations?: Type<any>[]|(() => Type<any>[])|RawScopeInfoFromDecorator[];\n\n  /** List of modules or `ModuleWithProviders` or standalone components imported by this module. */\n  imports?: Type<any>[]|(() => Type<any>[])|RawScopeInfoFromDecorator[];\n\n  /**\n   * List of modules, `ModuleWithProviders`, components, directives, or pipes exported by this\n   * module.\n   */\n  exports?: Type<any>[]|(() => Type<any>[])|RawScopeInfoFromDecorator[];\n\n  /**\n   * The set of components that are bootstrapped when this module is bootstrapped. This field is\n   * only available in local compilation mode. In full compilation mode bootstrap info is passed\n   * directly to the module def runtime after statically analyzed and resolved.\n   */\n  bootstrap?: Type<any>[]|(() => Type<any>[])|RawScopeInfoFromDecorator[];\n}\n\n/**\n * The array element type passed to:\n *  - NgModule's annotation imports/exports/declarations fields\n *  - standalone component annotation imports field\n */\nexport type RawScopeInfoFromDecorator =\n    Type<any>|ModuleWithProviders<any>|(() => Type<any>)|(() => ModuleWithProviders<any>)|any[];\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/definition.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAmgBH,iFAAiF;AACjF,0BAA0B;AAC1B,MAAM,CAAC,MAAM,6BAA6B,GAAG,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 {ModuleWithProviders, ProcessProvidersFunction} from '../../di/interface/provider';\nimport {EnvironmentInjector} from '../../di/r3_injector';\nimport {Type} from '../../interface/type';\nimport {SchemaMetadata} from '../../metadata/schema';\nimport {ViewEncapsulation} from '../../metadata/view';\nimport {FactoryFn} from '../definition_factory';\n\nimport {TAttributes, TConstantsOrFactory} from './node';\nimport {CssSelectorList} from './projection';\nimport {TView} from './view';\n\n\n/**\n * Definition of what a template rendering function should look like for a component.\n */\nexport type ComponentTemplate<T> = {\n  // Note: the ctx parameter is typed as T|U, as using only U would prevent a template with\n  // e.g. ctx: {} from being assigned to ComponentTemplate<any> as TypeScript won't infer U = any\n  // in that scenario. By including T this incompatibility is resolved.\n  <U extends T>(rf: RenderFlags, ctx: T|U): void;\n};\n\n/**\n * Definition of what a view queries function should look like.\n */\nexport type ViewQueriesFunction<T> = <U extends T>(rf: RenderFlags, ctx: U) => void;\n\n/**\n * Definition of what a content queries function should look like.\n */\nexport type ContentQueriesFunction<T> =\n    <U extends T>(rf: RenderFlags, ctx: U, directiveIndex: number) => void;\n\n/**\n * Flags passed into template functions to determine which blocks (i.e. creation, update)\n * should be executed.\n *\n * Typically, a template runs both the creation block and the update block on initialization and\n * subsequent runs only execute the update block. However, dynamically created views require that\n * the creation block be executed separately from the update block (for backwards compat).\n */\nexport const enum RenderFlags {\n  /* Whether to run the creation block (e.g. create elements and directives) */\n  Create = 0b01,\n\n  /* Whether to run the update block (e.g. refresh bindings) */\n  Update = 0b10\n}\n\n/**\n * A subclass of `Type` which has a static `ɵcmp`:`ComponentDef` field making it\n * consumable for rendering.\n */\nexport interface ComponentType<T> extends Type<T> {\n  ɵcmp: unknown;\n}\n\n/**\n * A subclass of `Type` which has a static `ɵdir`:`DirectiveDef` field making it\n * consumable for rendering.\n */\nexport interface DirectiveType<T> extends Type<T> {\n  ɵdir: unknown;\n  ɵfac: unknown;\n}\n\n/**\n * A subclass of `Type` which has a static `ɵpipe`:`PipeDef` field making it\n * consumable for rendering.\n */\nexport interface PipeType<T> extends Type<T> {\n  ɵpipe: unknown;\n}\n\n\n\n/**\n * Runtime link information for Directives.\n *\n * This is an internal data structure used by the render to link\n * directives into templates.\n *\n * NOTE: Always use `defineDirective` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * @param Selector type metadata specifying the selector of the directive or component\n *\n * See: {@link defineDirective}\n */\nexport interface DirectiveDef<T> {\n  /**\n   * A dictionary mapping the inputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Input('alias') propertyName: any;`).\n   */\n  readonly inputs: {[P in keyof T]: string};\n\n  /**\n   * A dictionary mapping the private names of inputs to their transformation functions.\n   * Note: the private names are used for the keys, rather than the public ones, because public\n   * names can be re-aliased in host directives which would invalidate the lookup.\n   */\n  readonly inputTransforms: {[classPropertyName: string]: InputTransformFunction}|null;\n\n  /**\n   * Contains the raw input information produced by the compiler. Can be\n   * used to do further processing after the `inputs` have been inverted.\n   */\n  readonly inputConfig:\n      {[classPropertyName: string]: string|[string, string, InputTransformFunction?]};\n\n  /**\n   * @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of\n   * public or minified name.\n   */\n  readonly declaredInputs: {[P in keyof T]: string};\n\n  /**\n   * A dictionary mapping the outputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Output('alias') propertyName: any;`).\n   */\n  readonly outputs: {[P in keyof T]: string};\n\n  /**\n   * Function to create and refresh content queries associated with a given directive.\n   */\n  contentQueries: ContentQueriesFunction<T>|null;\n\n  /**\n   * Query-related instructions for a directive. Note that while directives don't have a\n   * view and as such view queries won't necessarily do anything, there might be\n   * components that extend the directive.\n   */\n  viewQuery: ViewQueriesFunction<T>|null;\n\n  /**\n   * Refreshes host bindings on the associated directive.\n   */\n  readonly hostBindings: HostBindingsFunction<T>|null;\n\n  /**\n   * The number of bindings in this directive `hostBindings` (including pure fn bindings).\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the host binding start index.\n   */\n  readonly hostVars: number;\n\n  /**\n   * Assign static attribute values to a host element.\n   *\n   * This property will assign static attribute values as well as class and style\n   * values to a host element. Since attribute values can consist of different types of values, the\n   * `hostAttrs` array must include the values in the following format:\n   *\n   * attrs = [\n   *   // static attributes (like `title`, `name`, `id`...)\n   *   attr1, value1, attr2, value,\n   *\n   *   // a single namespace value (like `x:id`)\n   *   NAMESPACE_MARKER, namespaceUri1, name1, value1,\n   *\n   *   // another single namespace value (like `x:name`)\n   *   NAMESPACE_MARKER, namespaceUri2, name2, value2,\n   *\n   *   // a series of CSS classes that will be applied to the element (no spaces)\n   *   CLASSES_MARKER, class1, class2, class3,\n   *\n   *   // a series of CSS styles (property + value) that will be applied to the element\n   *   STYLES_MARKER, prop1, value1, prop2, value2\n   * ]\n   *\n   * All non-class and non-style attributes must be defined at the start of the list\n   * first before all class and style values are set. When there is a change in value\n   * type (like when classes and styles are introduced) a marker must be used to separate\n   * the entries. The marker values themselves are set via entries found in the\n   * [AttributeMarker] enum.\n   */\n  readonly hostAttrs: TAttributes|null;\n\n  /** Token representing the directive. Used by DI. */\n  readonly type: Type<T>;\n\n  /** Function that resolves providers and publishes them into the DI system. */\n  providersResolver:\n      (<U extends T>(def: DirectiveDef<U>, processProvidersFn?: ProcessProvidersFunction) =>\n           void)|null;\n\n  /** The selectors that will be used to match nodes to this directive. */\n  readonly selectors: CssSelectorList;\n\n  /**\n   * Name under which the directive is exported (for use with local references in template)\n   */\n  readonly exportAs: string[]|null;\n\n  /**\n   * Whether this directive (or component) is standalone.\n   */\n  readonly standalone: boolean;\n\n  /**\n   * Whether this directive (or component) uses the signals authoring experience.\n   */\n  readonly signals: boolean;\n\n  /**\n   * Factory function used to create a new directive instance. Will be null initially.\n   * Populated when the factory is first requested by directive instantiation logic.\n   */\n  readonly factory: FactoryFn<T>|null;\n\n  /**\n   * The features applied to this directive\n   */\n  readonly features: DirectiveDefFeature[]|null;\n\n  /**\n   * Function that will add the host directives to the list of matches during directive matching.\n   * Patched onto the definition by the `HostDirectivesFeature`.\n   * @param currentDef Definition that has been matched.\n   * @param matchedDefs List of all matches for a specified node. Will be mutated to include the\n   * host directives.\n   * @param hostDirectiveDefs Mapping of directive definitions to their host directive\n   * configuration. Host directives will be added to the map as they're being matched to the node.\n   */\n  findHostDirectiveDefs:\n      ((currentDef: DirectiveDef<unknown>, matchedDefs: DirectiveDef<unknown>[],\n        hostDirectiveDefs: HostDirectiveDefs) => void)|null;\n\n  /** Additional directives to be applied whenever the directive has been matched. */\n  hostDirectives: HostDirectiveDef[]|null;\n\n  setInput:\n      (<U extends T>(\n           this: DirectiveDef<U>, instance: U, value: any, publicName: string,\n           privateName: string) => void)|null;\n}\n\n/**\n * Runtime link information for Components.\n *\n * This is an internal data structure used by the render to link\n * components into templates.\n *\n * NOTE: Always use `defineComponent` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link defineComponent}\n */\nexport interface ComponentDef<T> extends DirectiveDef<T> {\n  /**\n   * Unique ID for the component. Used in view encapsulation and\n   * to keep track of the injector in standalone components.\n   */\n  readonly id: string;\n\n  /**\n   * The View template of the component.\n   */\n  readonly template: ComponentTemplate<T>;\n\n  /** Constants associated with the component's view. */\n  readonly consts: TConstantsOrFactory|null;\n\n  /**\n   * An array of `ngContent[selector]` values that were found in the template.\n   */\n  readonly ngContentSelectors?: string[];\n\n  /**\n   * A set of styles that the component needs to be present for component to render correctly.\n   */\n  readonly styles: string[];\n\n  /**\n   * The number of nodes, local refs, and pipes in this component template.\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the binding start index.\n   */\n  // TODO(kara): remove queries from this count\n  readonly decls: number;\n\n  /**\n   * The number of bindings in this component template (including pure fn bindings).\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the host binding start index.\n   */\n  readonly vars: number;\n\n  /**\n   * Query-related instructions for a component.\n   */\n  viewQuery: ViewQueriesFunction<T>|null;\n\n  /**\n   * The view encapsulation type, which determines how styles are applied to\n   * DOM elements. One of\n   * - `Emulated` (default): Emulate native scoping of styles.\n   * - `Native`: Use the native encapsulation mechanism of the renderer.\n   * - `ShadowDom`: Use modern [ShadowDOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n   *   create a ShadowRoot for component's host element.\n   * - `None`: Do not provide any template or style encapsulation.\n   */\n  readonly encapsulation: ViewEncapsulation;\n\n  /**\n   * Defines arbitrary developer-defined data to be stored on a renderer instance.\n   * This is useful for renderers that delegate to other renderers.\n   */\n  readonly data: {\n    [kind: string]: any,\n    animation?: any[],\n  };\n\n  /** Whether or not this component's ChangeDetectionStrategy is OnPush */\n  readonly onPush: boolean;\n\n  /** Whether or not this component is signal-based. */\n  readonly signals: boolean;\n\n  /**\n   * Registry of directives and components that may be found in this view.\n   *\n   * The property is either an array of `DirectiveDef`s or a function which returns the array of\n   * `DirectiveDef`s. The function is necessary to be able to support forward declarations.\n   */\n  directiveDefs: DirectiveDefListOrFactory|null;\n\n  /**\n   * Registry of pipes that may be found in this view.\n   *\n   * The property is either an array of `PipeDefs`s or a function which returns the array of\n   * `PipeDefs`s. The function is necessary to be able to support forward declarations.\n   */\n  pipeDefs: PipeDefListOrFactory|null;\n\n  /**\n   * Unfiltered list of all dependencies of a component, or `null` if none.\n   */\n  dependencies: TypeOrFactory<DependencyTypeList>|null;\n\n  /**\n   * The set of schemas that declare elements to be allowed in the component's template.\n   */\n  schemas: SchemaMetadata[]|null;\n\n  /**\n   * Ivy runtime uses this place to store the computed tView for the component. This gets filled on\n   * the first run of component.\n   */\n  tView: TView|null;\n\n  /**\n   * A function added by the {@link ɵɵStandaloneFeature} and used by the framework to create\n   * standalone injectors.\n   */\n  getStandaloneInjector: ((parentInjector: EnvironmentInjector) => EnvironmentInjector | null)|null;\n\n  /**\n   * Used to store the result of `noSideEffects` function so that it is not removed by closure\n   * compiler. The property should never be read.\n   */\n  readonly _?: unknown;\n}\n\n/**\n * Runtime link information for Pipes.\n *\n * This is an internal data structure used by the renderer to link\n * pipes into templates.\n *\n * NOTE: Always use `definePipe` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link definePipe}\n */\nexport interface PipeDef<T> {\n  /** Token representing the pipe. */\n  type: Type<T>;\n\n  /**\n   * Pipe name.\n   *\n   * Used to resolve pipe in templates.\n   */\n  readonly name: string;\n\n  /**\n   * Factory function used to create a new pipe instance. Will be null initially.\n   * Populated when the factory is first requested by pipe instantiation logic.\n   */\n  factory: FactoryFn<T>|null;\n\n  /**\n   * Whether or not the pipe is pure.\n   *\n   * Pure pipes result only depends on the pipe input and not on internal\n   * state of the pipe.\n   */\n  readonly pure: boolean;\n\n  /**\n   * Whether this pipe is standalone.\n   */\n  readonly standalone: boolean;\n\n  /* The following are lifecycle hooks for this pipe */\n  onDestroy: (() => void)|null;\n}\n\nexport interface DirectiveDefFeature {\n  <T>(directiveDef: DirectiveDef<T>): void;\n  /**\n   * Marks a feature as something that {@link InheritDefinitionFeature} will execute\n   * during inheritance.\n   *\n   * NOTE: DO NOT SET IN ROOT OF MODULE! Doing so will result in tree-shakers/bundlers\n   * identifying the change as a side effect, and the feature will be included in\n   * every bundle.\n   */\n  ngInherit?: true;\n}\n\n/** Runtime information used to configure a host directive. */\nexport interface HostDirectiveDef<T = unknown> {\n  /** Class representing the host directive. */\n  directive: Type<T>;\n\n  /** Directive inputs that have been exposed. */\n  inputs: HostDirectiveBindingMap;\n\n  /** Directive outputs that have been exposed. */\n  outputs: HostDirectiveBindingMap;\n}\n\n/**\n * Mapping between the public aliases of directive bindings and the underlying inputs/outputs that\n * they represent. Also serves as an allowlist of the inputs/outputs from the host directive that\n * the author has decided to expose.\n */\nexport type HostDirectiveBindingMap = {\n  [publicName: string]: string\n};\n\n/**\n * Mapping between a directive that was used as a host directive\n * and the configuration that was used to define it as such.\n */\nexport type HostDirectiveDefs = Map<DirectiveDef<unknown>, HostDirectiveDef>;\n\nexport interface ComponentDefFeature {\n  <T>(componentDef: ComponentDef<T>): void;\n  /**\n   * Marks a feature as something that {@link InheritDefinitionFeature} will execute\n   * during inheritance.\n   *\n   * NOTE: DO NOT SET IN ROOT OF MODULE! Doing so will result in tree-shakers/bundlers\n   * identifying the change as a side effect, and the feature will be included in\n   * every bundle.\n   */\n  ngInherit?: true;\n}\n\n/** Function that can be used to transform incoming input values. */\nexport type InputTransformFunction = (value: any) => any;\n\n/**\n * Type used for directiveDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type DirectiveDefListOrFactory = (() => DirectiveDefList)|DirectiveDefList;\n\nexport type DirectiveDefList = (DirectiveDef<any>|ComponentDef<any>)[];\n\nexport type DependencyDef = DirectiveDef<unknown>|ComponentDef<unknown>|PipeDef<unknown>;\n\nexport type DirectiveTypesOrFactory = (() => DirectiveTypeList)|DirectiveTypeList;\n\nexport type DirectiveTypeList =\n    (DirectiveType<any>|ComponentType<any>|\n     Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\nexport type DependencyType = DirectiveType<any>|ComponentType<any>|PipeType<any>|Type<any>;\n\nexport type DependencyTypeList = Array<DependencyType>;\n\nexport type TypeOrFactory<T> = T|(() => T);\n\nexport type HostBindingsFunction<T> = <U extends T>(rf: RenderFlags, ctx: U) => void;\n\n/**\n * Type used for PipeDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type PipeDefListOrFactory = (() => PipeDefList)|PipeDefList;\n\nexport type PipeDefList = PipeDef<any>[];\n\nexport type PipeTypesOrFactory = (() => PipeTypeList)|PipeTypeList;\n\nexport type PipeTypeList =\n    (PipeType<any>|Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n\n/**\n * NgModule scope info as provided by AoT compiler\n *\n * In full compilation Ivy resolved all the \"module with providers\" and forward refs the whole array\n * if at least one element is forward refed. So we end up with type `Type<any>[]|(() =>\n * Type<any>[])`.\n *\n * In local mode the compiler passes the raw info as they are to the runtime functions as it is not\n * possible to resolve them any further due to limited info at compile time. So we end up with type\n * `RawScopeInfoFromDecorator[]`.\n */\nexport interface NgModuleScopeInfoFromDecorator {\n  /** List of components, directives, and pipes declared by this module. */\n  declarations?: Type<any>[]|(() => Type<any>[])|RawScopeInfoFromDecorator[];\n\n  /** List of modules or `ModuleWithProviders` or standalone components imported by this module. */\n  imports?: Type<any>[]|(() => Type<any>[])|RawScopeInfoFromDecorator[];\n\n  /**\n   * List of modules, `ModuleWithProviders`, components, directives, or pipes exported by this\n   * module.\n   */\n  exports?: Type<any>[]|(() => Type<any>[])|RawScopeInfoFromDecorator[];\n\n  /**\n   * The set of components that are bootstrapped when this module is bootstrapped. This field is\n   * only available in local compilation mode. In full compilation mode bootstrap info is passed\n   * directly to the module def runtime after statically analyzed and resolved.\n   */\n  bootstrap?: Type<any>[]|(() => Type<any>[])|RawScopeInfoFromDecorator[];\n}\n\n/**\n * The array element type passed to:\n *  - NgModule's annotation imports/exports/declarations fields\n *  - standalone component annotation imports field\n */\nexport type RawScopeInfoFromDecorator =\n    Type<any>|ModuleWithProviders<any>|(() => Type<any>)|(() => ModuleWithProviders<any>)|any[];\n"]}

package/esm2022/src/render3/interfaces/view.mjs

@@ -45,4 +45,4 @@ export const HEADER_OFFSET = 25;
 // Note: This hack is necessary so we don't erroneously get a circular dependency
 // failure based on types.
 export const unusedValueExportToPlacateAjd = 1;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/view.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAuBH,yEAAyE;AACzE,mDAAmD;AACnD,wEAAwE;AACxE,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,CAAC;AACtB,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC;AACvB,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC;AACvB,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,CAAC;AACxB,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,CAAC;AACtB,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC;AAC7C,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,CAAC;AACxB,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,CAAC;AACzB,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,CAAC;AACzB,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAC;AAC1B,MAAM,CAAC,MAAM,WAAW,GAAG,EAAE,CAAC;AAC9B,MAAM,CAAC,MAAM,QAAQ,GAAG,EAAE,CAAC;AAC3B,MAAM,CAAC,MAAM,UAAU,GAAG,EAAE,CAAC;AAC7B,MAAM,CAAC,MAAM,UAAU,GAAG,EAAE,CAAC;AAC7B,6EAA6E;AAC7E,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AACnC,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAC7C,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC;AACzC,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AACtC,MAAM,CAAC,MAAM,OAAO,GAAG,EAAE,CAAC;AAC1B,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC;AACrB,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC;AACzC,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AACnC,MAAM,CAAC,MAAM,SAAS,GAAG,EAAE,CAAC;AAC5B,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAC7C,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,CAAC;AACjD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,CAAC;AAk1BhC,iFAAiF;AACjF,0BAA0B;AAC1B,MAAM,CAAC,MAAM,6BAA6B,GAAG,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 {Injector} from '../../di/injector';\nimport {ProviderToken} from '../../di/provider_token';\nimport {DehydratedView} from '../../hydration/interfaces';\nimport {SchemaMetadata} from '../../metadata/schema';\nimport {Sanitizer} from '../../sanitization/sanitizer';\nimport type {ReactiveLViewConsumer} from '../reactive_lview_consumer';\nimport type {FlushableEffectRunner} from '../reactivity/effect';\nimport type {AfterRenderEventManager} from '../after_render_hooks';\n\nimport {LContainer} from './container';\nimport {ComponentDef, ComponentTemplate, DirectiveDef, DirectiveDefList, HostBindingsFunction, PipeDef, PipeDefList, ViewQueriesFunction} from './definition';\nimport {I18nUpdateOpCodes, TI18n, TIcu} from './i18n';\nimport {TConstants, TNode} from './node';\nimport {LQueries, TQueries} from './query';\nimport {Renderer, RendererFactory} from './renderer';\nimport {RElement} from './renderer_dom';\nimport {TStylingKey, TStylingRange} from './styling';\nimport {TDeferBlockDetails} from './defer';\n\n\n\n// Below are constants for LView indices to help us look up LView members\n// without having to remember the specific indices.\n// Uglify will inline these when minifying so there shouldn't be a cost.\nexport const HOST = 0;\nexport const TVIEW = 1;\nexport const FLAGS = 2;\nexport const PARENT = 3;\nexport const NEXT = 4;\nexport const DESCENDANT_VIEWS_TO_REFRESH = 5;\nexport const T_HOST = 6;\nexport const CLEANUP = 7;\nexport const CONTEXT = 8;\nexport const INJECTOR = 9;\nexport const ENVIRONMENT = 10;\nexport const RENDERER = 11;\nexport const CHILD_HEAD = 12;\nexport const CHILD_TAIL = 13;\n// FIXME(misko): Investigate if the three declarations aren't all same thing.\nexport const DECLARATION_VIEW = 14;\nexport const DECLARATION_COMPONENT_VIEW = 15;\nexport const DECLARATION_LCONTAINER = 16;\nexport const PREORDER_HOOK_FLAGS = 17;\nexport const QUERIES = 18;\nexport const ID = 19;\nexport const EMBEDDED_VIEW_INJECTOR = 20;\nexport const ON_DESTROY_HOOKS = 21;\nexport const HYDRATION = 22;\nexport const REACTIVE_TEMPLATE_CONSUMER = 23;\nexport const REACTIVE_HOST_BINDING_CONSUMER = 24;\n/**\n * Size of LView's header. Necessary to adjust for it when setting slots.\n *\n * IMPORTANT: `HEADER_OFFSET` should only be referred to the in the `ɵɵ*` instructions to translate\n * instruction index into `LView` index. All other indexes should be in the `LView` index space and\n * there should be no need to refer to `HEADER_OFFSET` anywhere else.\n */\nexport const HEADER_OFFSET = 25;\n\n\n// This interface replaces the real LView interface if it is an arg or a\n// return value of a public instruction. This ensures we don't need to expose\n// the actual interface, which should be kept private.\nexport interface OpaqueViewState {\n  '__brand__': 'Brand for OpaqueViewState that nothing will match';\n}\n\n\n/**\n * `LView` stores all of the information needed to process the instructions as\n * they are invoked from the template. Each embedded view and component view has its\n * own `LView`. When processing a particular view, we set the `viewData` to that\n * `LView`. When that view is done processing, the `viewData` is set back to\n * whatever the original `viewData` was before (the parent `LView`).\n *\n * Keeping separate state for each view facilities view insertion / deletion, so we\n * don't have to edit the data array based on which views are present.\n */\nexport interface LView<T = unknown> extends Array<any> {\n  /**\n   * The node into which this `LView` is inserted.\n   */\n  [HOST]: RElement|null;\n\n  /**\n   * The static data for this view. We need a reference to this so we can easily walk up the\n   * node tree in DI and get the TView.data array associated with a node (where the\n   * directive defs are stored).\n   */\n  readonly[TVIEW]: TView;\n\n  /** Flags for this view. See LViewFlags for more info. */\n  [FLAGS]: LViewFlags;\n\n  /**\n   * This may store an {@link LView} or {@link LContainer}.\n   *\n   * `LView` - The parent view. This is needed when we exit the view and must restore the previous\n   * LView. Without this, the render method would have to keep a stack of\n   * views as it is recursively rendering templates.\n   *\n   * `LContainer` - The current view is part of a container, and is an embedded view.\n   */\n  [PARENT]: LView|LContainer|null;\n\n  /**\n   *\n   * The next sibling LView or LContainer.\n   *\n   * Allows us to propagate between sibling view states that aren't in the same\n   * container. Embedded views already have a node.next, but it is only set for\n   * views in the same container. We need a way to link component views and views\n   * across containers as well.\n   */\n  [NEXT]: LView|LContainer|null;\n\n  /** Queries active for this view - nodes from a view are reported to those queries. */\n  [QUERIES]: LQueries|null;\n\n  /**\n   * Store the `TNode` of the location where the current `LView` is inserted into.\n   *\n   * Given:\n   * ```\n   * <div>\n   *   <ng-template><span></span></ng-template>\n   * </div>\n   * ```\n   *\n   * We end up with two `TView`s.\n   * - `parent` `TView` which contains `<div><!-- anchor --></div>`\n   * - `child` `TView` which contains `<span></span>`\n   *\n   * Typically the `child` is inserted into the declaration location of the `parent`, but it can be\n   * inserted anywhere. Because it can be inserted anywhere it is not possible to store the\n   * insertion information in the `TView` and instead we must store it in the `LView[T_HOST]`.\n   *\n   * So to determine where is our insertion parent we would execute:\n   * ```\n   * const parentLView = lView[PARENT];\n   * const parentTNode = lView[T_HOST];\n   * const insertionParent = parentLView[parentTNode.index];\n   * ```\n   *\n   *\n   * If `null`, this is the root view of an application (root component is in this view) and it has\n   * no parents.\n   */\n  [T_HOST]: TNode|null;\n\n  /**\n   * When a view is destroyed, listeners need to be released and outputs need to be\n   * unsubscribed. This context array stores both listener functions wrapped with\n   * their context and output subscription instances for a particular view.\n   *\n   * These change per LView instance, so they cannot be stored on TView. Instead,\n   * TView.cleanup saves an index to the necessary context in this array.\n   *\n   * After `LView` is created it is possible to attach additional instance specific functions at the\n   * end of the `lView[CLEANUP]` because we know that no more `T` level cleanup functions will be\n   * added here.\n   */\n  [CLEANUP]: any[]|null;\n\n  /**\n   * - For dynamic views, this is the context with which to render the template (e.g.\n   *   `NgForContext`), or `{}` if not defined explicitly.\n   * - For root view of the root component it's a reference to the component instance itself.\n   * - For components, the context is a reference to the component instance itself.\n   * - For inline views, the context is null.\n   */\n  [CONTEXT]: T;\n\n  /** An optional Module Injector to be used as fall back after Element Injectors are consulted. */\n  readonly[INJECTOR]: Injector|null;\n\n  /**\n   * Contextual data that is shared across multiple instances of `LView` in the same application.\n   */\n  [ENVIRONMENT]: LViewEnvironment;\n\n  /** Renderer to be used for this view. */\n  [RENDERER]: Renderer;\n\n  /**\n   * Reference to the first LView or LContainer beneath this LView in\n   * the hierarchy.\n   *\n   * Necessary to store this so views can traverse through their nested views\n   * to remove listeners and call onDestroy callbacks.\n   */\n  [CHILD_HEAD]: LView|LContainer|null;\n\n  /**\n   * The last LView or LContainer beneath this LView in the hierarchy.\n   *\n   * The tail allows us to quickly add a new state to the end of the view list\n   * without having to propagate starting from the first child.\n   */\n  [CHILD_TAIL]: LView|LContainer|null;\n\n  /**\n   * View where this view's template was declared.\n   *\n   * The template for a dynamically created view may be declared in a different view than\n   * it is inserted. We already track the \"insertion view\" (view where the template was\n   * inserted) in LView[PARENT], but we also need access to the \"declaration view\"\n   * (view where the template was declared). Otherwise, we wouldn't be able to call the\n   * view's template function with the proper contexts. Context should be inherited from\n   * the declaration view tree, not the insertion view tree.\n   *\n   * Example (AppComponent template):\n   *\n   * <ng-template #foo></ng-template>       <-- declared here -->\n   * <some-comp [tpl]=\"foo\"></some-comp>    <-- inserted inside this component -->\n   *\n   * The <ng-template> above is declared in the AppComponent template, but it will be passed into\n   * SomeComp and inserted there. In this case, the declaration view would be the AppComponent,\n   * but the insertion view would be SomeComp. When we are removing views, we would want to\n   * traverse through the insertion view to clean up listeners. When we are calling the\n   * template function during change detection, we need the declaration view to get inherited\n   * context.\n   */\n  [DECLARATION_VIEW]: LView|null;\n\n\n  /**\n   * Points to the declaration component view, used to track transplanted `LView`s.\n   *\n   * See: `DECLARATION_VIEW` which points to the actual `LView` where it was declared, whereas\n   * `DECLARATION_COMPONENT_VIEW` points to the component which may not be same as\n   * `DECLARATION_VIEW`.\n   *\n   * Example:\n   * ```\n   * <#VIEW #myComp>\n   *  <div *ngIf=\"true\">\n   *   <ng-template #myTmpl>...</ng-template>\n   *  </div>\n   * </#VIEW>\n   * ```\n   * In the above case `DECLARATION_VIEW` for `myTmpl` points to the `LView` of `ngIf` whereas\n   * `DECLARATION_COMPONENT_VIEW` points to `LView` of the `myComp` which owns the template.\n   *\n   * The reason for this is that all embedded views are always check-always whereas the component\n   * view can be check-always or on-push. When we have a transplanted view it is important to\n   * determine if we have transplanted a view from check-always declaration to on-push insertion\n   * point. In such a case the transplanted view needs to be added to the `LContainer` in the\n   * declared `LView` and CD during the declared view CD (in addition to the CD at the insertion\n   * point.) (Any transplanted views which are intra Component are of no interest because the CD\n   * strategy of declaration and insertion will always be the same, because it is the same\n   * component.)\n   *\n   * Queries already track moved views in `LView[DECLARATION_LCONTAINER]` and\n   * `LContainer[MOVED_VIEWS]`. However the queries also track `LView`s which moved within the same\n   * component `LView`. Transplanted views are a subset of moved views, and we use\n   * `DECLARATION_COMPONENT_VIEW` to differentiate them. As in this example.\n   *\n   * Example showing intra component `LView` movement.\n   * ```\n   * <#VIEW #myComp>\n   *   <div *ngIf=\"condition; then thenBlock else elseBlock\"></div>\n   *   <ng-template #thenBlock>Content to render when condition is true.</ng-template>\n   *   <ng-template #elseBlock>Content to render when condition is false.</ng-template>\n   * </#VIEW>\n   * ```\n   * The `thenBlock` and `elseBlock` is moved but not transplanted.\n   *\n   * Example showing inter component `LView` movement (transplanted view).\n   * ```\n   * <#VIEW #myComp>\n   *   <ng-template #myTmpl>...</ng-template>\n   *   <insertion-component [template]=\"myTmpl\"></insertion-component>\n   * </#VIEW>\n   * ```\n   * In the above example `myTmpl` is passed into a different component. If `insertion-component`\n   * instantiates `myTmpl` and `insertion-component` is on-push then the `LContainer` needs to be\n   * marked as containing transplanted views and those views need to be CD as part of the\n   * declaration CD.\n   *\n   *\n   * When change detection runs, it iterates over `[MOVED_VIEWS]` and CDs any child `LView`s where\n   * the `DECLARATION_COMPONENT_VIEW` of the current component and the child `LView` does not match\n   * (it has been transplanted across components.)\n   *\n   * Note: `[DECLARATION_COMPONENT_VIEW]` points to itself if the LView is a component view (the\n   *       simplest / most common case).\n   *\n   * see also:\n   *   - https://hackmd.io/@mhevery/rJUJsvv9H write up of the problem\n   *   - `LContainer[HAS_TRANSPLANTED_VIEWS]` which marks which `LContainer` has transplanted views.\n   *   - `LContainer[TRANSPLANT_HEAD]` and `LContainer[TRANSPLANT_TAIL]` storage for transplanted\n   *   - `LView[DECLARATION_LCONTAINER]` similar problem for queries\n   *   - `LContainer[MOVED_VIEWS]` similar problem for queries\n   */\n  [DECLARATION_COMPONENT_VIEW]: LView;\n\n  /**\n   * A declaration point of embedded views (ones instantiated based on the content of a\n   * <ng-template>), null for other types of views.\n   *\n   * We need to track all embedded views created from a given declaration point so we can prepare\n   * query matches in a proper order (query matches are ordered based on their declaration point and\n   * _not_ the insertion point).\n   */\n  [DECLARATION_LCONTAINER]: LContainer|null;\n\n  /**\n   * More flags for this view. See PreOrderHookFlags for more info.\n   */\n  [PREORDER_HOOK_FLAGS]: PreOrderHookFlags;\n\n  /**\n   * The number of direct transplanted views which need a refresh or have descendants themselves\n   * that need a refresh but have not marked their ancestors as Dirty. This tells us that during\n   * change detection we should still descend to find those children to refresh, even if the parents\n   * are not `Dirty`/`CheckAlways`.\n   */\n  [DESCENDANT_VIEWS_TO_REFRESH]: number;\n\n  /** Unique ID of the view. Used for `__ngContext__` lookups in the `LView` registry. */\n  [ID]: number;\n\n  /**\n   * A container related to hydration annotation information that's associated with this LView.\n   */\n  [HYDRATION]: DehydratedView|null;\n\n  /**\n   * Optional injector assigned to embedded views that takes\n   * precedence over the element and module injectors.\n   */\n  readonly[EMBEDDED_VIEW_INJECTOR]: Injector|null;\n\n  /**\n   * A collection of callbacks functions that are executed when a given LView is destroyed. Those\n   * are user defined, LView-specific destroy callbacks that don't have any corresponding TView\n   * entries.\n   */\n  [ON_DESTROY_HOOKS]: Array<() => void>|null;\n\n  /**\n   * The `Consumer` for this `LView`'s template so that signal reads can be tracked.\n   *\n   * This is initially `null` and gets assigned a consumer after template execution\n   * if any signals were read.\n   */\n  [REACTIVE_TEMPLATE_CONSUMER]: ReactiveLViewConsumer|null;\n\n  /**\n   * Same as REACTIVE_TEMPLATE_CONSUMER, but for the host bindings of the LView.\n   */\n  [REACTIVE_HOST_BINDING_CONSUMER]: ReactiveLViewConsumer|null;\n}\n\n/**\n * Contextual data that is shared across multiple instances of `LView` in the same application.\n */\nexport interface LViewEnvironment {\n  /** Factory to be used for creating Renderer. */\n  rendererFactory: RendererFactory;\n\n  /** An optional custom sanitizer. */\n  sanitizer: Sanitizer|null;\n\n  /** Container for reactivity system `effect`s. */\n  inlineEffectRunner: FlushableEffectRunner|null;\n\n  /** Container for after render hooks */\n  afterRenderEventManager: AfterRenderEventManager|null;\n}\n\n/** Flags associated with an LView (saved in LView[FLAGS]) */\nexport const enum LViewFlags {\n  /** The state of the init phase on the first 2 bits */\n  InitPhaseStateIncrementer = 0b00000000001,\n  InitPhaseStateMask = 0b00000000011,\n\n  /**\n   * Whether or not the view is in creationMode.\n   *\n   * This must be stored in the view rather than using `data` as a marker so that\n   * we can properly support embedded views. Otherwise, when exiting a child view\n   * back into the parent view, `data` will be defined and `creationMode` will be\n   * improperly reported as false.\n   */\n  CreationMode = 1 << 2,\n\n  /**\n   * Whether or not this LView instance is on its first processing pass.\n   *\n   * An LView instance is considered to be on its \"first pass\" until it\n   * has completed one creation mode run and one update mode run. At this\n   * time, the flag is turned off.\n   */\n  FirstLViewPass = 1 << 3,\n\n  /** Whether this view has default change detection strategy (checks always) or onPush */\n  CheckAlways = 1 << 4,\n\n  /** Whether there are any i18n blocks inside this LView. */\n  HasI18n = 1 << 5,\n\n  /** Whether or not this view is currently dirty (needing check) */\n  Dirty = 1 << 6,\n\n  /** Whether or not this view is currently attached to change detection tree. */\n  Attached = 1 << 7,\n\n  /** Whether or not this view is destroyed. */\n  Destroyed = 1 << 8,\n\n  /** Whether or not this view is the root view */\n  IsRoot = 1 << 9,\n\n  /**\n   * Whether this moved LView was needs to be refreshed. Similar to the Dirty flag, but used for\n   * transplanted and signal views where the parent/ancestor views are not marked dirty as well.\n   * i.e. \"Refresh just this view\". Used in conjunction with the DESCENDANT_VIEWS_TO_REFRESH\n   * counter.\n   */\n  RefreshView = 1 << 10,\n\n  /** Indicates that the view **or any of its ancestors** have an embedded view injector. */\n  HasEmbeddedViewInjector = 1 << 11,\n\n  /** Indicates that the view was created with `signals: true`. */\n  SignalView = 1 << 12,\n\n  /**\n   * Index of the current init phase on last 21 bits\n   */\n  IndexWithinInitPhaseIncrementer = 1 << 13,\n  /**\n   * This is the count of the bits the 1 was shifted above (base 10)\n   */\n  IndexWithinInitPhaseShift = 13,\n\n  // Subtracting 1 gives all 1s to the right of the initial shift\n  // So `(1 << 3) - 1` would give 3 1s: 1 << 3 = 0b01000, subtract 1 = 0b00111\n  IndexWithinInitPhaseReset = (1 << 13) - 1,\n}\n\n/**\n * Possible states of the init phase:\n * - 00: OnInit hooks to be run.\n * - 01: AfterContentInit hooks to be run\n * - 10: AfterViewInit hooks to be run\n * - 11: All init hooks have been run\n */\nexport const enum InitPhaseState {\n  OnInitHooksToBeRun = 0b00,\n  AfterContentInitHooksToBeRun = 0b01,\n  AfterViewInitHooksToBeRun = 0b10,\n  InitPhaseCompleted = 0b11,\n}\n\n/** More flags associated with an LView (saved in LView[PREORDER_HOOK_FLAGS]) */\nexport const enum PreOrderHookFlags {\n  /**\n     The index of the next pre-order hook to be called in the hooks array, on the first 16\n     bits\n   */\n  IndexOfTheNextPreOrderHookMaskMask = 0b01111111111111111,\n\n  /**\n   * The number of init hooks that have already been called, on the last 16 bits\n   */\n  NumberOfInitHooksCalledIncrementer = 0b010000000000000000,\n  NumberOfInitHooksCalledShift = 16,\n  NumberOfInitHooksCalledMask = 0b11111111111111110000000000000000,\n}\n\n/**\n * Stores a set of OpCodes to process `HostBindingsFunction` associated with a current view.\n *\n * In order to invoke `HostBindingsFunction` we need:\n * 1. 'elementIdx`: Index to the element associated with the `HostBindingsFunction`.\n * 2. 'directiveIdx`: Index to the directive associated with the `HostBindingsFunction`. (This will\n *    become the context for the `HostBindingsFunction` invocation.)\n * 3. `bindingRootIdx`: Location where the bindings for the `HostBindingsFunction` start. Internally\n *    `HostBindingsFunction` binding indexes start from `0` so we need to add `bindingRootIdx` to\n *    it.\n * 4. `HostBindingsFunction`: A host binding function to execute.\n *\n * The above information needs to be encoded into the `HostBindingOpCodes` in an efficient manner.\n *\n * 1. `elementIdx` is encoded into the `HostBindingOpCodes` as `~elementIdx` (so a negative number);\n * 2. `directiveIdx`\n * 3. `bindingRootIdx`\n * 4. `HostBindingsFunction` is passed in as is.\n *\n * The `HostBindingOpCodes` array contains:\n * - negative number to select the element index.\n * - followed by 1 or more of:\n *    - a number to select the directive index\n *    - a number to select the bindingRoot index\n *    - and a function to invoke.\n *\n * ## Example\n *\n * ```\n * const hostBindingOpCodes = [\n *   ~30,                               // Select element 30\n *   40, 45, MyDir.ɵdir.hostBindings    // Invoke host bindings on MyDir on element 30;\n *                                      // directiveIdx = 40; bindingRootIdx = 45;\n *   50, 55, OtherDir.ɵdir.hostBindings // Invoke host bindings on OtherDire on element 30\n *                                      // directiveIdx = 50; bindingRootIdx = 55;\n * ]\n * ```\n *\n * ## Pseudocode\n * ```\n * const hostBindingOpCodes = tView.hostBindingOpCodes;\n * if (hostBindingOpCodes === null) return;\n * for (let i = 0; i < hostBindingOpCodes.length; i++) {\n *   const opCode = hostBindingOpCodes[i] as number;\n *   if (opCode < 0) {\n *     // Negative numbers are element indexes.\n *     setSelectedIndex(~opCode);\n *   } else {\n *     // Positive numbers are NumberTuple which store bindingRootIndex and directiveIndex.\n *     const directiveIdx = opCode;\n *     const bindingRootIndx = hostBindingOpCodes[++i] as number;\n *     const hostBindingFn = hostBindingOpCodes[++i] as HostBindingsFunction<any>;\n *     setBindingRootForHostBindings(bindingRootIndx, directiveIdx);\n *     const context = lView[directiveIdx];\n *     hostBindingFn(RenderFlags.Update, context);\n *   }\n * }\n * ```\n *\n */\nexport interface HostBindingOpCodes extends Array<number|HostBindingsFunction<any>> {\n  __brand__: 'HostBindingOpCodes';\n  debug?: string[];\n}\n\n/**\n * Explicitly marks `TView` as a specific type in `ngDevMode`\n *\n * It is useful to know conceptually what time of `TView` we are dealing with when\n * debugging an application (even if the runtime does not need it.) For this reason\n * we store this information in the `ngDevMode` `TView` and than use it for\n * better debugging experience.\n */\nexport const enum TViewType {\n  /**\n   * Root `TView` is the used to bootstrap components into. It is used in conjunction with\n   * `LView` which takes an existing DOM node not owned by Angular and wraps it in `TView`/`LView`\n   * so that other components can be loaded into it.\n   */\n  Root = 0,\n\n  /**\n   * `TView` associated with a Component. This would be the `TView` directly associated with the\n   * component view (as opposed an `Embedded` `TView` which would be a child of `Component` `TView`)\n   */\n  Component = 1,\n\n  /**\n   * `TView` associated with a template. Such as `*ngIf`, `<ng-template>` etc... A `Component`\n   * can have zero or more `Embedded` `TView`s.\n   */\n  Embedded = 2,\n}\n\n/**\n * The static data for an LView (shared between all templates of a\n * given type).\n *\n * Stored on the `ComponentDef.tView`.\n */\nexport interface TView {\n  /**\n   * Type of `TView` (`Root`|`Component`|`Embedded`).\n   */\n  type: TViewType;\n\n  /**\n   * This is a blueprint used to generate LView instances for this TView. Copying this\n   * blueprint is faster than creating a new LView from scratch.\n   */\n  blueprint: LView;\n\n  /**\n   * The template function used to refresh the view of dynamically created views\n   * and components. Will be null for inline views.\n   */\n  template: ComponentTemplate<{}>|null;\n\n  /**\n   * A function containing query-related instructions.\n   */\n  viewQuery: ViewQueriesFunction<{}>|null;\n\n  /**\n   * A `TNode` representing the declaration location of this `TView` (not part of this TView).\n   */\n  declTNode: TNode|null;\n\n  // FIXME(misko): Why does `TView` not have `declarationTView` property?\n\n  /** Whether or not this template has been processed in creation mode. */\n  firstCreatePass: boolean;\n\n  /**\n   *  Whether or not this template has been processed in update mode (e.g. change detected)\n   *\n   * `firstUpdatePass` is used by styling to set up `TData` to contain metadata about the styling\n   * instructions. (Mainly to build up a linked list of styling priority order.)\n   *\n   * Typically this function gets cleared after first execution. If exception is thrown then this\n   * flag can remain turned un until there is first successful (no exception) pass. This means that\n   * individual styling instructions keep track of if they have already been added to the linked\n   * list to prevent double adding.\n   */\n  firstUpdatePass: boolean;\n\n  /** Static data equivalent of LView.data[]. Contains TNodes, PipeDefInternal or TI18n. */\n  data: TData;\n\n  /**\n   * The binding start index is the index at which the data array\n   * starts to store bindings only. Saving this value ensures that we\n   * will begin reading bindings at the correct point in the array when\n   * we are in update mode.\n   *\n   * -1 means that it has not been initialized.\n   */\n  bindingStartIndex: number;\n\n  /**\n   * The index where the \"expando\" section of `LView` begins. The expando\n   * section contains injectors, directive instances, and host binding values.\n   * Unlike the \"decls\" and \"vars\" sections of `LView`, the length of this\n   * section cannot be calculated at compile-time because directives are matched\n   * at runtime to preserve locality.\n   *\n   * We store this start index so we know where to start checking host bindings\n   * in `setHostBindings`.\n   */\n  expandoStartIndex: number;\n\n  /**\n   * Whether or not there are any static view queries tracked on this view.\n   *\n   * We store this so we know whether or not we should do a view query\n   * refresh after creation mode to collect static query results.\n   */\n  staticViewQueries: boolean;\n\n  /**\n   * Whether or not there are any static content queries tracked on this view.\n   *\n   * We store this so we know whether or not we should do a content query\n   * refresh after creation mode to collect static query results.\n   */\n  staticContentQueries: boolean;\n\n  /**\n   * A reference to the first child node located in the view.\n   */\n  firstChild: TNode|null;\n\n  /**\n   * Stores the OpCodes to be replayed during change-detection to process the `HostBindings`\n   *\n   * See `HostBindingOpCodes` for encoding details.\n   */\n  hostBindingOpCodes: HostBindingOpCodes|null;\n\n  /**\n   * Full registry of directives and components that may be found in this view.\n   *\n   * It's necessary to keep a copy of the full def list on the TView so it's possible\n   * to render template functions without a host component.\n   */\n  directiveRegistry: DirectiveDefList|null;\n\n  /**\n   * Full registry of pipes that may be found in this view.\n   *\n   * The property is either an array of `PipeDefs`s or a function which returns the array of\n   * `PipeDefs`s. The function is necessary to be able to support forward declarations.\n   *\n   * It's necessary to keep a copy of the full def list on the TView so it's possible\n   * to render template functions without a host component.\n   */\n  pipeRegistry: PipeDefList|null;\n\n  /**\n   * Array of ngOnInit, ngOnChanges and ngDoCheck hooks that should be executed for this view in\n   * creation mode.\n   *\n   * This array has a flat structure and contains TNode indices, directive indices (where an\n   * instance can be found in `LView`) and hook functions. TNode index is followed by the directive\n   * index and a hook function. If there are multiple hooks for a given TNode, the TNode index is\n   * not repeated and the next lifecycle hook information is stored right after the previous hook\n   * function. This is done so that at runtime the system can efficiently iterate over all of the\n   * functions to invoke without having to make any decisions/lookups.\n   */\n  preOrderHooks: HookData|null;\n\n  /**\n   * Array of ngOnChanges and ngDoCheck hooks that should be executed for this view in update mode.\n   *\n   * This array has the same structure as the `preOrderHooks` one.\n   */\n  preOrderCheckHooks: HookData|null;\n\n  /**\n   * Array of ngAfterContentInit and ngAfterContentChecked hooks that should be executed\n   * for this view in creation mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  contentHooks: HookData|null;\n\n  /**\n   * Array of ngAfterContentChecked hooks that should be executed for this view in update\n   * mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  contentCheckHooks: HookData|null;\n\n  /**\n   * Array of ngAfterViewInit and ngAfterViewChecked hooks that should be executed for\n   * this view in creation mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  viewHooks: HookData|null;\n\n  /**\n   * Array of ngAfterViewChecked hooks that should be executed for this view in\n   * update mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  viewCheckHooks: HookData|null;\n\n  /**\n   * Array of ngOnDestroy hooks that should be executed when this view is destroyed.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  destroyHooks: DestroyHookData|null;\n\n  /**\n   * When a view is destroyed, listeners need to be released and outputs need to be\n   * unsubscribed. This cleanup array stores both listener data (in chunks of 4)\n   * and output data (in chunks of 2) for a particular view. Combining the arrays\n   * saves on memory (70 bytes per array) and on a few bytes of code size (for two\n   * separate for loops).\n   *\n   * If it's a native DOM listener or output subscription being stored:\n   * 1st index is: event name  `name = tView.cleanup[i+0]`\n   * 2nd index is: index of native element or a function that retrieves global target (window,\n   *               document or body) reference based on the native element:\n   *    `typeof idxOrTargetGetter === 'function'`: global target getter function\n   *    `typeof idxOrTargetGetter === 'number'`: index of native element\n   *\n   * 3rd index is: index of listener function `listener = lView[CLEANUP][tView.cleanup[i+2]]`\n   * 4th index is: `useCaptureOrIndx = tView.cleanup[i+3]`\n   *    `typeof useCaptureOrIndx == 'boolean' : useCapture boolean\n   *    `typeof useCaptureOrIndx == 'number':\n   *         `useCaptureOrIndx >= 0` `removeListener = LView[CLEANUP][useCaptureOrIndx]`\n   *         `useCaptureOrIndx <  0` `subscription = LView[CLEANUP][-useCaptureOrIndx]`\n   *\n   * If it's an output subscription or query list destroy hook:\n   * 1st index is: output unsubscribe function / query list destroy function\n   * 2nd index is: index of function context in LView.cleanupInstances[]\n   *               `tView.cleanup[i+0].call(lView[CLEANUP][tView.cleanup[i+1]])`\n   */\n  cleanup: any[]|null;\n\n  /**\n   * A list of element indices for child components that will need to be\n   * refreshed when the current view has finished its check. These indices have\n   * already been adjusted for the HEADER_OFFSET.\n   *\n   */\n  components: number[]|null;\n\n  /**\n   * A collection of queries tracked in a given view.\n   */\n  queries: TQueries|null;\n\n  /**\n   * An array of indices pointing to directives with content queries alongside with the\n   * corresponding query index. Each entry in this array is a tuple of:\n   * - index of the first content query index declared by a given directive;\n   * - index of a directive.\n   *\n   * We are storing those indexes so we can refresh content queries as part of a view refresh\n   * process.\n   */\n  contentQueries: number[]|null;\n\n  /**\n   * Set of schemas that declare elements to be allowed inside the view.\n   */\n  schemas: SchemaMetadata[]|null;\n\n  /**\n   * Array of constants for the view. Includes attribute arrays, local definition arrays etc.\n   * Used for directive matching, attribute bindings, local definitions and more.\n   */\n  consts: TConstants|null;\n\n  /**\n   * Indicates that there was an error before we managed to complete the first create pass of the\n   * view. This means that the view is likely corrupted and we should try to recover it.\n   */\n  incompleteFirstPass: boolean;\n\n  /**\n   * Unique id of this TView for hydration purposes:\n   * - TViewType.Embedded: a unique id generated during serialization on the server\n   * - TViewType.Component: an id generated based on component properties\n   *                        (see `getComponentId` function for details)\n   */\n  ssrId: string|null;\n}\n\n/** Single hook callback function. */\nexport type HookFn = () => void;\n\n/**\n * Information necessary to call a hook. E.g. the callback that\n * needs to invoked and the index at which to find its context.\n */\nexport type HookEntry = number|HookFn;\n\n/**\n * Array of hooks that should be executed for a view and their directive indices.\n *\n * For each node of the view, the following data is stored:\n * 1) Node index (optional)\n * 2) A series of number/function pairs where:\n *  - even indices are directive indices\n *  - odd indices are hook functions\n *\n * Special cases:\n *  - a negative directive index flags an init hook (ngOnInit, ngAfterContentInit, ngAfterViewInit)\n */\nexport type HookData = HookEntry[];\n\n/**\n * Array of destroy hooks that should be executed for a view and their directive indices.\n *\n * The array is set up as a series of number/function or number/(number|function)[]:\n * - Even indices represent the context with which hooks should be called.\n * - Odd indices are the hook functions themselves. If a value at an odd index is an array,\n *   it represents the destroy hooks of a `multi` provider where:\n *     - Even indices represent the index of the provider for which we've registered a destroy hook,\n *       inside of the `multi` provider array.\n *     - Odd indices are the destroy hook functions.\n * For example:\n * LView: `[0, 1, 2, AService, 4, [BService, CService, DService]]`\n * destroyHooks: `[3, AService.ngOnDestroy, 5, [0, BService.ngOnDestroy, 2, DService.ngOnDestroy]]`\n *\n * In the example above `AService` is a type provider with an `ngOnDestroy`, whereas `BService`,\n * `CService` and `DService` are part of a `multi` provider where only `BService` and `DService`\n * have an `ngOnDestroy` hook.\n */\nexport type DestroyHookData = (HookEntry|HookData)[];\n\n/**\n * Static data that corresponds to the instance-specific data array on an LView.\n *\n * Each node's static data is stored in tData at the same index that it's stored\n * in the data array.  Any nodes that do not have static data store a null value in\n * tData to avoid a sparse array.\n *\n * Each pipe's definition is stored here at the same index as its pipe instance in\n * the data array.\n *\n * Each host property's name is stored here at the same index as its value in the\n * data array.\n *\n * Each property binding name is stored here at the same index as its value in\n * the data array. If the binding is an interpolation, the static string values\n * are stored parallel to the dynamic values. Example:\n *\n * id=\"prefix {{ v0 }} a {{ v1 }} b {{ v2 }} suffix\"\n *\n * LView       |   TView.data\n *------------------------\n *  v0 value   |   'a'\n *  v1 value   |   'b'\n *  v2 value   |   id � prefix � suffix\n *\n * Injector bloom filters are also stored here.\n */\nexport type TData =\n    (TNode|PipeDef<any>|DirectiveDef<any>|ComponentDef<any>|number|TStylingRange|TStylingKey|\n     ProviderToken<any>|TI18n|I18nUpdateOpCodes|TIcu|null|string|TDeferBlockDetails)[];\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/view.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAuBH,yEAAyE;AACzE,mDAAmD;AACnD,wEAAwE;AACxE,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,CAAC;AACtB,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC;AACvB,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC;AACvB,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,CAAC;AACxB,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,CAAC;AACtB,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC;AAC7C,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,CAAC;AACxB,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,CAAC;AACzB,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,CAAC;AACzB,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAC;AAC1B,MAAM,CAAC,MAAM,WAAW,GAAG,EAAE,CAAC;AAC9B,MAAM,CAAC,MAAM,QAAQ,GAAG,EAAE,CAAC;AAC3B,MAAM,CAAC,MAAM,UAAU,GAAG,EAAE,CAAC;AAC7B,MAAM,CAAC,MAAM,UAAU,GAAG,EAAE,CAAC;AAC7B,6EAA6E;AAC7E,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AACnC,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAC7C,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC;AACzC,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AACtC,MAAM,CAAC,MAAM,OAAO,GAAG,EAAE,CAAC;AAC1B,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC;AACrB,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC;AACzC,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AACnC,MAAM,CAAC,MAAM,SAAS,GAAG,EAAE,CAAC;AAC5B,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAC7C,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,CAAC;AACjD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,CAAC;AAm1BhC,iFAAiF;AACjF,0BAA0B;AAC1B,MAAM,CAAC,MAAM,6BAA6B,GAAG,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 {Injector} from '../../di/injector';\nimport {ProviderToken} from '../../di/provider_token';\nimport {DehydratedView} from '../../hydration/interfaces';\nimport {SchemaMetadata} from '../../metadata/schema';\nimport {Sanitizer} from '../../sanitization/sanitizer';\nimport type {ReactiveLViewConsumer} from '../reactive_lview_consumer';\nimport type {FlushableEffectRunner} from '../reactivity/effect';\nimport type {AfterRenderEventManager} from '../after_render_hooks';\n\nimport {LContainer} from './container';\nimport {ComponentDef, ComponentTemplate, DirectiveDef, DirectiveDefList, HostBindingsFunction, PipeDef, PipeDefList, ViewQueriesFunction} from './definition';\nimport {I18nUpdateOpCodes, TI18n, TIcu} from './i18n';\nimport {TConstants, TNode} from './node';\nimport {LQueries, TQueries} from './query';\nimport {Renderer, RendererFactory} from './renderer';\nimport {RElement} from './renderer_dom';\nimport {TStylingKey, TStylingRange} from './styling';\nimport {TDeferBlockDetails} from './defer';\n\n\n\n// Below are constants for LView indices to help us look up LView members\n// without having to remember the specific indices.\n// Uglify will inline these when minifying so there shouldn't be a cost.\nexport const HOST = 0;\nexport const TVIEW = 1;\nexport const FLAGS = 2;\nexport const PARENT = 3;\nexport const NEXT = 4;\nexport const DESCENDANT_VIEWS_TO_REFRESH = 5;\nexport const T_HOST = 6;\nexport const CLEANUP = 7;\nexport const CONTEXT = 8;\nexport const INJECTOR = 9;\nexport const ENVIRONMENT = 10;\nexport const RENDERER = 11;\nexport const CHILD_HEAD = 12;\nexport const CHILD_TAIL = 13;\n// FIXME(misko): Investigate if the three declarations aren't all same thing.\nexport const DECLARATION_VIEW = 14;\nexport const DECLARATION_COMPONENT_VIEW = 15;\nexport const DECLARATION_LCONTAINER = 16;\nexport const PREORDER_HOOK_FLAGS = 17;\nexport const QUERIES = 18;\nexport const ID = 19;\nexport const EMBEDDED_VIEW_INJECTOR = 20;\nexport const ON_DESTROY_HOOKS = 21;\nexport const HYDRATION = 22;\nexport const REACTIVE_TEMPLATE_CONSUMER = 23;\nexport const REACTIVE_HOST_BINDING_CONSUMER = 24;\n/**\n * Size of LView's header. Necessary to adjust for it when setting slots.\n *\n * IMPORTANT: `HEADER_OFFSET` should only be referred to the in the `ɵɵ*` instructions to translate\n * instruction index into `LView` index. All other indexes should be in the `LView` index space and\n * there should be no need to refer to `HEADER_OFFSET` anywhere else.\n */\nexport const HEADER_OFFSET = 25;\n\n\n// This interface replaces the real LView interface if it is an arg or a\n// return value of a public instruction. This ensures we don't need to expose\n// the actual interface, which should be kept private.\nexport interface OpaqueViewState {\n  '__brand__': 'Brand for OpaqueViewState that nothing will match';\n}\n\n\n/**\n * `LView` stores all of the information needed to process the instructions as\n * they are invoked from the template. Each embedded view and component view has its\n * own `LView`. When processing a particular view, we set the `viewData` to that\n * `LView`. When that view is done processing, the `viewData` is set back to\n * whatever the original `viewData` was before (the parent `LView`).\n *\n * Keeping separate state for each view facilities view insertion / deletion, so we\n * don't have to edit the data array based on which views are present.\n */\nexport interface LView<T = unknown> extends Array<any> {\n  /**\n   * The node into which this `LView` is inserted.\n   */\n  [HOST]: RElement|null;\n\n  /**\n   * The static data for this view. We need a reference to this so we can easily walk up the\n   * node tree in DI and get the TView.data array associated with a node (where the\n   * directive defs are stored).\n   */\n  readonly[TVIEW]: TView;\n\n  /** Flags for this view. See LViewFlags for more info. */\n  [FLAGS]: LViewFlags;\n\n  /**\n   * This may store an {@link LView} or {@link LContainer}.\n   *\n   * `LView` - The parent view. This is needed when we exit the view and must restore the previous\n   * LView. Without this, the render method would have to keep a stack of\n   * views as it is recursively rendering templates.\n   *\n   * `LContainer` - The current view is part of a container, and is an embedded view.\n   */\n  [PARENT]: LView|LContainer|null;\n\n  /**\n   *\n   * The next sibling LView or LContainer.\n   *\n   * Allows us to propagate between sibling view states that aren't in the same\n   * container. Embedded views already have a node.next, but it is only set for\n   * views in the same container. We need a way to link component views and views\n   * across containers as well.\n   */\n  [NEXT]: LView|LContainer|null;\n\n  /** Queries active for this view - nodes from a view are reported to those queries. */\n  [QUERIES]: LQueries|null;\n\n  /**\n   * Store the `TNode` of the location where the current `LView` is inserted into.\n   *\n   * Given:\n   * ```\n   * <div>\n   *   <ng-template><span></span></ng-template>\n   * </div>\n   * ```\n   *\n   * We end up with two `TView`s.\n   * - `parent` `TView` which contains `<div><!-- anchor --></div>`\n   * - `child` `TView` which contains `<span></span>`\n   *\n   * Typically the `child` is inserted into the declaration location of the `parent`, but it can be\n   * inserted anywhere. Because it can be inserted anywhere it is not possible to store the\n   * insertion information in the `TView` and instead we must store it in the `LView[T_HOST]`.\n   *\n   * So to determine where is our insertion parent we would execute:\n   * ```\n   * const parentLView = lView[PARENT];\n   * const parentTNode = lView[T_HOST];\n   * const insertionParent = parentLView[parentTNode.index];\n   * ```\n   *\n   *\n   * If `null`, this is the root view of an application (root component is in this view) and it has\n   * no parents.\n   */\n  [T_HOST]: TNode|null;\n\n  /**\n   * When a view is destroyed, listeners need to be released and outputs need to be\n   * unsubscribed. This context array stores both listener functions wrapped with\n   * their context and output subscription instances for a particular view.\n   *\n   * These change per LView instance, so they cannot be stored on TView. Instead,\n   * TView.cleanup saves an index to the necessary context in this array.\n   *\n   * After `LView` is created it is possible to attach additional instance specific functions at the\n   * end of the `lView[CLEANUP]` because we know that no more `T` level cleanup functions will be\n   * added here.\n   */\n  [CLEANUP]: any[]|null;\n\n  /**\n   * - For dynamic views, this is the context with which to render the template (e.g.\n   *   `NgForContext`), or `{}` if not defined explicitly.\n   * - For root view of the root component it's a reference to the component instance itself.\n   * - For components, the context is a reference to the component instance itself.\n   * - For inline views, the context is null.\n   */\n  [CONTEXT]: T;\n\n  /** An optional Module Injector to be used as fall back after Element Injectors are consulted. */\n  readonly[INJECTOR]: Injector|null;\n\n  /**\n   * Contextual data that is shared across multiple instances of `LView` in the same application.\n   */\n  [ENVIRONMENT]: LViewEnvironment;\n\n  /** Renderer to be used for this view. */\n  [RENDERER]: Renderer;\n\n  /**\n   * Reference to the first LView or LContainer beneath this LView in\n   * the hierarchy.\n   *\n   * Necessary to store this so views can traverse through their nested views\n   * to remove listeners and call onDestroy callbacks.\n   */\n  [CHILD_HEAD]: LView|LContainer|null;\n\n  /**\n   * The last LView or LContainer beneath this LView in the hierarchy.\n   *\n   * The tail allows us to quickly add a new state to the end of the view list\n   * without having to propagate starting from the first child.\n   */\n  [CHILD_TAIL]: LView|LContainer|null;\n\n  /**\n   * View where this view's template was declared.\n   *\n   * The template for a dynamically created view may be declared in a different view than\n   * it is inserted. We already track the \"insertion view\" (view where the template was\n   * inserted) in LView[PARENT], but we also need access to the \"declaration view\"\n   * (view where the template was declared). Otherwise, we wouldn't be able to call the\n   * view's template function with the proper contexts. Context should be inherited from\n   * the declaration view tree, not the insertion view tree.\n   *\n   * Example (AppComponent template):\n   *\n   * <ng-template #foo></ng-template>       <-- declared here -->\n   * <some-comp [tpl]=\"foo\"></some-comp>    <-- inserted inside this component -->\n   *\n   * The <ng-template> above is declared in the AppComponent template, but it will be passed into\n   * SomeComp and inserted there. In this case, the declaration view would be the AppComponent,\n   * but the insertion view would be SomeComp. When we are removing views, we would want to\n   * traverse through the insertion view to clean up listeners. When we are calling the\n   * template function during change detection, we need the declaration view to get inherited\n   * context.\n   */\n  [DECLARATION_VIEW]: LView|null;\n\n\n  /**\n   * Points to the declaration component view, used to track transplanted `LView`s.\n   *\n   * See: `DECLARATION_VIEW` which points to the actual `LView` where it was declared, whereas\n   * `DECLARATION_COMPONENT_VIEW` points to the component which may not be same as\n   * `DECLARATION_VIEW`.\n   *\n   * Example:\n   * ```\n   * <#VIEW #myComp>\n   *  <div *ngIf=\"true\">\n   *   <ng-template #myTmpl>...</ng-template>\n   *  </div>\n   * </#VIEW>\n   * ```\n   * In the above case `DECLARATION_VIEW` for `myTmpl` points to the `LView` of `ngIf` whereas\n   * `DECLARATION_COMPONENT_VIEW` points to `LView` of the `myComp` which owns the template.\n   *\n   * The reason for this is that all embedded views are always check-always whereas the component\n   * view can be check-always or on-push. When we have a transplanted view it is important to\n   * determine if we have transplanted a view from check-always declaration to on-push insertion\n   * point. In such a case the transplanted view needs to be added to the `LContainer` in the\n   * declared `LView` and CD during the declared view CD (in addition to the CD at the insertion\n   * point.) (Any transplanted views which are intra Component are of no interest because the CD\n   * strategy of declaration and insertion will always be the same, because it is the same\n   * component.)\n   *\n   * Queries already track moved views in `LView[DECLARATION_LCONTAINER]` and\n   * `LContainer[MOVED_VIEWS]`. However the queries also track `LView`s which moved within the same\n   * component `LView`. Transplanted views are a subset of moved views, and we use\n   * `DECLARATION_COMPONENT_VIEW` to differentiate them. As in this example.\n   *\n   * Example showing intra component `LView` movement.\n   * ```\n   * <#VIEW #myComp>\n   *   <div *ngIf=\"condition; then thenBlock else elseBlock\"></div>\n   *   <ng-template #thenBlock>Content to render when condition is true.</ng-template>\n   *   <ng-template #elseBlock>Content to render when condition is false.</ng-template>\n   * </#VIEW>\n   * ```\n   * The `thenBlock` and `elseBlock` is moved but not transplanted.\n   *\n   * Example showing inter component `LView` movement (transplanted view).\n   * ```\n   * <#VIEW #myComp>\n   *   <ng-template #myTmpl>...</ng-template>\n   *   <insertion-component [template]=\"myTmpl\"></insertion-component>\n   * </#VIEW>\n   * ```\n   * In the above example `myTmpl` is passed into a different component. If `insertion-component`\n   * instantiates `myTmpl` and `insertion-component` is on-push then the `LContainer` needs to be\n   * marked as containing transplanted views and those views need to be CD as part of the\n   * declaration CD.\n   *\n   *\n   * When change detection runs, it iterates over `[MOVED_VIEWS]` and CDs any child `LView`s where\n   * the `DECLARATION_COMPONENT_VIEW` of the current component and the child `LView` does not match\n   * (it has been transplanted across components.)\n   *\n   * Note: `[DECLARATION_COMPONENT_VIEW]` points to itself if the LView is a component view (the\n   *       simplest / most common case).\n   *\n   * see also:\n   *   - https://hackmd.io/@mhevery/rJUJsvv9H write up of the problem\n   *   - `LContainer[HAS_TRANSPLANTED_VIEWS]` which marks which `LContainer` has transplanted views.\n   *   - `LContainer[TRANSPLANT_HEAD]` and `LContainer[TRANSPLANT_TAIL]` storage for transplanted\n   *   - `LView[DECLARATION_LCONTAINER]` similar problem for queries\n   *   - `LContainer[MOVED_VIEWS]` similar problem for queries\n   */\n  [DECLARATION_COMPONENT_VIEW]: LView;\n\n  /**\n   * A declaration point of embedded views (ones instantiated based on the content of a\n   * <ng-template>), null for other types of views.\n   *\n   * We need to track all embedded views created from a given declaration point so we can prepare\n   * query matches in a proper order (query matches are ordered based on their declaration point and\n   * _not_ the insertion point).\n   */\n  [DECLARATION_LCONTAINER]: LContainer|null;\n\n  /**\n   * More flags for this view. See PreOrderHookFlags for more info.\n   */\n  [PREORDER_HOOK_FLAGS]: PreOrderHookFlags;\n\n  /**\n   * The number of direct transplanted views which need a refresh or have descendants themselves\n   * that need a refresh but have not marked their ancestors as Dirty. This tells us that during\n   * change detection we should still descend to find those children to refresh, even if the parents\n   * are not `Dirty`/`CheckAlways`.\n   */\n  [DESCENDANT_VIEWS_TO_REFRESH]: number;\n\n  /** Unique ID of the view. Used for `__ngContext__` lookups in the `LView` registry. */\n  [ID]: number;\n\n  /**\n   * A container related to hydration annotation information that's associated with this LView.\n   */\n  [HYDRATION]: DehydratedView|null;\n\n  /**\n   * Optional injector assigned to embedded views that takes\n   * precedence over the element and module injectors.\n   */\n  readonly[EMBEDDED_VIEW_INJECTOR]: Injector|null;\n\n  /**\n   * A collection of callbacks functions that are executed when a given LView is destroyed. Those\n   * are user defined, LView-specific destroy callbacks that don't have any corresponding TView\n   * entries.\n   */\n  [ON_DESTROY_HOOKS]: Array<() => void>|null;\n\n  /**\n   * The `Consumer` for this `LView`'s template so that signal reads can be tracked.\n   *\n   * This is initially `null` and gets assigned a consumer after template execution\n   * if any signals were read.\n   */\n  [REACTIVE_TEMPLATE_CONSUMER]: ReactiveLViewConsumer|null;\n\n  /**\n   * Same as REACTIVE_TEMPLATE_CONSUMER, but for the host bindings of the LView.\n   */\n  [REACTIVE_HOST_BINDING_CONSUMER]: ReactiveLViewConsumer|null;\n}\n\n/**\n * Contextual data that is shared across multiple instances of `LView` in the same application.\n */\nexport interface LViewEnvironment {\n  /** Factory to be used for creating Renderer. */\n  rendererFactory: RendererFactory;\n\n  /** An optional custom sanitizer. */\n  sanitizer: Sanitizer|null;\n\n  /** Container for reactivity system `effect`s. */\n  inlineEffectRunner: FlushableEffectRunner|null;\n\n  /** Container for after render hooks */\n  afterRenderEventManager: AfterRenderEventManager|null;\n}\n\n/** Flags associated with an LView (saved in LView[FLAGS]) */\nexport const enum LViewFlags {\n  /** The state of the init phase on the first 2 bits */\n  InitPhaseStateIncrementer = 0b00000000001,\n  InitPhaseStateMask = 0b00000000011,\n\n  /**\n   * Whether or not the view is in creationMode.\n   *\n   * This must be stored in the view rather than using `data` as a marker so that\n   * we can properly support embedded views. Otherwise, when exiting a child view\n   * back into the parent view, `data` will be defined and `creationMode` will be\n   * improperly reported as false.\n   */\n  CreationMode = 1 << 2,\n\n  /**\n   * Whether or not this LView instance is on its first processing pass.\n   *\n   * An LView instance is considered to be on its \"first pass\" until it\n   * has completed one creation mode run and one update mode run. At this\n   * time, the flag is turned off.\n   */\n  FirstLViewPass = 1 << 3,\n\n  /** Whether this view has default change detection strategy (checks always) or onPush */\n  CheckAlways = 1 << 4,\n\n  /** Whether there are any i18n blocks inside this LView. */\n  HasI18n = 1 << 5,\n\n  /** Whether or not this view is currently dirty (needing check) */\n  Dirty = 1 << 6,\n\n  /** Whether or not this view is currently attached to change detection tree. */\n  Attached = 1 << 7,\n\n  /** Whether or not this view is destroyed. */\n  Destroyed = 1 << 8,\n\n  /** Whether or not this view is the root view */\n  IsRoot = 1 << 9,\n\n  /**\n   * Whether this moved LView was needs to be refreshed. Similar to the Dirty flag, but used for\n   * transplanted and signal views where the parent/ancestor views are not marked dirty as well.\n   * i.e. \"Refresh just this view\". Used in conjunction with the DESCENDANT_VIEWS_TO_REFRESH\n   * counter.\n   */\n  RefreshView = 1 << 10,\n\n  /** Indicates that the view **or any of its ancestors** have an embedded view injector. */\n  HasEmbeddedViewInjector = 1 << 11,\n\n  /** Indicates that the view was created with `signals: true`. */\n  SignalView = 1 << 12,\n\n  /**\n   * This is the count of the bits the 1 was shifted above (base 10)\n   */\n  IndexWithinInitPhaseShift = 13,\n\n  /**\n   * Index of the current init phase on last 21 bits\n   */\n  IndexWithinInitPhaseIncrementer = 1 << IndexWithinInitPhaseShift,\n\n  // Subtracting 1 gives all 1s to the right of the initial shift\n  // So `(1 << 3) - 1` would give 3 1s: 1 << 3 = 0b01000, subtract 1 = 0b00111\n  IndexWithinInitPhaseReset = (1 << IndexWithinInitPhaseShift) - 1,\n}\n\n/**\n * Possible states of the init phase:\n * - 00: OnInit hooks to be run.\n * - 01: AfterContentInit hooks to be run\n * - 10: AfterViewInit hooks to be run\n * - 11: All init hooks have been run\n */\nexport const enum InitPhaseState {\n  OnInitHooksToBeRun = 0b00,\n  AfterContentInitHooksToBeRun = 0b01,\n  AfterViewInitHooksToBeRun = 0b10,\n  InitPhaseCompleted = 0b11,\n}\n\n/** More flags associated with an LView (saved in LView[PREORDER_HOOK_FLAGS]) */\nexport const enum PreOrderHookFlags {\n  /**\n     The index of the next pre-order hook to be called in the hooks array, on the first 16\n     bits\n   */\n  IndexOfTheNextPreOrderHookMaskMask = 0b01111111111111111,\n\n  /**\n   * The number of init hooks that have already been called, on the last 16 bits\n   */\n  NumberOfInitHooksCalledIncrementer = 0b010000000000000000,\n  NumberOfInitHooksCalledShift = 16,\n  NumberOfInitHooksCalledMask = 0b11111111111111110000000000000000,\n}\n\n/**\n * Stores a set of OpCodes to process `HostBindingsFunction` associated with a current view.\n *\n * In order to invoke `HostBindingsFunction` we need:\n * 1. 'elementIdx`: Index to the element associated with the `HostBindingsFunction`.\n * 2. 'directiveIdx`: Index to the directive associated with the `HostBindingsFunction`. (This will\n *    become the context for the `HostBindingsFunction` invocation.)\n * 3. `bindingRootIdx`: Location where the bindings for the `HostBindingsFunction` start. Internally\n *    `HostBindingsFunction` binding indexes start from `0` so we need to add `bindingRootIdx` to\n *    it.\n * 4. `HostBindingsFunction`: A host binding function to execute.\n *\n * The above information needs to be encoded into the `HostBindingOpCodes` in an efficient manner.\n *\n * 1. `elementIdx` is encoded into the `HostBindingOpCodes` as `~elementIdx` (so a negative number);\n * 2. `directiveIdx`\n * 3. `bindingRootIdx`\n * 4. `HostBindingsFunction` is passed in as is.\n *\n * The `HostBindingOpCodes` array contains:\n * - negative number to select the element index.\n * - followed by 1 or more of:\n *    - a number to select the directive index\n *    - a number to select the bindingRoot index\n *    - and a function to invoke.\n *\n * ## Example\n *\n * ```\n * const hostBindingOpCodes = [\n *   ~30,                               // Select element 30\n *   40, 45, MyDir.ɵdir.hostBindings    // Invoke host bindings on MyDir on element 30;\n *                                      // directiveIdx = 40; bindingRootIdx = 45;\n *   50, 55, OtherDir.ɵdir.hostBindings // Invoke host bindings on OtherDire on element 30\n *                                      // directiveIdx = 50; bindingRootIdx = 55;\n * ]\n * ```\n *\n * ## Pseudocode\n * ```\n * const hostBindingOpCodes = tView.hostBindingOpCodes;\n * if (hostBindingOpCodes === null) return;\n * for (let i = 0; i < hostBindingOpCodes.length; i++) {\n *   const opCode = hostBindingOpCodes[i] as number;\n *   if (opCode < 0) {\n *     // Negative numbers are element indexes.\n *     setSelectedIndex(~opCode);\n *   } else {\n *     // Positive numbers are NumberTuple which store bindingRootIndex and directiveIndex.\n *     const directiveIdx = opCode;\n *     const bindingRootIndx = hostBindingOpCodes[++i] as number;\n *     const hostBindingFn = hostBindingOpCodes[++i] as HostBindingsFunction<any>;\n *     setBindingRootForHostBindings(bindingRootIndx, directiveIdx);\n *     const context = lView[directiveIdx];\n *     hostBindingFn(RenderFlags.Update, context);\n *   }\n * }\n * ```\n *\n */\nexport interface HostBindingOpCodes extends Array<number|HostBindingsFunction<any>> {\n  __brand__: 'HostBindingOpCodes';\n  debug?: string[];\n}\n\n/**\n * Explicitly marks `TView` as a specific type in `ngDevMode`\n *\n * It is useful to know conceptually what time of `TView` we are dealing with when\n * debugging an application (even if the runtime does not need it.) For this reason\n * we store this information in the `ngDevMode` `TView` and than use it for\n * better debugging experience.\n */\nexport const enum TViewType {\n  /**\n   * Root `TView` is the used to bootstrap components into. It is used in conjunction with\n   * `LView` which takes an existing DOM node not owned by Angular and wraps it in `TView`/`LView`\n   * so that other components can be loaded into it.\n   */\n  Root = 0,\n\n  /**\n   * `TView` associated with a Component. This would be the `TView` directly associated with the\n   * component view (as opposed an `Embedded` `TView` which would be a child of `Component` `TView`)\n   */\n  Component = 1,\n\n  /**\n   * `TView` associated with a template. Such as `*ngIf`, `<ng-template>` etc... A `Component`\n   * can have zero or more `Embedded` `TView`s.\n   */\n  Embedded = 2,\n}\n\n/**\n * The static data for an LView (shared between all templates of a\n * given type).\n *\n * Stored on the `ComponentDef.tView`.\n */\nexport interface TView {\n  /**\n   * Type of `TView` (`Root`|`Component`|`Embedded`).\n   */\n  type: TViewType;\n\n  /**\n   * This is a blueprint used to generate LView instances for this TView. Copying this\n   * blueprint is faster than creating a new LView from scratch.\n   */\n  blueprint: LView;\n\n  /**\n   * The template function used to refresh the view of dynamically created views\n   * and components. Will be null for inline views.\n   */\n  template: ComponentTemplate<{}>|null;\n\n  /**\n   * A function containing query-related instructions.\n   */\n  viewQuery: ViewQueriesFunction<{}>|null;\n\n  /**\n   * A `TNode` representing the declaration location of this `TView` (not part of this TView).\n   */\n  declTNode: TNode|null;\n\n  // FIXME(misko): Why does `TView` not have `declarationTView` property?\n\n  /** Whether or not this template has been processed in creation mode. */\n  firstCreatePass: boolean;\n\n  /**\n   *  Whether or not this template has been processed in update mode (e.g. change detected)\n   *\n   * `firstUpdatePass` is used by styling to set up `TData` to contain metadata about the styling\n   * instructions. (Mainly to build up a linked list of styling priority order.)\n   *\n   * Typically this function gets cleared after first execution. If exception is thrown then this\n   * flag can remain turned un until there is first successful (no exception) pass. This means that\n   * individual styling instructions keep track of if they have already been added to the linked\n   * list to prevent double adding.\n   */\n  firstUpdatePass: boolean;\n\n  /** Static data equivalent of LView.data[]. Contains TNodes, PipeDefInternal or TI18n. */\n  data: TData;\n\n  /**\n   * The binding start index is the index at which the data array\n   * starts to store bindings only. Saving this value ensures that we\n   * will begin reading bindings at the correct point in the array when\n   * we are in update mode.\n   *\n   * -1 means that it has not been initialized.\n   */\n  bindingStartIndex: number;\n\n  /**\n   * The index where the \"expando\" section of `LView` begins. The expando\n   * section contains injectors, directive instances, and host binding values.\n   * Unlike the \"decls\" and \"vars\" sections of `LView`, the length of this\n   * section cannot be calculated at compile-time because directives are matched\n   * at runtime to preserve locality.\n   *\n   * We store this start index so we know where to start checking host bindings\n   * in `setHostBindings`.\n   */\n  expandoStartIndex: number;\n\n  /**\n   * Whether or not there are any static view queries tracked on this view.\n   *\n   * We store this so we know whether or not we should do a view query\n   * refresh after creation mode to collect static query results.\n   */\n  staticViewQueries: boolean;\n\n  /**\n   * Whether or not there are any static content queries tracked on this view.\n   *\n   * We store this so we know whether or not we should do a content query\n   * refresh after creation mode to collect static query results.\n   */\n  staticContentQueries: boolean;\n\n  /**\n   * A reference to the first child node located in the view.\n   */\n  firstChild: TNode|null;\n\n  /**\n   * Stores the OpCodes to be replayed during change-detection to process the `HostBindings`\n   *\n   * See `HostBindingOpCodes` for encoding details.\n   */\n  hostBindingOpCodes: HostBindingOpCodes|null;\n\n  /**\n   * Full registry of directives and components that may be found in this view.\n   *\n   * It's necessary to keep a copy of the full def list on the TView so it's possible\n   * to render template functions without a host component.\n   */\n  directiveRegistry: DirectiveDefList|null;\n\n  /**\n   * Full registry of pipes that may be found in this view.\n   *\n   * The property is either an array of `PipeDefs`s or a function which returns the array of\n   * `PipeDefs`s. The function is necessary to be able to support forward declarations.\n   *\n   * It's necessary to keep a copy of the full def list on the TView so it's possible\n   * to render template functions without a host component.\n   */\n  pipeRegistry: PipeDefList|null;\n\n  /**\n   * Array of ngOnInit, ngOnChanges and ngDoCheck hooks that should be executed for this view in\n   * creation mode.\n   *\n   * This array has a flat structure and contains TNode indices, directive indices (where an\n   * instance can be found in `LView`) and hook functions. TNode index is followed by the directive\n   * index and a hook function. If there are multiple hooks for a given TNode, the TNode index is\n   * not repeated and the next lifecycle hook information is stored right after the previous hook\n   * function. This is done so that at runtime the system can efficiently iterate over all of the\n   * functions to invoke without having to make any decisions/lookups.\n   */\n  preOrderHooks: HookData|null;\n\n  /**\n   * Array of ngOnChanges and ngDoCheck hooks that should be executed for this view in update mode.\n   *\n   * This array has the same structure as the `preOrderHooks` one.\n   */\n  preOrderCheckHooks: HookData|null;\n\n  /**\n   * Array of ngAfterContentInit and ngAfterContentChecked hooks that should be executed\n   * for this view in creation mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  contentHooks: HookData|null;\n\n  /**\n   * Array of ngAfterContentChecked hooks that should be executed for this view in update\n   * mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  contentCheckHooks: HookData|null;\n\n  /**\n   * Array of ngAfterViewInit and ngAfterViewChecked hooks that should be executed for\n   * this view in creation mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  viewHooks: HookData|null;\n\n  /**\n   * Array of ngAfterViewChecked hooks that should be executed for this view in\n   * update mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  viewCheckHooks: HookData|null;\n\n  /**\n   * Array of ngOnDestroy hooks that should be executed when this view is destroyed.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  destroyHooks: DestroyHookData|null;\n\n  /**\n   * When a view is destroyed, listeners need to be released and outputs need to be\n   * unsubscribed. This cleanup array stores both listener data (in chunks of 4)\n   * and output data (in chunks of 2) for a particular view. Combining the arrays\n   * saves on memory (70 bytes per array) and on a few bytes of code size (for two\n   * separate for loops).\n   *\n   * If it's a native DOM listener or output subscription being stored:\n   * 1st index is: event name  `name = tView.cleanup[i+0]`\n   * 2nd index is: index of native element or a function that retrieves global target (window,\n   *               document or body) reference based on the native element:\n   *    `typeof idxOrTargetGetter === 'function'`: global target getter function\n   *    `typeof idxOrTargetGetter === 'number'`: index of native element\n   *\n   * 3rd index is: index of listener function `listener = lView[CLEANUP][tView.cleanup[i+2]]`\n   * 4th index is: `useCaptureOrIndx = tView.cleanup[i+3]`\n   *    `typeof useCaptureOrIndx == 'boolean' : useCapture boolean\n   *    `typeof useCaptureOrIndx == 'number':\n   *         `useCaptureOrIndx >= 0` `removeListener = LView[CLEANUP][useCaptureOrIndx]`\n   *         `useCaptureOrIndx <  0` `subscription = LView[CLEANUP][-useCaptureOrIndx]`\n   *\n   * If it's an output subscription or query list destroy hook:\n   * 1st index is: output unsubscribe function / query list destroy function\n   * 2nd index is: index of function context in LView.cleanupInstances[]\n   *               `tView.cleanup[i+0].call(lView[CLEANUP][tView.cleanup[i+1]])`\n   */\n  cleanup: any[]|null;\n\n  /**\n   * A list of element indices for child components that will need to be\n   * refreshed when the current view has finished its check. These indices have\n   * already been adjusted for the HEADER_OFFSET.\n   *\n   */\n  components: number[]|null;\n\n  /**\n   * A collection of queries tracked in a given view.\n   */\n  queries: TQueries|null;\n\n  /**\n   * An array of indices pointing to directives with content queries alongside with the\n   * corresponding query index. Each entry in this array is a tuple of:\n   * - index of the first content query index declared by a given directive;\n   * - index of a directive.\n   *\n   * We are storing those indexes so we can refresh content queries as part of a view refresh\n   * process.\n   */\n  contentQueries: number[]|null;\n\n  /**\n   * Set of schemas that declare elements to be allowed inside the view.\n   */\n  schemas: SchemaMetadata[]|null;\n\n  /**\n   * Array of constants for the view. Includes attribute arrays, local definition arrays etc.\n   * Used for directive matching, attribute bindings, local definitions and more.\n   */\n  consts: TConstants|null;\n\n  /**\n   * Indicates that there was an error before we managed to complete the first create pass of the\n   * view. This means that the view is likely corrupted and we should try to recover it.\n   */\n  incompleteFirstPass: boolean;\n\n  /**\n   * Unique id of this TView for hydration purposes:\n   * - TViewType.Embedded: a unique id generated during serialization on the server\n   * - TViewType.Component: an id generated based on component properties\n   *                        (see `getComponentId` function for details)\n   */\n  ssrId: string|null;\n}\n\n/** Single hook callback function. */\nexport type HookFn = () => void;\n\n/**\n * Information necessary to call a hook. E.g. the callback that\n * needs to invoked and the index at which to find its context.\n */\nexport type HookEntry = number|HookFn;\n\n/**\n * Array of hooks that should be executed for a view and their directive indices.\n *\n * For each node of the view, the following data is stored:\n * 1) Node index (optional)\n * 2) A series of number/function pairs where:\n *  - even indices are directive indices\n *  - odd indices are hook functions\n *\n * Special cases:\n *  - a negative directive index flags an init hook (ngOnInit, ngAfterContentInit, ngAfterViewInit)\n */\nexport type HookData = HookEntry[];\n\n/**\n * Array of destroy hooks that should be executed for a view and their directive indices.\n *\n * The array is set up as a series of number/function or number/(number|function)[]:\n * - Even indices represent the context with which hooks should be called.\n * - Odd indices are the hook functions themselves. If a value at an odd index is an array,\n *   it represents the destroy hooks of a `multi` provider where:\n *     - Even indices represent the index of the provider for which we've registered a destroy hook,\n *       inside of the `multi` provider array.\n *     - Odd indices are the destroy hook functions.\n * For example:\n * LView: `[0, 1, 2, AService, 4, [BService, CService, DService]]`\n * destroyHooks: `[3, AService.ngOnDestroy, 5, [0, BService.ngOnDestroy, 2, DService.ngOnDestroy]]`\n *\n * In the example above `AService` is a type provider with an `ngOnDestroy`, whereas `BService`,\n * `CService` and `DService` are part of a `multi` provider where only `BService` and `DService`\n * have an `ngOnDestroy` hook.\n */\nexport type DestroyHookData = (HookEntry|HookData)[];\n\n/**\n * Static data that corresponds to the instance-specific data array on an LView.\n *\n * Each node's static data is stored in tData at the same index that it's stored\n * in the data array.  Any nodes that do not have static data store a null value in\n * tData to avoid a sparse array.\n *\n * Each pipe's definition is stored here at the same index as its pipe instance in\n * the data array.\n *\n * Each host property's name is stored here at the same index as its value in the\n * data array.\n *\n * Each property binding name is stored here at the same index as its value in\n * the data array. If the binding is an interpolation, the static string values\n * are stored parallel to the dynamic values. Example:\n *\n * id=\"prefix {{ v0 }} a {{ v1 }} b {{ v2 }} suffix\"\n *\n * LView       |   TView.data\n *------------------------\n *  v0 value   |   'a'\n *  v1 value   |   'b'\n *  v2 value   |   id � prefix � suffix\n *\n * Injector bloom filters are also stored here.\n */\nexport type TData =\n    (TNode|PipeDef<any>|DirectiveDef<any>|ComponentDef<any>|number|TStylingRange|TStylingKey|\n     ProviderToken<any>|TI18n|I18nUpdateOpCodes|TIcu|null|string|TDeferBlockDetails)[];\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}