@angular/core 16.0.0-next.7 → 16.0.0-rc.0

package/fesm2022/rxjs-interop.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rxjs-interop.mjs","sources":["../../../../../../packages/core/rxjs-interop/src/from_observable.ts","../../../../../../packages/core/rxjs-interop/src/from_signal.ts","../../../../../../packages/core/rxjs-interop/src/take_until_destroyed.ts","../../../../../../packages/core/rxjs-interop/rxjs-interop.ts"],"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 {assertInInjectionContext, computed, DestroyRef, inject, signal, Signal, WritableSignal} from '@angular/core';\nimport {Observable} from 'rxjs';\n\n/**\n * Get the current value of an `Observable` as a reactive `Signal`.\n *\n * `fromObservable` returns a `Signal` which provides synchronous reactive access to values produced\n * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always\n * have the most recent value emitted by the subscription, and will throw an error if the\n * `Observable` errors.\n *\n * The subscription will last for the lifetime of the current injection context. That is, if\n * `fromObservable` is called from a component context, the subscription will be cleaned up when the\n * component is destroyed. When called outside of a component, the current `EnvironmentInjector`'s\n * lifetime will be used (which is typically the lifetime of the application itself).\n *\n * If the `Observable` does not produce a value before the `Signal` is read, the `Signal` will throw\n * an error. To avoid this, use a synchronous `Observable` (potentially created with the `startWith`\n * operator) or pass an initial value to `fromObservable` as the second argument.\n *\n * `fromObservable` must be called in an injection context.\n */\nexport function fromObservable<T>(source: Observable<T>): Signal<T>;\n\n/**\n * Get the current value of an `Observable` as a reactive `Signal`.\n *\n * `fromObservable` returns a `Signal` which provides synchronous reactive access to values produced\n * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always\n * have the most recent value emitted by the subscription, and will throw an error if the\n * `Observable` errors.\n *\n * The subscription will last for the lifetime of the current injection context. That is, if\n * `fromObservable` is called from a component context, the subscription will be cleaned up when the\n * component is destroyed. When called outside of a component, the current `EnvironmentInjector`'s\n * lifetime will be used (which is typically the lifetime of the application itself).\n *\n * Before the `Observable` emits its first value, the `Signal` will return the configured\n * `initialValue`. If the `Observable` is known to produce a value before the `Signal` will be read,\n * `initialValue` does not need to be passed.\n *\n * `fromObservable` must be called in an injection context.\n *\n * @developerPreview\n */\nexport function fromObservable<T, U extends T|null|undefined>(\n    // fromObservable(Observable<Animal>) -> Signal<Cat>\n    source: Observable<T>, initialValue: U): Signal<T|U>;\nexport function fromObservable<T, U = never>(source: Observable<T>, initialValue?: U): Signal<T|U> {\n  assertInInjectionContext(fromObservable);\n\n  // Note: T is the Observable value type, and U is the initial value type. They don't have to be\n  // the same - the returned signal gives values of type `T`.\n  let state: WritableSignal<State<T|U>>;\n  if (initialValue === undefined && arguments.length !== 2) {\n    // No initial value was passed, so initially the signal is in a `NoValue` state and will throw\n    // if accessed.\n    state = signal({kind: StateKind.NoValue});\n  } else {\n    // An initial value was passed, so use it.\n    state = signal<State<T|U>>({kind: StateKind.Value, value: initialValue!});\n  }\n\n  const sub = source.subscribe({\n    next: value => state.set({kind: StateKind.Value, value}),\n    error: error => state.set({kind: StateKind.Error, error}),\n    // Completion of the Observable is meaningless to the signal. Signals don't have a concept of\n    // \"complete\".\n  });\n\n  // Unsubscribe when the current context is destroyed.\n  inject(DestroyRef).onDestroy(sub.unsubscribe.bind(sub));\n\n  // The actual returned signal is a `computed` of the `State` signal, which maps the various states\n  // to either values or errors.\n  return computed(() => {\n    const current = state();\n    switch (current.kind) {\n      case StateKind.Value:\n        return current.value;\n      case StateKind.Error:\n        throw current.error;\n      case StateKind.NoValue:\n        // TODO(alxhub): use a RuntimeError when we finalize the error semantics\n        throw new Error(`fromObservable() signal read before the Observable emitted`);\n    }\n  });\n}\n\nconst enum StateKind {\n  NoValue,\n  Value,\n  Error,\n}\n\ninterface NoValueState {\n  kind: StateKind.NoValue;\n}\n\ninterface ValueState<T> {\n  kind: StateKind.Value;\n  value: T;\n}\n\ninterface ErrorState {\n  kind: StateKind.Error;\n  error: unknown;\n}\n\ntype State<T> = NoValueState|ValueState<T>|ErrorState;\n","/**\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 {assertInInjectionContext, effect, inject, Injector, Signal} from '@angular/core';\nimport {Observable} from 'rxjs';\n\n/**\n * Options for `fromSignal`.\n *\n * @developerPreview\n */\nexport interface FromSignalOptions {\n  /**\n   * The `Injector` to use when creating the effect.\n   *\n   * If this isn't specified, the current injection context will be used.\n   */\n  injector?: Injector;\n}\n\n/**\n * Exposes the value of an Angular `Signal` as an RxJS `Observable`.\n *\n * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.\n *\n * `fromSignal` must be called in an injection context.\n *\n * @developerPreview\n */\nexport function fromSignal<T>(\n    source: Signal<T>,\n    options?: FromSignalOptions,\n    ): Observable<T> {\n  !options?.injector && assertInInjectionContext(fromSignal);\n  const injector = options?.injector ?? inject(Injector);\n\n  // Creating a new `Observable` allows the creation of the effect to be lazy. This allows for all\n  // references to `source` to be dropped if the `Observable` is fully unsubscribed and thrown away.\n  return new Observable(observer => {\n    const watcher = effect(() => {\n      try {\n        observer.next(source());\n      } catch (err) {\n        observer.error(err);\n      }\n    }, {injector, manualCleanup: true});\n    return () => watcher.destroy();\n  });\n}\n","/**\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 {assertInInjectionContext, DestroyRef, inject} from '@angular/core';\nimport {MonoTypeOperatorFunction, Observable} from 'rxjs';\nimport {takeUntil} from 'rxjs/operators';\n\n/**\n * Operator which completes the Observable when the calling context (component, directive, service,\n * etc) is destroyed.\n *\n * @param destroyRef optionally, the `DestroyRef` representing the current context. This can be\n *     passed explicitly to use `takeUntilDestroyed` outside of an injection context. Otherwise, the\n * current `DestroyRef` is injected.\n *\n * @developerPreview\n */\nexport function takeUntilDestroyed<T>(destroyRef?: DestroyRef): MonoTypeOperatorFunction<T> {\n  if (!destroyRef) {\n    assertInInjectionContext(takeUntilDestroyed);\n    destroyRef = inject(DestroyRef);\n  }\n\n  const destroyed$ = new Observable<void>(observer => {\n    destroyRef!.onDestroy(observer.next.bind(observer));\n  });\n\n  return <T>(source: Observable<T>) => {\n    return source.pipe(takeUntil(destroyed$));\n  };\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"rxjs-interop.mjs","sources":["../../../../../../packages/core/rxjs-interop/src/take_until_destroyed.ts","../../../../../../packages/core/rxjs-interop/src/to_observable.ts","../../../../../../packages/core/src/signals/src/api.ts","../../../../../../packages/core/src/util/global.ts","../../../../../../packages/core/src/util/ng_dev_mode.ts","../../../../../../packages/core/src/signals/src/weak_ref.ts","../../../../../../packages/core/src/signals/src/graph.ts","../../../../../../packages/core/src/signals/src/computed.ts","../../../../../../packages/core/src/signals/src/errors.ts","../../../../../../packages/core/src/signals/src/signal.ts","../../../../../../packages/core/src/signals/src/untracked.ts","../../../../../../packages/core/src/signals/src/watch.ts","../../../../../../packages/core/rxjs-interop/src/to_signal.ts","../../../../../../packages/core/rxjs-interop/rxjs-interop.ts"],"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 {assertInInjectionContext, DestroyRef, inject} from '@angular/core';\nimport {MonoTypeOperatorFunction, Observable} from 'rxjs';\nimport {takeUntil} from 'rxjs/operators';\n\n/**\n * Operator which completes the Observable when the calling context (component, directive, service,\n * etc) is destroyed.\n *\n * @param destroyRef optionally, the `DestroyRef` representing the current context. This can be\n *     passed explicitly to use `takeUntilDestroyed` outside of an injection context. Otherwise, the\n * current `DestroyRef` is injected.\n *\n * @developerPreview\n */\nexport function takeUntilDestroyed<T>(destroyRef?: DestroyRef): MonoTypeOperatorFunction<T> {\n  if (!destroyRef) {\n    assertInInjectionContext(takeUntilDestroyed);\n    destroyRef = inject(DestroyRef);\n  }\n\n  const destroyed$ = new Observable<void>(observer => {\n    destroyRef!.onDestroy(observer.next.bind(observer));\n  });\n\n  return <T>(source: Observable<T>) => {\n    return source.pipe(takeUntil(destroyed$));\n  };\n}\n","/**\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 {assertInInjectionContext, effect, inject, Injector, Signal} from '@angular/core';\nimport {Observable} from 'rxjs';\n\n/**\n * Options for `toObservable`.\n *\n * @developerPreview\n */\nexport interface toObservableOptions {\n  /**\n   * The `Injector` to use when creating the effect.\n   *\n   * If this isn't specified, the current injection context will be used.\n   */\n  injector?: Injector;\n}\n\n/**\n * Exposes the value of an Angular `Signal` as an RxJS `Observable`.\n *\n * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.\n *\n * `toObservable` must be called in an injection context.\n *\n * @developerPreview\n */\nexport function toObservable<T>(\n    source: Signal<T>,\n    options?: toObservableOptions,\n    ): Observable<T> {\n  !options?.injector && assertInInjectionContext(toObservable);\n  const injector = options?.injector ?? inject(Injector);\n\n  // Creating a new `Observable` allows the creation of the effect to be lazy. This allows for all\n  // references to `source` to be dropped if the `Observable` is fully unsubscribed and thrown away.\n  return new Observable(observer => {\n    const watcher = effect(() => {\n      let value: T;\n      try {\n        value = source();\n      } catch (err) {\n        observer.error(err);\n        return;\n      }\n      observer.next(value);\n    }, {injector, manualCleanup: true, allowSignalWrites: true});\n    return () => watcher.destroy();\n  });\n}\n","/**\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 {ReactiveNode} from './graph';\n\n/**\n * Symbol used to tell `Signal`s apart from other functions.\n *\n * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.\n */\nconst SIGNAL = Symbol('SIGNAL');\n\n/**\n * A reactive value which notifies consumers of any changes.\n *\n * Signals are functions which returns their current value. To access the current value of a signal,\n * call it.\n *\n * Ordinary values can be turned into `Signal`s with the `signal` function.\n *\n * @developerPreview\n */\nexport type Signal<T> = (() => T)&{\n  [SIGNAL]: unknown;\n};\n\n/**\n * Checks if the given `value` function is a reactive `Signal`.\n */\nexport function isSignal(value: Function): value is Signal<unknown> {\n  return (value as Signal<unknown>)[SIGNAL] !== undefined;\n}\n\n/**\n * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`).\n *\n * @param fn A zero-argument function which will be converted into a `Signal`.\n */\nexport function createSignalFromFunction<T>(node: ReactiveNode, fn: () => T): Signal<T>;\n\n/**\n * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`), and\n * potentially add some set of extra properties (passed as an object record `extraApi`).\n *\n * @param fn A zero-argument function which will be converted into a `Signal`.\n * @param extraApi An object whose properties will be copied onto `fn` in order to create a specific\n *     desired interface for the `Signal`.\n */\nexport function createSignalFromFunction<T, U extends Record<string, unknown>>(\n    node: ReactiveNode, fn: () => T, extraApi: U): Signal<T>&U;\n\n/**\n * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`), and\n * potentially add some set of extra properties (passed as an object record `extraApi`).\n */\nexport function createSignalFromFunction<T, U extends Record<string, unknown> = {}>(\n    node: ReactiveNode, fn: () => T, extraApi: U = ({} as U)): Signal<T>&U {\n  (fn as any)[SIGNAL] = node;\n  // Copy properties from `extraApi` to `fn` to complete the desired API of the `Signal`.\n  return Object.assign(fn, extraApi) as (Signal<T>& U);\n}\n\n/**\n * A comparison function which can determine if two values are equal.\n *\n * @developerPreview\n */\nexport type ValueEqualityFn<T> = (a: T, b: T) => boolean;\n\n/**\n * The default equality function used for `signal` and `computed`, which treats objects and arrays\n * as never equal, and all other primitive values using identity semantics.\n *\n * This allows signals to hold non-primitive values (arrays, objects, other collections) and still\n * propagate change notification upon explicit mutation without identity change.\n *\n * @developerPreview\n */\nexport function defaultEquals<T>(a: T, b: T) {\n  // `Object.is` compares two values using identity semantics which is desired behavior for\n  // primitive values. If `Object.is` determines two values to be equal we need to make sure that\n  // those don't represent objects (we want to make sure that 2 objects are always considered\n  // \"unequal\"). The null check is needed for the special case of JavaScript reporting null values\n  // as objects (`typeof null === 'object'`).\n  return (a === null || typeof a !== 'object') && Object.is(a, b);\n}\n","/**\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\n// TODO(jteplitz602): Load WorkerGlobalScope from lib.webworker.d.ts file #3492\ndeclare var WorkerGlobalScope: any;\n// CommonJS / Node have global context exposed as \"global\" variable.\n// We don't want to include the whole node.d.ts this this compilation unit so we'll just fake\n// the global \"global\" var for now.\ndeclare var global: any;\n\n// Always use __globalThis if available, which is the spec-defined global variable across all\n// environments, then fallback to __global first, because in Node tests both __global and\n// __window may be defined and _global should be __global in that case. Note: Typeof/Instanceof\n// checks are considered side-effects in Terser. We explicitly mark this as side-effect free:\n// https://github.com/terser/terser/issues/250.\nconst _global: any = (/* @__PURE__ */ (\n    () => (typeof globalThis !== 'undefined' && globalThis) ||\n        (typeof global !== 'undefined' && global) || (typeof window !== 'undefined' && window) ||\n        (typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n         self instanceof WorkerGlobalScope && self))());\n\n/**\n * Attention: whenever providing a new value, be sure to add an\n * entry into the corresponding `....externs.js` file,\n * so that closure won't use that global for its purposes.\n */\nexport {_global as global};\n","/**\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 {global} from './global';\n\ndeclare global {\n  /**\n   * Values of ngDevMode\n   * Depending on the current state of the application, ngDevMode may have one of several values.\n   *\n   * For convenience, the “truthy” value which enables dev mode is also an object which contains\n   * Angular’s performance counters. This is not necessary, but cuts down on boilerplate for the\n   * perf counters.\n   *\n   * ngDevMode may also be set to false. This can happen in one of a few ways:\n   * - The user explicitly sets `window.ngDevMode = false` somewhere in their app.\n   * - The user calls `enableProdMode()`.\n   * - The URL contains a `ngDevMode=false` text.\n   * Finally, ngDevMode may not have been defined at all.\n   */\n  const ngDevMode: null|NgDevModePerfCounters;\n\n  interface NgDevModePerfCounters {\n    namedConstructors: boolean;\n    firstCreatePass: number;\n    tNode: number;\n    tView: number;\n    rendererCreateTextNode: number;\n    rendererSetText: number;\n    rendererCreateElement: number;\n    rendererAddEventListener: number;\n    rendererSetAttribute: number;\n    rendererRemoveAttribute: number;\n    rendererSetProperty: number;\n    rendererSetClassName: number;\n    rendererAddClass: number;\n    rendererRemoveClass: number;\n    rendererSetStyle: number;\n    rendererRemoveStyle: number;\n    rendererDestroy: number;\n    rendererDestroyNode: number;\n    rendererMoveNode: number;\n    rendererRemoveNode: number;\n    rendererAppendChild: number;\n    rendererInsertBefore: number;\n    rendererCreateComment: number;\n    hydratedNodes: number;\n    hydratedComponents: number;\n    dehydratedViewsRemoved: number;\n    dehydratedViewsCleanupRuns: number;\n    componentsSkippedHydration: number;\n  }\n}\n\nexport function ngDevModeResetPerfCounters(): NgDevModePerfCounters {\n  const locationString = typeof location !== 'undefined' ? location.toString() : '';\n  const newCounters: NgDevModePerfCounters = {\n    namedConstructors: locationString.indexOf('ngDevMode=namedConstructors') != -1,\n    firstCreatePass: 0,\n    tNode: 0,\n    tView: 0,\n    rendererCreateTextNode: 0,\n    rendererSetText: 0,\n    rendererCreateElement: 0,\n    rendererAddEventListener: 0,\n    rendererSetAttribute: 0,\n    rendererRemoveAttribute: 0,\n    rendererSetProperty: 0,\n    rendererSetClassName: 0,\n    rendererAddClass: 0,\n    rendererRemoveClass: 0,\n    rendererSetStyle: 0,\n    rendererRemoveStyle: 0,\n    rendererDestroy: 0,\n    rendererDestroyNode: 0,\n    rendererMoveNode: 0,\n    rendererRemoveNode: 0,\n    rendererAppendChild: 0,\n    rendererInsertBefore: 0,\n    rendererCreateComment: 0,\n    hydratedNodes: 0,\n    hydratedComponents: 0,\n    dehydratedViewsRemoved: 0,\n    dehydratedViewsCleanupRuns: 0,\n    componentsSkippedHydration: 0,\n  };\n\n  // Make sure to refer to ngDevMode as ['ngDevMode'] for closure.\n  const allowNgDevModeTrue = locationString.indexOf('ngDevMode=false') === -1;\n  global['ngDevMode'] = allowNgDevModeTrue && newCounters;\n  return newCounters;\n}\n\n/**\n * This function checks to see if the `ngDevMode` has been set. If yes,\n * then we honor it, otherwise we default to dev mode with additional checks.\n *\n * The idea is that unless we are doing production build where we explicitly\n * set `ngDevMode == false` we should be helping the developer by providing\n * as much early warning and errors as possible.\n *\n * `ɵɵdefineComponent` is guaranteed to have been called before any component template functions\n * (and thus Ivy instructions), so a single initialization there is sufficient to ensure ngDevMode\n * is defined for the entire instruction set.\n *\n * When checking `ngDevMode` on toplevel, always init it before referencing it\n * (e.g. `((typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode())`), otherwise you can\n *  get a `ReferenceError` like in https://github.com/angular/angular/issues/31595.\n *\n * Details on possible values for `ngDevMode` can be found on its docstring.\n *\n * NOTE:\n * - changes to the `ngDevMode` name must be synced with `compiler-cli/src/tooling.ts`.\n */\nexport function initNgDevMode(): boolean {\n  // The below checks are to ensure that calling `initNgDevMode` multiple times does not\n  // reset the counters.\n  // If the `ngDevMode` is not an object, then it means we have not created the perf counters\n  // yet.\n  if (typeof ngDevMode === 'undefined' || ngDevMode) {\n    if (typeof ngDevMode !== 'object') {\n      ngDevModeResetPerfCounters();\n    }\n    return typeof ngDevMode !== 'undefined' && !!ngDevMode;\n  }\n  return false;\n}\n","/**\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\n// Required as the signals library is in a separate package, so we need to explicitly ensure the\n// global `ngDevMode` type is defined.\nimport '../../util/ng_dev_mode';\n\nimport {global} from '../../util/global';\n\n/**\n * A `WeakRef`-compatible reference that fakes the API with a strong reference\n * internally.\n */\nclass LeakyRef<T>/* implements WeakRef<T> */ {\n  constructor(private readonly ref: T) {}\n\n  deref(): T|undefined {\n    return this.ref;\n  }\n}\n\n// `WeakRef` is not always defined in every TS environment where Angular is compiled. Instead,\n// read it off of the global context if available.\n// tslint:disable-next-line: no-toplevel-property-access\nlet WeakRefImpl: WeakRefCtor|undefined = global['WeakRef'] ?? LeakyRef;\n\nexport interface WeakRef<T extends object> {\n  deref(): T|undefined;\n}\n\nexport function newWeakRef<T extends object>(value: T): WeakRef<T> {\n  if (typeof ngDevMode !== 'undefined' && ngDevMode && WeakRefImpl === undefined) {\n    throw new Error(`Angular requires a browser which supports the 'WeakRef' API`);\n  }\n  return new WeakRefImpl!(value);\n}\n\nexport interface WeakRefCtor {\n  new<T extends object>(value: T): WeakRef<T>;\n}\n\nexport function setAlternateWeakRefImpl(impl: WeakRefCtor) {\n  // no-op since the alternate impl is included by default by the framework. Remove once internal\n  // migration is complete.\n}\n","/**\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\n// Required as the signals library is in a separate package, so we need to explicitly ensure the\n// global `ngDevMode` type is defined.\nimport '../../util/ng_dev_mode';\n\nimport {throwInvalidWriteToSignalError} from './errors';\nimport {newWeakRef, WeakRef} from './weak_ref';\n\n/**\n * Counter tracking the next `ProducerId` or `ConsumerId`.\n */\nlet _nextReactiveId: number = 0;\n\n/**\n * Tracks the currently active reactive consumer (or `null` if there is no active\n * consumer).\n */\nlet activeConsumer: ReactiveNode|null = null;\n\n/**\n * Whether the graph is currently propagating change notifications.\n */\nlet inNotificationPhase = false;\n\nexport function setActiveConsumer(consumer: ReactiveNode|null): ReactiveNode|null {\n  const prev = activeConsumer;\n  activeConsumer = consumer;\n  return prev;\n}\n\n/**\n * A bidirectional edge in the dependency graph of `ReactiveNode`s.\n */\ninterface ReactiveEdge {\n  /**\n   * Weakly held reference to the consumer side of this edge.\n   */\n  readonly producerNode: WeakRef<ReactiveNode>;\n\n  /**\n   * Weakly held reference to the producer side of this edge.\n   */\n  readonly consumerNode: WeakRef<ReactiveNode>;\n  /**\n   * `trackingVersion` of the consumer at which this dependency edge was last observed.\n   *\n   * If this doesn't match the consumer's current `trackingVersion`, then this dependency record\n   * is stale, and needs to be cleaned up.\n   */\n  atTrackingVersion: number;\n\n  /**\n   * `valueVersion` of the producer at the time this dependency was last accessed.\n   */\n  seenValueVersion: number;\n}\n\n/**\n * A node in the reactive graph.\n *\n * Nodes can be producers of reactive values, consumers of other reactive values, or both.\n *\n * Producers are nodes that produce values, and can be depended upon by consumer nodes.\n *\n * Producers expose a monotonic `valueVersion` counter, and are responsible for incrementing this\n * version when their value semantically changes. Some producers may produce their values lazily and\n * thus at times need to be polled for potential updates to their value (and by extension their\n * `valueVersion`). This is accomplished via the `onProducerUpdateValueVersion` method for\n * implemented by producers, which should perform whatever calculations are necessary to ensure\n * `valueVersion` is up to date.\n *\n * Consumers are nodes that depend on the values of producers and are notified when those values\n * might have changed.\n *\n * Consumers do not wrap the reads they consume themselves, but rather can be set as the active\n * reader via `setActiveConsumer`. Reads of producers that happen while a consumer is active will\n * result in those producers being added as dependencies of that consumer node.\n *\n * The set of dependencies of a consumer is dynamic. Implementers expose a monotonically increasing\n * `trackingVersion` counter, which increments whenever the consumer is about to re-run any reactive\n * reads it needs and establish a new set of dependencies as a result.\n *\n * Producers store the last `trackingVersion` they've seen from `Consumer`s which have read them.\n * This allows a producer to identify whether its record of the dependency is current or stale, by\n * comparing the consumer's `trackingVersion` to the version at which the dependency was\n * last observed.\n */\nexport abstract class ReactiveNode {\n  private readonly id = _nextReactiveId++;\n\n  /**\n   * A cached weak reference to this node, which will be used in `ReactiveEdge`s.\n   */\n  private readonly ref = newWeakRef(this);\n\n  /**\n   * Edges to producers on which this node depends (in its consumer capacity).\n   */\n  private readonly producers = new Map<number, ReactiveEdge>();\n\n  /**\n   * Edges to consumers on which this node depends (in its producer capacity).\n   */\n  private readonly consumers = new Map<number, ReactiveEdge>();\n\n  /**\n   * Monotonically increasing counter representing a version of this `Consumer`'s\n   * dependencies.\n   */\n  protected trackingVersion = 0;\n\n  /**\n   * Monotonically increasing counter which increases when the value of this `Producer`\n   * semantically changes.\n   */\n  protected valueVersion = 0;\n\n  /**\n   * Whether signal writes should be allowed while this `ReactiveNode` is the current consumer.\n   */\n  protected abstract readonly consumerAllowSignalWrites: boolean;\n\n  /**\n   * Called for consumers whenever one of their dependencies notifies that it might have a new\n   * value.\n   */\n  protected abstract onConsumerDependencyMayHaveChanged(): void;\n\n  /**\n   * Called for producers when a dependent consumer is checking if the producer's value has actually\n   * changed.\n   */\n  protected abstract onProducerUpdateValueVersion(): void;\n\n  /**\n   * Polls dependencies of a consumer to determine if they have actually changed.\n   *\n   * If this returns `false`, then even though the consumer may have previously been notified of a\n   * change, the values of its dependencies have not actually changed and the consumer should not\n   * rerun any reactions.\n   */\n  protected consumerPollProducersForChange(): boolean {\n    for (const [producerId, edge] of this.producers) {\n      const producer = edge.producerNode.deref();\n\n      if (producer === undefined || edge.atTrackingVersion !== this.trackingVersion) {\n        // This dependency edge is stale, so remove it.\n        this.producers.delete(producerId);\n        producer?.consumers.delete(this.id);\n        continue;\n      }\n\n      if (producer.producerPollStatus(edge.seenValueVersion)) {\n        // One of the dependencies reports a real value change.\n        return true;\n      }\n    }\n\n    // No dependency reported a real value change, so the `Consumer` has also not been\n    // impacted.\n    return false;\n  }\n\n  /**\n   * Notify all consumers of this producer that its value may have changed.\n   */\n  protected producerMayHaveChanged(): void {\n    // Prevent signal reads when we're updating the graph\n    const prev = inNotificationPhase;\n    inNotificationPhase = true;\n    try {\n      for (const [consumerId, edge] of this.consumers) {\n        const consumer = edge.consumerNode.deref();\n        if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {\n          this.consumers.delete(consumerId);\n          consumer?.producers.delete(this.id);\n          continue;\n        }\n\n        consumer.onConsumerDependencyMayHaveChanged();\n      }\n    } finally {\n      inNotificationPhase = prev;\n    }\n  }\n\n  /**\n   * Mark that this producer node has been accessed in the current reactive context.\n   */\n  protected producerAccessed(): void {\n    if (inNotificationPhase) {\n      throw new Error(\n          typeof ngDevMode !== 'undefined' && ngDevMode ?\n              `Assertion error: signal read during notification phase` :\n              '');\n    }\n\n    if (activeConsumer === null) {\n      return;\n    }\n\n    // Either create or update the dependency `Edge` in both directions.\n    let edge = activeConsumer.producers.get(this.id);\n    if (edge === undefined) {\n      edge = {\n        consumerNode: activeConsumer.ref,\n        producerNode: this.ref,\n        seenValueVersion: this.valueVersion,\n        atTrackingVersion: activeConsumer.trackingVersion,\n      };\n      activeConsumer.producers.set(this.id, edge);\n      this.consumers.set(activeConsumer.id, edge);\n    } else {\n      edge.seenValueVersion = this.valueVersion;\n      edge.atTrackingVersion = activeConsumer.trackingVersion;\n    }\n  }\n\n  /**\n   * Whether this consumer currently has any producers registered.\n   */\n  protected get hasProducers(): boolean {\n    return this.producers.size > 0;\n  }\n\n  /**\n   * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,\n   * based on the current consumer context.\n   */\n  protected get producerUpdatesAllowed(): boolean {\n    return activeConsumer?.consumerAllowSignalWrites !== false;\n  }\n\n  /**\n   * Checks if a `Producer` has a current value which is different than the value\n   * last seen at a specific version by a `Consumer` which recorded a dependency on\n   * this `Producer`.\n   */\n  private producerPollStatus(lastSeenValueVersion: number): boolean {\n    // `producer.valueVersion` may be stale, but a mismatch still means that the value\n    // last seen by the `Consumer` is also stale.\n    if (this.valueVersion !== lastSeenValueVersion) {\n      return true;\n    }\n\n    // Trigger the `Producer` to update its `valueVersion` if necessary.\n    this.onProducerUpdateValueVersion();\n\n    // At this point, we can trust `producer.valueVersion`.\n    return this.valueVersion !== lastSeenValueVersion;\n  }\n}\n","/**\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 {createSignalFromFunction, defaultEquals, Signal, ValueEqualityFn} from './api';\nimport {ReactiveNode, setActiveConsumer} from './graph';\n\n/**\n * Options passed to the `computed` creation function.\n *\n * @developerPreview\n */\nexport interface CreateComputedOptions<T> {\n  /**\n   * A comparison function which defines equality for computed values.\n   */\n  equal?: ValueEqualityFn<T>;\n}\n\n\n/**\n * Create a computed `Signal` which derives a reactive value from an expression.\n *\n * @developerPreview\n */\nexport function computed<T>(computation: () => T, options?: CreateComputedOptions<T>): Signal<T> {\n  const node = new ComputedImpl(computation, options?.equal ?? defaultEquals);\n\n  // Casting here is required for g3, as TS inference behavior is slightly different between our\n  // version/options and g3's.\n  return createSignalFromFunction(node, node.signal.bind(node)) as unknown as Signal<T>;\n}\n\n/**\n * A dedicated symbol used before a computed value has been calculated for the first time.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst UNSET: any = Symbol('UNSET');\n\n/**\n * A dedicated symbol used in place of a computed signal value to indicate that a given computation\n * is in progress. Used to detect cycles in computation chains.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst COMPUTING: any = Symbol('COMPUTING');\n\n/**\n * A dedicated symbol used in place of a computed signal value to indicate that a given computation\n * failed. The thrown error is cached until the computation gets dirty again.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst ERRORED: any = Symbol('ERRORED');\n\n/**\n * A computation, which derives a value from a declarative reactive expression.\n *\n * `Computed`s are both producers and consumers of reactivity.\n */\nclass ComputedImpl<T> extends ReactiveNode {\n  constructor(private computation: () => T, private equal: (oldValue: T, newValue: T) => boolean) {\n    super();\n  }\n  /**\n   * Current value of the computation.\n   *\n   * This can also be one of the special values `UNSET`, `COMPUTING`, or `ERRORED`.\n   */\n  private value: T = UNSET;\n\n  /**\n   * If `value` is `ERRORED`, the error caught from the last computation attempt which will\n   * be re-thrown.\n   */\n  private error: unknown = null;\n\n  /**\n   * Flag indicating that the computation is currently stale, meaning that one of the\n   * dependencies has notified of a potential change.\n   *\n   * It's possible that no dependency has _actually_ changed, in which case the `stale`\n   * state can be resolved without recomputing the value.\n   */\n  private stale = true;\n\n  protected override readonly consumerAllowSignalWrites = false;\n\n  protected override onConsumerDependencyMayHaveChanged(): void {\n    if (this.stale) {\n      // We've already notified consumers that this value has potentially changed.\n      return;\n    }\n\n    // Record that the currently cached value may be stale.\n    this.stale = true;\n\n    // Notify any consumers about the potential change.\n    this.producerMayHaveChanged();\n  }\n\n  protected override onProducerUpdateValueVersion(): void {\n    if (!this.stale) {\n      // The current value and its version are already up to date.\n      return;\n    }\n\n    // The current value is stale. Check whether we need to produce a new one.\n\n    if (this.value !== UNSET && this.value !== COMPUTING &&\n        !this.consumerPollProducersForChange()) {\n      // Even though we were previously notified of a potential dependency update, all of\n      // our dependencies report that they have not actually changed in value, so we can\n      // resolve the stale state without needing to recompute the current value.\n      this.stale = false;\n      return;\n    }\n\n    // The current value is stale, and needs to be recomputed. It still may not change -\n    // that depends on whether the newly computed value is equal to the old.\n    this.recomputeValue();\n  }\n\n  private recomputeValue(): void {\n    if (this.value === COMPUTING) {\n      // Our computation somehow led to a cyclic read of itself.\n      throw new Error('Detected cycle in computations.');\n    }\n\n    const oldValue = this.value;\n    this.value = COMPUTING;\n\n    // As we're re-running the computation, update our dependent tracking version number.\n    this.trackingVersion++;\n    const prevConsumer = setActiveConsumer(this);\n    let newValue: T;\n    try {\n      newValue = this.computation();\n    } catch (err) {\n      newValue = ERRORED;\n      this.error = err;\n    } finally {\n      setActiveConsumer(prevConsumer);\n    }\n\n    this.stale = false;\n\n    if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&\n        this.equal(oldValue, newValue)) {\n      // No change to `valueVersion` - old and new values are\n      // semantically equivalent.\n      this.value = oldValue;\n      return;\n    }\n\n    this.value = newValue;\n    this.valueVersion++;\n  }\n\n  signal(): T {\n    // Check if the value needs updating before returning it.\n    this.onProducerUpdateValueVersion();\n\n    // Record that someone looked at this signal.\n    this.producerAccessed();\n\n    if (this.value === ERRORED) {\n      throw this.error;\n    }\n\n    return this.value;\n  }\n}\n","/**\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\nfunction defaultThrowError(): never {\n  throw new Error();\n}\n\nlet throwInvalidWriteToSignalErrorFn = defaultThrowError;\n\nexport function throwInvalidWriteToSignalError() {\n  throwInvalidWriteToSignalErrorFn();\n}\n\nexport function setThrowInvalidWriteToSignalError(fn: () => never): void {\n  throwInvalidWriteToSignalErrorFn = fn;\n}\n","/**\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 {createSignalFromFunction, defaultEquals, Signal, ValueEqualityFn} from './api';\nimport {throwInvalidWriteToSignalError} from './errors';\nimport {ReactiveNode} from './graph';\n\n/**\n * If set, called after `WritableSignal`s are updated.\n *\n * This hook can be used to achieve various effects, such as running effects synchronously as part\n * of setting a signal.\n */\nlet postSignalSetFn: (() => void)|null = null;\n\n/**\n * A `Signal` with a value that can be mutated via a setter interface.\n *\n * @developerPreview\n */\nexport interface WritableSignal<T> extends Signal<T> {\n  /**\n   * Directly set the signal to a new value, and notify any dependents.\n   */\n  set(value: T): void;\n\n  /**\n   * Update the value of the signal based on its current value, and\n   * notify any dependents.\n   */\n  update(updateFn: (value: T) => T): void;\n\n  /**\n   * Update the current value by mutating it in-place, and\n   * notify any dependents.\n   */\n  mutate(mutatorFn: (value: T) => void): void;\n}\n\nclass WritableSignalImpl<T> extends ReactiveNode {\n  protected override readonly consumerAllowSignalWrites = false;\n\n  constructor(private value: T, private equal: ValueEqualityFn<T>) {\n    super();\n  }\n\n  protected override onConsumerDependencyMayHaveChanged(): void {\n    // This never happens for writable signals as they're not consumers.\n  }\n\n  protected override onProducerUpdateValueVersion(): void {\n    // Writable signal value versions are always up to date.\n  }\n\n  /**\n   * Directly update the value of the signal to a new value, which may or may not be\n   * equal to the previous.\n   *\n   * In the event that `newValue` is semantically equal to the current value, `set` is\n   * a no-op.\n   */\n  set(newValue: T): void {\n    if (!this.producerUpdatesAllowed) {\n      throwInvalidWriteToSignalError();\n    }\n    if (!this.equal(this.value, newValue)) {\n      this.value = newValue;\n      this.valueVersion++;\n      this.producerMayHaveChanged();\n\n      postSignalSetFn?.();\n    }\n  }\n\n  /**\n   * Derive a new value for the signal from its current value using the `updater` function.\n   *\n   * This is equivalent to calling `set` on the result of running `updater` on the current\n   * value.\n   */\n  update(updater: (value: T) => T): void {\n    if (!this.producerUpdatesAllowed) {\n      throwInvalidWriteToSignalError();\n    }\n    this.set(updater(this.value));\n  }\n\n  /**\n   * Calls `mutator` on the current value and assumes that it has been mutated.\n   */\n  mutate(mutator: (value: T) => void): void {\n    if (!this.producerUpdatesAllowed) {\n      throwInvalidWriteToSignalError();\n    }\n    // Mutate bypasses equality checks as it's by definition changing the value.\n    mutator(this.value);\n    this.valueVersion++;\n    this.producerMayHaveChanged();\n\n    postSignalSetFn?.();\n  }\n\n  signal(): T {\n    this.producerAccessed();\n    return this.value;\n  }\n}\n\n/**\n * Options passed to the `signal` creation function.\n *\n * @developerPreview\n */\nexport interface CreateSignalOptions<T> {\n  /**\n   * A comparison function which defines equality for signal values.\n   */\n  equal?: ValueEqualityFn<T>;\n}\n\n/**\n * Create a `Signal` that can be set or updated directly.\n *\n * @developerPreview\n */\nexport function signal<T>(initialValue: T, options?: CreateSignalOptions<T>): WritableSignal<T> {\n  const signalNode = new WritableSignalImpl(initialValue, options?.equal ?? defaultEquals);\n\n  // Casting here is required for g3, as TS inference behavior is slightly different between our\n  // version/options and g3's.\n  const signalFn = createSignalFromFunction(signalNode, signalNode.signal.bind(signalNode), {\n                     set: signalNode.set.bind(signalNode),\n                     update: signalNode.update.bind(signalNode),\n                     mutate: signalNode.mutate.bind(signalNode),\n                   }) as unknown as WritableSignal<T>;\n  return signalFn;\n}\n\nexport function setPostSignalSetFn(fn: (() => void)|null): (() => void)|null {\n  const prev = postSignalSetFn;\n  postSignalSetFn = fn;\n  return prev;\n}\n","/**\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 {setActiveConsumer} from './graph';\n\n/**\n * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function\n * can, optionally, return a value.\n *\n * @developerPreview\n */\nexport function untracked<T>(nonReactiveReadsFn: () => T): T {\n  const prevConsumer = setActiveConsumer(null);\n  // We are not trying to catch any particular errors here, just making sure that the consumers\n  // stack is restored in case of errors.\n  try {\n    return nonReactiveReadsFn();\n  } finally {\n    setActiveConsumer(prevConsumer);\n  }\n}\n","/**\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 {ReactiveNode, setActiveConsumer} from './graph';\n\n/**\n * A cleanup function that can be optionally registered from the watch logic. If registered, the\n * cleanup logic runs before the next watch execution.\n */\nexport type WatchCleanupFn = () => void;\n\n/**\n * A callback passed to the watch function that makes it possible to register cleanup logic.\n */\nexport type WatchCleanupRegisterFn = (cleanupFn: WatchCleanupFn) => void;\n\nconst NOOP_CLEANUP_FN: WatchCleanupFn = () => {};\n\n/**\n * Watches a reactive expression and allows it to be scheduled to re-run\n * when any dependencies notify of a change.\n *\n * `Watch` doesn't run reactive expressions itself, but relies on a consumer-\n * provided scheduling operation to coordinate calling `Watch.run()`.\n */\nexport class Watch extends ReactiveNode {\n  protected override readonly consumerAllowSignalWrites: boolean;\n  private dirty = false;\n  private cleanupFn = NOOP_CLEANUP_FN;\n  private registerOnCleanup =\n      (cleanupFn: WatchCleanupFn) => {\n        this.cleanupFn = cleanupFn;\n      }\n\n  constructor(\n      private watch: (onCleanup: WatchCleanupRegisterFn) => void,\n      private schedule: (watch: Watch) => void, allowSignalWrites: boolean) {\n    super();\n    this.consumerAllowSignalWrites = allowSignalWrites;\n  }\n\n  notify(): void {\n    if (!this.dirty) {\n      this.schedule(this);\n    }\n    this.dirty = true;\n  }\n\n  protected override onConsumerDependencyMayHaveChanged(): void {\n    this.notify();\n  }\n\n  protected override onProducerUpdateValueVersion(): void {\n    // Watches are not producers.\n  }\n\n  /**\n   * Execute the reactive expression in the context of this `Watch` consumer.\n   *\n   * Should be called by the user scheduling algorithm when the provided\n   * `schedule` hook is called by `Watch`.\n   */\n  run(): void {\n    this.dirty = false;\n    if (this.trackingVersion !== 0 && !this.consumerPollProducersForChange()) {\n      return;\n    }\n\n    const prevConsumer = setActiveConsumer(this);\n    this.trackingVersion++;\n    try {\n      this.cleanupFn();\n      this.cleanupFn = NOOP_CLEANUP_FN;\n      this.watch(this.registerOnCleanup);\n    } finally {\n      setActiveConsumer(prevConsumer);\n    }\n  }\n\n  cleanup() {\n    this.cleanupFn();\n  }\n}\n","/**\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 {assertInInjectionContext, computed, DestroyRef, inject, signal, Signal, WritableSignal} from '@angular/core';\nimport {RuntimeError, RuntimeErrorCode} from '@angular/core/src/errors';\nimport {Observable} from 'rxjs';\n\nimport {untracked} from '../../src/signals';\n\n/**\n * Get the current value of an `Observable` as a reactive `Signal`.\n *\n * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced\n * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always\n * have the most recent value emitted by the subscription, and will throw an error if the\n * `Observable` errors.\n *\n * The subscription will last for the lifetime of the current injection context. That is, if\n * `toSignal` is called from a component context, the subscription will be cleaned up when the\n * component is destroyed. When called outside of a component, the current `EnvironmentInjector`'s\n * lifetime will be used (which is typically the lifetime of the application itself).\n *\n * If the `Observable` does not produce a value before the `Signal` is read, the `Signal` will throw\n * an error. To avoid this, use a synchronous `Observable` (potentially created with the `startWith`\n * operator) or pass an initial value to `toSignal` as the second argument.\n *\n * `toSignal` must be called in an injection context.\n */\nexport function toSignal<T>(source: Observable<T>): Signal<T|undefined>;\n\n/**\n * Get the current value of an `Observable` as a reactive `Signal`.\n *\n * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced\n * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always\n * have the most recent value emitted by the subscription, and will throw an error if the\n * `Observable` errors.\n *\n * The subscription will last for the lifetime of the current injection context. That is, if\n * `toSignal` is called from a component context, the subscription will be cleaned up when the\n * component is destroyed. When called outside of a component, the current `EnvironmentInjector`'s\n * lifetime will be used (which is typically the lifetime of the application itself).\n *\n * Before the `Observable` emits its first value, the `Signal` will return the configured\n * `initialValue`. If the `Observable` is known to produce a value before the `Signal` will be read,\n * `initialValue` does not need to be passed.\n *\n * `toSignal` must be called in an injection context.\n *\n * @developerPreview\n */\nexport function toSignal<T, U extends T|null|undefined>(\n    // toSignal(Observable<Animal>, {initialValue: null}) -> Signal<Animal|null>\n    source: Observable<T>, options: {initialValue: U, requireSync?: false}): Signal<T|U>;\nexport function toSignal<T>(\n    // toSignal(Observable<Animal>, {requireSync: true}) -> Signal<Animal>\n    source: Observable<T>, options: {requireSync: true}): Signal<T>;\n// toSignal(Observable<Animal>) -> Signal<Animal|undefined>\nexport function toSignal<T, U = undefined>(\n    source: Observable<T>, options?: {initialValue?: U, requireSync?: boolean}): Signal<T|U> {\n  assertInInjectionContext(toSignal);\n\n  // Note: T is the Observable value type, and U is the initial value type. They don't have to be\n  // the same - the returned signal gives values of type `T`.\n  let state: WritableSignal<State<T|U>>;\n  if (options?.requireSync) {\n    // Initially the signal is in a `NoValue` state.\n    state = signal({kind: StateKind.NoValue});\n  } else {\n    // If an initial value was passed, use it. Otherwise, use `undefined` as the initial value.\n    state = signal<State<T|U>>({kind: StateKind.Value, value: options?.initialValue as U});\n  }\n\n  const sub = source.subscribe({\n    next: value => state.set({kind: StateKind.Value, value}),\n    error: error => state.set({kind: StateKind.Error, error}),\n    // Completion of the Observable is meaningless to the signal. Signals don't have a concept of\n    // \"complete\".\n  });\n\n  if (ngDevMode && options?.requireSync && untracked(state).kind === StateKind.NoValue) {\n    throw new RuntimeError(\n        RuntimeErrorCode.REQUIRE_SYNC_WITHOUT_SYNC_EMIT,\n        '`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');\n  }\n\n  // Unsubscribe when the current context is destroyed.\n  inject(DestroyRef).onDestroy(sub.unsubscribe.bind(sub));\n\n  // The actual returned signal is a `computed` of the `State` signal, which maps the various states\n  // to either values or errors.\n  return computed(() => {\n    const current = state();\n    switch (current.kind) {\n      case StateKind.Value:\n        return current.value;\n      case StateKind.Error:\n        throw current.error;\n      case StateKind.NoValue:\n        // This shouldn't really happen because the error is thrown on creation.\n        // TODO(alxhub): use a RuntimeError when we finalize the error semantics\n        throw new RuntimeError(\n            RuntimeErrorCode.REQUIRE_SYNC_WITHOUT_SYNC_EMIT,\n            '`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');\n    }\n  });\n}\n\nconst enum StateKind {\n  NoValue,\n  Value,\n  Error,\n}\n\ninterface NoValueState {\n  kind: StateKind.NoValue;\n}\n\ninterface ValueState<T> {\n  kind: StateKind.Value;\n  value: T;\n}\n\ninterface ErrorState {\n  kind: StateKind.Error;\n  error: unknown;\n}\n\ntype State<T> = NoValueState|ValueState<T>|ErrorState;\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":["global","signal","computed"],"mappings":"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"}

package/fesm2022/testing.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.0.0-next.7
+ * @license Angular v16.0.0-rc.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -3319,7 +3319,7 @@ function isComponentDef(def) {
     return !!def.template;
 }
 function isRootView(target) {
-    return (target[FLAGS] & 256 /* LViewFlags.IsRoot */) !== 0;
+    return (target[FLAGS] & 512 /* LViewFlags.IsRoot */) !== 0;
 }
 function isProjectionTNode(tNode) {
     return (tNode.type & 16 /* TNodeType.Projection */) === 16 /* TNodeType.Projection */;
@@ -3954,6 +3954,9 @@ class Watch extends ReactiveNode {
         this.schedule = schedule;
         this.dirty = false;
         this.cleanupFn = NOOP_CLEANUP_FN;
+        this.registerOnCleanup = (cleanupFn) => {
+            this.cleanupFn = cleanupFn;
+        };
         this.consumerAllowSignalWrites = allowSignalWrites;
     }
     notify() {
@@ -3983,7 +3986,8 @@ class Watch extends ReactiveNode {
         this.trackingVersion++;
         try {
             this.cleanupFn();
-            this.cleanupFn = this.watch() ?? NOOP_CLEANUP_FN;
+            this.cleanupFn = NOOP_CLEANUP_FN;
+            this.watch(this.registerOnCleanup);
         }
         finally {
             setActiveConsumer(prevConsumer);
@@ -4244,7 +4248,7 @@ function isCreationMode(view) {
  * into a container. For that, you'll want `viewAttachedToContainer` below.
  */
 function viewAttachedToChangeDetector(view) {
-    return (view[FLAGS] & 64 /* LViewFlags.Attached */) === 64 /* LViewFlags.Attached */;
+    return (view[FLAGS] & 128 /* LViewFlags.Attached */) === 128 /* LViewFlags.Attached */;
 }
 /** Returns a boolean for whether the view is attached to a container. */
 function viewAttachedToContainer(view) {
@@ -4984,7 +4988,7 @@ function incrementInitPhaseFlags(lView, initPhase) {
         assertNotEqual(initPhase, 3 /* InitPhaseState.InitPhaseCompleted */, 'Init hooks phase should not be incremented after all init hooks have been run.');
     let flags = lView[FLAGS];
     if ((flags & 3 /* LViewFlags.InitPhaseStateMask */) === initPhase) {
-        flags &= 2047 /* LViewFlags.IndexWithinInitPhaseReset */;
+        flags &= 4095 /* LViewFlags.IndexWithinInitPhaseReset */;
         flags += 1 /* LViewFlags.InitPhaseStateIncrementer */;
         lView[FLAGS] = flags;
     }
@@ -5065,12 +5069,12 @@ function callHook(currentView, initPhase, arr, i) {
     const directiveIndex = isInitHook ? -arr[i] : arr[i];
     const directive = currentView[directiveIndex];
     if (isInitHook) {
-        const indexWithintInitPhase = currentView[FLAGS] >> 11 /* LViewFlags.IndexWithinInitPhaseShift */;
+        const indexWithintInitPhase = currentView[FLAGS] >> 12 /* LViewFlags.IndexWithinInitPhaseShift */;
         // The init phase state must be always checked here as it may have been recursively updated.
         if (indexWithintInitPhase <
             (currentView[PREORDER_HOOK_FLAGS] >> 16 /* PreOrderHookFlags.NumberOfInitHooksCalledShift */) &&
             (currentView[FLAGS] & 3 /* LViewFlags.InitPhaseStateMask */) === initPhase) {
-            currentView[FLAGS] += 2048 /* LViewFlags.IndexWithinInitPhaseIncrementer */;
+            currentView[FLAGS] += 4096 /* LViewFlags.IndexWithinInitPhaseIncrementer */;
             callHookInternal(directive, hook);
         }
     }
@@ -5660,7 +5664,7 @@ function getOrCreateInjectable(tNode, lView, token, flags = InjectFlags.Default,
     if (tNode !== null) {
         // If the view or any of its ancestors have an embedded
         // view injector, we have to look it up there first.
-        if (lView[FLAGS] & 1024 /* LViewFlags.HasEmbeddedViewInjector */) {
+        if (lView[FLAGS] & 2048 /* LViewFlags.HasEmbeddedViewInjector */) {
             const embeddedInjectorValue = lookupTokenUsingEmbeddedInjector(tNode, lView, token, flags, NOT_FOUND);
             if (embeddedInjectorValue !== NOT_FOUND) {
                 return embeddedInjectorValue;
@@ -6003,8 +6007,8 @@ function lookupTokenUsingEmbeddedInjector(tNode, lView, token, flags, notFoundVa
     // hierarchy when resolving the value is to walk it node-by-node while attempting to resolve
     // the token at each level.
     while (currentTNode !== null && currentLView !== null &&
-        (currentLView[FLAGS] & 1024 /* LViewFlags.HasEmbeddedViewInjector */) &&
-        !(currentLView[FLAGS] & 256 /* LViewFlags.IsRoot */)) {
+        (currentLView[FLAGS] & 2048 /* LViewFlags.HasEmbeddedViewInjector */) &&
+        !(currentLView[FLAGS] & 512 /* LViewFlags.IsRoot */)) {
         ngDevMode && assertTNodeForLView(currentTNode, currentLView);
         // Note that this lookup on the node injector is using the `Self` flag, because
         // we don't want the node injector to look at any parent injectors since we
@@ -6967,7 +6971,7 @@ function getLViewParent(lView) {
 function getRootView(componentOrLView) {
     ngDevMode && assertDefined(componentOrLView, 'component');
     let lView = isLView(componentOrLView) ? componentOrLView : readPatchedLView(componentOrLView);
-    while (lView && !(lView[FLAGS] & 256 /* LViewFlags.IsRoot */)) {
+    while (lView && !(lView[FLAGS] & 512 /* LViewFlags.IsRoot */)) {
         lView = getLViewParent(lView);
     }
     ngDevMode && assertLView(lView);
@@ -7213,7 +7217,7 @@ function insertView(tView, lView, lContainer, index) {
         lQueries.insertView(tView);
     }
     // Sets the attached flag
-    lView[FLAGS] |= 64 /* LViewFlags.Attached */;
+    lView[FLAGS] |= 128 /* LViewFlags.Attached */;
 }
 /**
  * Track views created from the declaration container (TemplateRef) and inserted into a
@@ -7253,8 +7257,8 @@ function detachMovedView(declarationContainer, lView) {
     // If the view was marked for refresh but then detached before it was checked (where the flag
     // would be cleared and the counter decremented), we need to decrement the view counter here
     // instead.
-    if (lView[FLAGS] & 512 /* LViewFlags.RefreshTransplantedView */) {
-        lView[FLAGS] &= ~512 /* LViewFlags.RefreshTransplantedView */;
+    if (lView[FLAGS] & 1024 /* LViewFlags.RefreshTransplantedView */) {
+        lView[FLAGS] &= ~1024 /* LViewFlags.RefreshTransplantedView */;
         updateTransplantedViewCount(insertionLContainer, -1);
     }
     movedViews.splice(declarationViewIndex, 1);
@@ -7292,7 +7296,7 @@ function detachView(lContainer, removeIndex) {
         viewToDetach[PARENT] = null;
         viewToDetach[NEXT] = null;
         // Unsets the attached flag
-        viewToDetach[FLAGS] &= ~64 /* LViewFlags.Attached */;
+        viewToDetach[FLAGS] &= ~128 /* LViewFlags.Attached */;
     }
     return viewToDetach;
 }
@@ -7304,7 +7308,7 @@ function detachView(lContainer, removeIndex) {
  * @param lView The view to be destroyed.
  */
 function destroyLView(tView, lView) {
-    if (!(lView[FLAGS] & 128 /* LViewFlags.Destroyed */)) {
+    if (!(lView[FLAGS] & 256 /* LViewFlags.Destroyed */)) {
         const renderer = lView[RENDERER];
         lView[REACTIVE_TEMPLATE_CONSUMER]?.destroy();
         lView[REACTIVE_HOST_BINDING_CONSUMER]?.destroy();
@@ -7323,16 +7327,16 @@ function destroyLView(tView, lView) {
  * @param lView The LView to clean up
  */
 function cleanUpView(tView, lView) {
-    if (!(lView[FLAGS] & 128 /* LViewFlags.Destroyed */)) {
+    if (!(lView[FLAGS] & 256 /* LViewFlags.Destroyed */)) {
         // Usually the Attached flag is removed when the view is detached from its parent, however
         // if it's a root view, the flag won't be unset hence why we're also removing on destroy.
-        lView[FLAGS] &= ~64 /* LViewFlags.Attached */;
+        lView[FLAGS] &= ~128 /* LViewFlags.Attached */;
         // Mark the LView as destroyed *before* executing the onDestroy hooks. An onDestroy hook
         // runs arbitrary user code, which could include its own `viewRef.destroy()` (or similar). If
         // We don't flag the view as destroyed before the hooks, this could lead to an infinite loop.
         // This also aligns with the ViewEngine behavior. It also means that the onDestroy hook is
         // really more of an "afterDestroy" hook if you think about it.
-        lView[FLAGS] |= 128 /* LViewFlags.Destroyed */;
+        lView[FLAGS] |= 256 /* LViewFlags.Destroyed */;
         executeOnDestroys(tView, lView);
         processCleanups(tView, lView);
         // For component views only, the local renderer is destroyed at clean up time.
@@ -9797,6 +9801,16 @@ const CSP_NONCE = new InjectionToken('CSP nonce', {
         return getDocument().body.querySelector('[ngCspNonce]')?.getAttribute('ngCspNonce') || null;
     },
 });
+/**
+ * Internal token to collect all SSR-related features enabled for this application.
+ *
+ * Note: the token is in `core` to let other packages register features (the `core`
+ * package is imported in other packages).
+ */
+const ENABLED_SSR_FEATURES = new InjectionToken((typeof ngDevMode === 'undefined' || ngDevMode) ? 'ENABLED_SSR_FEATURES' : '', {
+    providedIn: 'root',
+    factory: () => new Set(),
+});
 
 function escapeTransferStateContent(text) {
     const escapedText = {
@@ -10350,7 +10364,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('16.0.0-next.7');
+const VERSION = new Version('16.0.0-rc.0');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -10384,7 +10398,7 @@ const NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};
  */
 function markViewDirty(lView) {
     while (lView) {
-        lView[FLAGS] |= 32 /* LViewFlags.Dirty */;
+        lView[FLAGS] |= 64 /* LViewFlags.Dirty */;
         const parent = getLViewParent(lView);
         // Stop traversing up as soon as you find a root view that wasn't attached to any container
         if (isRootView(lView) && !parent) {
@@ -11088,10 +11102,10 @@ function renderChildComponents(hostLView, components) {
 function createLView(parentLView, tView, context, flags, host, tHostNode, environment, renderer, injector, embeddedViewInjector, hydrationInfo) {
     const lView = tView.blueprint.slice();
     lView[HOST] = host;
-    lView[FLAGS] = flags | 4 /* LViewFlags.CreationMode */ | 64 /* LViewFlags.Attached */ | 8 /* LViewFlags.FirstLViewPass */;
+    lView[FLAGS] = flags | 4 /* LViewFlags.CreationMode */ | 128 /* LViewFlags.Attached */ | 8 /* LViewFlags.FirstLViewPass */;
     if (embeddedViewInjector !== null ||
-        (parentLView && (parentLView[FLAGS] & 1024 /* LViewFlags.HasEmbeddedViewInjector */))) {
-        lView[FLAGS] |= 1024 /* LViewFlags.HasEmbeddedViewInjector */;
+        (parentLView && (parentLView[FLAGS] & 2048 /* LViewFlags.HasEmbeddedViewInjector */))) {
+        lView[FLAGS] |= 2048 /* LViewFlags.HasEmbeddedViewInjector */;
     }
     resetPreOrderHookFlags(lView);
     ngDevMode && tView.declTNode && parentLView && assertTNodeForLView(tView.declTNode, parentLView);
@@ -11277,7 +11291,7 @@ function renderView(tView, lView, context) {
 function refreshView(tView, lView, templateFn, context) {
     ngDevMode && assertEqual(isCreationMode(lView), false, 'Should be run in update mode');
     const flags = lView[FLAGS];
-    if ((flags & 128 /* LViewFlags.Destroyed */) === 128 /* LViewFlags.Destroyed */)
+    if ((flags & 256 /* LViewFlags.Destroyed */) === 256 /* LViewFlags.Destroyed */)
         return;
     // Check no changes mode is a dev only mode used to verify that bindings have not changed
     // since they were assigned. We do not want to execute lifecycle hooks in that mode.
@@ -11380,10 +11394,10 @@ function refreshView(tView, lView, templateFn, context) {
         // no changes cycle, the component would be not be dirty for the next update pass. This would
         // be different in production mode where the component dirty state is not reset.
         if (!isInCheckNoChangesPass) {
-            lView[FLAGS] &= ~(32 /* LViewFlags.Dirty */ | 8 /* LViewFlags.FirstLViewPass */);
+            lView[FLAGS] &= ~(64 /* LViewFlags.Dirty */ | 8 /* LViewFlags.FirstLViewPass */);
         }
-        if (lView[FLAGS] & 512 /* LViewFlags.RefreshTransplantedView */) {
-            lView[FLAGS] &= ~512 /* LViewFlags.RefreshTransplantedView */;
+        if (lView[FLAGS] & 1024 /* LViewFlags.RefreshTransplantedView */) {
+            lView[FLAGS] &= ~1024 /* LViewFlags.RefreshTransplantedView */;
             updateTransplantedViewCount(lView[PARENT], -1);
         }
     }
@@ -11835,7 +11849,7 @@ function markDirtyIfOnPush(lView, viewIndex) {
     ngDevMode && assertLView(lView);
     const childComponentLView = getComponentLViewByIndex(viewIndex, lView);
     if (!(childComponentLView[FLAGS] & 16 /* LViewFlags.CheckAlways */)) {
-        childComponentLView[FLAGS] |= 32 /* LViewFlags.Dirty */;
+        childComponentLView[FLAGS] |= 64 /* LViewFlags.Dirty */;
     }
 }
 function setNgReflectProperty(lView, element, type, attrName, value) {
@@ -12208,7 +12222,7 @@ function addComponentLogic(lView, hostTNode, def) {
     // Only component views should be added to the view tree directly. Embedded views are
     // accessed through their containers because they may be removed / re-added later.
     const rendererFactory = lView[ENVIRONMENT].rendererFactory;
-    const componentView = addToViewTree(lView, createLView(lView, tView, null, def.onPush ? 32 /* LViewFlags.Dirty */ : 16 /* LViewFlags.CheckAlways */, native, hostTNode, null, rendererFactory.createRenderer(native, def), null, null, null));
+    const componentView = addToViewTree(lView, createLView(lView, tView, null, def.onPush ? 64 /* LViewFlags.Dirty */ : 16 /* LViewFlags.CheckAlways */, native, hostTNode, null, rendererFactory.createRenderer(native, def), null, null, null));
     // Component view will always be created before any injected LContainers,
     // so this is a regular element, wrap it with the component view
     lView[hostTNode.index] = componentView;
@@ -12381,14 +12395,14 @@ function markTransplantedViewsForRefresh(lView) {
             ngDevMode && assertLContainer(insertionLContainer);
             // We don't want to increment the counter if the moved LView was already marked for
             // refresh.
-            if ((movedLView[FLAGS] & 512 /* LViewFlags.RefreshTransplantedView */) === 0) {
+            if ((movedLView[FLAGS] & 1024 /* LViewFlags.RefreshTransplantedView */) === 0) {
                 updateTransplantedViewCount(insertionLContainer, 1);
             }
             // Note, it is possible that the `movedViews` is tracking views that are transplanted *and*
             // those that aren't (declaration component === insertion component). In the latter case,
             // it's fine to add the flag, as we will clear it immediately in
             // `refreshEmbeddedViews` for the view currently being refreshed.
-            movedLView[FLAGS] |= 512 /* LViewFlags.RefreshTransplantedView */;
+            movedLView[FLAGS] |= 1024 /* LViewFlags.RefreshTransplantedView */;
         }
     }
 }
@@ -12404,7 +12418,7 @@ function refreshComponent(hostLView, componentHostIdx) {
     // Only attached components that are CheckAlways or OnPush and dirty should be refreshed
     if (viewAttachedToChangeDetector(componentView)) {
         const tView = componentView[TVIEW];
-        if (componentView[FLAGS] & (16 /* LViewFlags.CheckAlways */ | 32 /* LViewFlags.Dirty */)) {
+        if (componentView[FLAGS] & (16 /* LViewFlags.CheckAlways */ | 64 /* LViewFlags.Dirty */)) {
             refreshView(tView, componentView, tView.template, componentView[CONTEXT]);
         }
         else if (componentView[TRANSPLANTED_VIEWS_TO_REFRESH] > 0) {
@@ -12424,7 +12438,7 @@ function refreshContainsDirtyView(lView) {
         for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
             const embeddedLView = lContainer[i];
             if (viewAttachedToChangeDetector(embeddedLView)) {
-                if (embeddedLView[FLAGS] & 512 /* LViewFlags.RefreshTransplantedView */) {
+                if (embeddedLView[FLAGS] & 1024 /* LViewFlags.RefreshTransplantedView */) {
                     const embeddedTView = embeddedLView[TVIEW];
                     ngDevMode && assertDefined(embeddedTView, 'TView must be allocated');
                     refreshView(embeddedTView, embeddedLView, embeddedTView.template, embeddedLView[CONTEXT]);
@@ -12885,7 +12899,7 @@ class ViewRef {
         this._lView[CONTEXT] = value;
     }
     get destroyed() {
-        return (this._lView[FLAGS] & 128 /* LViewFlags.Destroyed */) === 128 /* LViewFlags.Destroyed */;
+        return (this._lView[FLAGS] & 256 /* LViewFlags.Destroyed */) === 256 /* LViewFlags.Destroyed */;
     }
     destroy() {
         if (this._appRef) {
@@ -12998,7 +13012,7 @@ class ViewRef {
      * ```
      */
     detach() {
-        this._lView[FLAGS] &= ~64 /* LViewFlags.Attached */;
+        this._lView[FLAGS] &= ~128 /* LViewFlags.Attached */;
     }
     /**
      * Re-attaches a view to the change detection tree.
@@ -13057,7 +13071,7 @@ class ViewRef {
      * ```
      */
     reattach() {
-        this._lView[FLAGS] |= 64 /* LViewFlags.Attached */;
+        this._lView[FLAGS] |= 128 /* LViewFlags.Attached */;
     }
     /**
      * Checks the view and its children.
@@ -13243,8 +13257,8 @@ class ComponentFactory extends ComponentFactory$1 {
         const hostRNode = rootSelectorOrNode ?
             locateHostElement(hostRenderer, rootSelectorOrNode, this.componentDef.encapsulation, rootViewInjector) :
             createElementNode(hostRenderer, elementName, getNamespace(elementName));
-        const rootFlags = this.componentDef.onPush ? 32 /* LViewFlags.Dirty */ | 256 /* LViewFlags.IsRoot */ :
-            16 /* LViewFlags.CheckAlways */ | 256 /* LViewFlags.IsRoot */;
+        const rootFlags = this.componentDef.onPush ? 64 /* LViewFlags.Dirty */ | 512 /* LViewFlags.IsRoot */ :
+            16 /* LViewFlags.CheckAlways */ | 512 /* LViewFlags.IsRoot */;
         // Create the root view. Uses empty TView and ContentTemplate.
         const rootTView = createTView(0 /* TViewType.Root */, null, null, 1, 0, null, null, null, null, null, null);
         const rootLView = createLView(null, rootTView, null, rootFlags, null, null, environment, hostRenderer, rootViewInjector, null, null);
@@ -13387,7 +13401,7 @@ function createRootComponentView(tNode, hostRNode, rootComponentDef, rootDirecti
         hydrationInfo = retrieveHydrationInfo(hostRNode, rootView[INJECTOR$1]);
     }
     const viewRenderer = environment.rendererFactory.createRenderer(hostRNode, rootComponentDef);
-    const componentView = createLView(rootView, getOrCreateComponentTView(rootComponentDef), null, rootComponentDef.onPush ? 32 /* LViewFlags.Dirty */ : 16 /* LViewFlags.CheckAlways */, rootView[tNode.index], tNode, environment, viewRenderer, null, null, hydrationInfo);
+    const componentView = createLView(rootView, getOrCreateComponentTView(rootComponentDef), null, rootComponentDef.onPush ? 64 /* LViewFlags.Dirty */ : 16 /* LViewFlags.CheckAlways */, rootView[tNode.index], tNode, environment, viewRenderer, null, null, hydrationInfo);
     if (tView.firstCreatePass) {
         markAsComponentHost(tView, tNode, rootDirectives.length - 1);
     }
@@ -14677,22 +14691,6 @@ function invalidSkipHydrationHost(rNode) {
     const message = header + actual + footer;
     return new RuntimeError(-504 /* RuntimeErrorCode.INVALID_SKIP_HYDRATION_HOST */, message);
 }
-/**
- * Builds the hydration error message in the case that a user is attempting to enable
- * hydration on internationalized nodes, which is not yet supported.
- *
- * @param rNode the HTML Element
- * @returns an error
- */
-function notYetSupportedI18nBlockError(rNode) {
-    const header = 'Hydration for nodes marked with `i18n` is not yet supported. ' +
-        'You can opt-out a component that uses `i18n` in a template using ' +
-        'the `ngSkipHydration` attribute or fall back to the previous ' +
-        'hydration logic (which re-creates the application structure).\n\n';
-    const actual = `${describeDomFromNode(rNode)}\n\n`;
-    const message = header + actual;
-    return new RuntimeError(518 /* RuntimeErrorCode.HYDRATION_I18N_NOT_YET_SUPPORTED */, message);
-}
 // Stringification methods
 /**
  * Stringifies a given TNode's attributes
@@ -21281,6 +21279,18 @@ function ɵɵi18nStart(index, messageIndex, subTemplateIndex = -1) {
     if (tView.firstCreatePass) {
         i18nStartFirstCreatePass(tView, parentTNode === null ? 0 : parentTNode.index, lView, adjustedIndex, message, subTemplateIndex);
     }
+    // Set a flag that this LView has i18n blocks.
+    // The flag is later used to determine whether this component should
+    // be hydrated (currently hydration is not supported for i18n blocks).
+    if (tView.type === 2 /* TViewType.Embedded */) {
+        // Annotate host component's LView (not embedded view's LView),
+        // since hydration can be skipped on per-component basis only.
+        const componentLView = lView[DECLARATION_COMPONENT_VIEW];
+        componentLView[FLAGS] |= 32 /* LViewFlags.HasI18n */;
+    }
+    else {
+        lView[FLAGS] |= 32 /* LViewFlags.HasI18n */;
+    }
     const tI18n = tView.data[adjustedIndex];
     const sameViewParentTNode = parentTNode === lView[T_HOST] ? null : parentTNode;
     const parentRNode = getClosestRElement(tView, sameViewParentTNode, lView);
@@ -21978,7 +21988,7 @@ function getOwningComponent(elementOrDir) {
     while (lView[TVIEW].type === 2 /* TViewType.Embedded */ && (parent = getLViewParent(lView))) {
         lView = parent;
     }
-    return lView[FLAGS] & 256 /* LViewFlags.IsRoot */ ? null : lView[CONTEXT];
+    return lView[FLAGS] & 512 /* LViewFlags.IsRoot */ ? null : lView[CONTEXT];
 }
 /**
  * Retrieves all root components associated with a DOM element, directive or component instance.