@angular/core 16.2.1 → 17.0.0-next.0

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

@@ -0,0 +1,61 @@
+/**
+ * @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 { assertLContainer, assertTNode } from '../assert';
+import { bindingUpdated } from '../bindings';
+import { CONTEXT, HEADER_OFFSET, TVIEW } from '../interfaces/view';
+import { getLView, nextBindingIndex } from '../state';
+import { getTNode } from '../util/view_utils';
+import { addLViewToLContainer, createAndRenderEmbeddedLView, getLViewFromLContainer, removeLViewFromLContainer } from '../view_manipulation';
+/**
+ * The conditional instruction represents the basic building block on the runtime side to support
+ * built-in "if" and "switch". On the high level this instruction is responsible for adding and
+ * removing views selected by a conditional expression.
+ *
+ * @param containerIndex index of a container in a host view (indexed from HEADER_OFFSET) where
+ *     conditional views should be inserted.
+ * @param matchingTemplateIndex index of a template TNode representing a conditional view to be
+ *     inserted; -1 represents a special case when there is no view to insert.
+ * @codeGenApi
+ */
+export function ɵɵconditional(containerIndex, matchingTemplateIndex, value) {
+    const hostLView = getLView();
+    const bindingIndex = nextBindingIndex();
+    const lContainer = getLContainer(hostLView, HEADER_OFFSET + containerIndex);
+    const viewInContainerIdx = 0;
+    if (bindingUpdated(hostLView, bindingIndex, matchingTemplateIndex)) {
+        // The index of the view to show changed - remove the previously displayed one
+        // (it is a noop if there are no active views in a container).
+        removeLViewFromLContainer(lContainer, viewInContainerIdx);
+        // Index -1 is a special case where none of the conditions evaluates to
+        // a truthy value and as the consequence we've got no view to show.
+        if (matchingTemplateIndex !== -1) {
+            const templateTNode = getExistingTNode(hostLView[TVIEW], matchingTemplateIndex);
+            const embeddedLView = createAndRenderEmbeddedLView(hostLView, templateTNode, value);
+            addLViewToLContainer(lContainer, embeddedLView, viewInContainerIdx);
+        }
+    }
+    else {
+        // We might keep displaying the same template but the actual value of the expression could have
+        // changed - re-bind in context.
+        const lView = getLViewFromLContainer(lContainer, viewInContainerIdx);
+        if (lView !== undefined) {
+            lView[CONTEXT] = value;
+        }
+    }
+}
+function getLContainer(lView, index) {
+    const lContainer = lView[index];
+    ngDevMode && assertLContainer(lContainer);
+    return lContainer;
+}
+function getExistingTNode(tView, index) {
+    const tNode = getTNode(tView, index + HEADER_OFFSET);
+    ngDevMode && assertTNode(tNode);
+    return tNode;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -8,12 +8,94 @@
 /**
  * Creates runtime data structures for `{#defer}` blocks.
  *
- * @param index The index of the defer block in the data array
+ * @param deferIndex Index of the underlying deferred block data structure.
+ * @param primaryTemplateIndex Index of the template function with the block's content.
  * @param deferredDepsFn Function that contains dependencies for this defer block
+ * @param loadingIndex Index of the template with the `{:loading}` block content.
+ * @param placeholderIndex Index of the template with the `{:placeholder}` block content.
+ * @param error Index of the template with the `{:error}` block content.
+ * @param loadingConfigIndex Index in the constants array of the configuration of the `{:loading}`
+ *     block.
+ * @param placeholderConfigIndexIndex in the constants array of the configuration of the
+ *     `{:placeholder}` block.
  *
  * @codeGenApi
  */
-export function ɵɵdefer(index, deferredDepsFn) {
-    // TODO: implement runtime logic.
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9yZW5kZXIzL2luc3RydWN0aW9ucy9kZWZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFNSDs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxVQUFVLE9BQU8sQ0FBQyxLQUFhLEVBQUUsY0FBbUM7SUFDeEUsaUNBQWlDO0FBQ25DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtUeXBlfSBmcm9tICcuLi8uLi9pbnRlcmZhY2UvdHlwZSc7XG5cbmV4cG9ydCB0eXBlIERlZmVycmVkRGVwc0ZuID0gKCkgPT4gQXJyYXk8UHJvbWlzZTxUeXBlPHVua25vd24+PnxUeXBlPHVua25vd24+PjtcblxuLyoqXG4gKiBDcmVhdGVzIHJ1bnRpbWUgZGF0YSBzdHJ1Y3R1cmVzIGZvciBgeyNkZWZlcn1gIGJsb2Nrcy5cbiAqXG4gKiBAcGFyYW0gaW5kZXggVGhlIGluZGV4IG9mIHRoZSBkZWZlciBibG9jayBpbiB0aGUgZGF0YSBhcnJheVxuICogQHBhcmFtIGRlZmVycmVkRGVwc0ZuIEZ1bmN0aW9uIHRoYXQgY29udGFpbnMgZGVwZW5kZW5jaWVzIGZvciB0aGlzIGRlZmVyIGJsb2NrXG4gKlxuICogQGNvZGVHZW5BcGlcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIMm1ybVkZWZlcihpbmRleDogbnVtYmVyLCBkZWZlcnJlZERlcHNGbjogRGVmZXJyZWREZXBzRm58bnVsbCkge1xuICAvLyBUT0RPOiBpbXBsZW1lbnQgcnVudGltZSBsb2dpYy5cbn1cbiJdfQ==
+export function ɵɵdefer(deferIndex, primaryTemplateIndex, deferredDepsFn, loadingIndex, placeholderIndex, errorIndex, loadingConfigIndex, placeholderConfigIndex) { } // TODO: implement runtime logic.
+/**
+ * Loads the deferred content when a value becomes truthy.
+ * @codeGenApi
+ */
+export function ɵɵdeferWhen(value) { } // TODO: implement runtime logic.
+/**
+ * Prefetches the deferred content when a value becomes truthy.
+ * @codeGenApi
+ */
+export function ɵɵdeferPrefetchWhen(value) { } // TODO: implement runtime logic.
+/**
+ * Creates runtime data structures for the `on idle` deferred trigger.
+ * @codeGenApi
+ */
+export function ɵɵdeferOnIdle() { } // TODO: implement runtime logic.
+/**
+ * Creates runtime data structures for the `prefetech on idle` deferred trigger.
+ * @codeGenApi
+ */
+export function ɵɵdeferPrefetchOnIdle() { } // TODO: implement runtime logic.
+/**
+ * Creates runtime data structures for the `on immediate` deferred trigger.
+ * @codeGenApi
+ */
+export function ɵɵdeferOnImmediate() { } // TODO: implement runtime logic.
+/**
+ * Creates runtime data structures for the `prefetech on immediate` deferred trigger.
+ * @codeGenApi
+ */
+export function ɵɵdeferPrefetchOnImmediate() { } // TODO: implement runtime logic.
+/**
+ * Creates runtime data structures for the `on timer` deferred trigger.
+ * @param delay Amount of time to wait before loading the content.
+ * @codeGenApi
+ */
+export function ɵɵdeferOnTimer(delay) { } // TODO: implement runtime logic.
+/**
+ * Creates runtime data structures for the `prefetch on timer` deferred trigger.
+ * @param delay Amount of time to wait before prefetching the content.
+ * @codeGenApi
+ */
+export function ɵɵdeferPrefetchOnTimer(delay) { } // TODO: implement runtime logic.
+/**
+ * Creates runtime data structures for the `on hover` deferred trigger.
+ * @codeGenApi
+ */
+export function ɵɵdeferOnHover() { } // TODO: implement runtime logic.
+/**
+ * Creates runtime data structures for the `prefetech on hover` deferred trigger.
+ * @codeGenApi
+ */
+export function ɵɵdeferPrefetchOnHover() { } // TODO: implement runtime logic.
+/**
+ * Creates runtime data structures for the `on interaction` deferred trigger.
+ * @param target Optional element on which to listen for hover events.
+ * @codeGenApi
+ */
+export function ɵɵdeferOnInteraction(target) { } // TODO: implement runtime logic.
+/**
+ * Creates runtime data structures for the `prefetch on interaction` deferred trigger.
+ * @param target Optional element on which to listen for hover events.
+ * @codeGenApi
+ */
+export function ɵɵdeferPrefetchOnInteraction(target) { } // TODO: implement runtime logic.
+/**
+ * Creates runtime data structures for the `on viewport` deferred trigger.
+ * @param target Optional element on which to listen for hover events.
+ * @codeGenApi
+ */
+export function ɵɵdeferOnViewport(target) { } // TODO: implement runtime logic.
+/**
+ * Creates runtime data structures for the `prefetch on viewport` deferred trigger.
+ * @param target Optional element on which to listen for hover events.
+ * @codeGenApi
+ */
+export function ɵɵdeferPrefetchOnViewport(target) { } // TODO: implement runtime logic.
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defer.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/defer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAYH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,OAAO,CACnB,UAAkB,EAClB,oBAA4B,EAC5B,cAAoC,EACpC,YAA0B,EAC1B,gBAA8B,EAC9B,UAAwB,EACxB,kBAAgC,EAChC,sBAAoC,IACrC,CAAC,CAAE,iCAAiC;AAEvC;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,KAAc,IAAG,CAAC,CAAE,iCAAiC;AAEjF;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAc,IAAG,CAAC,CAAE,iCAAiC;AAEzF;;;GAGG;AACH,MAAM,UAAU,aAAa,KAAI,CAAC,CAAE,iCAAiC;AAErE;;;GAGG;AACH,MAAM,UAAU,qBAAqB,KAAI,CAAC,CAAE,iCAAiC;AAE7E;;;GAGG;AACH,MAAM,UAAU,kBAAkB,KAAI,CAAC,CAAE,iCAAiC;AAG1E;;;GAGG;AACH,MAAM,UAAU,0BAA0B,KAAI,CAAC,CAAE,iCAAiC;AAElF;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa,IAAG,CAAC,CAAE,iCAAiC;AAEnF;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAa,IAAG,CAAC,CAAE,iCAAiC;AAE3F;;;GAGG;AACH,MAAM,UAAU,cAAc,KAAI,CAAC,CAAE,iCAAiC;AAEtE;;;GAGG;AACH,MAAM,UAAU,sBAAsB,KAAI,CAAC,CAAE,iCAAiC;AAE9E;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAgB,IAAG,CAAC,CAAE,iCAAiC;AAE5F;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAAC,MAAgB,IAAG,CAAC,CAAE,iCAAiC;AAEpG;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAgB,IAAG,CAAC,CAAE,iCAAiC;AAEzF;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CAAC,MAAgB,IAAG,CAAC,CAAE,iCAAiC","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 {Type} from '../../interface/type';\n\nexport type DeferredDepsFn = () => Array<Promise<Type<unknown>>|Type<unknown>>;\n\n/** Configuration object for a `{:loading}` block as it is stored in the component constants. */\ntype DeferredLoadingConfig = [minimumTime: number|null, afterTime: number|null];\n\n/** Configuration object for a `{:placeholder}` block as it is stored in the component constants. */\ntype DeferredPlaceholderConfig = [afterTime: number|null];\n\n/**\n * Creates runtime data structures for `{#defer}` blocks.\n *\n * @param deferIndex Index of the underlying deferred block data structure.\n * @param primaryTemplateIndex Index of the template function with the block's content.\n * @param deferredDepsFn Function that contains dependencies for this defer block\n * @param loadingIndex Index of the template with the `{:loading}` block content.\n * @param placeholderIndex Index of the template with the `{:placeholder}` block content.\n * @param error Index of the template with the `{:error}` block content.\n * @param loadingConfigIndex Index in the constants array of the configuration of the `{:loading}`\n *     block.\n * @param placeholderConfigIndexIndex in the constants array of the configuration of the\n *     `{:placeholder}` block.\n *\n * @codeGenApi\n */\nexport function ɵɵdefer(\n    deferIndex: number,\n    primaryTemplateIndex: number,\n    deferredDepsFn?: DeferredDepsFn|null,\n    loadingIndex?: number|null,\n    placeholderIndex?: number|null,\n    errorIndex?: number|null,\n    loadingConfigIndex?: number|null,\n    placeholderConfigIndex?: number|null,\n) {}  // TODO: implement runtime logic.\n\n/**\n * Loads the deferred content when a value becomes truthy.\n * @codeGenApi\n */\nexport function ɵɵdeferWhen(value: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Prefetches the deferred content when a value becomes truthy.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchWhen(value: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on idle` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnIdle() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetech on idle` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnIdle() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on immediate` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnImmediate() {}  // TODO: implement runtime logic.\n\n\n/**\n * Creates runtime data structures for the `prefetech on immediate` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnImmediate() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on timer` deferred trigger.\n * @param delay Amount of time to wait before loading the content.\n * @codeGenApi\n */\nexport function ɵɵdeferOnTimer(delay: number) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetch on timer` deferred trigger.\n * @param delay Amount of time to wait before prefetching the content.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnTimer(delay: number) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on hover` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnHover() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetech on hover` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnHover() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on interaction` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferOnInteraction(target?: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetch on interaction` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnInteraction(target?: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on viewport` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferOnViewport(target?: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetch on viewport` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnViewport(target?: unknown) {}  // TODO: implement runtime logic.\n"]}

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

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