@angular/core 17.1.0-next.5 → 17.1.0

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

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { setActiveConsumer, SIGNAL } from '@angular/core/primitives/signals';
+import { applyValueToInputField } from '../apply_value_input_field';
+import { InputFlags } from '../interfaces/definition';
+export function writeToDirectiveInput(def, instance, publicName, privateName, flags, value) {
+    const prevConsumer = setActiveConsumer(null);
+    try {
+        // If we know we are dealing with a signal input, we cache its reference
+        // in a tree-shakable way. The input signal node can then be used for
+        // value transform execution or actual value updates without introducing
+        // additional megamorphic accesses for accessing the instance field.
+        let inputSignalNode = null;
+        if ((flags & InputFlags.SignalBased) !== 0) {
+            const field = instance[privateName];
+            inputSignalNode = field[SIGNAL];
+        }
+        // If there is a signal node and a transform, run it before potentially
+        // delegating to features like `NgOnChanges`.
+        if (inputSignalNode !== null && inputSignalNode.transformFn !== undefined) {
+            value = inputSignalNode.transformFn(value);
+        }
+        // If there is a decorator input transform, run it.
+        if ((flags & InputFlags.HasDecoratorInputTransform) !== 0) {
+            value = def.inputTransforms[privateName].call(instance, value);
+        }
+        if (def.setInput !== null) {
+            def.setInput(instance, inputSignalNode, value, publicName, privateName);
+        }
+        else {
+            applyValueToInputField(instance, inputSignalNode, privateName, value);
+        }
+    }
+    finally {
+        setActiveConsumer(prevConsumer);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -41,10 +41,5 @@ export var LContainerFlags;
      * This flag, once set, is never unset for the `LContainer`.
      */
     LContainerFlags[LContainerFlags["HasTransplantedViews"] = 2] = "HasTransplantedViews";
-    /**
-     * Indicates that this LContainer has a view underneath it that needs to be refreshed during
-     * change detection.
-     */
-    LContainerFlags[LContainerFlags["HasChildViewsToRefresh"] = 4] = "HasChildViewsToRefresh";
 })(LContainerFlags || (LContainerFlags = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -5,5 +5,11 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/definition.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG","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\nexport interface ClassDebugInfo {\n  className: string;\n  filePath?: string;\n  lineNumber?: number;\n  forbidOrphanRendering?: boolean;\n}\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   * Note: Signal inputs will not have transforms captured here. This is because their\n   * transform function is already integrated into the `InputSignal`.\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   * Info related to debugging/troubleshooting for this component. This info is only available in\n   * dev mode.\n   */\n  debugInfo: ClassDebugInfo|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 * 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"]}
+/** Flags describing an input for a directive. */
+export var InputFlags;
+(function (InputFlags) {
+    InputFlags[InputFlags["None"] = 0] = "None";
+    InputFlags[InputFlags["SignalBased"] = 1] = "SignalBased";
+    InputFlags[InputFlags["HasDecoratorInputTransform"] = 2] = "HasDecoratorInputTransform";
+})(InputFlags || (InputFlags = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/definition.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAoFH,iDAAiD;AACjD,MAAM,CAAN,IAAY,UAIX;AAJD,WAAY,UAAU;IACpB,2CAAQ,CAAA;IACR,yDAAoB,CAAA;IACpB,uFAAmC,CAAA;AACrC,CAAC,EAJW,UAAU,KAAV,UAAU,QAIrB","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 {InputSignalNode} from '../../authoring/input_signal_node';\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\nexport interface ClassDebugInfo {\n  className: string;\n  filePath?: string;\n  lineNumber?: number;\n  forbidOrphanRendering?: boolean;\n}\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/** Flags describing an input for a directive. */\nexport enum InputFlags {\n  None = 0,\n  SignalBased = 1 << 0,\n  HasDecoratorInputTransform = 1 << 1,\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' public name to their minified property names\n   * (along with flags if there are any).\n   */\n  readonly inputs: {[P in keyof T]?: string|[minifiedName: string, flags: InputFlags]};\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   * Note: Signal inputs will not have transforms captured here. This is because their\n   * transform function is already integrated into the `InputSignal`.\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      {[P in keyof T]?: string|[InputFlags, 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: Record<string, 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   * Info related to debugging/troubleshooting for this component. This info is only available in\n   * dev mode.\n   */\n  debugInfo: ClassDebugInfo|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,\n           inputSignalNode: null|InputSignalNode<unknown, unknown>, 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 * 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/node.mjs

@@ -76,4 +76,4 @@ export function hasClassInput(tNode) {
 export function hasStyleInput(tNode) {
     return (tNode.flags & 16 /* TNodeFlags.hasStyleInput */) !== 0;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/node.ts"],"names":[],"mappings":"AAkFA;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,SAAoB;IACtD,IAAI,IAAI,GAAG,EAAE,CAAC;IACd,CAAC,SAAS,yBAAiB,CAAC,IAAI,CAAC,IAAI,IAAI,OAAO,CAAC,CAAC;IAClD,CAAC,SAAS,4BAAoB,CAAC,IAAI,CAAC,IAAI,IAAI,UAAU,CAAC,CAAC;IACxD,CAAC,SAAS,8BAAsB,CAAC,IAAI,CAAC,IAAI,IAAI,YAAY,CAAC,CAAC;IAC5D,CAAC,SAAS,qCAA6B,CAAC,IAAI,CAAC,IAAI,IAAI,mBAAmB,CAAC,CAAC;IAC1E,CAAC,SAAS,gCAAuB,CAAC,IAAI,CAAC,IAAI,IAAI,aAAa,CAAC,CAAC;IAC9D,CAAC,SAAS,yBAAgB,CAAC,IAAI,CAAC,IAAI,IAAI,eAAe,CAAC,CAAC;IACzD,CAAC,SAAS,iCAAwB,CAAC,IAAI,CAAC,IAAI,IAAI,cAAc,CAAC,CAAC;IAChE,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACpD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,KAAK,IAAI,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAC7C,CAAE,KAAe,CAAC,iBAAiB,KAAK,IAAI;YAC3C,OAAQ,KAAe,CAAC,iBAAiB,KAAK,QAAQ;YACtD,KAAK,CAAC,OAAO,CAAE,KAAe,CAAC,iBAAiB,CAAC,CAAC,CAAC;AAC1D,CAAC;AAu0BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,aAAa,CAAC,KAAY;IACxC,OAAO,CAAC,KAAK,CAAC,KAAK,mCAA2B,CAAC,KAAK,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,aAAa,CAAC,KAAY;IACxC,OAAO,CAAC,KAAK,CAAC,KAAK,oCAA2B,CAAC,KAAK,CAAC,CAAC;AACxD,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 */\nimport {KeyValueArray} from '../../util/array_utils';\nimport {TStylingRange} from '../interfaces/styling';\n\nimport {TIcu} from './i18n';\nimport {CssSelector} from './projection';\nimport {RNode} from './renderer_dom';\nimport {LView, TView} from './view';\n\n\n/**\n * TNodeType corresponds to the {@link TNode} `type` property.\n *\n * NOTE: type IDs are such that we use each bit to denote a type. This is done so that we can easily\n * check if the `TNode` is of more than one type.\n *\n * `if (tNode.type === TNodeType.Text || tNode.type === TNode.Element)`\n * can be written as:\n * `if (tNode.type & (TNodeType.Text | TNodeType.Element))`\n *\n * However any given `TNode` can only be of one type.\n */\nexport const enum TNodeType {\n  /**\n   * The TNode contains information about a DOM element aka {@link RText}.\n   */\n  Text = 0b1,\n\n  /**\n   * The TNode contains information about a DOM element aka {@link RElement}.\n   */\n  Element = 0b10,\n\n  /**\n   * The TNode contains information about an {@link LContainer} for embedded views.\n   */\n  Container = 0b100,\n\n  /**\n   * The TNode contains information about an `<ng-container>` element {@link RNode}.\n   */\n  ElementContainer = 0b1000,\n\n  /**\n   * The TNode contains information about an `<ng-content>` projection\n   */\n  Projection = 0b10000,\n\n  /**\n   * The TNode contains information about an ICU comment used in `i18n`.\n   */\n  Icu = 0b100000,\n\n  /**\n   * Special node type representing a placeholder for future `TNode` at this location.\n   *\n   * I18n translation blocks are created before the element nodes which they contain. (I18n blocks\n   * can span over many elements.) Because i18n `TNode`s (representing text) are created first they\n   * often may need to point to element `TNode`s which are not yet created. In such a case we create\n   * a `Placeholder` `TNode`. This allows the i18n to structurally link the `TNode`s together\n   * without knowing any information about the future nodes which will be at that location.\n   *\n   * On `firstCreatePass` When element instruction executes it will try to create a `TNode` at that\n   * location. Seeing a `Placeholder` `TNode` already there tells the system that it should reuse\n   * existing `TNode` (rather than create a new one) and just update the missing information.\n   */\n  Placeholder = 0b1000000,\n\n  // Combined Types These should never be used for `TNode.type` only as a useful way to check\n  // if `TNode.type` is one of several choices.\n\n  // See: https://github.com/microsoft/TypeScript/issues/35875 why we can't refer to existing enum.\n  AnyRNode = 0b11,        // Text | Element\n  AnyContainer = 0b1100,  // Container | ElementContainer\n}\n\n/**\n * Converts `TNodeType` into human readable text.\n * Make sure this matches with `TNodeType`\n */\nexport function toTNodeTypeAsString(tNodeType: TNodeType): string {\n  let text = '';\n  (tNodeType & TNodeType.Text) && (text += '|Text');\n  (tNodeType & TNodeType.Element) && (text += '|Element');\n  (tNodeType & TNodeType.Container) && (text += '|Container');\n  (tNodeType & TNodeType.ElementContainer) && (text += '|ElementContainer');\n  (tNodeType & TNodeType.Projection) && (text += '|Projection');\n  (tNodeType & TNodeType.Icu) && (text += '|IcuContainer');\n  (tNodeType & TNodeType.Placeholder) && (text += '|Placeholder');\n  return text.length > 0 ? text.substring(1) : text;\n}\n\n/**\n * Helper function to detect if a given value matches a `TNode` shape.\n *\n * The logic uses the `insertBeforeIndex` and its possible values as\n * a way to differentiate a TNode shape from other types of objects\n * within the `TView.data`. This is not a perfect check, but it can\n * be a reasonable differentiator, since we control the shapes of objects\n * within `TView.data`.\n */\nexport function isTNodeShape(value: unknown): value is TNode {\n  return value != null && typeof value === 'object' &&\n      ((value as TNode).insertBeforeIndex === null ||\n       typeof (value as TNode).insertBeforeIndex === 'number' ||\n       Array.isArray((value as TNode).insertBeforeIndex));\n}\n\n/**\n * Corresponds to the TNode.flags property.\n */\nexport const enum TNodeFlags {\n  /** Bit #1 - This bit is set if the node is a host for any directive (including a component) */\n  isDirectiveHost = 0x1,\n\n  /** Bit #2 - This bit is set if the node has been projected */\n  isProjected = 0x2,\n\n  /** Bit #3 - This bit is set if any directive on this node has content queries */\n  hasContentQuery = 0x4,\n\n  /** Bit #4 - This bit is set if the node has any \"class\" inputs */\n  hasClassInput = 0x8,\n\n  /** Bit #5 - This bit is set if the node has any \"style\" inputs */\n  hasStyleInput = 0x10,\n\n  /** Bit #6 - This bit is set if the node has been detached by i18n */\n  isDetached = 0x20,\n\n  /**\n   * Bit #7 - This bit is set if the node has directives with host bindings.\n   *\n   * This flags allows us to guard host-binding logic and invoke it only on nodes\n   * that actually have directives with host bindings.\n   */\n  hasHostBindings = 0x40,\n\n  /**\n   * Bit #8 - This bit is set if the node is a located inside skip hydration block.\n   */\n  inSkipHydrationBlock = 0x80,\n}\n\n/**\n * Corresponds to the TNode.providerIndexes property.\n */\nexport const enum TNodeProviderIndexes {\n  /** The index of the first provider on this node is encoded on the least significant bits. */\n  ProvidersStartIndexMask = 0b00000000000011111111111111111111,\n\n  /**\n   * The count of view providers from the component on this node is\n   * encoded on the 20 most significant bits.\n   */\n  CptViewProvidersCountShift = 20,\n  CptViewProvidersCountShifter = 0b00000000000100000000000000000000,\n}\n\n/**\n * A set of marker values to be used in the attributes arrays. These markers indicate that some\n * items are not regular attributes and the processing should be adapted accordingly.\n */\nexport const enum AttributeMarker {\n  /**\n   * An implicit marker which indicates that the value in the array are of `attributeKey`,\n   * `attributeValue` format.\n   *\n   * NOTE: This is implicit as it is the type when no marker is present in array. We indicate that\n   * it should not be present at runtime by the negative number.\n   */\n  ImplicitAttributes = -1,\n\n  /**\n   * Marker indicates that the following 3 values in the attributes array are:\n   * namespaceUri, attributeName, attributeValue\n   * in that order.\n   */\n  NamespaceURI = 0,\n\n  /**\n   * Signals class declaration.\n   *\n   * Each value following `Classes` designates a class name to include on the element.\n   * ## Example:\n   *\n   * Given:\n   * ```\n   * <div class=\"foo bar baz\">...<d/vi>\n   * ```\n   *\n   * the generated code is:\n   * ```\n   * var _c1 = [AttributeMarker.Classes, 'foo', 'bar', 'baz'];\n   * ```\n   */\n  Classes = 1,\n\n  /**\n   * Signals style declaration.\n   *\n   * Each pair of values following `Styles` designates a style name and value to include on the\n   * element.\n   * ## Example:\n   *\n   * Given:\n   * ```\n   * <div style=\"width:100px; height:200px; color:red\">...</div>\n   * ```\n   *\n   * the generated code is:\n   * ```\n   * var _c1 = [AttributeMarker.Styles, 'width', '100px', 'height'. '200px', 'color', 'red'];\n   * ```\n   */\n  Styles = 2,\n\n  /**\n   * Signals that the following attribute names were extracted from input or output bindings.\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <div moo=\"car\" [foo]=\"exp\" (bar)=\"doSth()\">\n   * ```\n   *\n   * the generated code is:\n   *\n   * ```\n   * var _c1 = ['moo', 'car', AttributeMarker.Bindings, 'foo', 'bar'];\n   * ```\n   */\n  Bindings = 3,\n\n  /**\n   * Signals that the following attribute names were hoisted from an inline-template declaration.\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <div *ngFor=\"let value of values; trackBy:trackBy\" dirA [dirB]=\"value\">\n   * ```\n   *\n   * the generated code for the `template()` instruction would include:\n   *\n   * ```\n   * ['dirA', '', AttributeMarker.Bindings, 'dirB', AttributeMarker.Template, 'ngFor', 'ngForOf',\n   * 'ngForTrackBy', 'let-value']\n   * ```\n   *\n   * while the generated code for the `element()` instruction inside the template function would\n   * include:\n   *\n   * ```\n   * ['dirA', '', AttributeMarker.Bindings, 'dirB']\n   * ```\n   */\n  Template = 4,\n\n  /**\n   * Signals that the following attribute is `ngProjectAs` and its value is a parsed\n   * `CssSelector`.\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <h1 attr=\"value\" ngProjectAs=\"[title]\">\n   * ```\n   *\n   * the generated code for the `element()` instruction would include:\n   *\n   * ```\n   * ['attr', 'value', AttributeMarker.ProjectAs, ['', 'title', '']]\n   * ```\n   */\n  ProjectAs = 5,\n\n  /**\n   * Signals that the following attribute will be translated by runtime i18n\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <div moo=\"car\" foo=\"value\" i18n-foo [bar]=\"binding\" i18n-bar>\n   * ```\n   *\n   * the generated code is:\n   *\n   * ```\n   * var _c1 = ['moo', 'car', AttributeMarker.I18n, 'foo', 'bar'];\n   */\n  I18n = 6,\n}\n\n/**\n * A combination of:\n * - Attribute names and values.\n * - Special markers acting as flags to alter attributes processing.\n * - Parsed ngProjectAs selectors.\n */\nexport type TAttributes = (string|AttributeMarker|CssSelector)[];\n\n/**\n * Constants that are associated with a view. Includes:\n * - Attribute arrays.\n * - Local definition arrays.\n * - Translated messages (i18n).\n */\nexport type TConstants = (TAttributes|string)[];\n\n/**\n * Factory function that returns an array of consts. Consts can be represented as a function in\n * case any additional statements are required to define consts in the list. An example is i18n\n * where additional i18n calls are generated, which should be executed when consts are requested\n * for the first time.\n */\nexport type TConstantsFactory = () => TConstants;\n\n/**\n * TConstants type that describes how the `consts` field is generated on ComponentDef: it can be\n * either an array or a factory function that returns that array.\n */\nexport type TConstantsOrFactory = TConstants|TConstantsFactory;\n\n/**\n * Binding data (flyweight) for a particular node that is shared between all templates\n * of a specific type.\n *\n * If a property is:\n *    - PropertyAliases: that property's data was generated and this is it\n *    - Null: that property's data was already generated and nothing was found.\n *    - Undefined: that property's data has not yet been generated\n *\n * see: https://en.wikipedia.org/wiki/Flyweight_pattern for more on the Flyweight pattern\n */\nexport interface TNode {\n  /** The type of the TNode. See TNodeType. */\n  type: TNodeType;\n\n  /**\n   * Index of the TNode in TView.data and corresponding native element in LView.\n   *\n   * This is necessary to get from any TNode to its corresponding native element when\n   * traversing the node tree.\n   *\n   * If index is -1, this is a dynamically created container node or embedded view node.\n   */\n  index: number;\n\n  /**\n   * Insert before existing DOM node index.\n   *\n   * When DOM nodes are being inserted, normally they are being appended as they are created.\n   * Under i18n case, the translated text nodes are created ahead of time as part of the\n   * `ɵɵi18nStart` instruction which means that this `TNode` can't just be appended and instead\n   * needs to be inserted using `insertBeforeIndex` semantics.\n   *\n   * Additionally sometimes it is necessary to insert new text nodes as a child of this `TNode`. In\n   * such a case the value stores an array of text nodes to insert.\n   *\n   * Example:\n   * ```\n   * <div i18n>\n   *   Hello <span>World</span>!\n   * </div>\n   * ```\n   * In the above example the `ɵɵi18nStart` instruction can create `Hello `, `World` and `!` text\n   * nodes. It can also insert `Hello ` and `!` text node as a child of `<div>`, but it can't\n   * insert `World` because the `<span>` node has not yet been created. In such a case the\n   * `<span>` `TNode` will have an array which will direct the `<span>` to not only insert\n   * itself in front of `!` but also to insert the `World` (created by `ɵɵi18nStart`) into\n   * `<span>` itself.\n   *\n   * Pseudo code:\n   * ```\n   *   if (insertBeforeIndex === null) {\n   *     // append as normal\n   *   } else if (Array.isArray(insertBeforeIndex)) {\n   *     // First insert current `TNode` at correct location\n   *     const currentNode = lView[this.index];\n   *     parentNode.insertBefore(currentNode, lView[this.insertBeforeIndex[0]]);\n   *     // Now append all of the children\n   *     for(let i=1; i<this.insertBeforeIndex; i++) {\n   *       currentNode.appendChild(lView[this.insertBeforeIndex[i]]);\n   *     }\n   *   } else {\n   *     parentNode.insertBefore(lView[this.index], lView[this.insertBeforeIndex])\n   *   }\n   * ```\n   * - null: Append as normal using `parentNode.appendChild`\n   * - `number`: Append using\n   *      `parentNode.insertBefore(lView[this.index], lView[this.insertBeforeIndex])`\n   *\n   * *Initialization*\n   *\n   * Because `ɵɵi18nStart` executes before nodes are created, on `TView.firstCreatePass` it is not\n   * possible for `ɵɵi18nStart` to set the `insertBeforeIndex` value as the corresponding `TNode`\n   * has not yet been created. For this reason the `ɵɵi18nStart` creates a `TNodeType.Placeholder`\n   * `TNode` at that location. See `TNodeType.Placeholder` for more information.\n   */\n  insertBeforeIndex: InsertBeforeIndex;\n\n  /**\n   * The index of the closest injector in this node's LView.\n   *\n   * If the index === -1, there is no injector on this node or any ancestor node in this view.\n   *\n   * If the index !== -1, it is the index of this node's injector OR the index of a parent\n   * injector in the same view. We pass the parent injector index down the node tree of a view so\n   * it's possible to find the parent injector without walking a potentially deep node tree.\n   * Injector indices are not set across view boundaries because there could be multiple component\n   * hosts.\n   *\n   * If tNode.injectorIndex === tNode.parent.injectorIndex, then the index belongs to a parent\n   * injector.\n   */\n  injectorIndex: number;\n\n  /** Stores starting index of the directives. */\n  directiveStart: number;\n\n  /**\n   * Stores final exclusive index of the directives.\n   *\n   * The area right behind the `directiveStart-directiveEnd` range is used to allocate the\n   * `HostBindingFunction` `vars` (or null if no bindings.) Therefore `directiveEnd` is used to set\n   * `LFrame.bindingRootIndex` before `HostBindingFunction` is executed.\n   */\n  directiveEnd: number;\n\n  /**\n   * Offset from the `directiveStart` at which the component (one at most) of the node is stored.\n   * Set to -1 if no components have been applied to the node. Component index can be found using\n   * `directiveStart + componentOffset`.\n   */\n  componentOffset: number;\n\n  /**\n   * Stores the last directive which had a styling instruction.\n   *\n   * Initial value of this is `-1` which means that no `hostBindings` styling instruction has\n   * executed. As `hostBindings` instructions execute they set the value to the index of the\n   * `DirectiveDef` which contained the last `hostBindings` styling instruction.\n   *\n   * Valid values are:\n   * - `-1` No `hostBindings` instruction has executed.\n   * - `directiveStart <= directiveStylingLast < directiveEnd`: Points to the `DirectiveDef` of\n   * the last styling instruction which executed in the `hostBindings`.\n   *\n   * This data is needed so that styling instructions know which static styling data needs to be\n   * collected from the `DirectiveDef.hostAttrs`. A styling instruction needs to collect all data\n   * since last styling instruction.\n   */\n  directiveStylingLast: number;\n\n  /**\n   * Stores indexes of property bindings. This field is only set in the ngDevMode and holds\n   * indexes of property bindings so TestBed can get bound property metadata for a given node.\n   */\n  propertyBindings: number[]|null;\n\n  /**\n   * Stores if Node isComponent, isProjected, hasContentQuery, hasClassInput and hasStyleInput\n   * etc.\n   */\n  flags: TNodeFlags;\n\n  /**\n   * This number stores two values using its bits:\n   *\n   * - the index of the first provider on that node (first 16 bits)\n   * - the count of view providers from the component on this node (last 16 bits)\n   */\n  // TODO(misko): break this into actual vars.\n  providerIndexes: TNodeProviderIndexes;\n\n  /**\n   * The value name associated with this node.\n   * if type:\n   *   `TNodeType.Text`: text value\n   *   `TNodeType.Element`: tag name\n   *   `TNodeType.ICUContainer`: `TIcu`\n   */\n  value: any;\n\n  /**\n   * Attributes associated with an element. We need to store attributes to support various\n   * use-cases (attribute injection, content projection with selectors, directives matching).\n   * Attributes are stored statically because reading them from the DOM would be way too slow for\n   * content projection and queries.\n   *\n   * Since attrs will always be calculated first, they will never need to be marked undefined by\n   * other instructions.\n   *\n   * For regular attributes a name of an attribute and its value alternate in the array.\n   * e.g. ['role', 'checkbox']\n   * This array can contain flags that will indicate \"special attributes\" (attributes with\n   * namespaces, attributes extracted from bindings and outputs).\n   */\n  attrs: TAttributes|null;\n\n  /**\n   * Same as `TNode.attrs` but contains merged data across all directive host bindings.\n   *\n   * We need to keep `attrs` as unmerged so that it can be used for attribute selectors.\n   * We merge attrs here so that it can be used in a performant way for initial rendering.\n   *\n   * The `attrs` are merged in first pass in following order:\n   * - Component's `hostAttrs`\n   * - Directives' `hostAttrs`\n   * - Template `TNode.attrs` associated with the current `TNode`.\n   */\n  mergedAttrs: TAttributes|null;\n\n  /**\n   * A set of local names under which a given element is exported in a template and\n   * visible to queries. An entry in this array can be created for different reasons:\n   * - an element itself is referenced, ex.: `<div #foo>`\n   * - a component is referenced, ex.: `<my-cmpt #foo>`\n   * - a directive is referenced, ex.: `<my-cmpt #foo=\"directiveExportAs\">`.\n   *\n   * A given element might have different local names and those names can be associated\n   * with a directive. We store local names at even indexes while odd indexes are reserved\n   * for directive index in a view (or `-1` if there is no associated directive).\n   *\n   * Some examples:\n   * - `<div #foo>` => `[\"foo\", -1]`\n   * - `<my-cmpt #foo>` => `[\"foo\", myCmptIdx]`\n   * - `<my-cmpt #foo #bar=\"directiveExportAs\">` => `[\"foo\", myCmptIdx, \"bar\", directiveIdx]`\n   * - `<div #foo #bar=\"directiveExportAs\">` => `[\"foo\", -1, \"bar\", directiveIdx]`\n   */\n  localNames: (string|number)[]|null;\n\n  /** Information about input properties that need to be set once from attribute data. */\n  initialInputs: InitialInputData|null|undefined;\n\n  /**\n   * Input data for all directives on this node. `null` means that there are no directives with\n   * inputs on this node.\n   */\n  inputs: PropertyAliases|null;\n\n  /**\n   * Output data for all directives on this node. `null` means that there are no directives with\n   * outputs on this node.\n   */\n  outputs: PropertyAliases|null;\n\n  /**\n   * The TView attached to this node.\n   *\n   * If this TNode corresponds to an LContainer with a template (e.g. structural\n   * directive), the template's TView will be stored here.\n   *\n   * If this TNode corresponds to an element, tView will be `null`.\n   */\n  tView: TView|null;\n\n  /**\n   * The next sibling node. Necessary so we can propagate through the root nodes of a view\n   * to insert them or remove them from the DOM.\n   */\n  next: TNode|null;\n\n  /**\n   * The previous sibling node.\n   * This simplifies operations when we need a pointer to the previous node.\n   */\n  prev: TNode|null;\n\n  /**\n   * The next projected sibling. Since in Angular content projection works on the node-by-node\n   * basis the act of projecting nodes might change nodes relationship at the insertion point\n   * (target view). At the same time we need to keep initial relationship between nodes as\n   * expressed in content view.\n   */\n  projectionNext: TNode|null;\n\n  /**\n   * First child of the current node.\n   *\n   * For component nodes, the child will always be a ContentChild (in same view).\n   * For embedded view nodes, the child will be in their child view.\n   */\n  child: TNode|null;\n\n  /**\n   * Parent node (in the same view only).\n   *\n   * We need a reference to a node's parent so we can append the node to its parent's native\n   * element at the appropriate time.\n   *\n   * If the parent would be in a different view (e.g. component host), this property will be null.\n   * It's important that we don't try to cross component boundaries when retrieving the parent\n   * because the parent will change (e.g. index, attrs) depending on where the component was\n   * used (and thus shouldn't be stored on TNode). In these cases, we retrieve the parent through\n   * LView.node instead (which will be instance-specific).\n   *\n   * If this is an inline view node (V), the parent will be its container.\n   */\n  parent: TElementNode|TContainerNode|null;\n\n  /**\n   * List of projected TNodes for a given component host element OR index into the said nodes.\n   *\n   * For easier discussion assume this example:\n   * `<parent>`'s view definition:\n   * ```\n   * <child id=\"c1\">content1</child>\n   * <child id=\"c2\"><span>content2</span></child>\n   * ```\n   * `<child>`'s view definition:\n   * ```\n   * <ng-content id=\"cont1\"></ng-content>\n   * ```\n   *\n   * If `Array.isArray(projection)` then `TNode` is a host element:\n   * - `projection` stores the content nodes which are to be projected.\n   *    - The nodes represent categories defined by the selector: For example:\n   *      `<ng-content/><ng-content select=\"abc\"/>` would represent the heads for `<ng-content/>`\n   *      and `<ng-content select=\"abc\"/>` respectively.\n   *    - The nodes we store in `projection` are heads only, we used `.next` to get their\n   *      siblings.\n   *    - The nodes `.next` is sorted/rewritten as part of the projection setup.\n   *    - `projection` size is equal to the number of projections `<ng-content>`. The size of\n   *      `c1` will be `1` because `<child>` has only one `<ng-content>`.\n   * - we store `projection` with the host (`c1`, `c2`) rather than the `<ng-content>` (`cont1`)\n   *   because the same component (`<child>`) can be used in multiple locations (`c1`, `c2`) and\n   * as a result have different set of nodes to project.\n   * - without `projection` it would be difficult to efficiently traverse nodes to be projected.\n   *\n   * If `typeof projection == 'number'` then `TNode` is a `<ng-content>` element:\n   * - `projection` is an index of the host's `projection`Nodes.\n   *   - This would return the first head node to project:\n   *     `getHost(currentTNode).projection[currentTNode.projection]`.\n   * - When projecting nodes the parent node retrieved may be a `<ng-content>` node, in which case\n   *   the process is recursive in nature.\n   *\n   * If `projection` is of type `RNode[][]` than we have a collection of native nodes passed as\n   * projectable nodes during dynamic component creation.\n   */\n  projection: (TNode|RNode[])[]|number|null;\n\n  /**\n   * A collection of all `style` static values for an element (including from host).\n   *\n   * This field will be populated if and when:\n   *\n   * - There are one or more initial `style`s on an element (e.g. `<div style=\"width:200px;\">`)\n   * - There are one or more initial `style`s on a directive/component host\n   *   (e.g. `@Directive({host: {style: \"width:200px;\" } }`)\n   */\n  styles: string|null;\n\n\n  /**\n   * A collection of all `style` static values for an element excluding host sources.\n   *\n   * Populated when there are one or more initial `style`s on an element\n   * (e.g. `<div style=\"width:200px;\">`)\n   * Must be stored separately from `tNode.styles` to facilitate setting directive\n   * inputs that shadow the `style` property. If we used `tNode.styles` as is for shadowed inputs,\n   * we would feed host styles back into directives as \"inputs\". If we used `tNode.attrs`, we\n   * would have to concatenate the attributes on every template pass. Instead, we process once on\n   * first create pass and store here.\n   */\n  stylesWithoutHost: string|null;\n\n  /**\n   * A `KeyValueArray` version of residual `styles`.\n   *\n   * When there are styling instructions than each instruction stores the static styling\n   * which is of lower priority than itself. This means that there may be a higher priority\n   * styling than the instruction.\n   *\n   * Imagine:\n   * ```\n   * <div style=\"color: highest;\" my-dir>\n   *\n   * @Directive({\n   *   host: {\n   *     style: 'color: lowest; ',\n   *     '[styles.color]': 'exp' // ɵɵstyleProp('color', ctx.exp);\n   *   }\n   * })\n   * ```\n   *\n   * In the above case:\n   * - `color: lowest` is stored with `ɵɵstyleProp('color', ctx.exp);` instruction\n   * -  `color: highest` is the residual and is stored here.\n   *\n   * - `undefined': not initialized.\n   * - `null`: initialized but `styles` is `null`\n   * - `KeyValueArray`: parsed version of `styles`.\n   */\n  residualStyles: KeyValueArray<any>|undefined|null;\n\n  /**\n   * A collection of all class static values for an element (including from host).\n   *\n   * This field will be populated if and when:\n   *\n   * - There are one or more initial classes on an element (e.g. `<div class=\"one two three\">`)\n   * - There are one or more initial classes on an directive/component host\n   *   (e.g. `@Directive({host: {class: \"SOME_CLASS\" } }`)\n   */\n  classes: string|null;\n\n  /**\n   * A collection of all class static values for an element excluding host sources.\n   *\n   * Populated when there are one or more initial classes on an element\n   * (e.g. `<div class=\"SOME_CLASS\">`)\n   * Must be stored separately from `tNode.classes` to facilitate setting directive\n   * inputs that shadow the `class` property. If we used `tNode.classes` as is for shadowed\n   * inputs, we would feed host classes back into directives as \"inputs\". If we used\n   * `tNode.attrs`, we would have to concatenate the attributes on every template pass. Instead,\n   * we process once on first create pass and store here.\n   */\n  classesWithoutHost: string|null;\n\n  /**\n   * A `KeyValueArray` version of residual `classes`.\n   *\n   * Same as `TNode.residualStyles` but for classes.\n   *\n   * - `undefined': not initialized.\n   * - `null`: initialized but `classes` is `null`\n   * - `KeyValueArray`: parsed version of `classes`.\n   */\n  residualClasses: KeyValueArray<any>|undefined|null;\n\n  /**\n   * Stores the head/tail index of the class bindings.\n   *\n   * - If no bindings, the head and tail will both be 0.\n   * - If there are template bindings, stores the head/tail of the class bindings in the template.\n   * - If no template bindings but there are host bindings, the head value will point to the last\n   *   host binding for \"class\" (not the head of the linked list), tail will be 0.\n   *\n   * See: `style_binding_list.ts` for details.\n   *\n   * This is used by `insertTStylingBinding` to know where the next styling binding should be\n   * inserted so that they can be sorted in priority order.\n   */\n  classBindings: TStylingRange;\n\n  /**\n   * Stores the head/tail index of the class bindings.\n   *\n   * - If no bindings, the head and tail will both be 0.\n   * - If there are template bindings, stores the head/tail of the style bindings in the template.\n   * - If no template bindings but there are host bindings, the head value will point to the last\n   *   host binding for \"style\" (not the head of the linked list), tail will be 0.\n   *\n   * See: `style_binding_list.ts` for details.\n   *\n   * This is used by `insertTStylingBinding` to know where the next styling binding should be\n   * inserted so that they can be sorted in priority order.\n   */\n  styleBindings: TStylingRange;\n}\n\n/**\n * See `TNode.insertBeforeIndex`\n */\nexport type InsertBeforeIndex = null|number|number[];\n\n/** Static data for an element  */\nexport interface TElementNode extends TNode {\n  /** Index in the data[] array */\n  index: number;\n  child: TElementNode|TTextNode|TElementContainerNode|TContainerNode|TProjectionNode|null;\n  /**\n   * Element nodes will have parents unless they are the first node of a component or\n   * embedded view (which means their parent is in a different view and must be\n   * retrieved using viewData[HOST_NODE]).\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tView: null;\n\n  /**\n   * If this is a component TNode with projection, this will be an array of projected\n   * TNodes or native nodes (see TNode.projection for more info). If it's a regular element node\n   * or a component without projection, it will be null.\n   */\n  projection: (TNode|RNode[])[]|null;\n\n  /**\n   * Stores TagName\n   */\n  value: string;\n}\n\n/** Static data for a text node */\nexport interface TTextNode extends TNode {\n  /** Index in the data[] array */\n  index: number;\n  child: null;\n  /**\n   * Text nodes will have parents unless they are the first node of a component or\n   * embedded view (which means their parent is in a different view and must be\n   * retrieved using LView.node).\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tView: null;\n  projection: null;\n}\n\n/** Static data for an LContainer */\nexport interface TContainerNode extends TNode {\n  /**\n   * Index in the data[] array.\n   *\n   * If it's -1, this is a dynamically created container node that isn't stored in\n   * data[] (e.g. when you inject ViewContainerRef) .\n   */\n  index: number;\n  child: null;\n\n  /**\n   * Container nodes will have parents unless:\n   *\n   * - They are the first node of a component or embedded view\n   * - They are dynamically created\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tView: TView|null;\n  projection: null;\n  value: null;\n}\n\n/** Static data for an <ng-container> */\nexport interface TElementContainerNode extends TNode {\n  /** Index in the LView[] array. */\n  index: number;\n  child: TElementNode|TTextNode|TContainerNode|TElementContainerNode|TProjectionNode|null;\n  parent: TElementNode|TElementContainerNode|null;\n  tView: null;\n  projection: null;\n}\n\n/** Static data for an ICU expression */\nexport interface TIcuContainerNode extends TNode {\n  /** Index in the LView[] array. */\n  index: number;\n  child: null;\n  parent: TElementNode|TElementContainerNode|null;\n  tView: null;\n  projection: null;\n  value: TIcu;\n}\n\n/** Static data for an LProjectionNode  */\nexport interface TProjectionNode extends TNode {\n  /** Index in the data[] array */\n  child: null;\n  /**\n   * Projection nodes will have parents unless they are the first node of a component\n   * or embedded view (which means their parent is in a different view and must be\n   * retrieved using LView.node).\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tView: null;\n\n  /** Index of the projection node. (See TNode.projection for more info.) */\n  projection: number;\n  value: null;\n}\n\n/**\n * A union type representing all TNode types that can host a directive.\n */\nexport type TDirectiveHostNode = TElementNode|TContainerNode|TElementContainerNode;\n\n/**\n * This mapping is necessary so we can set input properties and output listeners\n * properly at runtime when property names are minified or aliased.\n *\n * Key: unminified / public input or output name\n * Value: array containing minified / internal name and related directive index\n *\n * The value must be an array to support inputs and outputs with the same name\n * on the same node.\n */\nexport type PropertyAliases = {\n  // This uses an object map because using the Map type would be too slow\n  [key: string]: PropertyAliasValue\n};\n\n/**\n * Store the runtime input or output names for all the directives.\n *\n * i+0: directive instance index\n * i+1: privateName\n *\n * e.g. [0, 'change-minified']\n */\nexport type PropertyAliasValue = (number|string)[];\n\n/**\n * This array contains information about input properties that\n * need to be set once from attribute data. It's ordered by\n * directive index (relative to element) so it's simple to\n * look up a specific directive's initial input data.\n *\n * Within each sub-array:\n *\n * i+0: attribute name\n * i+1: minified/internal input name\n * i+2: initial value\n *\n * If a directive on a node does not have any input properties\n * that should be set from attributes, its index is set to null\n * to avoid a sparse array.\n *\n * e.g. [null, ['role-min', 'minified-input', 'button']]\n */\nexport type InitialInputData = (InitialInputs|null)[];\n\n/**\n * Used by InitialInputData to store input properties\n * that should be set once from attributes.\n *\n * i+0: attribute name\n * i+1: minified/internal input name\n * i+2: initial value\n *\n * e.g. ['role-min', 'minified-input', 'button']\n */\nexport type InitialInputs = string[];\n\n/**\n * Type representing a set of TNodes that can have local refs (`#foo`) placed on them.\n */\nexport type TNodeWithLocalRefs = TContainerNode|TElementNode|TElementContainerNode;\n\n/**\n * Type for a function that extracts a value for a local refs.\n * Example:\n * - `<div #nativeDivEl>` - `nativeDivEl` should point to the native `<div>` element;\n * - `<ng-template #tplRef>` - `tplRef` should point to the `TemplateRef` instance;\n */\nexport type LocalRefExtractor = (tNode: TNodeWithLocalRefs, currentView: LView) => any;\n\n/**\n * Returns `true` if the `TNode` has a directive which has `@Input()` for `class` binding.\n *\n * ```\n * <div my-dir [class]=\"exp\"></div>\n * ```\n * and\n * ```\n * @Directive({\n * })\n * class MyDirective {\n *   @Input()\n *   class: string;\n * }\n * ```\n *\n * In the above case it is necessary to write the reconciled styling information into the\n * directive's input.\n *\n * @param tNode\n */\nexport function hasClassInput(tNode: TNode) {\n  return (tNode.flags & TNodeFlags.hasClassInput) !== 0;\n}\n\n/**\n * Returns `true` if the `TNode` has a directive which has `@Input()` for `style` binding.\n *\n * ```\n * <div my-dir [style]=\"exp\"></div>\n * ```\n * and\n * ```\n * @Directive({\n * })\n * class MyDirective {\n *   @Input()\n *   class: string;\n * }\n * ```\n *\n * In the above case it is necessary to write the reconciled styling information into the\n * directive's input.\n *\n * @param tNode\n */\nexport function hasStyleInput(tNode: TNode) {\n  return (tNode.flags & TNodeFlags.hasStyleInput) !== 0;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/node.ts"],"names":[],"mappings":"AAmFA;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,SAAoB;IACtD,IAAI,IAAI,GAAG,EAAE,CAAC;IACd,CAAC,SAAS,yBAAiB,CAAC,IAAI,CAAC,IAAI,IAAI,OAAO,CAAC,CAAC;IAClD,CAAC,SAAS,4BAAoB,CAAC,IAAI,CAAC,IAAI,IAAI,UAAU,CAAC,CAAC;IACxD,CAAC,SAAS,8BAAsB,CAAC,IAAI,CAAC,IAAI,IAAI,YAAY,CAAC,CAAC;IAC5D,CAAC,SAAS,qCAA6B,CAAC,IAAI,CAAC,IAAI,IAAI,mBAAmB,CAAC,CAAC;IAC1E,CAAC,SAAS,gCAAuB,CAAC,IAAI,CAAC,IAAI,IAAI,aAAa,CAAC,CAAC;IAC9D,CAAC,SAAS,yBAAgB,CAAC,IAAI,CAAC,IAAI,IAAI,eAAe,CAAC,CAAC;IACzD,CAAC,SAAS,iCAAwB,CAAC,IAAI,CAAC,IAAI,IAAI,cAAc,CAAC,CAAC;IAChE,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACpD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,KAAK,IAAI,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAC7C,CAAE,KAAe,CAAC,iBAAiB,KAAK,IAAI;YAC3C,OAAQ,KAAe,CAAC,iBAAiB,KAAK,QAAQ;YACtD,KAAK,CAAC,OAAO,CAAE,KAAe,CAAC,iBAAiB,CAAC,CAAC,CAAC;AAC1D,CAAC;AAg1BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,aAAa,CAAC,KAAY;IACxC,OAAO,CAAC,KAAK,CAAC,KAAK,mCAA2B,CAAC,KAAK,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,aAAa,CAAC,KAAY;IACxC,OAAO,CAAC,KAAK,CAAC,KAAK,oCAA2B,CAAC,KAAK,CAAC,CAAC;AACxD,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 */\nimport {KeyValueArray} from '../../util/array_utils';\nimport {TStylingRange} from '../interfaces/styling';\n\nimport type {InputFlags} from './definition';\nimport {TIcu} from './i18n';\nimport {CssSelector} from './projection';\nimport {RNode} from './renderer_dom';\nimport {LView, TView} from './view';\n\n\n/**\n * TNodeType corresponds to the {@link TNode} `type` property.\n *\n * NOTE: type IDs are such that we use each bit to denote a type. This is done so that we can easily\n * check if the `TNode` is of more than one type.\n *\n * `if (tNode.type === TNodeType.Text || tNode.type === TNode.Element)`\n * can be written as:\n * `if (tNode.type & (TNodeType.Text | TNodeType.Element))`\n *\n * However any given `TNode` can only be of one type.\n */\nexport const enum TNodeType {\n  /**\n   * The TNode contains information about a DOM element aka {@link RText}.\n   */\n  Text = 0b1,\n\n  /**\n   * The TNode contains information about a DOM element aka {@link RElement}.\n   */\n  Element = 0b10,\n\n  /**\n   * The TNode contains information about an {@link LContainer} for embedded views.\n   */\n  Container = 0b100,\n\n  /**\n   * The TNode contains information about an `<ng-container>` element {@link RNode}.\n   */\n  ElementContainer = 0b1000,\n\n  /**\n   * The TNode contains information about an `<ng-content>` projection\n   */\n  Projection = 0b10000,\n\n  /**\n   * The TNode contains information about an ICU comment used in `i18n`.\n   */\n  Icu = 0b100000,\n\n  /**\n   * Special node type representing a placeholder for future `TNode` at this location.\n   *\n   * I18n translation blocks are created before the element nodes which they contain. (I18n blocks\n   * can span over many elements.) Because i18n `TNode`s (representing text) are created first they\n   * often may need to point to element `TNode`s which are not yet created. In such a case we create\n   * a `Placeholder` `TNode`. This allows the i18n to structurally link the `TNode`s together\n   * without knowing any information about the future nodes which will be at that location.\n   *\n   * On `firstCreatePass` When element instruction executes it will try to create a `TNode` at that\n   * location. Seeing a `Placeholder` `TNode` already there tells the system that it should reuse\n   * existing `TNode` (rather than create a new one) and just update the missing information.\n   */\n  Placeholder = 0b1000000,\n\n  // Combined Types These should never be used for `TNode.type` only as a useful way to check\n  // if `TNode.type` is one of several choices.\n\n  // See: https://github.com/microsoft/TypeScript/issues/35875 why we can't refer to existing enum.\n  AnyRNode = 0b11,        // Text | Element\n  AnyContainer = 0b1100,  // Container | ElementContainer\n}\n\n/**\n * Converts `TNodeType` into human readable text.\n * Make sure this matches with `TNodeType`\n */\nexport function toTNodeTypeAsString(tNodeType: TNodeType): string {\n  let text = '';\n  (tNodeType & TNodeType.Text) && (text += '|Text');\n  (tNodeType & TNodeType.Element) && (text += '|Element');\n  (tNodeType & TNodeType.Container) && (text += '|Container');\n  (tNodeType & TNodeType.ElementContainer) && (text += '|ElementContainer');\n  (tNodeType & TNodeType.Projection) && (text += '|Projection');\n  (tNodeType & TNodeType.Icu) && (text += '|IcuContainer');\n  (tNodeType & TNodeType.Placeholder) && (text += '|Placeholder');\n  return text.length > 0 ? text.substring(1) : text;\n}\n\n/**\n * Helper function to detect if a given value matches a `TNode` shape.\n *\n * The logic uses the `insertBeforeIndex` and its possible values as\n * a way to differentiate a TNode shape from other types of objects\n * within the `TView.data`. This is not a perfect check, but it can\n * be a reasonable differentiator, since we control the shapes of objects\n * within `TView.data`.\n */\nexport function isTNodeShape(value: unknown): value is TNode {\n  return value != null && typeof value === 'object' &&\n      ((value as TNode).insertBeforeIndex === null ||\n       typeof (value as TNode).insertBeforeIndex === 'number' ||\n       Array.isArray((value as TNode).insertBeforeIndex));\n}\n\n/**\n * Corresponds to the TNode.flags property.\n */\nexport const enum TNodeFlags {\n  /** Bit #1 - This bit is set if the node is a host for any directive (including a component) */\n  isDirectiveHost = 0x1,\n\n  /** Bit #2 - This bit is set if the node has been projected */\n  isProjected = 0x2,\n\n  /** Bit #3 - This bit is set if any directive on this node has content queries */\n  hasContentQuery = 0x4,\n\n  /** Bit #4 - This bit is set if the node has any \"class\" inputs */\n  hasClassInput = 0x8,\n\n  /** Bit #5 - This bit is set if the node has any \"style\" inputs */\n  hasStyleInput = 0x10,\n\n  /** Bit #6 - This bit is set if the node has been detached by i18n */\n  isDetached = 0x20,\n\n  /**\n   * Bit #7 - This bit is set if the node has directives with host bindings.\n   *\n   * This flags allows us to guard host-binding logic and invoke it only on nodes\n   * that actually have directives with host bindings.\n   */\n  hasHostBindings = 0x40,\n\n  /**\n   * Bit #8 - This bit is set if the node is a located inside skip hydration block.\n   */\n  inSkipHydrationBlock = 0x80,\n}\n\n/**\n * Corresponds to the TNode.providerIndexes property.\n */\nexport const enum TNodeProviderIndexes {\n  /** The index of the first provider on this node is encoded on the least significant bits. */\n  ProvidersStartIndexMask = 0b00000000000011111111111111111111,\n\n  /**\n   * The count of view providers from the component on this node is\n   * encoded on the 20 most significant bits.\n   */\n  CptViewProvidersCountShift = 20,\n  CptViewProvidersCountShifter = 0b00000000000100000000000000000000,\n}\n\n/**\n * A set of marker values to be used in the attributes arrays. These markers indicate that some\n * items are not regular attributes and the processing should be adapted accordingly.\n */\nexport const enum AttributeMarker {\n  /**\n   * An implicit marker which indicates that the value in the array are of `attributeKey`,\n   * `attributeValue` format.\n   *\n   * NOTE: This is implicit as it is the type when no marker is present in array. We indicate that\n   * it should not be present at runtime by the negative number.\n   */\n  ImplicitAttributes = -1,\n\n  /**\n   * Marker indicates that the following 3 values in the attributes array are:\n   * namespaceUri, attributeName, attributeValue\n   * in that order.\n   */\n  NamespaceURI = 0,\n\n  /**\n   * Signals class declaration.\n   *\n   * Each value following `Classes` designates a class name to include on the element.\n   * ## Example:\n   *\n   * Given:\n   * ```\n   * <div class=\"foo bar baz\">...<d/vi>\n   * ```\n   *\n   * the generated code is:\n   * ```\n   * var _c1 = [AttributeMarker.Classes, 'foo', 'bar', 'baz'];\n   * ```\n   */\n  Classes = 1,\n\n  /**\n   * Signals style declaration.\n   *\n   * Each pair of values following `Styles` designates a style name and value to include on the\n   * element.\n   * ## Example:\n   *\n   * Given:\n   * ```\n   * <div style=\"width:100px; height:200px; color:red\">...</div>\n   * ```\n   *\n   * the generated code is:\n   * ```\n   * var _c1 = [AttributeMarker.Styles, 'width', '100px', 'height'. '200px', 'color', 'red'];\n   * ```\n   */\n  Styles = 2,\n\n  /**\n   * Signals that the following attribute names were extracted from input or output bindings.\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <div moo=\"car\" [foo]=\"exp\" (bar)=\"doSth()\">\n   * ```\n   *\n   * the generated code is:\n   *\n   * ```\n   * var _c1 = ['moo', 'car', AttributeMarker.Bindings, 'foo', 'bar'];\n   * ```\n   */\n  Bindings = 3,\n\n  /**\n   * Signals that the following attribute names were hoisted from an inline-template declaration.\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <div *ngFor=\"let value of values; trackBy:trackBy\" dirA [dirB]=\"value\">\n   * ```\n   *\n   * the generated code for the `template()` instruction would include:\n   *\n   * ```\n   * ['dirA', '', AttributeMarker.Bindings, 'dirB', AttributeMarker.Template, 'ngFor', 'ngForOf',\n   * 'ngForTrackBy', 'let-value']\n   * ```\n   *\n   * while the generated code for the `element()` instruction inside the template function would\n   * include:\n   *\n   * ```\n   * ['dirA', '', AttributeMarker.Bindings, 'dirB']\n   * ```\n   */\n  Template = 4,\n\n  /**\n   * Signals that the following attribute is `ngProjectAs` and its value is a parsed\n   * `CssSelector`.\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <h1 attr=\"value\" ngProjectAs=\"[title]\">\n   * ```\n   *\n   * the generated code for the `element()` instruction would include:\n   *\n   * ```\n   * ['attr', 'value', AttributeMarker.ProjectAs, ['', 'title', '']]\n   * ```\n   */\n  ProjectAs = 5,\n\n  /**\n   * Signals that the following attribute will be translated by runtime i18n\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <div moo=\"car\" foo=\"value\" i18n-foo [bar]=\"binding\" i18n-bar>\n   * ```\n   *\n   * the generated code is:\n   *\n   * ```\n   * var _c1 = ['moo', 'car', AttributeMarker.I18n, 'foo', 'bar'];\n   */\n  I18n = 6,\n}\n\n/**\n * A combination of:\n * - Attribute names and values.\n * - Special markers acting as flags to alter attributes processing.\n * - Parsed ngProjectAs selectors.\n */\nexport type TAttributes = (string|AttributeMarker|CssSelector)[];\n\n/**\n * Constants that are associated with a view. Includes:\n * - Attribute arrays.\n * - Local definition arrays.\n * - Translated messages (i18n).\n */\nexport type TConstants = (TAttributes|string)[];\n\n/**\n * Factory function that returns an array of consts. Consts can be represented as a function in\n * case any additional statements are required to define consts in the list. An example is i18n\n * where additional i18n calls are generated, which should be executed when consts are requested\n * for the first time.\n */\nexport type TConstantsFactory = () => TConstants;\n\n/**\n * TConstants type that describes how the `consts` field is generated on ComponentDef: it can be\n * either an array or a factory function that returns that array.\n */\nexport type TConstantsOrFactory = TConstants|TConstantsFactory;\n\n/**\n * Binding data (flyweight) for a particular node that is shared between all templates\n * of a specific type.\n *\n * If a property is:\n *    - PropertyAliases: that property's data was generated and this is it\n *    - Null: that property's data was already generated and nothing was found.\n *    - Undefined: that property's data has not yet been generated\n *\n * see: https://en.wikipedia.org/wiki/Flyweight_pattern for more on the Flyweight pattern\n */\nexport interface TNode {\n  /** The type of the TNode. See TNodeType. */\n  type: TNodeType;\n\n  /**\n   * Index of the TNode in TView.data and corresponding native element in LView.\n   *\n   * This is necessary to get from any TNode to its corresponding native element when\n   * traversing the node tree.\n   *\n   * If index is -1, this is a dynamically created container node or embedded view node.\n   */\n  index: number;\n\n  /**\n   * Insert before existing DOM node index.\n   *\n   * When DOM nodes are being inserted, normally they are being appended as they are created.\n   * Under i18n case, the translated text nodes are created ahead of time as part of the\n   * `ɵɵi18nStart` instruction which means that this `TNode` can't just be appended and instead\n   * needs to be inserted using `insertBeforeIndex` semantics.\n   *\n   * Additionally sometimes it is necessary to insert new text nodes as a child of this `TNode`. In\n   * such a case the value stores an array of text nodes to insert.\n   *\n   * Example:\n   * ```\n   * <div i18n>\n   *   Hello <span>World</span>!\n   * </div>\n   * ```\n   * In the above example the `ɵɵi18nStart` instruction can create `Hello `, `World` and `!` text\n   * nodes. It can also insert `Hello ` and `!` text node as a child of `<div>`, but it can't\n   * insert `World` because the `<span>` node has not yet been created. In such a case the\n   * `<span>` `TNode` will have an array which will direct the `<span>` to not only insert\n   * itself in front of `!` but also to insert the `World` (created by `ɵɵi18nStart`) into\n   * `<span>` itself.\n   *\n   * Pseudo code:\n   * ```\n   *   if (insertBeforeIndex === null) {\n   *     // append as normal\n   *   } else if (Array.isArray(insertBeforeIndex)) {\n   *     // First insert current `TNode` at correct location\n   *     const currentNode = lView[this.index];\n   *     parentNode.insertBefore(currentNode, lView[this.insertBeforeIndex[0]]);\n   *     // Now append all of the children\n   *     for(let i=1; i<this.insertBeforeIndex; i++) {\n   *       currentNode.appendChild(lView[this.insertBeforeIndex[i]]);\n   *     }\n   *   } else {\n   *     parentNode.insertBefore(lView[this.index], lView[this.insertBeforeIndex])\n   *   }\n   * ```\n   * - null: Append as normal using `parentNode.appendChild`\n   * - `number`: Append using\n   *      `parentNode.insertBefore(lView[this.index], lView[this.insertBeforeIndex])`\n   *\n   * *Initialization*\n   *\n   * Because `ɵɵi18nStart` executes before nodes are created, on `TView.firstCreatePass` it is not\n   * possible for `ɵɵi18nStart` to set the `insertBeforeIndex` value as the corresponding `TNode`\n   * has not yet been created. For this reason the `ɵɵi18nStart` creates a `TNodeType.Placeholder`\n   * `TNode` at that location. See `TNodeType.Placeholder` for more information.\n   */\n  insertBeforeIndex: InsertBeforeIndex;\n\n  /**\n   * The index of the closest injector in this node's LView.\n   *\n   * If the index === -1, there is no injector on this node or any ancestor node in this view.\n   *\n   * If the index !== -1, it is the index of this node's injector OR the index of a parent\n   * injector in the same view. We pass the parent injector index down the node tree of a view so\n   * it's possible to find the parent injector without walking a potentially deep node tree.\n   * Injector indices are not set across view boundaries because there could be multiple component\n   * hosts.\n   *\n   * If tNode.injectorIndex === tNode.parent.injectorIndex, then the index belongs to a parent\n   * injector.\n   */\n  injectorIndex: number;\n\n  /** Stores starting index of the directives. */\n  directiveStart: number;\n\n  /**\n   * Stores final exclusive index of the directives.\n   *\n   * The area right behind the `directiveStart-directiveEnd` range is used to allocate the\n   * `HostBindingFunction` `vars` (or null if no bindings.) Therefore `directiveEnd` is used to set\n   * `LFrame.bindingRootIndex` before `HostBindingFunction` is executed.\n   */\n  directiveEnd: number;\n\n  /**\n   * Offset from the `directiveStart` at which the component (one at most) of the node is stored.\n   * Set to -1 if no components have been applied to the node. Component index can be found using\n   * `directiveStart + componentOffset`.\n   */\n  componentOffset: number;\n\n  /**\n   * Stores the last directive which had a styling instruction.\n   *\n   * Initial value of this is `-1` which means that no `hostBindings` styling instruction has\n   * executed. As `hostBindings` instructions execute they set the value to the index of the\n   * `DirectiveDef` which contained the last `hostBindings` styling instruction.\n   *\n   * Valid values are:\n   * - `-1` No `hostBindings` instruction has executed.\n   * - `directiveStart <= directiveStylingLast < directiveEnd`: Points to the `DirectiveDef` of\n   * the last styling instruction which executed in the `hostBindings`.\n   *\n   * This data is needed so that styling instructions know which static styling data needs to be\n   * collected from the `DirectiveDef.hostAttrs`. A styling instruction needs to collect all data\n   * since last styling instruction.\n   */\n  directiveStylingLast: number;\n\n  /**\n   * Stores indexes of property bindings. This field is only set in the ngDevMode and holds\n   * indexes of property bindings so TestBed can get bound property metadata for a given node.\n   */\n  propertyBindings: number[]|null;\n\n  /**\n   * Stores if Node isComponent, isProjected, hasContentQuery, hasClassInput and hasStyleInput\n   * etc.\n   */\n  flags: TNodeFlags;\n\n  /**\n   * This number stores two values using its bits:\n   *\n   * - the index of the first provider on that node (first 16 bits)\n   * - the count of view providers from the component on this node (last 16 bits)\n   */\n  // TODO(misko): break this into actual vars.\n  providerIndexes: TNodeProviderIndexes;\n\n  /**\n   * The value name associated with this node.\n   * if type:\n   *   `TNodeType.Text`: text value\n   *   `TNodeType.Element`: tag name\n   *   `TNodeType.ICUContainer`: `TIcu`\n   */\n  value: any;\n\n  /**\n   * Attributes associated with an element. We need to store attributes to support various\n   * use-cases (attribute injection, content projection with selectors, directives matching).\n   * Attributes are stored statically because reading them from the DOM would be way too slow for\n   * content projection and queries.\n   *\n   * Since attrs will always be calculated first, they will never need to be marked undefined by\n   * other instructions.\n   *\n   * For regular attributes a name of an attribute and its value alternate in the array.\n   * e.g. ['role', 'checkbox']\n   * This array can contain flags that will indicate \"special attributes\" (attributes with\n   * namespaces, attributes extracted from bindings and outputs).\n   */\n  attrs: TAttributes|null;\n\n  /**\n   * Same as `TNode.attrs` but contains merged data across all directive host bindings.\n   *\n   * We need to keep `attrs` as unmerged so that it can be used for attribute selectors.\n   * We merge attrs here so that it can be used in a performant way for initial rendering.\n   *\n   * The `attrs` are merged in first pass in following order:\n   * - Component's `hostAttrs`\n   * - Directives' `hostAttrs`\n   * - Template `TNode.attrs` associated with the current `TNode`.\n   */\n  mergedAttrs: TAttributes|null;\n\n  /**\n   * A set of local names under which a given element is exported in a template and\n   * visible to queries. An entry in this array can be created for different reasons:\n   * - an element itself is referenced, ex.: `<div #foo>`\n   * - a component is referenced, ex.: `<my-cmpt #foo>`\n   * - a directive is referenced, ex.: `<my-cmpt #foo=\"directiveExportAs\">`.\n   *\n   * A given element might have different local names and those names can be associated\n   * with a directive. We store local names at even indexes while odd indexes are reserved\n   * for directive index in a view (or `-1` if there is no associated directive).\n   *\n   * Some examples:\n   * - `<div #foo>` => `[\"foo\", -1]`\n   * - `<my-cmpt #foo>` => `[\"foo\", myCmptIdx]`\n   * - `<my-cmpt #foo #bar=\"directiveExportAs\">` => `[\"foo\", myCmptIdx, \"bar\", directiveIdx]`\n   * - `<div #foo #bar=\"directiveExportAs\">` => `[\"foo\", -1, \"bar\", directiveIdx]`\n   */\n  localNames: (string|number)[]|null;\n\n  /** Information about input properties that need to be set once from attribute data. */\n  initialInputs: InitialInputData|null|undefined;\n\n  /**\n   * Input data for all directives on this node. `null` means that there are no directives with\n   * inputs on this node.\n   */\n  inputs: NodeInputBindings|null;\n\n  /**\n   * Output data for all directives on this node. `null` means that there are no directives with\n   * outputs on this node.\n   */\n  outputs: NodeOutputBindings|null;\n\n  /**\n   * The TView attached to this node.\n   *\n   * If this TNode corresponds to an LContainer with a template (e.g. structural\n   * directive), the template's TView will be stored here.\n   *\n   * If this TNode corresponds to an element, tView will be `null`.\n   */\n  tView: TView|null;\n\n  /**\n   * The next sibling node. Necessary so we can propagate through the root nodes of a view\n   * to insert them or remove them from the DOM.\n   */\n  next: TNode|null;\n\n  /**\n   * The previous sibling node.\n   * This simplifies operations when we need a pointer to the previous node.\n   */\n  prev: TNode|null;\n\n  /**\n   * The next projected sibling. Since in Angular content projection works on the node-by-node\n   * basis the act of projecting nodes might change nodes relationship at the insertion point\n   * (target view). At the same time we need to keep initial relationship between nodes as\n   * expressed in content view.\n   */\n  projectionNext: TNode|null;\n\n  /**\n   * First child of the current node.\n   *\n   * For component nodes, the child will always be a ContentChild (in same view).\n   * For embedded view nodes, the child will be in their child view.\n   */\n  child: TNode|null;\n\n  /**\n   * Parent node (in the same view only).\n   *\n   * We need a reference to a node's parent so we can append the node to its parent's native\n   * element at the appropriate time.\n   *\n   * If the parent would be in a different view (e.g. component host), this property will be null.\n   * It's important that we don't try to cross component boundaries when retrieving the parent\n   * because the parent will change (e.g. index, attrs) depending on where the component was\n   * used (and thus shouldn't be stored on TNode). In these cases, we retrieve the parent through\n   * LView.node instead (which will be instance-specific).\n   *\n   * If this is an inline view node (V), the parent will be its container.\n   */\n  parent: TElementNode|TContainerNode|null;\n\n  /**\n   * List of projected TNodes for a given component host element OR index into the said nodes.\n   *\n   * For easier discussion assume this example:\n   * `<parent>`'s view definition:\n   * ```\n   * <child id=\"c1\">content1</child>\n   * <child id=\"c2\"><span>content2</span></child>\n   * ```\n   * `<child>`'s view definition:\n   * ```\n   * <ng-content id=\"cont1\"></ng-content>\n   * ```\n   *\n   * If `Array.isArray(projection)` then `TNode` is a host element:\n   * - `projection` stores the content nodes which are to be projected.\n   *    - The nodes represent categories defined by the selector: For example:\n   *      `<ng-content/><ng-content select=\"abc\"/>` would represent the heads for `<ng-content/>`\n   *      and `<ng-content select=\"abc\"/>` respectively.\n   *    - The nodes we store in `projection` are heads only, we used `.next` to get their\n   *      siblings.\n   *    - The nodes `.next` is sorted/rewritten as part of the projection setup.\n   *    - `projection` size is equal to the number of projections `<ng-content>`. The size of\n   *      `c1` will be `1` because `<child>` has only one `<ng-content>`.\n   * - we store `projection` with the host (`c1`, `c2`) rather than the `<ng-content>` (`cont1`)\n   *   because the same component (`<child>`) can be used in multiple locations (`c1`, `c2`) and\n   * as a result have different set of nodes to project.\n   * - without `projection` it would be difficult to efficiently traverse nodes to be projected.\n   *\n   * If `typeof projection == 'number'` then `TNode` is a `<ng-content>` element:\n   * - `projection` is an index of the host's `projection`Nodes.\n   *   - This would return the first head node to project:\n   *     `getHost(currentTNode).projection[currentTNode.projection]`.\n   * - When projecting nodes the parent node retrieved may be a `<ng-content>` node, in which case\n   *   the process is recursive in nature.\n   *\n   * If `projection` is of type `RNode[][]` than we have a collection of native nodes passed as\n   * projectable nodes during dynamic component creation.\n   */\n  projection: (TNode|RNode[])[]|number|null;\n\n  /**\n   * A collection of all `style` static values for an element (including from host).\n   *\n   * This field will be populated if and when:\n   *\n   * - There are one or more initial `style`s on an element (e.g. `<div style=\"width:200px;\">`)\n   * - There are one or more initial `style`s on a directive/component host\n   *   (e.g. `@Directive({host: {style: \"width:200px;\" } }`)\n   */\n  styles: string|null;\n\n\n  /**\n   * A collection of all `style` static values for an element excluding host sources.\n   *\n   * Populated when there are one or more initial `style`s on an element\n   * (e.g. `<div style=\"width:200px;\">`)\n   * Must be stored separately from `tNode.styles` to facilitate setting directive\n   * inputs that shadow the `style` property. If we used `tNode.styles` as is for shadowed inputs,\n   * we would feed host styles back into directives as \"inputs\". If we used `tNode.attrs`, we\n   * would have to concatenate the attributes on every template pass. Instead, we process once on\n   * first create pass and store here.\n   */\n  stylesWithoutHost: string|null;\n\n  /**\n   * A `KeyValueArray` version of residual `styles`.\n   *\n   * When there are styling instructions than each instruction stores the static styling\n   * which is of lower priority than itself. This means that there may be a higher priority\n   * styling than the instruction.\n   *\n   * Imagine:\n   * ```\n   * <div style=\"color: highest;\" my-dir>\n   *\n   * @Directive({\n   *   host: {\n   *     style: 'color: lowest; ',\n   *     '[styles.color]': 'exp' // ɵɵstyleProp('color', ctx.exp);\n   *   }\n   * })\n   * ```\n   *\n   * In the above case:\n   * - `color: lowest` is stored with `ɵɵstyleProp('color', ctx.exp);` instruction\n   * -  `color: highest` is the residual and is stored here.\n   *\n   * - `undefined': not initialized.\n   * - `null`: initialized but `styles` is `null`\n   * - `KeyValueArray`: parsed version of `styles`.\n   */\n  residualStyles: KeyValueArray<any>|undefined|null;\n\n  /**\n   * A collection of all class static values for an element (including from host).\n   *\n   * This field will be populated if and when:\n   *\n   * - There are one or more initial classes on an element (e.g. `<div class=\"one two three\">`)\n   * - There are one or more initial classes on an directive/component host\n   *   (e.g. `@Directive({host: {class: \"SOME_CLASS\" } }`)\n   */\n  classes: string|null;\n\n  /**\n   * A collection of all class static values for an element excluding host sources.\n   *\n   * Populated when there are one or more initial classes on an element\n   * (e.g. `<div class=\"SOME_CLASS\">`)\n   * Must be stored separately from `tNode.classes` to facilitate setting directive\n   * inputs that shadow the `class` property. If we used `tNode.classes` as is for shadowed\n   * inputs, we would feed host classes back into directives as \"inputs\". If we used\n   * `tNode.attrs`, we would have to concatenate the attributes on every template pass. Instead,\n   * we process once on first create pass and store here.\n   */\n  classesWithoutHost: string|null;\n\n  /**\n   * A `KeyValueArray` version of residual `classes`.\n   *\n   * Same as `TNode.residualStyles` but for classes.\n   *\n   * - `undefined': not initialized.\n   * - `null`: initialized but `classes` is `null`\n   * - `KeyValueArray`: parsed version of `classes`.\n   */\n  residualClasses: KeyValueArray<any>|undefined|null;\n\n  /**\n   * Stores the head/tail index of the class bindings.\n   *\n   * - If no bindings, the head and tail will both be 0.\n   * - If there are template bindings, stores the head/tail of the class bindings in the template.\n   * - If no template bindings but there are host bindings, the head value will point to the last\n   *   host binding for \"class\" (not the head of the linked list), tail will be 0.\n   *\n   * See: `style_binding_list.ts` for details.\n   *\n   * This is used by `insertTStylingBinding` to know where the next styling binding should be\n   * inserted so that they can be sorted in priority order.\n   */\n  classBindings: TStylingRange;\n\n  /**\n   * Stores the head/tail index of the class bindings.\n   *\n   * - If no bindings, the head and tail will both be 0.\n   * - If there are template bindings, stores the head/tail of the style bindings in the template.\n   * - If no template bindings but there are host bindings, the head value will point to the last\n   *   host binding for \"style\" (not the head of the linked list), tail will be 0.\n   *\n   * See: `style_binding_list.ts` for details.\n   *\n   * This is used by `insertTStylingBinding` to know where the next styling binding should be\n   * inserted so that they can be sorted in priority order.\n   */\n  styleBindings: TStylingRange;\n}\n\n/**\n * See `TNode.insertBeforeIndex`\n */\nexport type InsertBeforeIndex = null|number|number[];\n\n/** Static data for an element  */\nexport interface TElementNode extends TNode {\n  /** Index in the data[] array */\n  index: number;\n  child: TElementNode|TTextNode|TElementContainerNode|TContainerNode|TProjectionNode|null;\n  /**\n   * Element nodes will have parents unless they are the first node of a component or\n   * embedded view (which means their parent is in a different view and must be\n   * retrieved using viewData[HOST_NODE]).\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tView: null;\n\n  /**\n   * If this is a component TNode with projection, this will be an array of projected\n   * TNodes or native nodes (see TNode.projection for more info). If it's a regular element node\n   * or a component without projection, it will be null.\n   */\n  projection: (TNode|RNode[])[]|null;\n\n  /**\n   * Stores TagName\n   */\n  value: string;\n}\n\n/** Static data for a text node */\nexport interface TTextNode extends TNode {\n  /** Index in the data[] array */\n  index: number;\n  child: null;\n  /**\n   * Text nodes will have parents unless they are the first node of a component or\n   * embedded view (which means their parent is in a different view and must be\n   * retrieved using LView.node).\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tView: null;\n  projection: null;\n}\n\n/** Static data for an LContainer */\nexport interface TContainerNode extends TNode {\n  /**\n   * Index in the data[] array.\n   *\n   * If it's -1, this is a dynamically created container node that isn't stored in\n   * data[] (e.g. when you inject ViewContainerRef) .\n   */\n  index: number;\n  child: null;\n\n  /**\n   * Container nodes will have parents unless:\n   *\n   * - They are the first node of a component or embedded view\n   * - They are dynamically created\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tView: TView|null;\n  projection: null;\n  value: null;\n}\n\n/** Static data for an <ng-container> */\nexport interface TElementContainerNode extends TNode {\n  /** Index in the LView[] array. */\n  index: number;\n  child: TElementNode|TTextNode|TContainerNode|TElementContainerNode|TProjectionNode|null;\n  parent: TElementNode|TElementContainerNode|null;\n  tView: null;\n  projection: null;\n}\n\n/** Static data for an ICU expression */\nexport interface TIcuContainerNode extends TNode {\n  /** Index in the LView[] array. */\n  index: number;\n  child: null;\n  parent: TElementNode|TElementContainerNode|null;\n  tView: null;\n  projection: null;\n  value: TIcu;\n}\n\n/** Static data for an LProjectionNode  */\nexport interface TProjectionNode extends TNode {\n  /** Index in the data[] array */\n  child: null;\n  /**\n   * Projection nodes will have parents unless they are the first node of a component\n   * or embedded view (which means their parent is in a different view and must be\n   * retrieved using LView.node).\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tView: null;\n\n  /** Index of the projection node. (See TNode.projection for more info.) */\n  projection: number;\n  value: null;\n}\n\n/**\n * A union type representing all TNode types that can host a directive.\n */\nexport type TDirectiveHostNode = TElementNode|TContainerNode|TElementContainerNode;\n\n/**\n * Store the runtime output names for all the directives.\n *\n * i+0: directive instance index\n * i+1: privateName\n *\n * e.g.\n * ```\n * {\n *   \"publicName\": [0, 'change-minified']\n * }\n */\nexport type NodeOutputBindings = Record<string, (number|string)[]>;\n\n/**\n * Store the runtime input for all directives applied to a node.\n *\n * This allows efficiently setting the same input on a directive that\n * might apply to multiple directives.\n *\n * i+0: directive instance index\n * i+1: privateName\n * i+2: input flags\n *\n * e.g.\n * ```\n * {\n *   \"publicName\": [0, 'change-minified', <bit-input-flags>]\n * }\n * ```\n */\nexport type NodeInputBindings = Record<string, (number|string|InputFlags)[]>;\n\n/**\n * This array contains information about input properties that\n * need to be set once from attribute data. It's ordered by\n * directive index (relative to element) so it's simple to\n * look up a specific directive's initial input data.\n *\n * Within each sub-array:\n *\n * i+0: attribute name\n * i+1: minified/internal input name\n * i+2: initial value\n *\n * If a directive on a node does not have any input properties\n * that should be set from attributes, its index is set to null\n * to avoid a sparse array.\n *\n * e.g. [null, ['role-min', 'minified-input', 'button']]\n */\nexport type InitialInputData = (InitialInputs|null)[];\n\n/**\n * Used by InitialInputData to store input properties\n * that should be set once from attributes.\n *\n * i+0: attribute name\n * i+1: minified/internal input name\n * i+2: input flags\n * i+3: initial value\n *\n * e.g. ['role-min', 'minified-input', 'button']\n */\nexport type InitialInputs = (string|InputFlags)[];\n\n/**\n * Type representing a set of TNodes that can have local refs (`#foo`) placed on them.\n */\nexport type TNodeWithLocalRefs = TContainerNode|TElementNode|TElementContainerNode;\n\n/**\n * Type for a function that extracts a value for a local refs.\n * Example:\n * - `<div #nativeDivEl>` - `nativeDivEl` should point to the native `<div>` element;\n * - `<ng-template #tplRef>` - `tplRef` should point to the `TemplateRef` instance;\n */\nexport type LocalRefExtractor = (tNode: TNodeWithLocalRefs, currentView: LView) => any;\n\n/**\n * Returns `true` if the `TNode` has a directive which has `@Input()` for `class` binding.\n *\n * ```\n * <div my-dir [class]=\"exp\"></div>\n * ```\n * and\n * ```\n * @Directive({\n * })\n * class MyDirective {\n *   @Input()\n *   class: string;\n * }\n * ```\n *\n * In the above case it is necessary to write the reconciled styling information into the\n * directive's input.\n *\n * @param tNode\n */\nexport function hasClassInput(tNode: TNode) {\n  return (tNode.flags & TNodeFlags.hasClassInput) !== 0;\n}\n\n/**\n * Returns `true` if the `TNode` has a directive which has `@Input()` for `style` binding.\n *\n * ```\n * <div my-dir [style]=\"exp\"></div>\n * ```\n * and\n * ```\n * @Directive({\n * })\n * class MyDirective {\n *   @Input()\n *   class: string;\n * }\n * ```\n *\n * In the above case it is necessary to write the reconciled styling information into the\n * directive's input.\n *\n * @param tNode\n */\nexport function hasStyleInput(tNode: TNode) {\n  return (tNode.flags & TNodeFlags.hasStyleInput) !== 0;\n}\n"]}