{
  "version": 3,
  "sources": ["../src/import/di/interface/provider.ts", "../src/import/errors.ts", "../src/import/render3/definition_factory.ts", "../src/import/render3/errors_di.ts", "../src/import/util/property.ts", "../src/import/render3/fields.ts", "../src/import/util/empty.ts", "../src/import/util/stringify.ts", "../src/import/di/forward_ref.ts", "../src/import/di/interface/defs.ts", "../src/import/di/injection_token.ts", "../src/import/di/initializer_token.ts", "../src/import/di/interface/injector.ts", "../src/import/di/inject_switch.ts", "../src/primitives/di/src/injector.ts", "../src/primitives/di/src/not_found.ts", "../src/import/di/injector_compatibility.ts", "../src/import/di/injector_token.ts", "../src/import/di/internal_tokens.ts", "../src/import/di/null_injector.ts", "../src/import/di/provider_collection.ts", "../src/import/di/scope.ts", "../src/import/di/r3_injector.ts", "../src/import/util/closure.ts", "../src/import/util/decorators.ts", "../src/import/di/metadata.ts", "../src/import/di/create_injector.ts", "../src/import/di/injector.ts", "../src/import/render3/instructions/di.ts", "../src/primitives/signals/src/equality.ts", "../src/primitives/signals/src/graph.ts", "../src/primitives/signals/src/computed.ts", "../src/primitives/signals/src/errors.ts", "../src/primitives/signals/src/signal.ts", "../src/primitives/signals/src/linked_signal.ts", "../src/primitives/signals/src/untracked.ts", "../src/import/render3/reactivity/api.ts", "../src/import/render3/reactivity/computed.ts", "../src/import/render3/reactivity/signal.ts", "../src/import/render3/reactivity/linked_signal.ts", "../src/import/render3/reactivity/untracked.ts", "../src/import/render3/reactivity/asserts.ts", "../src/import/linker/destroy_ref.ts", "../src/import/util/noop.ts", "../src/import/change_detection/scheduling/zoneless_scheduling.ts", "../src/import/render3/reactivity/root_effect_scheduler.ts", "../src/import/render3/reactivity/effect.ts", "../src/import/util/callback_scheduler.ts", "../src/import/change_detection/scheduling/zoneless_scheduling_impl.ts", "../src/import/pending_tasks.ts", "../src/import/error_handler.ts", "../src/import/resource/resource.ts", "../src/import/index.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.dev/license\n */\n\nimport { Type } from '../../interface/type';\n\n/**\n * Configures the `Injector` to return a value for a token.\n * Base for `ValueProvider` decorator.\n *\n * @publicApi\n */\nexport interface ValueSansProvider {\n  /**\n   * The value to inject.\n   */\n  useValue: any;\n}\n\n/**\n * Configures the `Injector` to return a value for a token.\n * @see [Dependency Injection Guide](guide/di/dependency-injection.\n *\n * @usageNotes\n *\n * ### Example\n *\n * {@example core/di/ts/provider_spec.ts region='ValueProvider'}\n *\n * ### Multi-value example\n *\n * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}\n *\n * @publicApi\n */\nexport interface ValueProvider extends ValueSansProvider {\n  /**\n   * An injection token. Typically an instance of `Type` or `InjectionToken`, but can be `any`.\n   */\n  provide: any;\n\n  /**\n   * When true, injector returns an array of instances. This is useful to allow multiple\n   * providers spread across many files to provide configuration information to a common token.\n   */\n  multi?: boolean;\n}\n\n/**\n * Configures the `Injector` to return an instance of `useClass` for a token.\n * Base for `StaticClassProvider` decorator.\n *\n * @publicApi\n */\nexport interface StaticClassSansProvider {\n  /**\n   * An optional class to instantiate for the `token`. By default, the `provide`\n   * class is instantiated.\n   */\n  useClass: Type<any>;\n\n  /**\n   * A list of `token`s to be resolved by the injector. The list of values is then\n   * used as arguments to the `useClass` constructor.\n   */\n  deps: any[];\n}\n\n/**\n * Configures the `Injector` to return an instance of `useClass` for a token.\n * @see [Dependency Injection Guide](guide/di/dependency-injection.\n *\n * @usageNotes\n *\n * {@example core/di/ts/provider_spec.ts region='StaticClassProvider'}\n *\n * Note that following two providers are not equal:\n *\n * {@example core/di/ts/provider_spec.ts region='StaticClassProviderDifference'}\n *\n * ### Multi-value example\n *\n * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}\n *\n * @publicApi\n */\nexport interface StaticClassProvider extends StaticClassSansProvider {\n  /**\n   * An injection token. Typically an instance of `Type` or `InjectionToken`, but can be `any`.\n   */\n  provide: any;\n\n  /**\n   * When true, injector returns an array of instances. This is useful to allow multiple\n   * providers spread across many files to provide configuration information to a common token.\n   */\n  multi?: boolean;\n}\n\n/**\n * Configures the `Injector` to return an instance of a token.\n *\n * @see [Dependency Injection Guide](guide/di/dependency-injection.\n *\n * @usageNotes\n *\n * ```ts\n * @Injectable(SomeModule, {deps: []})\n * class MyService {}\n * ```\n *\n * @publicApi\n */\nexport interface ConstructorSansProvider {\n  /**\n   * A list of `token`s to be resolved by the injector.\n   */\n  deps?: any[];\n}\n\n/**\n * Configures the `Injector` to return an instance of a token.\n *\n * @see [Dependency Injection Guide](guide/di/dependency-injection.\n *\n * @usageNotes\n *\n * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}\n *\n * ### Multi-value example\n *\n * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}\n *\n * @publicApi\n */\nexport interface ConstructorProvider extends ConstructorSansProvider {\n  /**\n   * An injection token. Typically an instance of `Type` or `InjectionToken`, but can be `any`.\n   */\n  provide: Type<any>;\n\n  /**\n   * When true, injector returns an array of instances. This is useful to allow multiple\n   * providers spread across many files to provide configuration information to a common token.\n   */\n  multi?: boolean;\n}\n\n/**\n * Configures the `Injector` to return a value of another `useExisting` token.\n *\n * @see {@link ExistingProvider}\n * @see [Dependency Injection Guide](guide/di/dependency-injection.\n *\n * @publicApi\n */\nexport interface ExistingSansProvider {\n  /**\n   * Existing `token` to return. (Equivalent to `injector.get(useExisting)`)\n   */\n  useExisting: any;\n}\n\n/**\n * Configures the `Injector` to return a value of another `useExisting` token.\n *\n * @see [Dependency Injection Guide](guide/di/dependency-injection.\n *\n * @usageNotes\n *\n * {@example core/di/ts/provider_spec.ts region='ExistingProvider'}\n *\n * ### Multi-value example\n *\n * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}\n *\n * @publicApi\n */\nexport interface ExistingProvider extends ExistingSansProvider {\n  /**\n   * An injection token. Typically an instance of `Type` or `InjectionToken`, but can be `any`.\n   */\n  provide: any;\n\n  /**\n   * When true, injector returns an array of instances. This is useful to allow multiple\n   * providers spread across many files to provide configuration information to a common token.\n   */\n  multi?: boolean;\n}\n\n/**\n * Configures the `Injector` to return a value by invoking a `useFactory` function.\n *\n * @see {@link FactoryProvider}\n * @see [Dependency Injection Guide](guide/di/dependency-injection.\n *\n * @publicApi\n */\nexport interface FactorySansProvider {\n  /**\n   * A function to invoke to create a value for this `token`. The function is invoked with\n   * resolved values of `token`s in the `deps` field.\n   */\n  useFactory: Function;\n\n  /**\n   * A list of `token`s to be resolved by the injector. The list of values is then\n   * used as arguments to the `useFactory` function.\n   */\n  deps?: any[];\n}\n\n/**\n * Configures the `Injector` to return a value by invoking a `useFactory` function.\n * @see [Dependency Injection Guide](guide/di/dependency-injection.\n *\n * @usageNotes\n *\n * {@example core/di/ts/provider_spec.ts region='FactoryProvider'}\n *\n * Dependencies can also be marked as optional:\n *\n * {@example core/di/ts/provider_spec.ts region='FactoryProviderOptionalDeps'}\n *\n * ### Multi-value example\n *\n * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}\n *\n * @publicApi\n */\nexport interface FactoryProvider extends FactorySansProvider {\n  /**\n   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).\n   */\n  provide: any;\n\n  /**\n   * When true, injector returns an array of instances. This is useful to allow multiple\n   * providers spread across many files to provide configuration information to a common token.\n   */\n  multi?: boolean;\n}\n\n/**\n * Describes how an `Injector` should be configured as static (that is, without reflection).\n * A static provider provides tokens to an injector for various types of dependencies.\n *\n * @see {@link Injector.create()}\n * @see [Dependency Injection Guide](guide/di/dependency-injection-providers).\n *\n * @publicApi\n */\nexport type StaticProvider = ValueProvider | ExistingProvider | StaticClassProvider | ConstructorProvider | FactoryProvider | any[];\n\n/**\n * Configures the `Injector` to return an instance of `Type` when `Type' is used as the token.\n *\n * Create an instance by invoking the `new` operator and supplying additional arguments.\n * This form is a short form of `TypeProvider`;\n *\n * For more details, see the [\"Dependency Injection Guide\"](guide/di/dependency-injection.\n *\n * @usageNotes\n *\n * {@example core/di/ts/provider_spec.ts region='TypeProvider'}\n *\n * @publicApi\n */\nexport interface TypeProvider extends Type<any> {}\n\n/**\n * Configures the `Injector` to return a value by invoking a `useClass` function.\n * Base for `ClassProvider` decorator.\n *\n * @see [Dependency Injection Guide](guide/di/dependency-injection.\n *\n * @publicApi\n */\nexport interface ClassSansProvider {\n  /**\n   * Class to instantiate for the `token`.\n   */\n  useClass: Type<any>;\n}\n\n/**\n * Configures the `Injector` to return an instance of `useClass` for a token.\n * @see [Dependency Injection Guide](guide/di/dependency-injection.\n *\n * @usageNotes\n *\n * {@example core/di/ts/provider_spec.ts region='ClassProvider'}\n *\n * Note that following two providers are not equal:\n *\n * {@example core/di/ts/provider_spec.ts region='ClassProviderDifference'}\n *\n * ### Multi-value example\n *\n * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}\n *\n * @publicApi\n */\nexport interface ClassProvider extends ClassSansProvider {\n  /**\n   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).\n   */\n  provide: any;\n\n  /**\n   * When true, injector returns an array of instances. This is useful to allow multiple\n   * providers spread across many files to provide configuration information to a common token.\n   */\n  multi?: boolean;\n}\n\n/**\n * Describes how the `Injector` should be configured.\n * @see [Dependency Injection Guide](guide/di/dependency-injection.\n *\n * @see {@link StaticProvider}\n *\n * @publicApi\n */\nexport type Provider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | any[];\n\n/**\n * Encapsulated `Provider`s that are only accepted during creation of an `EnvironmentInjector` (e.g.\n * in an `NgModule`).\n *\n * Using this wrapper type prevents providers which are only designed to work in\n * application/environment injectors from being accidentally included in\n * `@Component.providers` and ending up in a component injector.\n *\n * This wrapper type prevents access to the `Provider`s inside.\n *\n * @see {@link makeEnvironmentProviders}\n * @see {@link importProvidersFrom}\n *\n * @publicApi\n */\nexport type EnvironmentProviders = {\n  ɵbrand: 'EnvironmentProviders';\n};\n\nexport interface InternalEnvironmentProviders extends EnvironmentProviders {\n  ɵproviders: (Provider | EnvironmentProviders)[];\n\n  /**\n   * If present, indicates that the `EnvironmentProviders` were derived from NgModule providers.\n   *\n   * This is used to produce clearer error messages.\n   */\n  ɵfromNgModule?: true;\n}\n\nexport function isEnvironmentProviders(value: Provider | EnvironmentProviders | InternalEnvironmentProviders): value is InternalEnvironmentProviders {\n  return value && !!(value as InternalEnvironmentProviders).ɵproviders;\n}\n\n/**\n * Describes a function that is used to process provider lists (such as provider\n * overrides).\n */\nexport type ProcessProvidersFunction = (providers: Provider[]) => Provider[];\n\n/**\n * A wrapper around an NgModule that associates it with providers\n * Usage without a generic type is deprecated.\n *\n * @publicApi\n */\nexport interface ModuleWithProviders<T> {\n  ngModule: Type<T>;\n  providers?: Array<Provider | EnvironmentProviders>;\n}\n\n/**\n * Providers that were imported from NgModules via the `importProvidersFrom` function.\n *\n * These providers are meant for use in an application injector (or other environment injectors) and\n * should not be used in component injectors.\n *\n * This type cannot be directly implemented. It's returned from the `importProvidersFrom` function\n * and serves to prevent the extracted NgModule providers from being used in the wrong contexts.\n *\n * @see {@link importProvidersFrom}\n *\n * @publicApi\n * @deprecated replaced by `EnvironmentProviders`\n */\nexport type ImportedNgModuleProviders = EnvironmentProviders;\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.dev/license\n */\n\n/**\n * The list of error codes used in runtime code of the `core` package.\n * Reserved error code range: 100-999.\n *\n * Note: the minus sign denotes the fact that a particular code has a detailed guide on\n * angular.io. This extra annotation is needed to avoid introducing a separate set to store\n * error codes which have guides, which might leak into runtime code.\n *\n * Full list of available error guides can be found at https://angular.dev/errors.\n *\n * Error code ranges per package:\n *  - core (this package): 100-999\n *  - forms: 1000-1999\n *  - common: 2000-2999\n *  - animations: 3000-3999\n *  - router: 4000-4999\n *  - platform-browser: 5000-5500\n */\nexport const enum RuntimeErrorCode {\n  // Change Detection Errors\n  EXPRESSION_CHANGED_AFTER_CHECKED = -100,\n  RECURSIVE_APPLICATION_REF_TICK = 101,\n  INFINITE_CHANGE_DETECTION = 103,\n\n  // Dependency Injection Errors\n  CYCLIC_DI_DEPENDENCY = -200,\n  PROVIDER_NOT_FOUND = -201,\n  INVALID_FACTORY_DEPENDENCY = 202,\n  MISSING_INJECTION_CONTEXT = -203,\n  INVALID_INJECTION_TOKEN = 204,\n  INJECTOR_ALREADY_DESTROYED = 205,\n  PROVIDER_IN_WRONG_CONTEXT = 207,\n  MISSING_INJECTION_TOKEN = 208,\n  INVALID_MULTI_PROVIDER = -209,\n  MISSING_DOCUMENT = 210,\n\n  // Template Errors\n  MULTIPLE_COMPONENTS_MATCH = -300,\n  EXPORT_NOT_FOUND = -301,\n  PIPE_NOT_FOUND = -302,\n  UNKNOWN_BINDING = 303,\n  UNKNOWN_ELEMENT = 304,\n  TEMPLATE_STRUCTURE_ERROR = 305,\n  INVALID_EVENT_BINDING = 306,\n  HOST_DIRECTIVE_UNRESOLVABLE = 307,\n  HOST_DIRECTIVE_NOT_STANDALONE = 308,\n  DUPLICATE_DIRECTIVE = 309,\n  HOST_DIRECTIVE_COMPONENT = 310,\n  HOST_DIRECTIVE_UNDEFINED_BINDING = 311,\n  HOST_DIRECTIVE_CONFLICTING_ALIAS = 312,\n  MULTIPLE_MATCHING_PIPES = 313,\n  UNINITIALIZED_LET_ACCESS = 314,\n  NO_BINDING_TARGET = 315,\n  INVALID_BINDING_TARGET = 316,\n  INVALID_SET_INPUT_CALL = 317,\n\n  // Bootstrap Errors\n  MULTIPLE_PLATFORMS = 400,\n  PLATFORM_NOT_FOUND = 401,\n  MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP = 402,\n  BOOTSTRAP_COMPONENTS_NOT_FOUND = -403,\n  PLATFORM_ALREADY_DESTROYED = 404,\n  ASYNC_INITIALIZERS_STILL_RUNNING = 405,\n  APPLICATION_REF_ALREADY_DESTROYED = 406,\n  RENDERER_NOT_FOUND = 407,\n  PROVIDED_BOTH_ZONE_AND_ZONELESS = 408,\n\n  // Hydration Errors\n  HYDRATION_NODE_MISMATCH = -500,\n  HYDRATION_MISSING_SIBLINGS = -501,\n  HYDRATION_MISSING_NODE = -502,\n  UNSUPPORTED_PROJECTION_DOM_NODES = -503,\n  INVALID_SKIP_HYDRATION_HOST = -504,\n  MISSING_HYDRATION_ANNOTATIONS = -505,\n  HYDRATION_STABLE_TIMEDOUT = -506,\n  MISSING_SSR_CONTENT_INTEGRITY_MARKER = -507,\n  MISCONFIGURED_INCREMENTAL_HYDRATION = 508,\n\n  // Signal Errors\n  SIGNAL_WRITE_FROM_ILLEGAL_CONTEXT = 600,\n  REQUIRE_SYNC_WITHOUT_SYNC_EMIT = 601,\n  ASSERTION_NOT_INSIDE_REACTIVE_CONTEXT = -602,\n\n  // Styling Errors\n\n  // Declarations Errors\n\n  // i18n Errors\n  INVALID_I18N_STRUCTURE = 700,\n  MISSING_LOCALE_DATA = 701,\n\n  // Defer errors (750-799 range)\n  DEFER_LOADING_FAILED = -750,\n  DEFER_IN_HMR_MODE = -751,\n\n  // standalone errors\n  IMPORT_PROVIDERS_FROM_STANDALONE = 800,\n\n  // JIT Compilation Errors\n  // Other\n  INVALID_DIFFER_INPUT = 900,\n  NO_SUPPORTING_DIFFER_FACTORY = 901,\n  VIEW_ALREADY_ATTACHED = 902,\n  INVALID_INHERITANCE = 903,\n  UNSAFE_VALUE_IN_RESOURCE_URL = 904,\n  UNSAFE_VALUE_IN_SCRIPT = 905,\n  MISSING_GENERATED_DEF = 906,\n  TYPE_IS_NOT_STANDALONE = 907,\n  MISSING_ZONEJS = 908,\n  UNEXPECTED_ZONE_STATE = 909,\n  UNSAFE_IFRAME_ATTRS = -910,\n  VIEW_ALREADY_DESTROYED = 911,\n  COMPONENT_ID_COLLISION = -912,\n  IMAGE_PERFORMANCE_WARNING = -913,\n  UNEXPECTED_ZONEJS_PRESENT_IN_ZONELESS_MODE = 914,\n  MISSING_NG_MODULE_DEFINITION = 915,\n  MISSING_DIRECTIVE_DEFINITION = 916,\n  NO_COMPONENT_FACTORY_FOUND = 917,\n\n  // Signal integration errors\n  REQUIRED_INPUT_NO_VALUE = -950,\n  REQUIRED_QUERY_NO_VALUE = -951,\n  REQUIRED_MODEL_NO_VALUE = 952,\n\n  // Output()\n  OUTPUT_REF_DESTROYED = 953,\n\n  // Repeater errors\n  LOOP_TRACK_DUPLICATE_KEYS = -955,\n  LOOP_TRACK_RECREATE = -956,\n\n  // Runtime dependency tracker errors\n  RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 980,\n  RUNTIME_DEPS_ORPHAN_COMPONENT = 981,\n\n  // Resource errors\n  MUST_PROVIDE_STREAM_OPTION = 990,\n  RESOURCE_COMPLETED_BEFORE_PRODUCING_VALUE = 991,\n\n  // Upper bounds for core runtime errors is 999\n}\n\n/**\n * Class that represents a runtime error.\n * Formats and outputs the error message in a consistent way.\n *\n * Example:\n * ```ts\n *  throw new RuntimeError(\n *    RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED,\n *    ngDevMode && 'Injector has already been destroyed.');\n * ```\n *\n * Note: the `message` argument contains a descriptive error message as a string in development\n * mode (when the `ngDevMode` is defined). In production mode (after tree-shaking pass), the\n * `message` argument becomes `false`, thus we account for it in the typings and the runtime\n * logic.\n */\nexport class RuntimeError<T extends number = RuntimeErrorCode> extends Error {\n  constructor(\n    public code: T,\n    message: null | false | string,\n  ) {\n    super(formatRuntimeError<T>(code, message));\n  }\n}\n\nexport function formatRuntimeErrorCode<T extends number = RuntimeErrorCode>(code: T): string {\n  // Error code might be a negative number, which is a special marker that instructs the logic to\n  // generate a link to the error details page on angular.io.\n  // We also prepend `0` to non-compile-time errors.\n  return `NG0${Math.abs(code)}`;\n}\n\n/**\n * Called to format a runtime error.\n * See additional info on the `message` argument type in the `RuntimeError` class description.\n */\nexport function formatRuntimeError<T extends number = RuntimeErrorCode>(code: T, message: null | false | string): string {\n  const fullCode = formatRuntimeErrorCode(code);\n\n  const errorMessage = `${fullCode}${message ? ': ' + message : ''}`;\n\n  if (false) {\n  }\n  return errorMessage;\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.dev/license\n */\n\nimport { Type } from '../interface/type';\n\n/**\n * Definition of what a factory function should look like.\n */\nexport type FactoryFn<T> = {\n  /**\n   * Subclasses without an explicit constructor call through to the factory of their base\n   * definition, providing it with their own constructor to instantiate.\n   */\n  <U extends T>(t?: Type<U>): U;\n\n  /**\n   * If no constructor to instantiate is provided, an instance of type T itself is created.\n   */\n  (t?: undefined): T;\n};\n\nexport function getFactoryDef<T>(type: any, throwNotFound: true): FactoryFn<T>;\nexport function getFactoryDef<T>(type: any): FactoryFn<T> | null;\nexport function getFactoryDef<T>(type: any, throwNotFound?: boolean): FactoryFn<T> | null {\n  return () => new type();\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.dev/license\n */\n\nimport type { ProviderToken } from '../di';\nimport { RuntimeError, RuntimeErrorCode } from '../errors';\n\n/** Called when directives inject each other (creating a circular dependency) */\nexport function throwCyclicDependencyError(token: string, path?: string[]): never {\n  throw new RuntimeError(RuntimeErrorCode.CYCLIC_DI_DEPENDENCY, token);\n}\n\n/** Throws an error when a token is not found in DI. */\nexport function throwProviderNotFoundError(token: ProviderToken<unknown>, injectorName?: string): never {\n  const errorMessage = undefined as any;\n  throw new RuntimeError(RuntimeErrorCode.PROVIDER_NOT_FOUND, errorMessage);\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.dev/license\n */\n\nexport function getClosureSafeProperty<T>(objWithPropertyToExtract: T): string {\n  for (const key in objWithPropertyToExtract) {\n    if (objWithPropertyToExtract[key] === (getClosureSafeProperty as any)) {\n      return key;\n    }\n  }\n  // Cannot change it to `RuntimeError` because the `util` target cannot\n  // circularly depend on the `core` target.\n  throw Error('');\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.dev/license\n */\n\nimport { getClosureSafeProperty } from '../util/property';\nexport const NG_FACTORY_DEF: string = getClosureSafeProperty({ ɵfac: getClosureSafeProperty });\n\n/**\n * The `NG_ENV_ID` field on a DI token indicates special processing in the `EnvironmentInjector`:\n * getting such tokens from the `EnvironmentInjector` will bypass the standard DI resolution\n * strategy and instead will return implementation produced by the `NG_ENV_ID` factory function.\n *\n * This particular retrieval of DI tokens is mostly done to eliminate circular dependencies and\n * improve tree-shaking.\n */\nexport const NG_ENV_ID: string = getClosureSafeProperty({ __NG_ENV_ID__: getClosureSafeProperty });\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.dev/license\n */\n\n/**\n * This file contains reuseable \"empty\" symbols that can be used as default return values\n * in different parts of the rendering code. Because the same symbols are returned, this\n * allows for identity checks against these values to be consistently used by the framework\n * code.\n */\n\nexport const EMPTY_OBJ: never = {} as never;\nexport const EMPTY_ARRAY: any[] = [];\n\n// freezing the values prevents any code from accidentally inserting new values in\nif (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.dev/license\n */\n\nexport function stringify(token: any): string {\n  if (typeof token === 'string') {\n    return token;\n  }\n\n  if (Array.isArray(token)) {\n    return `[${token.map(stringify).join(', ')}]`;\n  }\n\n  if (token == null) {\n    return '' + token;\n  }\n\n  const name = token.overriddenName || token.name;\n  if (name) {\n    return `${name}`;\n  }\n\n  const result = token.toString();\n\n  if (result == null) {\n    return '' + result;\n  }\n\n  const newLineIndex = result.indexOf('\\n');\n  return newLineIndex >= 0 ? result.slice(0, newLineIndex) : result;\n}\n\n/**\n * Ellipses the string in the middle when longer than the max length\n *\n * @param string\n * @param maxLength of the output string\n * @returns ellipsed string with ... in the middle\n */\nexport function truncateMiddle(str: string, maxLength = 100): string {\n  if (!str || maxLength < 1 || str.length <= maxLength) return str;\n  if (maxLength == 1) return str.substring(0, 1) + '...';\n\n  const halfLimit = Math.round(maxLength / 2);\n  return str.substring(0, halfLimit) + '...' + str.substring(str.length - halfLimit);\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.dev/license\n */\n\nimport { Type } from '../interface/type';\nimport { getClosureSafeProperty } from '../util/property';\nimport { stringify } from '../util/stringify';\n\n/**\n * An interface that a function passed into `forwardRef` has to implement.\n *\n * @usageNotes\n * ### Example\n *\n * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref_fn'}\n * @publicApi\n */\nexport interface ForwardRefFn {\n  (): any;\n}\n\nconst __forward_ref__ = getClosureSafeProperty({ __forward_ref__: getClosureSafeProperty });\n\n/**\n * Allows to refer to references which are not yet defined.\n *\n * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of\n * DI is declared, but not yet defined. It is also used when the `token` which we use when creating\n * a query is not yet defined.\n *\n * `forwardRef` is also used to break circularities in standalone components imports.\n *\n * @usageNotes\n * ### Circular dependency example\n * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}\n *\n * ### Circular standalone reference import example\n * ```angular-ts\n * @Component({\n *   imports: [ChildComponent],\n *   selector: 'app-parent',\n *   template: `<app-child [hideParent]=\"hideParent()\"></app-child>`,\n * })\n * export class ParentComponent {\n *    hideParent = input.required<boolean>();\n * }\n *\n *\n * @Component({\n *   imports: [forwardRef(() => ParentComponent)],\n *   selector: 'app-child',\n *   template: `\n *    @if(!hideParent() {\n *       <app-parent/>\n *    }\n *  `,\n * })\n * export class ChildComponent {\n *    hideParent = input.required<boolean>();\n * }\n * ```\n *\n * @publicApi\n */\nexport function forwardRef(forwardRefFn: ForwardRefFn): Type<any> {\n  (<any>forwardRefFn).__forward_ref__ = forwardRef;\n  (<any>forwardRefFn).toString = function () {\n    return stringify(this());\n  };\n  return <Type<any>>(<any>forwardRefFn);\n}\n\n/**\n * Lazily retrieves the reference value from a forwardRef.\n *\n * Acts as the identity function when given a non-forward-ref value.\n *\n * @usageNotes\n * ### Example\n *\n * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}\n *\n * @see {@link forwardRef}\n * @publicApi\n */\nexport function resolveForwardRef<T>(type: T): T {\n  return isForwardRef(type) ? type() : type;\n}\n\n/** Checks whether a function is wrapped by a `forwardRef`. */\nexport function isForwardRef(fn: any): fn is () => any {\n  return typeof fn === 'function' && fn.hasOwnProperty(__forward_ref__) && fn.__forward_ref__ === forwardRef;\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.dev/license\n */\n\nimport { Type } from '../../interface/type';\nimport { getClosureSafeProperty } from '../../util/property';\n\nimport { ClassProvider, ConstructorProvider, EnvironmentProviders, ExistingProvider, FactoryProvider, StaticClassProvider, ValueProvider } from './provider';\n\n/**\n * Information about how a type or `InjectionToken` interfaces with the DI system.\n *\n * At a minimum, this includes a `factory` which defines how to create the given type `T`, possibly\n * requesting injection of other types if necessary.\n *\n * Optionally, a `providedIn` parameter specifies that the given type belongs to a particular\n * `Injector`, `NgModule`, or a special scope (e.g. `'root'`). A value of `null` indicates\n * that the injectable does not belong to any scope.\n *\n * @codeGenApi\n * @publicApi The ViewEngine compiler emits code with this type for injectables. This code is\n *   deployed to npm, and should be treated as public api.\n\n */\nexport interface ɵɵInjectableDeclaration<T> {\n  /**\n   * Specifies that the given type belongs to a particular injector:\n   * - `InjectorType` such as `NgModule`,\n   * - `'root'` the root injector\n   * - `'any'` all injectors.\n   * - `null`, does not belong to any injector. Must be explicitly listed in the injector\n   *   `providers`.\n   */\n  providedIn: InjectorType<any> | 'root' | 'platform' | 'any' | 'environment' | null;\n\n  /**\n   * The token to which this definition belongs.\n   *\n   * Note that this may not be the same as the type that the `factory` will create.\n   */\n  token: unknown;\n\n  /**\n   * Factory method to execute to create an instance of the injectable.\n   */\n  factory: (t?: Type<any>) => T;\n\n  /**\n   * In a case of no explicit injector, a location where the instance of the injectable is stored.\n   */\n  value: T | undefined;\n}\n\n/**\n * Information about the providers to be included in an `Injector` as well as how the given type\n * which carries the information should be created by the DI system.\n *\n * An `InjectorDef` can import other types which have `InjectorDefs`, forming a deep nested\n * structure of providers with a defined priority (identically to how `NgModule`s also have\n * an import/dependency structure).\n *\n * NOTE: This is a private type and should not be exported\n *\n * @codeGenApi\n */\nexport interface ɵɵInjectorDef<T> {\n  // TODO(alxhub): Narrow down the type here once decorators properly change the return type of the\n  // class they are decorating (to add the ɵprov property for example).\n  providers: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | EnvironmentProviders | any[])[];\n\n  imports: (InjectorType<any> | InjectorTypeWithProviders<any>)[];\n}\n\n/**\n * A `Type` which has a `ɵprov: ɵɵInjectableDeclaration` static field.\n *\n * `InjectableType`s contain their own Dependency Injection metadata and are usable in an\n * `InjectorDef`-based `StaticInjector`.\n *\n * @publicApi\n */\nexport interface InjectableType<T> extends Type<T> {\n  /**\n   * Opaque type whose structure is highly version dependent. Do not rely on any properties.\n   */\n  ɵprov: unknown;\n}\n\n/**\n * A type which has an `InjectorDef` static field.\n *\n * `InjectorTypes` can be used to configure a `StaticInjector`.\n *\n * This is an opaque type whose structure is highly version dependent. Do not rely on any\n * properties.\n *\n * @publicApi\n */\nexport interface InjectorType<T> extends Type<T> {\n  ɵfac?: unknown;\n}\n\n/**\n * Describes the `InjectorDef` equivalent of a `ModuleWithProviders`, an `InjectorType` with an\n * associated array of providers.\n *\n * Objects of this type can be listed in the imports section of an `InjectorDef`.\n *\n * NOTE: This is a private type and should not be exported\n */\nexport interface InjectorTypeWithProviders<T> {\n  ngModule: InjectorType<T>;\n  providers?: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | EnvironmentProviders | any[])[];\n}\n\n/**\n * Construct an injectable definition which defines how a token will be constructed by the DI\n * system, and in which injectors (if any) it will be available.\n *\n * This should be assigned to a static `ɵprov` field on a type, which will then be an\n * `InjectableType`.\n *\n * Options:\n * * `providedIn` determines which injectors will include the injectable, by either associating it\n *   with an `@NgModule` or other `InjectorType`, or by specifying that this injectable should be\n *   provided in the `'root'` injector, which will be the application-level injector in most apps.\n * * `factory` gives the zero argument function which will create an instance of the injectable.\n *   The factory can call [`inject`](api/core/inject) to access the `Injector` and request injection\n * of dependencies.\n *\n * @codeGenApi\n * @publicApi This instruction has been emitted by ViewEngine for some time and is deployed to npm.\n */\nexport function ɵɵdefineInjectable<T>(opts: { token: unknown; providedIn?: Type<any> | 'root' | 'platform' | 'any' | 'environment' | null; factory: () => T }): unknown {\n  return {\n    token: opts.token,\n    providedIn: (opts.providedIn as any) || null,\n    factory: opts.factory,\n    value: undefined,\n  } as ɵɵInjectableDeclaration<T>;\n}\n\n/**\n * Construct an `InjectorDef` which configures an injector.\n *\n * This should be assigned to a static injector def (`ɵinj`) field on a type, which will then be an\n * `InjectorType`.\n *\n * Options:\n *\n * * `providers`: an optional array of providers to add to the injector. Each provider must\n *   either have a factory or point to a type which has a `ɵprov` static property (the\n *   type must be an `InjectableType`).\n * * `imports`: an optional array of imports of other `InjectorType`s or `InjectorTypeWithModule`s\n *   whose providers will also be added to the injector. Locally provided types will override\n *   providers from imports.\n *\n * @codeGenApi\n */\nexport function ɵɵdefineInjector(options: { providers?: any[]; imports?: any[] }): unknown {\n  return { providers: options.providers || [], imports: options.imports || [] };\n}\n\n/**\n * Read the injectable def (`ɵprov`) for `type` in a way which is immune to accidentally reading\n * inherited value.\n *\n * @param type A type which may have its own (non-inherited) `ɵprov`.\n */\nexport function getInjectableDef<T>(type: any): ɵɵInjectableDeclaration<T> | null {\n  return getOwnDefinition(type, NG_PROV_DEF) || { token: type, factory: () => new type(), ...type.injectOptions };\n}\n\nexport function isInjectable(type: any): boolean {\n  return getInjectableDef(type) !== null;\n}\n\n/**\n * Return definition only if it is defined directly on `type` and is not inherited from a base\n * class of `type`.\n */\nfunction getOwnDefinition<T>(type: any, field: string): ɵɵInjectableDeclaration<T> | null {\n  // if the ɵprov prop exist but is undefined we still want to return null\n  return (type.hasOwnProperty(field) && type[field]) || null;\n}\n\n/**\n * Read the injectable def (`ɵprov`) for `type` or read the `ɵprov` from one of its ancestors.\n *\n * @param type A type which may have `ɵprov`, via inheritance.\n *\n * @deprecated Will be removed in a future version of Angular, where an error will occur in the\n *     scenario if we find the `ɵprov` on an ancestor only.\n */\nexport function getInheritedInjectableDef<T>(type: any): ɵɵInjectableDeclaration<T> | null {\n  // if the ɵprov prop exist but is undefined we still want to return null\n  const def = type?.[NG_PROV_DEF] ?? null;\n\n  if (def) {\n    undefined as any;\n    return def;\n  } else {\n    return null;\n  }\n}\n\n/**\n * Read the injector def type in a way which is immune to accidentally reading inherited value.\n *\n * @param type type which may have an injector def (`ɵinj`)\n */\nexport function getInjectorDef<T>(type: any): ɵɵInjectorDef<T> | null {\n  return type && type.hasOwnProperty(NG_INJ_DEF) ? (type as any)[NG_INJ_DEF] : null;\n}\n\nexport const NG_PROV_DEF: string = getClosureSafeProperty({ ɵprov: getClosureSafeProperty });\nexport const NG_INJ_DEF: string = getClosureSafeProperty({ ɵinj: getClosureSafeProperty });\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.dev/license\n */\n\nimport { Type } from '../interface/type';\n\nimport { ɵɵdefineInjectable } from './interface/defs';\n\n/**\n * Creates a token that can be used in a DI Provider.\n *\n * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a\n * runtime representation) such as when injecting an interface, callable type, array or\n * parameterized type.\n *\n * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by\n * the `Injector`. This provides an additional level of type safety.\n *\n * <div class=\"docs-alert docs-alert-helpful\">\n *\n * **Important Note**: Ensure that you use the same instance of the `InjectionToken` in both the\n * provider and the injection call. Creating a new instance of `InjectionToken` in different places,\n * even with the same description, will be treated as different tokens by Angular's DI system,\n * leading to a `NullInjectorError`.\n *\n * </div>\n *\n * {@example injection-token/src/main.ts region='InjectionToken'}\n *\n * When creating an `InjectionToken`, you can optionally specify a factory function which returns\n * (possibly by creating) a default value of the parameterized type `T`. This sets up the\n * `InjectionToken` using this factory as a provider as if it was defined explicitly in the\n * application's root injector. If the factory function, which takes zero arguments, needs to inject\n * dependencies, it can do so using the [`inject`](api/core/inject) function.\n * As you can see in the Tree-shakable InjectionToken example below.\n *\n * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which\n * overrides the above behavior and marks the token as belonging to a particular `@NgModule` (note:\n * this option is now deprecated). As mentioned above, `'root'` is the default value for\n * `providedIn`.\n *\n * The `providedIn: NgModule` and `providedIn: 'any'` options are deprecated.\n *\n * @usageNotes\n * ### Basic Examples\n *\n * ### Plain InjectionToken\n *\n * {@example core/di/ts/injector_spec.ts region='InjectionToken'}\n *\n * ### Tree-shakable InjectionToken\n *\n * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}\n *\n * @publicApi\n */\nexport class InjectionToken<T> {\n  /** @internal */\n  readonly ngMetadataName = 'InjectionToken';\n\n  readonly ɵprov: unknown;\n\n  /**\n   * @param _desc   Description for the token,\n   *                used only for debugging purposes,\n   *                it should but does not need to be unique\n   * @param options Options for the token's usage, as described above\n   */\n  constructor(\n    protected _desc: string,\n    options?: {\n      providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;\n      factory: () => T;\n    },\n  ) {\n    this.ɵprov = undefined;\n    if (typeof options === 'number') {\n      undefined as any;\n      // This is a special hack to assign __NG_ELEMENT_ID__ to this instance.\n      // See `InjectorMarkers`\n    } else if (options !== undefined) {\n      this.ɵprov = ɵɵdefineInjectable({\n        token: this,\n        providedIn: options.providedIn || 'root',\n        factory: options.factory,\n      });\n    }\n  }\n\n  /**\n   * @internal\n   */\n  get multi(): InjectionToken<Array<T>> {\n    return this as InjectionToken<Array<T>>;\n  }\n\n  toString(): string {\n    return `InjectionToken ${this._desc}`;\n  }\n}\n\nexport interface InjectableDefToken<T> extends InjectionToken<T> {\n  ɵprov: unknown;\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.dev/license\n */\n\nimport { InjectionToken } from './injection_token';\n\n/**\n * A multi-provider token for initialization functions that will run upon construction of an\n * environment injector.\n *\n * @deprecated from v19.0.0, use provideEnvironmentInitializer instead\n *\n * @see {@link provideEnvironmentInitializer}\n *\n * Note: As opposed to the `APP_INITIALIZER` token, the `ENVIRONMENT_INITIALIZER` functions are not awaited,\n * hence they should not be `async`.\n *\n * @publicApi\n */\nexport const ENVIRONMENT_INITIALIZER = new InjectionToken<ReadonlyArray<() => void>>('');\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.dev/license\n */\n\n/**\n * Special flag indicating that a decorator is of type `Inject`. It's used to make `Inject`\n * decorator tree-shakable (so we don't have to rely on the `instanceof` checks).\n * Note: this flag is not included into the `InjectFlags` since it's an internal-only API.\n */\nexport const enum DecoratorFlags {\n  Inject = -1,\n}\n\n/**\n * This enum is an exact copy of the `InjectFlags` enum above, but the difference is that this is a\n * const enum, so actual enum values would be inlined in generated code. The `InjectFlags` enum can\n * be turned into a const enum when ViewEngine is removed (see TODO at the `InjectFlags` enum\n * above). The benefit of inlining is that we can use these flags at the top level without affecting\n * tree-shaking (see \"no-toplevel-property-access\" tslint rule for more info).\n * Keep this enum in sync with `InjectFlags` enum above.\n */\nexport const enum InternalInjectFlags {\n  /** Check self and check parent injector if needed */\n  Default = 0b0000,\n\n  /**\n   * Specifies that an injector should retrieve a dependency from any injector until reaching the\n   * host element of the current component. (Only used with Element Injector)\n   */\n  Host = 0b0001,\n\n  /** Don't ascend to ancestors of the node requesting injection. */\n  Self = 0b0010,\n\n  /** Skip the node that is requesting injection. */\n  SkipSelf = 0b0100,\n\n  /** Inject `defaultValue` instead if token not found. */\n  Optional = 0b1000,\n\n  /**\n   * This token is being injected into a pipe.\n   *\n   * This flag is intentionally not in the public facing `InjectFlags` because it is only added by\n   * the compiler and is not a developer applicable flag.\n   */\n  ForPipe = 0b10000,\n}\n\n/**\n * Type of the options argument to [`inject`](api/core/inject).\n *\n * @publicApi\n */\nexport interface InjectOptions {\n  /**\n   * Use optional injection, and return `null` if the requested token is not found.\n   */\n  optional?: boolean;\n\n  /**\n   * Start injection at the parent of the current injector.\n   */\n  skipSelf?: boolean;\n\n  /**\n   * Only query the current injector for the token, and don't fall back to the parent injector if\n   * it's not found.\n   */\n  self?: boolean;\n\n  /**\n   * Stop injection at the host component's injector. Only relevant when injecting from an element\n   * injector, and a no-op for environment injectors.\n   */\n  host?: boolean;\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.dev/license\n */\n\nimport { throwProviderNotFoundError } from '../render3/errors_di';\n\nimport { getInjectableDef, ɵɵInjectableDeclaration } from './interface/defs';\nimport { InternalInjectFlags } from './interface/injector';\nimport { ProviderToken } from './provider_token';\n\n/**\n * Current implementation of inject.\n *\n * By default, it is `injectInjectorOnly`, which makes it `Injector`-only aware. It can be changed\n * to `directiveInject`, which brings in the `NodeInjector` system of ivy. It is designed this\n * way for two reasons:\n *  1. `Injector` should not depend on ivy logic.\n *  2. To maintain tree shake-ability we don't want to bring in unnecessary code.\n */\nlet _injectImplementation: (<T>(token: ProviderToken<T>, flags?: InternalInjectFlags) => T | null) | undefined;\nexport function getInjectImplementation() {\n  return _injectImplementation;\n}\n\n/**\n * Sets the current inject implementation.\n */\nexport function setInjectImplementation(\n  impl: (<T>(token: ProviderToken<T>, flags?: InternalInjectFlags) => T | null) | undefined,\n): (<T>(token: ProviderToken<T>, flags?: InternalInjectFlags) => T | null) | undefined {\n  const previous = _injectImplementation;\n  _injectImplementation = impl;\n  return previous;\n}\n\n/**\n * Injects `root` tokens in limp mode.\n *\n * If no injector exists, we can still inject tree-shakable providers which have `providedIn` set to\n * `\"root\"`. This is known as the limp mode injection. In such case the value is stored in the\n * injectable definition.\n */\nexport function injectRootLimpMode<T>(token: ProviderToken<T>, notFoundValue: T | undefined, flags: InternalInjectFlags): T | null {\n  const injectableDef: ɵɵInjectableDeclaration<T> | null = getInjectableDef(token);\n  if (injectableDef && injectableDef.providedIn == 'root') {\n    return injectableDef.value === undefined ? (injectableDef.value = injectableDef.factory()) : injectableDef.value;\n  }\n  if (flags & InternalInjectFlags.Optional) return null;\n  if (notFoundValue !== undefined) return notFoundValue;\n  throwProviderNotFoundError(token, 'Injector');\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.dev/license\n */\n\nimport { InjectionToken } from './injection_token';\nimport { NotFound } from './not_found';\n\nexport interface Injector {\n  retrieve<T>(token: InjectionToken<T>, options?: unknown): T | NotFound;\n}\n\n/**\n * Current injector value used by `inject`.\n * - `undefined`: it is an error to call `inject`\n * - `null`: `inject` can be called but there is no injector (limp-mode).\n * - Injector instance: Use the injector for resolution.\n */\nlet _currentInjector: Injector | undefined | null = undefined;\n\nexport function getCurrentInjector(): Injector | undefined | null {\n  return _currentInjector;\n}\n\nexport function setCurrentInjector(injector: Injector | null | undefined): Injector | undefined | null {\n  const former = _currentInjector;\n  _currentInjector = injector;\n  return former;\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.dev/license\n */\n\n/**\n * Value returned if the key-value pair couldn't be found in the context\n * hierarchy.\n */\nexport const NOT_FOUND: unique symbol = Symbol('NotFound');\n\n/**\n * Error thrown when the key-value pair couldn't be found in the context\n * hierarchy. Context can be attached below.\n */\nexport class NotFoundError extends Error {\n  override readonly name: string = 'ɵNotFound';\n  constructor(message: string) {\n    super(message);\n  }\n}\n\n/**\n * Type guard for checking if an unknown value is a NotFound.\n */\nexport function isNotFound(e: unknown): e is NotFound {\n  return e === NOT_FOUND || (e as NotFoundError)?.name === 'ɵNotFound';\n}\n\n/**\n * Type union of NotFound and NotFoundError.\n */\nexport type NotFound = typeof NOT_FOUND | NotFoundError;\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.dev/license\n */\n\nimport { RuntimeError, RuntimeErrorCode } from '../errors';\nimport { Type } from '../interface/type';\n\nimport { stringify } from '../util/stringify';\n\nimport { resolveForwardRef } from './forward_ref';\nimport { getInjectImplementation, injectRootLimpMode } from './inject_switch';\nimport type { Injector } from './injector';\nimport { DecoratorFlags, InternalInjectFlags, InjectOptions } from './interface/injector';\nimport { ProviderToken } from './provider_token';\n\nimport { Injector as PrimitivesInjector, isNotFound, NotFound, InjectionToken as PrimitivesInjectionToken, getCurrentInjector } from '../../primitives/di';\n\nimport { InjectionToken } from './injection_token';\n\nconst _THROW_IF_NOT_FOUND = {};\nexport const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\n\nexport { getCurrentInjector, setCurrentInjector } from '../../primitives/di';\n\n/*\n * Name of a property (that we patch onto DI decorator), which is used as an annotation of which\n * InjectFlag this decorator represents. This allows to avoid direct references to the DI decorators\n * in the code, thus making them tree-shakable.\n */\nconst DI_DECORATOR_FLAG = '__NG_DI_FLAG__';\n\n/**\n * A wrapper around an `Injector` that implements the `PrimitivesInjector` interface.\n *\n * This is used to allow the `inject` function to be used with the new primitives-based DI system.\n */\nexport class RetrievingInjector implements PrimitivesInjector {\n  constructor(readonly injector: Injector) {}\n  retrieve<T>(token: PrimitivesInjectionToken<T>, options: unknown): T | NotFound {\n    const flags: InternalInjectFlags = convertToBitFlags(options as InjectOptions | undefined) || InternalInjectFlags.Default;\n    try {\n      return (this.injector as BackwardsCompatibleInjector).get(\n        token as unknown as InjectionToken<T>,\n        // When a dependency is requested with an optional flag, DI returns null as the default value.\n        (flags & InternalInjectFlags.Optional ? null : THROW_IF_NOT_FOUND) as T,\n        flags,\n      ) as T;\n    } catch (e: any) {\n      if (isNotFound(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n}\n\nexport const NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';\nconst NG_TOKEN_PATH = 'ngTokenPath';\nconst NEW_LINE = /\\n/gm;\nconst NO_NEW_LINE = 'ɵ';\nexport const SOURCE = '__source';\n\n/**\n * Temporary type to allow internal symbols to use inject flags. This should be\n * removed once we consolidate the flags and the object literal approach.\n */\nexport type BackwardsCompatibleInjector = Injector & {\n  get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InternalInjectFlags | InjectOptions): T;\n};\n\nexport function injectInjectorOnly<T>(token: ProviderToken<T>): T;\nexport function injectInjectorOnly<T>(token: ProviderToken<T>, flags?: InternalInjectFlags): T | null;\nexport function injectInjectorOnly<T>(token: ProviderToken<T>, flags = InternalInjectFlags.Default): T | null {\n  const currentInjector = getCurrentInjector();\n  if (currentInjector === undefined) {\n    throw new RuntimeError(RuntimeErrorCode.MISSING_INJECTION_CONTEXT, undefined as any);\n  } else if (currentInjector === null) {\n    return injectRootLimpMode(token, undefined, flags);\n  } else {\n    const options = convertToInjectOptions(flags);\n    const value = currentInjector.retrieve(token as PrimitivesInjectionToken<T>, options) as T;\n    undefined as any;\n    if (isNotFound(value)) {\n      if (options.optional) {\n        return null;\n      }\n      throw value;\n    }\n    return value;\n  }\n}\n\n/**\n * Generated instruction: injects a token from the currently active injector.\n *\n * (Additional documentation moved to `inject`, as it is the public API, and an alias for this\n * instruction)\n *\n * @see inject\n * @codeGenApi\n * @publicApi This instruction has been emitted by ViewEngine for some time and is deployed to npm.\n */\nexport function ɵɵinject<T>(token: ProviderToken<T>): T;\nexport function ɵɵinject<T>(token: ProviderToken<T>, flags?: InternalInjectFlags): T | null;\n\nexport function ɵɵinject<T>(token: ProviderToken<T>, flags?: InternalInjectFlags): string | null;\nexport function ɵɵinject<T>(token: ProviderToken<T>, flags = InternalInjectFlags.Default): T | null {\n  return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token as Type<T>), flags);\n}\n\n/**\n * Throws an error indicating that a factory function could not be generated by the compiler for a\n * particular class.\n *\n * The name of the class is not mentioned here, but will be in the generated factory function name\n * and thus in the stack trace.\n *\n * @codeGenApi\n */\nexport function ɵɵinvalidFactoryDep(index: number): void {\n  throw new RuntimeError(RuntimeErrorCode.INVALID_FACTORY_DEPENDENCY, undefined as any);\n}\n\n/**\n * @param token A token that represents a dependency that should be injected.\n * @returns the injected value if operation is successful, `null` otherwise.\n * @throws if called outside of a supported context.\n *\n * @publicApi\n */\nexport function inject<T>(token: ProviderToken<T>): T;\n/**\n * @param token A token that represents a dependency that should be injected.\n * @param options Control how injection is executed. Options correspond to injection strategies\n *     that can be specified with parameter decorators `@Host`, `@Self`, `@SkipSelf`, and\n *     `@Optional`.\n * @returns the injected value if operation is successful.\n * @throws if called outside of a supported context, or if the token is not found.\n *\n * @publicApi\n */\nexport function inject<T>(token: ProviderToken<T>, options: InjectOptions & { optional?: false }): T;\n/**\n * @param token A token that represents a dependency that should be injected.\n * @param options Control how injection is executed. Options correspond to injection strategies\n *     that can be specified with parameter decorators `@Host`, `@Self`, `@SkipSelf`, and\n *     `@Optional`.\n * @returns the injected value if operation is successful,  `null` if the token is not\n *     found and optional injection has been requested.\n * @throws if called outside of a supported context, or if the token is not found and optional\n *     injection was not requested.\n *\n * @publicApi\n */\nexport function inject<T>(token: ProviderToken<T>, options: InjectOptions): T | null;\n/**\n * @param token A token that represents a static attribute on the host node that should be injected.\n * @returns Value of the attribute if it exists.\n * @throws If called outside of a supported context or the attribute does not exist.\n *\n * @publicApi\n */\n\n/**\n * @param token A token that represents a static attribute on the host node that should be injected.\n * @returns Value of the attribute if it exists, otherwise `null`.\n * @throws If called outside of a supported context.\n *\n * @publicApi\n */\n\n/**\n * @param token A token that represents a static attribute on the host node that should be injected.\n * @returns Value of the attribute if it exists.\n * @throws If called outside of a supported context or the attribute does not exist.\n *\n * @publicApi\n */\n\n/**\n * Injects a token from the currently active injector.\n * `inject` is only supported in an [injection context](guide/di/dependency-injection-context). It\n * can be used during:\n * - Construction (via the `constructor`) of a class being instantiated by the DI system, such\n * as an `@Injectable` or `@Component`.\n * - In the initializer for fields of such classes.\n * - In the factory function specified for `useFactory` of a `Provider` or an `@Injectable`.\n * - In the `factory` function specified for an `InjectionToken`.\n * - In a stackframe of a function call in a DI context\n *\n * @param token A token that represents a dependency that should be injected.\n * @param flags Optional flags that control how injection is executed.\n * The flags correspond to injection strategies that can be specified with\n * parameter decorators `@Host`, `@Self`, `@SkipSelf`, and `@Optional`.\n * @returns the injected value if operation is successful, `null` otherwise.\n * @throws if called outside of a supported context.\n *\n * @usageNotes\n * In practice the `inject()` calls are allowed in a constructor, a constructor parameter and a\n * field initializer:\n *\n * ```ts\n * @Injectable({providedIn: 'root'})\n * export class Car {\n *   radio: Radio|undefined;\n *   // OK: field initializer\n *   spareTyre = inject(Tyre);\n *\n *   constructor() {\n *     // OK: constructor body\n *     this.radio = inject(Radio);\n *   }\n * }\n * ```\n *\n * It is also legal to call `inject` from a provider's factory:\n *\n * ```ts\n * providers: [\n *   {provide: Car, useFactory: () => {\n *     // OK: a class factory\n *     const engine = inject(Engine);\n *     return new Car(engine);\n *   }}\n * ]\n * ```\n *\n * Calls to the `inject()` function outside of the class creation context will result in error. Most\n * notably, calls to `inject()` are disallowed after a class instance was created, in methods\n * (including lifecycle hooks):\n *\n * ```ts\n * @Component({ ... })\n * export class CarComponent {\n *   ngOnInit() {\n *     // ERROR: too late, the component instance was already created\n *     const engine = inject(Engine);\n *     engine.start();\n *   }\n * }\n * ```\n *\n * @publicApi\n */\nexport function inject<T>(token: ProviderToken<T>, options?: InjectOptions) {\n  // The `as any` here _shouldn't_ be necessary, but without it JSCompiler\n  // throws a disambiguation  error due to the multiple signatures.\n  return ɵɵinject(token as any, convertToBitFlags(options));\n}\n\n// Converts object-based DI flags (`InjectOptions`) to bit flags (`InjectFlags`).\nexport function convertToBitFlags(flags: InjectOptions | InternalInjectFlags | undefined): InternalInjectFlags | undefined {\n  if (typeof flags === 'undefined' || typeof flags === 'number') {\n    return flags;\n  }\n\n  // While TypeScript doesn't accept it without a cast, bitwise OR with false-y values in\n  // JavaScript is a no-op. We can use that for a very codesize-efficient conversion from\n  // `InjectOptions` to `InjectFlags`.\n  return (InternalInjectFlags.Default | // comment to force a line break in the formatter\n    ((flags.optional && InternalInjectFlags.Optional) as number) |\n    0 |\n    ((flags.self && InternalInjectFlags.Self) as number) |\n    ((flags.skipSelf && InternalInjectFlags.SkipSelf) as number)) as InternalInjectFlags;\n}\n\n// Converts bitflags to inject options\nfunction convertToInjectOptions(flags: InternalInjectFlags): InjectOptions {\n  return {\n    optional: !!(flags & InternalInjectFlags.Optional),\n    host: !!(flags & InternalInjectFlags.Host),\n    self: !!(flags & InternalInjectFlags.Self),\n    skipSelf: !!(flags & InternalInjectFlags.SkipSelf),\n  };\n}\n\nexport function injectArgs(types: (ProviderToken<any> | any[])[]): any[] {\n  const args: any[] = [];\n  for (let i = 0; i < types.length; i++) {\n    const arg = resolveForwardRef(types[i]);\n    if (Array.isArray(arg)) {\n      if (arg.length === 0) {\n        throw new RuntimeError(RuntimeErrorCode.INVALID_DIFFER_INPUT, undefined as any);\n      }\n      let type: Type<any> | undefined = undefined;\n      let flags: InternalInjectFlags = InternalInjectFlags.Default;\n\n      for (let j = 0; j < arg.length; j++) {\n        const meta = arg[j];\n        const flag = getInjectFlag(meta);\n        if (typeof flag === 'number') {\n          // Special case when we handle @Inject decorator.\n          if (flag === DecoratorFlags.Inject) {\n            type = meta.token;\n          } else {\n            flags |= flag;\n          }\n        } else {\n          type = meta;\n        }\n      }\n\n      args.push(ɵɵinject(type!, flags));\n    } else {\n      args.push(ɵɵinject(arg));\n    }\n  }\n  return args;\n}\n\n/**\n * Attaches a given InjectFlag to a given decorator using monkey-patching.\n * Since DI decorators can be used in providers `deps` array (when provider is configured using\n * `useFactory`) without initialization (e.g. `Host`) and as an instance (e.g. `new Host()`), we\n * attach the flag to make it available both as a static property and as a field on decorator\n * instance.\n *\n * @param decorator Provided DI decorator.\n * @param flag InjectFlag that should be applied.\n */\nexport function attachInjectFlag(decorator: any, flag: InternalInjectFlags | DecoratorFlags): any {\n  decorator[DI_DECORATOR_FLAG] = flag;\n  decorator.prototype[DI_DECORATOR_FLAG] = flag;\n  return decorator;\n}\n\n/**\n * Reads monkey-patched property that contains InjectFlag attached to a decorator.\n *\n * @param token Token that may contain monkey-patched DI flags property.\n */\nexport function getInjectFlag(token: any): number | undefined {\n  return token[DI_DECORATOR_FLAG];\n}\n\nexport function catchInjectorError(e: any, token: any, injectorErrorName: string, source: string | null): never {\n  const tokenPath: any[] = e[NG_TEMP_TOKEN_PATH];\n  if (token[SOURCE]) {\n    tokenPath.unshift(token[SOURCE]);\n  }\n  e.message = formatError('\\n' + e.message, tokenPath, injectorErrorName, source);\n  e[NG_TOKEN_PATH] = tokenPath;\n  e[NG_TEMP_TOKEN_PATH] = null;\n  throw e;\n}\n\nexport function formatError(text: string, obj: any, injectorErrorName: string, source: string | null = null): string {\n  text = text && text.charAt(0) === '\\n' && text.charAt(1) == NO_NEW_LINE ? text.slice(2) : text;\n  let context = stringify(obj);\n  if (Array.isArray(obj)) {\n    context = obj.map(stringify).join(' -> ');\n  } else if (typeof obj === 'object') {\n    const parts = <string[]>[];\n    for (const key in obj) {\n      if (obj.hasOwnProperty(key)) {\n        const value = obj[key];\n        parts.push(key + ':' + (typeof value === 'string' ? JSON.stringify(value) : stringify(value)));\n      }\n    }\n    context = `{${parts.join(', ')}}`;\n  }\n  return `${injectorErrorName}${source ? '(' + source + ')' : ''}[${context}]: ${text.replace(NEW_LINE, '\\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.dev/license\n */\n\nimport { InjectionToken } from './injection_token';\nimport type { Injector } from './injector';\nimport { InjectorMarkers } from './injector_marker';\n\n/**\n * An InjectionToken that gets the current `Injector` for `createInjector()`-style injectors.\n *\n * Requesting this token instead of `Injector` allows `StaticInjector` to be tree-shaken from a\n * project.\n *\n * @publicApi\n */\nexport const INJECTOR = new InjectionToken<Injector>(\n  '',\n  // Disable tslint because this is const enum which gets inlined not top level prop access.\n  // tslint:disable-next-line: no-toplevel-property-access\n  InjectorMarkers.Injector as any, // Special value used by Ivy to identify `Injector`.\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.dev/license\n */\n\nimport { Type } from '../interface/type';\n\nimport { InjectionToken } from './injection_token';\n\nexport const INJECTOR_DEF_TYPES = new InjectionToken<ReadonlyArray<Type<unknown>>>('');\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.dev/license\n */\n\nimport { NotFoundError } from '@angular/core/primitives/di';\nimport { stringify } from '../util/stringify';\nimport type { Injector } from './injector';\nimport { THROW_IF_NOT_FOUND } from './injector_compatibility';\n\nexport class NullInjector implements Injector {\n  get(token: any, notFoundValue: any = THROW_IF_NOT_FOUND): any {\n    if (notFoundValue === THROW_IF_NOT_FOUND) {\n      const error = new NotFoundError(`NullInjectorError: No provider for ${stringify(token)}!`);\n      throw error;\n    }\n    return notFoundValue;\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.dev/license\n */\n\nimport { Type } from '../interface/type';\n\nimport { getClosureSafeProperty } from '../util/property';\n\nimport { ENVIRONMENT_INITIALIZER } from './initializer_token';\nimport { InjectorType } from './interface/defs';\nimport {\n  ClassProvider,\n  ConstructorProvider,\n  EnvironmentProviders,\n  ExistingProvider,\n  FactoryProvider,\n  ModuleWithProviders,\n  Provider,\n  StaticClassProvider,\n  TypeProvider,\n  ValueProvider,\n} from './interface/provider';\n\n/**\n * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally\n * referenced in `@Component` in a component injector.\n *\n * @publicApi\n */\nexport function makeEnvironmentProviders(providers: (Provider | EnvironmentProviders)[]): EnvironmentProviders {\n  return {\n    ɵproviders: providers,\n  } as unknown as EnvironmentProviders;\n}\n\n/**\n * @description\n * This function is used to provide initialization functions that will be executed upon construction\n * of an environment injector.\n *\n * Note that the provided initializer is run in the injection context.\n *\n * Previously, this was achieved using the `ENVIRONMENT_INITIALIZER` token which is now deprecated.\n *\n * @see {@link ENVIRONMENT_INITIALIZER}\n *\n * @usageNotes\n * The following example illustrates how to configure an initialization function using\n * `provideEnvironmentInitializer()`\n * ```ts\n * createEnvironmentInjector(\n *   [\n *     provideEnvironmentInitializer(() => {\n *       console.log('environment initialized');\n *     }),\n *   ],\n *   parentInjector\n * );\n * ```\n *\n * @publicApi\n */\nexport function provideEnvironmentInitializer(initializerFn: () => void): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: ENVIRONMENT_INITIALIZER,\n      multi: true,\n      useValue: initializerFn,\n    },\n  ]);\n}\n\n/**\n * A source of providers for the `importProvidersFrom` function.\n *\n * @publicApi\n */\nexport type ImportProvidersSource = Type<unknown> | ModuleWithProviders<unknown> | Array<ImportProvidersSource>;\n\ntype WalkProviderTreeVisitor = (provider: SingleProvider, container: Type<unknown> | InjectorType<unknown>) => void;\n\n/**\n * Internal type for a single provider in a deep provider array.\n */\nexport type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;\n\nexport const USE_VALUE: string = getClosureSafeProperty<ValueProvider>({\n  provide: String,\n  useValue: getClosureSafeProperty,\n});\n\nexport function isValueProvider(value: SingleProvider): value is ValueProvider {\n  return value !== null && typeof value === 'object' && USE_VALUE in value;\n}\n\nexport function isExistingProvider(value: SingleProvider): value is ExistingProvider {\n  return !!(value && (value as ExistingProvider).useExisting);\n}\n\nexport function isFactoryProvider(value: SingleProvider): value is FactoryProvider {\n  return !!(value && (value as FactoryProvider).useFactory);\n}\n\nexport function isTypeProvider(value: SingleProvider): value is TypeProvider {\n  return typeof value === 'function';\n}\n\nexport function isClassProvider(value: SingleProvider): value is ClassProvider {\n  return !!(value as StaticClassProvider | ClassProvider).useClass;\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.dev/license\n */\n\nimport { InjectionToken } from './injection_token';\n\nexport type InjectorScope = 'root' | 'platform' | 'environment';\n\n/**\n * An internal token whose presence in an injector indicates that the injector should treat itself\n * as a root scoped injector when processing requests for unknown tokens which may indicate\n * they are provided in the root scope.\n */\nexport const INJECTOR_SCOPE = new InjectionToken<InjectorScope | null>('');\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.dev/license\n */\n\nimport { RuntimeError, RuntimeErrorCode } from '../errors';\nimport { OnDestroy } from '../interface/lifecycle_hooks';\nimport { Type } from '../interface/type';\n\nimport { FactoryFn, getFactoryDef } from '../render3/definition_factory';\nimport { throwCyclicDependencyError } from '../render3/errors_di';\nimport { NG_ENV_ID } from '../render3/fields';\n\nimport { EMPTY_ARRAY } from '../util/empty';\nimport { stringify } from '../util/stringify';\n\nimport { resolveForwardRef } from './forward_ref';\nimport { ENVIRONMENT_INITIALIZER } from './initializer_token';\nimport { setInjectImplementation } from './inject_switch';\nimport { InjectionToken } from './injection_token';\nimport type { Injector } from './injector';\nimport { BackwardsCompatibleInjector, catchInjectorError, convertToBitFlags, injectArgs, NG_TEMP_TOKEN_PATH, setCurrentInjector, THROW_IF_NOT_FOUND, ɵɵinject } from './injector_compatibility';\nimport { INJECTOR } from './injector_token';\nimport { getInheritedInjectableDef, getInjectableDef, InjectorType, ɵɵInjectableDeclaration } from './interface/defs';\nimport { InternalInjectFlags, InjectOptions } from './interface/injector';\nimport { ClassProvider, ConstructorProvider, EnvironmentProviders, InternalEnvironmentProviders, isEnvironmentProviders, Provider, StaticClassProvider } from './interface/provider';\nimport { INJECTOR_DEF_TYPES } from './internal_tokens';\nimport { NullInjector } from './null_injector';\nimport { isExistingProvider, isFactoryProvider, isTypeProvider, isValueProvider, SingleProvider } from './provider_collection';\nimport { ProviderToken } from './provider_token';\nimport { INJECTOR_SCOPE, InjectorScope } from './scope';\n\nimport { Injector as PrimitivesInjector, InjectionToken as PrimitivesInjectionToken, NotFound, isNotFound } from '@angular/core/primitives/di';\n\n/**\n * Marker which indicates that a value has not yet been created from the factory function.\n */\nconst NOT_YET = {};\n\n/**\n * Marker which indicates that the factory function for a token is in the process of being called.\n *\n * If the injector is asked to inject a token with its value set to CIRCULAR, that indicates\n * injection of a dependency has recursively attempted to inject the original token, and there is\n * a circular dependency among the providers.\n */\nconst CIRCULAR = {};\n\n/**\n * A lazily initialized NullInjector.\n */\nlet NULL_INJECTOR: Injector | undefined = undefined;\n\nexport function getNullInjector(): Injector {\n  if (NULL_INJECTOR === undefined) {\n    NULL_INJECTOR = new NullInjector();\n  }\n  return NULL_INJECTOR;\n}\n\n/**\n * An entry in the injector which tracks information about the given token, including a possible\n * current value.\n */\ninterface Record<T> {\n  factory: (() => T) | undefined;\n  value: T | {};\n  multi: any[] | undefined;\n}\n\n/**\n * An `Injector` that's part of the environment injector hierarchy, which exists outside of the\n * component tree.\n *\n * @publicApi\n */\nexport abstract class EnvironmentInjector implements Injector {\n  /**\n   * Retrieves an instance from the injector based on the provided token.\n   * @returns The instance from the injector if defined, otherwise the `notFoundValue`.\n   * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.\n   */\n  abstract get<T>(\n    token: ProviderToken<T>,\n    notFoundValue: undefined,\n    options: InjectOptions & {\n      optional?: false;\n    },\n  ): T;\n  /**\n   * Retrieves an instance from the injector based on the provided token.\n   * @returns The instance from the injector if defined, otherwise the `notFoundValue`.\n   * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.\n   */\n  abstract get<T>(token: ProviderToken<T>, notFoundValue: null | undefined, options: InjectOptions): T | null;\n  /**\n   * Retrieves an instance from the injector based on the provided token.\n   * @returns The instance from the injector if defined, otherwise the `notFoundValue`.\n   * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.\n   */\n  abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions): T;\n  /**\n   * @deprecated from v4.0.0 use ProviderToken<T>\n   * @suppress {duplicate}\n   */\n  abstract get<T>(token: string | ProviderToken<T>, notFoundValue?: any): any;\n\n  /**\n   * Runs the given function in the context of this `EnvironmentInjector`.\n   *\n   * Within the function's stack frame, [`inject`](api/core/inject) can be used to inject\n   * dependencies from this injector. Note that `inject` is only usable synchronously, and cannot be\n   * used in any asynchronous callbacks or after any `await` points.\n   *\n   * @param fn the closure to be run in the context of this injector\n   * @returns the return value of the function, if any\n   * @deprecated use the standalone function `runInInjectionContext` instead\n   */\n  abstract runInContext<ReturnT>(fn: () => ReturnT): ReturnT;\n\n  abstract destroy(): void;\n\n  /** @internal */\n  abstract get destroyed(): boolean;\n\n  /**\n   * @internal\n   */\n  abstract onDestroy(callback: () => void): () => void;\n}\n\nexport class R3Injector extends EnvironmentInjector implements PrimitivesInjector {\n  /**\n   * Map of tokens to records which contain the instances of those tokens.\n   * - `null` value implies that we don't have the record. Used by tree-shakable injectors\n   * to prevent further searches.\n   */\n  private records = new Map<ProviderToken<any>, Record<any> | null>();\n\n  /**\n   * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.\n   */\n  private _ngOnDestroyHooks = new Set<OnDestroy>();\n\n  private _onDestroyHooks: Array<() => void> = [];\n\n  /**\n   * Flag indicating that this injector was previously destroyed.\n   */\n  override get destroyed(): boolean {\n    return this._destroyed;\n  }\n  private _destroyed = false;\n\n  private injectorDefTypes: Set<Type<unknown>>;\n\n  constructor(\n    providers: Array<Provider | EnvironmentProviders>,\n    readonly parent: Injector,\n    readonly source: string | null,\n    readonly scopes: Set<InjectorScope>,\n  ) {\n    super();\n    // Start off by creating Records for every provider.\n    forEachSingleProvider(providers as Array<Provider | InternalEnvironmentProviders>, (provider) => this.processProvider(provider));\n\n    // Make sure the INJECTOR token provides this injector.\n    this.records.set(INJECTOR, makeRecord(undefined, this));\n\n    // And `EnvironmentInjector` if the current injector is supposed to be env-scoped.\n    if (scopes.has('environment')) {\n      this.records.set(EnvironmentInjector, makeRecord(undefined, this));\n    }\n\n    // Detect whether this injector has the APP_ROOT_SCOPE token and thus should provide\n    // any injectable scoped to APP_ROOT_SCOPE.\n    const record = this.records.get(INJECTOR_SCOPE) as Record<InjectorScope | null>;\n    if (record != null && typeof record.value === 'string') {\n      this.scopes.add(record.value as InjectorScope);\n    }\n\n    this.injectorDefTypes = new Set(this.get(INJECTOR_DEF_TYPES, EMPTY_ARRAY, { self: true }));\n  }\n\n  retrieve<T>(token: PrimitivesInjectionToken<T>, options?: unknown): T | NotFound {\n    const flags: InternalInjectFlags = convertToBitFlags(options as InjectOptions | undefined) || InternalInjectFlags.Default;\n    try {\n      return (this as BackwardsCompatibleInjector).get(\n        token as unknown as InjectionToken<T>,\n        // When a dependency is requested with an optional flag, DI returns null as the default value.\n        THROW_IF_NOT_FOUND as T,\n        flags,\n      );\n    } catch (e: any) {\n      if (isNotFound(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Destroy the injector and release references to every instance or provider associated with it.\n   *\n   * Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a\n   * hook was found.\n   */\n  override destroy(): void {\n    assertNotDestroyed(this);\n\n    // Set destroyed = true first, in case lifecycle hooks re-enter destroy().\n    this._destroyed = true;\n\n    try {\n      // Call all the lifecycle hooks.\n      for (const service of this._ngOnDestroyHooks) {\n        service.ngOnDestroy();\n      }\n      const onDestroyHooks = this._onDestroyHooks;\n      // Reset the _onDestroyHooks array before iterating over it to prevent hooks that unregister\n      // themselves from mutating the array during iteration.\n      this._onDestroyHooks = [];\n      for (const hook of onDestroyHooks) {\n        hook();\n      }\n    } finally {\n      // Release all references.\n      this.records.clear();\n      this._ngOnDestroyHooks.clear();\n      this.injectorDefTypes.clear();\n    }\n  }\n\n  override onDestroy(callback: () => void): () => void {\n    assertNotDestroyed(this);\n    this._onDestroyHooks.push(callback);\n    return () => this.removeOnDestroy(callback);\n  }\n\n  override runInContext<ReturnT>(fn: () => ReturnT): ReturnT {\n    assertNotDestroyed(this);\n\n    const previousInjector = setCurrentInjector(this);\n    const previousInjectImplementation = setInjectImplementation(undefined);\n\n    if (false) {\n    }\n\n    try {\n      return fn();\n    } finally {\n      setCurrentInjector(previousInjector);\n      setInjectImplementation(previousInjectImplementation);\n      undefined as any;\n    }\n  }\n\n  override get<T>(token: ProviderToken<T>, notFoundValue: any = THROW_IF_NOT_FOUND, options?: InjectOptions): T {\n    assertNotDestroyed(this);\n\n    if (token.hasOwnProperty(NG_ENV_ID)) {\n      return (token as any)[NG_ENV_ID](this);\n    }\n\n    const flags = convertToBitFlags(options) as InternalInjectFlags;\n\n    // Set the injection context.\n    if (false) {\n    }\n    const previousInjector = setCurrentInjector(this);\n    const previousInjectImplementation = setInjectImplementation(undefined);\n    try {\n      // Check for the SkipSelf flag.\n      if (!(flags & InternalInjectFlags.SkipSelf)) {\n        // SkipSelf isn't set, check if the record belongs to this injector.\n        let record: Record<T> | undefined | null = this.records.get(token);\n        if (record === undefined) {\n          // No record, but maybe the token is scoped to this injector. Look for an injectable\n          // def with a scope matching this injector.\n          const def = couldBeInjectableType(token) && getInjectableDef(token);\n          if (def && this.injectableDefInScope(def)) {\n            // Found an injectable def and it's scoped to this injector. Pretend as if it was here\n            // all along.\n\n            if (false) {\n            }\n\n            record = makeRecord(injectableDefOrInjectorDefFactory(token), NOT_YET);\n          } else {\n            record = null;\n          }\n          this.records.set(token, record);\n        }\n        // If a record was found, get the instance for it and return it.\n        if (record != null /* NOT null || undefined */) {\n          return this.hydrate(token, record);\n        }\n      }\n\n      // Select the next injector based on the Self flag - if self is set, the next injector is\n      // the NullInjector, otherwise it's the parent.\n      const nextInjector = !(flags & InternalInjectFlags.Self) ? this.parent : getNullInjector();\n      // Set the notFoundValue based on the Optional flag - if optional is set and notFoundValue\n      // is undefined, the value is null, otherwise it's the notFoundValue.\n      notFoundValue = flags & InternalInjectFlags.Optional && notFoundValue === THROW_IF_NOT_FOUND ? null : notFoundValue;\n      return nextInjector.get(token, notFoundValue);\n    } catch (e: any) {\n      if (isNotFound(e)) {\n        // @ts-ignore\n        const path: any[] = (e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || []);\n        path.unshift(stringify(token));\n        if (previousInjector) {\n          // We still have a parent injector, keep throwing\n          throw e;\n        } else {\n          // Format & throw the final error message when we don't have any previous injector\n          return catchInjectorError(e, token, 'R3InjectorError', this.source);\n        }\n      } else {\n        throw e;\n      }\n    } finally {\n      // Lastly, restore the previous injection context.\n      setInjectImplementation(previousInjectImplementation);\n      setCurrentInjector(previousInjector);\n      undefined as any;\n    }\n  }\n\n  /** @internal */\n  resolveInjectorInitializers() {\n    const previousInjector = setCurrentInjector(this);\n    const previousInjectImplementation = setInjectImplementation(undefined);\n    if (false) {\n    }\n\n    try {\n      const initializers = this.get(ENVIRONMENT_INITIALIZER, EMPTY_ARRAY, { self: true });\n      if (false) {\n      }\n      for (const initializer of initializers) {\n        initializer();\n      }\n    } finally {\n      setCurrentInjector(previousInjector);\n      setInjectImplementation(previousInjectImplementation);\n      undefined as any;\n    }\n  }\n\n  override toString() {\n    const tokens: string[] = [];\n    const records = this.records;\n    for (const token of records.keys()) {\n      tokens.push(stringify(token));\n    }\n    return `R3Injector[${tokens.join(', ')}]`;\n  }\n\n  /**\n   * Process a `SingleProvider` and add it.\n   */\n  private processProvider(provider: SingleProvider): void {\n    // Determine the token from the provider. Either it's its own token, or has a {provide: ...}\n    // property.\n    provider = resolveForwardRef(provider);\n    let token: any = isTypeProvider(provider) ? provider : resolveForwardRef(provider && provider.provide);\n\n    // Construct a `Record` for the provider.\n    const record = providerToRecord(provider);\n    if (false) {\n    }\n\n    if (!isTypeProvider(provider) && provider.multi === true) {\n      // If the provider indicates that it's a multi-provider, process it specially.\n      // First check whether it's been defined already.\n      let multiRecord = this.records.get(token);\n      if (multiRecord) {\n        // It has. Throw a nice error if\n        if (false) {\n        }\n      } else {\n        multiRecord = makeRecord(undefined, NOT_YET, true);\n        multiRecord.factory = () => injectArgs(multiRecord!.multi!);\n        this.records.set(token, multiRecord);\n      }\n      token = provider;\n      multiRecord.multi!.push(provider);\n    } else {\n      if (false) {\n      }\n    }\n    this.records.set(token, record);\n  }\n\n  private hydrate<T>(token: ProviderToken<T>, record: Record<T>): T {\n    try {\n      if (record.value === CIRCULAR) {\n        throwCyclicDependencyError(stringify(token));\n      } else if (record.value === NOT_YET) {\n        record.value = CIRCULAR;\n\n        if (false) {\n        } else {\n          record.value = record.factory!();\n        }\n      }\n      if (typeof record.value === 'object' && record.value && hasOnDestroy(record.value)) {\n        this._ngOnDestroyHooks.add(record.value);\n      }\n      return record.value as T;\n    } finally {\n    }\n  }\n\n  private injectableDefInScope(def: ɵɵInjectableDeclaration<any>): boolean {\n    if (!def.providedIn) {\n      return false;\n    }\n    const providedIn = resolveForwardRef(def.providedIn);\n    if (typeof providedIn === 'string') {\n      return providedIn === 'any' || this.scopes.has(providedIn);\n    } else {\n      return this.injectorDefTypes.has(providedIn);\n    }\n  }\n\n  private removeOnDestroy(callback: () => void): void {\n    const destroyCBIdx = this._onDestroyHooks.indexOf(callback);\n    if (destroyCBIdx !== -1) {\n      this._onDestroyHooks.splice(destroyCBIdx, 1);\n    }\n  }\n}\n\nfunction injectableDefOrInjectorDefFactory(token: ProviderToken<any>): FactoryFn<any> {\n  // Most tokens will have an injectable def directly on them, which specifies a factory directly.\n  const injectableDef = getInjectableDef(token);\n  const factory = injectableDef !== null ? injectableDef.factory : getFactoryDef(token);\n\n  if (factory !== null) {\n    return factory;\n  }\n\n  // InjectionTokens should have an injectable def (ɵprov) and thus should be handled above.\n  // If it's missing that, it's an error.\n  if (token instanceof InjectionToken) {\n    throw new RuntimeError(RuntimeErrorCode.INVALID_INJECTION_TOKEN, undefined as any);\n  }\n\n  // Undecorated types can sometimes be created if they have no constructor arguments.\n  if (token instanceof Function) {\n    return getUndecoratedInjectableFactory(token);\n  }\n\n  // There was no way to resolve a factory for this token.\n  throw new RuntimeError(RuntimeErrorCode.INVALID_INJECTION_TOKEN, undefined as any);\n}\n\nfunction getUndecoratedInjectableFactory(token: Function) {\n  // If the token has parameters then it has dependencies that we cannot resolve implicitly.\n  const paramLength = token.length;\n  if (paramLength > 0) {\n    throw new RuntimeError(RuntimeErrorCode.INVALID_INJECTION_TOKEN, undefined as any);\n  }\n\n  // The constructor function appears to have no parameters.\n  // This might be because it inherits from a super-class. In which case, use an injectable\n  // def from an ancestor if there is one.\n  // Otherwise this really is a simple class with no dependencies, so return a factory that\n  // just instantiates the zero-arg constructor.\n  const inheritedInjectableDef = getInheritedInjectableDef(token);\n  if (inheritedInjectableDef !== null) {\n    return () => inheritedInjectableDef.factory(token as Type<any>);\n  } else {\n    return () => new (token as Type<any>)();\n  }\n}\n\nfunction providerToRecord(provider: SingleProvider): Record<any> {\n  if (isValueProvider(provider)) {\n    return makeRecord(undefined, provider.useValue);\n  } else {\n    const factory: (() => any) | undefined = providerToFactory(provider);\n    return makeRecord(factory, NOT_YET);\n  }\n}\n\n/**\n * Converts a `SingleProvider` into a factory function.\n *\n * @param provider provider to convert to factory\n */\nexport function providerToFactory(provider: SingleProvider, ngModuleType?: InjectorType<any>, providers?: any[]): () => any {\n  let factory: (() => any) | undefined = undefined;\n  if (false) {\n  }\n\n  if (isTypeProvider(provider)) {\n    const unwrappedProvider = resolveForwardRef(provider);\n    return getFactoryDef(unwrappedProvider) || injectableDefOrInjectorDefFactory(unwrappedProvider);\n  } else {\n    if (isValueProvider(provider)) {\n      factory = () => resolveForwardRef(provider.useValue);\n    } else if (isFactoryProvider(provider)) {\n      factory = () => provider.useFactory(...injectArgs(provider.deps || []));\n    } else if (isExistingProvider(provider)) {\n      factory = () => ɵɵinject(resolveForwardRef(provider.useExisting));\n    } else {\n      const classRef = resolveForwardRef(provider && ((provider as StaticClassProvider | ClassProvider).useClass || provider.provide));\n      if (false) {\n      }\n      if (hasDeps(provider)) {\n        factory = () => new classRef(...injectArgs(provider.deps));\n      } else {\n        return getFactoryDef(classRef) || injectableDefOrInjectorDefFactory(classRef);\n      }\n    }\n  }\n  return factory;\n}\n\nexport function assertNotDestroyed(injector: R3Injector): void {\n  if (injector.destroyed) {\n    throw new RuntimeError(RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED, undefined as any);\n  }\n}\n\nfunction makeRecord<T>(factory: (() => T) | undefined, value: T | {}, multi: boolean = false): Record<T> {\n  return {\n    factory: factory,\n    value: value,\n    multi: multi ? [] : undefined,\n  };\n}\n\nfunction hasDeps(value: ClassProvider | ConstructorProvider | StaticClassProvider): value is ClassProvider & { deps: any[] } {\n  return !!(value as any).deps;\n}\n\nfunction hasOnDestroy(value: any): value is OnDestroy {\n  return value !== null && typeof value === 'object' && typeof (value as OnDestroy).ngOnDestroy === 'function';\n}\n\nfunction couldBeInjectableType(value: any): value is ProviderToken<any> {\n  return typeof value === 'function' || (typeof value === 'object' && value.ngMetadataName === 'InjectionToken');\n}\n\nfunction forEachSingleProvider(providers: Array<Provider | EnvironmentProviders>, fn: (provider: SingleProvider) => void): void {\n  for (const provider of providers) {\n    if (Array.isArray(provider)) {\n      forEachSingleProvider(provider, fn);\n    } else if (provider && isEnvironmentProviders(provider)) {\n      forEachSingleProvider(provider.ɵproviders, fn);\n    } else {\n      fn(provider as SingleProvider);\n    }\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.dev/license\n */\n\n/**\n * Convince closure compiler that the wrapped function has no side-effects.\n *\n * Closure compiler always assumes that `toString` has no side-effects. We use this quirk to\n * allow us to execute a function but have closure compiler mark the call as no-side-effects.\n * It is important that the return value for the `noSideEffects` function be assigned\n * to something which is retained otherwise the call to `noSideEffects` will be removed by closure\n * compiler.\n */\nexport function noSideEffects<T>(fn: () => T): T {\n  return { toString: fn }.toString() as unknown as T;\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.dev/license\n */\n\nimport { Type } from '../interface/type';\n\nimport { noSideEffects } from './closure';\n\n/**\n * An interface implemented by all Angular type decorators, which allows them to be used as\n * decorators as well as Angular syntax.\n *\n * ```ts\n * @ng.Component({...})\n * class MyClass {...}\n * ```\n *\n * @publicApi\n */\nexport interface TypeDecorator {\n  /**\n   * Invoke as decorator.\n   */\n  <T extends Type<any>>(type: T): T;\n\n  // Make TypeDecorator assignable to built-in ParameterDecorator type.\n  // ParameterDecorator is declared in lib.d.ts as a `declare type`\n  // so we cannot declare this interface as a subtype.\n  // see https://github.com/angular/angular/issues/3379#issuecomment-126169417\n  (target: object, propertyKey?: string | symbol, parameterIndex?: number): void;\n  // Standard (non-experimental) Decorator signature that avoids direct usage of\n  // any TS 5.0+ specific types.\n  (target: unknown, context: unknown): void;\n}\nexport const PARAMETERS = '__parameters__';\n\nfunction makeMetadataCtor(props?: (...args: any[]) => any): any {\n  return function ctor(this: any, ...args: any[]) {\n    if (props) {\n      const values = props(...args);\n      for (const propName in values) {\n        this[propName] = values[propName];\n      }\n    }\n  };\n}\n\nexport function makeParamDecorator(name: string, props?: (...args: any[]) => any, parentClass?: any): any {\n  return noSideEffects(() => {\n    const metaCtor = makeMetadataCtor(props);\n    function ParamDecoratorFactory(this: unknown | typeof ParamDecoratorFactory, ...args: any[]): any {\n      metaCtor.apply(this, args);\n      return this;\n    }\n    if (parentClass) {\n    }\n\n    return ParamDecoratorFactory;\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.dev/license\n */\n\nimport { makeParamDecorator } from '../util/decorators';\n\nimport { attachInjectFlag } from './injector_compatibility';\nimport { DecoratorFlags, InternalInjectFlags } from './interface/injector';\n\n/**\n * Type of the Inject decorator / constructor function.\n *\n * @publicApi\n */\nexport interface InjectDecorator {\n  /**\n   * Warning: String tokens are not recommended.\n   *\n   * Use an InjectionToken or a class as a token instead.\n   */\n  (token: string): any;\n  new (token: string): Inject;\n\n  /**\n   * Parameter decorator on a dependency parameter of a class constructor\n   * that specifies a custom provider of the dependency.\n   *\n   * @usageNotes\n   * The following example shows a class constructor that specifies a\n   * custom provider of a dependency using the parameter decorator.\n   *\n   * When `@Inject()` is not present, the injector uses the type annotation of the\n   * parameter as the provider.\n   *\n   * {@example core/di/ts/metadata_spec.ts region='InjectWithoutDecorator'}\n   *\n   * @see [Dependency Injection Guide](guide/di/dependency-injection\n   *\n   */\n  (token: any): any;\n  new (token: any): Inject;\n}\n\n/**\n * Type of the Inject metadata.\n *\n * @publicApi\n */\nexport interface Inject {\n  /**\n   * A DI token that maps to the dependency to be injected.\n   */\n  token: any;\n}\n\n/**\n * Inject decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nexport const Inject: InjectDecorator = attachInjectFlag(\n  // Disable tslint because `DecoratorFlags` is a const enum which gets inlined.\n  makeParamDecorator('Inject', (token: any) => ({ token })),\n  // tslint:disable-next-line: no-toplevel-property-access\n  DecoratorFlags.Inject,\n);\n\n/**\n * Type of the Optional decorator / constructor function.\n *\n * @publicApi\n */\nexport interface OptionalDecorator {\n  /**\n   * Parameter decorator to be used on constructor parameters,\n   * which marks the parameter as being an optional dependency.\n   * The DI framework provides `null` if the dependency is not found.\n   *\n   * Can be used together with other parameter decorators\n   * that modify how dependency injection operates.\n   *\n   * @usageNotes\n   *\n   * The following code allows the possibility of a `null` result:\n   *\n   * {@example core/di/ts/metadata_spec.ts region='Optional'}\n   *\n   * @see [Dependency Injection Guide](guide/di/dependency-injection.\n   */\n  (): any;\n  new (): Optional;\n}\n\n/**\n * Type of the Optional metadata.\n *\n * @publicApi\n */\nexport interface Optional {}\n\n/**\n * Optional decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nexport const Optional: OptionalDecorator =\n  // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.\n  // tslint:disable-next-line: no-toplevel-property-access\n  attachInjectFlag(makeParamDecorator('Optional'), InternalInjectFlags.Optional);\n\n/**\n * Type of the Self decorator / constructor function.\n *\n * @publicApi\n */\nexport interface SelfDecorator {\n  /**\n   * Parameter decorator to be used on constructor parameters,\n   * which tells the DI framework to start dependency resolution from the local injector.\n   *\n   * Resolution works upward through the injector hierarchy, so the children\n   * of this class must configure their own providers or be prepared for a `null` result.\n   *\n   * @usageNotes\n   *\n   * In the following example, the dependency can be resolved\n   * by the local injector when instantiating the class itself, but not\n   * when instantiating a child.\n   *\n   * {@example core/di/ts/metadata_spec.ts region='Self'}\n   *\n   * @see {@link SkipSelf}\n   * @see {@link Optional}\n   *\n   */\n  (): any;\n  new (): Self;\n}\n\n/**\n * Type of the Self metadata.\n *\n * @publicApi\n */\nexport interface Self {}\n\n/**\n * Self decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nexport const Self: SelfDecorator =\n  // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.\n  // tslint:disable-next-line: no-toplevel-property-access\n  attachInjectFlag(makeParamDecorator('Self'), InternalInjectFlags.Self);\n\n/**\n * Type of the `SkipSelf` decorator / constructor function.\n *\n * @publicApi\n */\nexport interface SkipSelfDecorator {\n  /**\n   * Parameter decorator to be used on constructor parameters,\n   * which tells the DI framework to start dependency resolution from the parent injector.\n   * Resolution works upward through the injector hierarchy, so the local injector\n   * is not checked for a provider.\n   *\n   * @usageNotes\n   *\n   * In the following example, the dependency can be resolved when\n   * instantiating a child, but not when instantiating the class itself.\n   *\n   * {@example core/di/ts/metadata_spec.ts region='SkipSelf'}\n   *\n   * @see [Dependency Injection guide](guide/di/di-in-action#skip).\n   * @see {@link Self}\n   * @see {@link Optional}\n   *\n   */\n  (): any;\n  new (): SkipSelf;\n}\n\n/**\n * Type of the `SkipSelf` metadata.\n *\n * @publicApi\n */\nexport interface SkipSelf {}\n\n/**\n * `SkipSelf` decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nexport const SkipSelf: SkipSelfDecorator =\n  // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.\n  // tslint:disable-next-line: no-toplevel-property-access\n  attachInjectFlag(makeParamDecorator('SkipSelf'), InternalInjectFlags.SkipSelf);\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.dev/license\n */\n\nimport { EMPTY_ARRAY } from '../util/empty';\nimport { stringify } from '../util/stringify';\n\nimport type { Injector } from './injector';\nimport type { Provider, StaticProvider } from './interface/provider';\nimport { getNullInjector, R3Injector } from './r3_injector';\nimport { InjectorScope } from './scope';\n\n/**\n * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.\n */\nexport function createInjector(defType: /* InjectorType<any> */ any, parent: Injector | null = null, additionalProviders: Array<Provider | StaticProvider> | null = null, name?: string): Injector {\n  const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);\n  injector.resolveInjectorInitializers();\n  return injector;\n}\n\n/**\n * Creates a new injector without eagerly resolving its injector types. Can be used in places\n * where resolving the injector types immediately can lead to an infinite loop. The injector types\n * should be resolved at a later point by calling `_resolveInjectorDefTypes`.\n */\nexport function createInjectorWithoutInjectorInstances(\n  defType: /* InjectorType<any> */ any,\n  parent: Injector | null = null,\n  additionalProviders: Array<Provider | StaticProvider> | null = null,\n  name?: string,\n  scopes = new Set<InjectorScope>(),\n): R3Injector {\n  const providers = [additionalProviders || EMPTY_ARRAY];\n  name = name || (typeof defType === 'object' ? undefined : stringify(defType));\n\n  return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);\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.dev/license\n */\n\nimport { createInjector } from './create_injector';\nimport { THROW_IF_NOT_FOUND, ɵɵinject } from './injector_compatibility';\nimport { InjectorMarkers } from './injector_marker';\nimport { INJECTOR } from './injector_token';\nimport { ɵɵdefineInjectable } from './interface/defs';\nimport { InjectOptions } from './interface/injector';\nimport { Provider, StaticProvider } from './interface/provider';\nimport { NullInjector } from './null_injector';\nimport { ProviderToken } from './provider_token';\n\n/**\n * Concrete injectors implement this interface. Injectors are configured\n * with [providers](guide/di/dependency-injection-providers) that associate\n * dependencies of various types with [injection tokens](guide/di/dependency-injection-providers).\n *\n * @see [DI Providers](guide/di/dependency-injection-providers).\n * @see {@link StaticProvider}\n *\n * @usageNotes\n *\n *  The following example creates a service injector instance.\n *\n * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}\n *\n * ### Usage example\n *\n * {@example core/di/ts/injector_spec.ts region='Injector'}\n *\n * `Injector` returns itself when given `Injector` as a token:\n *\n * {@example core/di/ts/injector_spec.ts region='injectInjector'}\n *\n * @publicApi\n */\nexport abstract class Injector {\n  static THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;\n  static NULL: Injector = /* @__PURE__ */ new NullInjector();\n\n  /**\n   * Retrieves an instance from the injector based on the provided token.\n   * @returns The instance from the injector if defined, otherwise the `notFoundValue`.\n   * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.\n   */\n  abstract get<T>(\n    token: ProviderToken<T>,\n    notFoundValue: undefined,\n    options: InjectOptions & {\n      optional?: false;\n    },\n  ): T;\n  /**\n   * Retrieves an instance from the injector based on the provided token.\n   * @returns The instance from the injector if defined, otherwise the `notFoundValue`.\n   * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.\n   */\n  abstract get<T>(token: ProviderToken<T>, notFoundValue: null | undefined, options: InjectOptions): T | null;\n  /**\n   * Retrieves an instance from the injector based on the provided token.\n   * @returns The instance from the injector if defined, otherwise the `notFoundValue`.\n   * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.\n   */\n  abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions): T;\n  /**\n   * @deprecated from v4.0.0 use ProviderToken<T>\n   * @suppress {duplicate}\n   */\n  abstract get<T>(token: string | ProviderToken<T>, notFoundValue?: any): any;\n\n  /**\n   * @deprecated from v5 use the new signature Injector.create(options)\n   */\n  static create(providers: StaticProvider[], parent?: Injector): Injector;\n\n  /**\n   * Creates a new injector instance that provides one or more dependencies,\n   * according to a given type or types of `StaticProvider`.\n   *\n   * @param options An object with the following properties:\n   * * `providers`: An array of providers of the [StaticProvider type](api/core/StaticProvider).\n   * * `parent`: (optional) A parent injector.\n   * * `name`: (optional) A developer-defined identifying name for the new injector.\n   *\n   * @returns The new injector instance.\n   *\n   */\n  static create(options: { providers: Array<Provider | StaticProvider>; parent?: Injector; name?: string }): DestroyableInjector;\n\n  static create(options: StaticProvider[] | { providers: Array<Provider | StaticProvider>; parent?: Injector; name?: string }, parent?: Injector): Injector {\n    if (Array.isArray(options)) {\n      return createInjector({ name: '' }, parent, options, '');\n    } else {\n      const name = options.name ?? '';\n      return createInjector({ name }, options.parent, options.providers, name);\n    }\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ /* @__PURE__ */ ɵɵdefineInjectable({\n    token: Injector,\n    providedIn: 'any',\n    factory: () => ɵɵinject(INJECTOR),\n  });\n\n  /**\n   * @internal\n   * @nocollapse\n   */\n  static __NG_ELEMENT_ID__ = InjectorMarkers.Injector;\n}\n\n/**\n * An Injector that the owner can destroy and trigger the DestroyRef.destroy hooks.\n *\n * @publicApi\n */\nexport interface DestroyableInjector extends Injector {\n  destroy(): void;\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.dev/license\n */\n\n/**\n * Throws an error indicating that a factory function could not be generated by the compiler for a\n * particular class.\n *\n * This instruction allows the actual error message to be optimized away when ngDevMode is turned\n * off, saving bytes of generated code while still providing a good experience in dev mode.\n *\n * The name of the class is not mentioned here, but will be in the generated factory function name\n * and thus in the stack trace.\n *\n * @codeGenApi\n */\nexport function ɵɵinvalidFactory(): never {\n  const msg = 'invalid';\n  throw new Error(msg);\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.dev/license\n */\n\n/**\n * A comparison function which can determine if two values are equal.\n */\nexport type ValueEqualityFn<T> = (a: T, b: T) => boolean;\n\n/**\n * The default equality function used for `signal` and `computed`, which uses referential equality.\n */\nexport function defaultEquals<T>(a: T, b: T) {\n  return 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.dev/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.\ndeclare const ngDevMode: boolean | undefined;\n\n/**\n * The currently active consumer `ReactiveNode`, if running code in a reactive context.\n *\n * Change this via `setActiveConsumer`.\n */\nlet activeConsumer: ReactiveNode | null = null;\nlet inNotificationPhase = false;\n\ntype Version = number & { __brand: 'Version' };\n\n/**\n * Global epoch counter. Incremented whenever a source signal is set.\n */\nlet epoch: Version = 1 as Version;\n\nexport type ReactiveHookFn = (node: ReactiveNode) => void;\n\n/**\n * If set, called after a producer `ReactiveNode` is created.\n */\nlet postProducerCreatedFn: ReactiveHookFn | null = null;\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 */\nexport const SIGNAL: unique symbol = /* @__PURE__ */ Symbol('SIGNAL');\n\nexport function setActiveConsumer(consumer: ReactiveNode | null): ReactiveNode | null {\n  const prev = activeConsumer;\n  activeConsumer = consumer;\n  return prev;\n}\n\nexport function getActiveConsumer(): ReactiveNode | null {\n  return activeConsumer;\n}\n\nexport function isInNotificationPhase(): boolean {\n  return inNotificationPhase;\n}\n\nexport interface Reactive {\n  [SIGNAL]: ReactiveNode;\n}\n\nexport function isReactive(value: unknown): value is Reactive {\n  return (value as Partial<Reactive>)[SIGNAL] !== undefined;\n}\n\nexport const REACTIVE_NODE: ReactiveNode = {\n  version: 0 as Version,\n  lastCleanEpoch: 0 as Version,\n  dirty: false,\n  producerNode: undefined,\n  producerLastReadVersion: undefined,\n  producerIndexOfThis: undefined,\n  nextProducerIndex: 0,\n  liveConsumerNode: undefined,\n  liveConsumerIndexOfThis: undefined,\n  consumerAllowSignalWrites: false,\n  consumerIsAlwaysLive: false,\n  kind: 'unknown',\n  producerMustRecompute: () => false,\n  producerRecomputeValue: () => {},\n  consumerMarkedDirty: () => {},\n  consumerOnSignalRead: () => {},\n};\n\n/**\n * A producer and/or consumer which participates in the reactive graph.\n *\n * Producer `ReactiveNode`s which are accessed when a consumer `ReactiveNode` is the\n * `activeConsumer` are tracked as dependencies of that consumer.\n *\n * Certain consumers are also tracked as \"live\" consumers and create edges in the other direction,\n * from producer to consumer. These edges are used to propagate change notifications when a\n * producer's value is updated.\n *\n * A `ReactiveNode` may be both a producer and consumer.\n */\nexport interface ReactiveNode {\n  /**\n   * Version of the value that this node produces.\n   *\n   * This is incremented whenever a new value is produced by this node which is not equal to the\n   * previous value (by whatever definition of equality is in use).\n   */\n  version: Version;\n\n  /**\n   * Epoch at which this node is verified to be clean.\n   *\n   * This allows skipping of some polling operations in the case where no signals have been set\n   * since this node was last read.\n   */\n  lastCleanEpoch: Version;\n\n  /**\n   * Whether this node (in its consumer capacity) is dirty.\n   *\n   * Only live consumers become dirty, when receiving a change notification from a dependency\n   * producer.\n   */\n  dirty: boolean;\n\n  /**\n   * Producers which are dependencies of this consumer.\n   *\n   * Uses the same indices as the `producerLastReadVersion` and `producerIndexOfThis` arrays.\n   */\n  producerNode: ReactiveNode[] | undefined;\n\n  /**\n   * `Version` of the value last read by a given producer.\n   *\n   * Uses the same indices as the `producerNode` and `producerIndexOfThis` arrays.\n   */\n  producerLastReadVersion: Version[] | undefined;\n\n  /**\n   * Index of `this` (consumer) in each producer's `liveConsumers` array.\n   *\n   * This value is only meaningful if this node is live (`liveConsumers.length > 0`). Otherwise\n   * these indices are stale.\n   *\n   * Uses the same indices as the `producerNode` and `producerLastReadVersion` arrays.\n   */\n  producerIndexOfThis: number[] | undefined;\n\n  /**\n   * Index into the producer arrays that the next dependency of this node as a consumer will use.\n   *\n   * This index is zeroed before this node as a consumer begins executing. When a producer is read,\n   * it gets inserted into the producers arrays at this index. There may be an existing dependency\n   * in this location which may or may not match the incoming producer, depending on whether the\n   * same producers were read in the same order as the last computation.\n   */\n  nextProducerIndex: number;\n\n  /**\n   * Array of consumers of this producer that are \"live\" (they require push notifications).\n   *\n   * `liveConsumerNode.length` is effectively our reference count for this node.\n   */\n  liveConsumerNode: ReactiveNode[] | undefined;\n\n  /**\n   * Index of `this` (producer) in each consumer's `producerNode` array.\n   *\n   * Uses the same indices as the `liveConsumerNode` array.\n   */\n  liveConsumerIndexOfThis: number[] | undefined;\n\n  /**\n   * Whether writes to signals are allowed when this consumer is the `activeConsumer`.\n   *\n   * This is used to enforce guardrails such as preventing writes to writable signals in the\n   * computation function of computed signals, which is supposed to be pure.\n   */\n  consumerAllowSignalWrites: boolean;\n\n  readonly consumerIsAlwaysLive: boolean;\n\n  /**\n   * Tracks whether producers need to recompute their value independently of the reactive graph (for\n   * example, if no initial value has been computed).\n   */\n  producerMustRecompute(node: unknown): boolean;\n  producerRecomputeValue(node: unknown): void;\n  consumerMarkedDirty(node: unknown): void;\n\n  /**\n   * Called when a signal is read within this consumer.\n   */\n  consumerOnSignalRead(node: unknown): void;\n\n  /**\n   * A debug name for the reactive node. Used in Angular DevTools to identify the node.\n   */\n  debugName?: string;\n\n  /**\n   * Kind of node. Example: 'signal', 'computed', 'input', 'effect'.\n   *\n   * ReactiveNode has this as 'unknown' by default, but derived node types should override this to\n   * make available the kind of signal that particular instance of a ReactiveNode represents.\n   *\n   * Used in Angular DevTools to identify the kind of signal.\n   */\n  kind: string;\n}\n\ninterface ConsumerNode extends ReactiveNode {\n  producerNode: NonNullable<ReactiveNode['producerNode']>;\n  producerIndexOfThis: NonNullable<ReactiveNode['producerIndexOfThis']>;\n  producerLastReadVersion: NonNullable<ReactiveNode['producerLastReadVersion']>;\n}\n\ninterface ProducerNode extends ReactiveNode {\n  liveConsumerNode: NonNullable<ReactiveNode['liveConsumerNode']>;\n  liveConsumerIndexOfThis: NonNullable<ReactiveNode['liveConsumerIndexOfThis']>;\n}\n\n/**\n * Called by implementations when a producer's signal is read.\n */\nexport function producerAccessed(node: ReactiveNode): void {\n  if (inNotificationPhase) {\n    throw new Error(typeof ngDevMode !== 'undefined' && ngDevMode ? `Assertion error: signal read during notification phase` : '');\n  }\n\n  if (activeConsumer === null) {\n    // Accessed outside of a reactive context, so nothing to record.\n    return;\n  }\n\n  activeConsumer.consumerOnSignalRead(node);\n\n  // This producer is the `idx`th dependency of `activeConsumer`.\n  const idx = activeConsumer.nextProducerIndex++;\n\n  assertConsumerNode(activeConsumer);\n\n  if (idx < activeConsumer.producerNode.length && activeConsumer.producerNode[idx] !== node) {\n    // There's been a change in producers since the last execution of `activeConsumer`.\n    // `activeConsumer.producerNode[idx]` holds a stale dependency which will be be removed and\n    // replaced with `this`.\n    //\n    // If `activeConsumer` isn't live, then this is a no-op, since we can replace the producer in\n    // `activeConsumer.producerNode` directly. However, if `activeConsumer` is live, then we need\n    // to remove it from the stale producer's `liveConsumer`s.\n    if (consumerIsLive(activeConsumer)) {\n      const staleProducer = activeConsumer.producerNode[idx];\n      producerRemoveLiveConsumerAtIndex(staleProducer, activeConsumer.producerIndexOfThis[idx]);\n\n      // At this point, the only record of `staleProducer` is the reference at\n      // `activeConsumer.producerNode[idx]` which will be overwritten below.\n    }\n  }\n\n  if (activeConsumer.producerNode[idx] !== node) {\n    // We're a new dependency of the consumer (at `idx`).\n    activeConsumer.producerNode[idx] = node;\n\n    // If the active consumer is live, then add it as a live consumer. If not, then use 0 as a\n    // placeholder value.\n    activeConsumer.producerIndexOfThis[idx] = consumerIsLive(activeConsumer) ? producerAddLiveConsumer(node, activeConsumer, idx) : 0;\n  }\n  activeConsumer.producerLastReadVersion[idx] = node.version;\n}\n\n/**\n * Increment the global epoch counter.\n *\n * Called by source producers (that is, not computeds) whenever their values change.\n */\nexport function producerIncrementEpoch(): void {\n  epoch++;\n}\n\n/**\n * Ensure this producer's `version` is up-to-date.\n */\nexport function producerUpdateValueVersion(node: ReactiveNode): void {\n  if (consumerIsLive(node) && !node.dirty) {\n    // A live consumer will be marked dirty by producers, so a clean state means that its version\n    // is guaranteed to be up-to-date.\n    return;\n  }\n\n  if (!node.dirty && node.lastCleanEpoch === epoch) {\n    // Even non-live consumers can skip polling if they previously found themselves to be clean at\n    // the current epoch, since their dependencies could not possibly have changed (such a change\n    // would've increased the epoch).\n    return;\n  }\n\n  if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {\n    // None of our producers report a change since the last time they were read, so no\n    // recomputation of our value is necessary, and we can consider ourselves clean.\n    producerMarkClean(node);\n    return;\n  }\n\n  node.producerRecomputeValue(node);\n\n  // After recomputing the value, we're no longer dirty.\n  producerMarkClean(node);\n}\n\n/**\n * Propagate a dirty notification to live consumers of this producer.\n */\nexport function producerNotifyConsumers(node: ReactiveNode): void {\n  if (node.liveConsumerNode === undefined) {\n    return;\n  }\n\n  // Prevent signal reads when we're updating the graph\n  const prev = inNotificationPhase;\n  inNotificationPhase = true;\n  try {\n    for (const consumer of node.liveConsumerNode) {\n      if (!consumer.dirty) {\n        consumerMarkDirty(consumer);\n      }\n    }\n  } finally {\n    inNotificationPhase = prev;\n  }\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 */\nexport function producerUpdatesAllowed(): boolean {\n  return activeConsumer?.consumerAllowSignalWrites !== false;\n}\n\nexport function consumerMarkDirty(node: ReactiveNode): void {\n  node.dirty = true;\n  producerNotifyConsumers(node);\n  node.consumerMarkedDirty?.(node);\n}\n\nexport function producerMarkClean(node: ReactiveNode): void {\n  node.dirty = false;\n  node.lastCleanEpoch = epoch;\n}\n\n/**\n * Prepare this consumer to run a computation in its reactive context.\n *\n * Must be called by subclasses which represent reactive computations, before those computations\n * begin.\n */\nexport function consumerBeforeComputation(node: ReactiveNode | null): ReactiveNode | null {\n  node && (node.nextProducerIndex = 0);\n  return setActiveConsumer(node);\n}\n\n/**\n * Finalize this consumer's state after a reactive computation has run.\n *\n * Must be called by subclasses which represent reactive computations, after those computations\n * have finished.\n */\nexport function consumerAfterComputation(node: ReactiveNode | null, prevConsumer: ReactiveNode | null): void {\n  setActiveConsumer(prevConsumer);\n\n  if (!node || node.producerNode === undefined || node.producerIndexOfThis === undefined || node.producerLastReadVersion === undefined) {\n    return;\n  }\n\n  if (consumerIsLive(node)) {\n    // For live consumers, we need to remove the producer -> consumer edge for any stale producers\n    // which weren't dependencies after the recomputation.\n    for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {\n      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);\n    }\n  }\n\n  // Truncate the producer tracking arrays.\n  // Perf note: this is essentially truncating the length to `node.nextProducerIndex`, but\n  // benchmarking has shown that individual pop operations are faster.\n  while (node.producerNode.length > node.nextProducerIndex) {\n    node.producerNode.pop();\n    node.producerLastReadVersion.pop();\n    node.producerIndexOfThis.pop();\n  }\n}\n\n/**\n * Determine whether this consumer has any dependencies which have changed since the last time\n * they were read.\n */\nexport function consumerPollProducersForChange(node: ReactiveNode): boolean {\n  assertConsumerNode(node);\n\n  // Poll producers for change.\n  for (let i = 0; i < node.producerNode.length; i++) {\n    const producer = node.producerNode[i];\n    const seenVersion = node.producerLastReadVersion[i];\n\n    // First check the versions. A mismatch means that the producer's value is known to have\n    // changed since the last time we read it.\n    if (seenVersion !== producer.version) {\n      return true;\n    }\n\n    // The producer's version is the same as the last time we read it, but it might itself be\n    // stale. Force the producer to recompute its version (calculating a new value if necessary).\n    producerUpdateValueVersion(producer);\n\n    // Now when we do this check, `producer.version` is guaranteed to be up to date, so if the\n    // versions still match then it has not changed since the last time we read it.\n    if (seenVersion !== producer.version) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Disconnect this consumer from the graph.\n */\nexport function consumerDestroy(node: ReactiveNode): void {\n  assertConsumerNode(node);\n  if (consumerIsLive(node)) {\n    // Drop all connections from the graph to this node.\n    for (let i = 0; i < node.producerNode.length; i++) {\n      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);\n    }\n  }\n\n  // Truncate all the arrays to drop all connection from this node to the graph.\n  node.producerNode.length = node.producerLastReadVersion.length = node.producerIndexOfThis.length = 0;\n  if (node.liveConsumerNode) {\n    node.liveConsumerNode.length = node.liveConsumerIndexOfThis!.length = 0;\n  }\n}\n\n/**\n * Add `consumer` as a live consumer of this node.\n *\n * Note that this operation is potentially transitive. If this node becomes live, then it becomes\n * a live consumer of all of its current producers.\n */\nfunction producerAddLiveConsumer(node: ReactiveNode, consumer: ReactiveNode, indexOfThis: number): number {\n  assertProducerNode(node);\n  if (node.liveConsumerNode.length === 0 && isConsumerNode(node)) {\n    // When going from 0 to 1 live consumers, we become a live consumer to our producers.\n    for (let i = 0; i < node.producerNode.length; i++) {\n      node.producerIndexOfThis[i] = producerAddLiveConsumer(node.producerNode[i], node, i);\n    }\n  }\n  node.liveConsumerIndexOfThis.push(indexOfThis);\n  return node.liveConsumerNode.push(consumer) - 1;\n}\n\n/**\n * Remove the live consumer at `idx`.\n */\nfunction producerRemoveLiveConsumerAtIndex(node: ReactiveNode, idx: number): void {\n  assertProducerNode(node);\n\n  if (typeof ngDevMode !== 'undefined' && ngDevMode && idx >= node.liveConsumerNode.length) {\n    throw new Error(`Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`);\n  }\n\n  if (node.liveConsumerNode.length === 1 && isConsumerNode(node)) {\n    // When removing the last live consumer, we will no longer be live. We need to remove\n    // ourselves from our producers' tracking (which may cause consumer-producers to lose\n    // liveness as well).\n    for (let i = 0; i < node.producerNode.length; i++) {\n      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);\n    }\n  }\n\n  // Move the last value of `liveConsumers` into `idx`. Note that if there's only a single\n  // live consumer, this is a no-op.\n  const lastIdx = node.liveConsumerNode.length - 1;\n  node.liveConsumerNode[idx] = node.liveConsumerNode[lastIdx];\n  node.liveConsumerIndexOfThis[idx] = node.liveConsumerIndexOfThis[lastIdx];\n\n  // Truncate the array.\n  node.liveConsumerNode.length--;\n  node.liveConsumerIndexOfThis.length--;\n\n  // If the index is still valid, then we need to fix the index pointer from the producer to this\n  // consumer, and update it from `lastIdx` to `idx` (accounting for the move above).\n  if (idx < node.liveConsumerNode.length) {\n    const idxProducer = node.liveConsumerIndexOfThis[idx];\n    const consumer = node.liveConsumerNode[idx];\n    assertConsumerNode(consumer);\n    consumer.producerIndexOfThis[idxProducer] = idx;\n  }\n}\n\nfunction consumerIsLive(node: ReactiveNode): boolean {\n  return node.consumerIsAlwaysLive || (node?.liveConsumerNode?.length ?? 0) > 0;\n}\n\nfunction assertConsumerNode(node: ReactiveNode): asserts node is ConsumerNode {\n  node.producerNode ??= [];\n  node.producerIndexOfThis ??= [];\n  node.producerLastReadVersion ??= [];\n}\n\nfunction assertProducerNode(node: ReactiveNode): asserts node is ProducerNode {\n  node.liveConsumerNode ??= [];\n  node.liveConsumerIndexOfThis ??= [];\n}\n\nfunction isConsumerNode(node: ReactiveNode): node is ConsumerNode {\n  return node.producerNode !== undefined;\n}\n\nexport function runPostProducerCreatedFn(node: ReactiveNode): void {\n  postProducerCreatedFn?.(node);\n}\n\nexport function setPostProducerCreatedFn(fn: ReactiveHookFn | null): ReactiveHookFn | null {\n  const prev = postProducerCreatedFn;\n  postProducerCreatedFn = 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.dev/license\n */\n\nimport { defaultEquals, ValueEqualityFn } from './equality';\nimport {\n  consumerAfterComputation,\n  consumerBeforeComputation,\n  producerAccessed,\n  producerUpdateValueVersion,\n  REACTIVE_NODE,\n  ReactiveNode,\n  setActiveConsumer,\n  SIGNAL,\n  runPostProducerCreatedFn,\n} from './graph';\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.\ndeclare const ngDevMode: boolean | undefined;\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 */\nexport interface ComputedNode<T> extends ReactiveNode {\n  /**\n   * Current value of the computation, or one of the sentinel values above (`UNSET`, `COMPUTING`,\n   * `ERROR`).\n   */\n  value: T;\n\n  /**\n   * If `value` is `ERRORED`, the error caught from the last computation attempt which will\n   * be re-thrown.\n   */\n  error: unknown;\n\n  /**\n   * The computation function which will produce a new value.\n   */\n  computation: () => T;\n\n  equal: ValueEqualityFn<T>;\n}\n\nexport type ComputedGetter<T> = (() => T) & {\n  [SIGNAL]: ComputedNode<T>;\n};\n\n/**\n * Create a computed signal which derives a reactive value from an expression.\n */\nexport function createComputed<T>(computation: () => T, equal?: ValueEqualityFn<T>): ComputedGetter<T> {\n  const node: ComputedNode<T> = Object.create(COMPUTED_NODE);\n  node.computation = computation;\n\n  if (equal !== undefined) {\n    node.equal = equal;\n  }\n\n  const computed = () => {\n    // Check if the value needs updating before returning it.\n    producerUpdateValueVersion(node);\n\n    // Record that someone looked at this signal.\n    producerAccessed(node);\n\n    if (node.value === ERRORED) {\n      throw node.error;\n    }\n\n    return node.value;\n  };\n\n  (computed as ComputedGetter<T>)[SIGNAL] = node;\n  if (typeof ngDevMode !== 'undefined' && ngDevMode) {\n    const debugName = node.debugName ? ' (' + node.debugName + ')' : '';\n    computed.toString = () => `[Computed${debugName}: ${node.value}]`;\n  }\n\n  runPostProducerCreatedFn(node);\n\n  return computed as unknown as ComputedGetter<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 */\nexport const UNSET: any = /* @__PURE__ */ 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 */\nexport const COMPUTING: any = /* @__PURE__ */ 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 */\nexport const ERRORED: any = /* @__PURE__ */ Symbol('ERRORED');\n\n// Note: Using an IIFE here to ensure that the spread assignment is not considered\n// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.\n// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.\nconst COMPUTED_NODE = /* @__PURE__ */ (() => ({\n  ...REACTIVE_NODE,\n  value: UNSET,\n  dirty: true,\n  error: null,\n  equal: defaultEquals,\n  kind: 'computed',\n\n  producerMustRecompute(node: ComputedNode<unknown>): boolean {\n    // Force a recomputation if there's no current value, or if the current value is in the\n    // process of being calculated (which should throw an error).\n    return node.value === UNSET || node.value === COMPUTING;\n  },\n\n  producerRecomputeValue(node: ComputedNode<unknown>): void {\n    if (node.value === COMPUTING) {\n      // Our computation somehow led to a cyclic read of itself.\n      throw new Error(typeof ngDevMode !== 'undefined' && ngDevMode ? 'Detected cycle in computations.' : '');\n    }\n\n    const oldValue = node.value;\n    node.value = COMPUTING;\n\n    const prevConsumer = consumerBeforeComputation(node);\n    let newValue: unknown;\n    let wasEqual = false;\n    try {\n      newValue = node.computation();\n      // We want to mark this node as errored if calling `equal` throws; however, we don't want\n      // to track any reactive reads inside `equal`.\n      setActiveConsumer(null);\n      wasEqual = oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED && node.equal(oldValue, newValue);\n    } catch (err) {\n      newValue = ERRORED;\n      node.error = err;\n    } finally {\n      consumerAfterComputation(node, prevConsumer);\n    }\n\n    if (wasEqual) {\n      // No change to `valueVersion` - old and new values are\n      // semantically equivalent.\n      node.value = oldValue;\n      return;\n    }\n\n    node.value = newValue;\n    node.version++;\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.dev/license\n */\n\nimport type { SignalNode } from './signal';\n\nfunction defaultThrowError(): never {\n  throw new Error();\n}\n\nlet throwInvalidWriteToSignalErrorFn: <T>(node: SignalNode<T>) => never = defaultThrowError;\n\nexport function throwInvalidWriteToSignalError<T>(node: SignalNode<T>) {\n  throwInvalidWriteToSignalErrorFn(node);\n}\n\nexport function setThrowInvalidWriteToSignalError(fn: <T>(node: SignalNode<T>) => 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.dev/license\n */\n\nimport { defaultEquals, ValueEqualityFn } from './equality';\nimport { throwInvalidWriteToSignalError } from './errors';\nimport { producerAccessed, producerIncrementEpoch, producerNotifyConsumers, producerUpdatesAllowed, REACTIVE_NODE, ReactiveNode, ReactiveHookFn, runPostProducerCreatedFn, SIGNAL } from './graph';\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.\ndeclare const ngDevMode: boolean | undefined;\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: ReactiveHookFn | null = null;\n\nexport interface SignalNode<T> extends ReactiveNode {\n  value: T;\n  equal: ValueEqualityFn<T>;\n}\n\nexport type SignalBaseGetter<T> = (() => T) & { readonly [SIGNAL]: unknown };\nexport type SignalSetter<T> = (newValue: T) => void;\nexport type SignalUpdater<T> = (updateFn: (value: T) => T) => void;\n\n// Note: Closure *requires* this to be an `interface` and not a type, which is why the\n// `SignalBaseGetter` type exists to provide the correct shape.\nexport interface SignalGetter<T> extends SignalBaseGetter<T> {\n  readonly [SIGNAL]: SignalNode<T>;\n}\n\n/**\n * Creates a `Signal` getter, setter, and updater function.\n */\nexport function createSignal<T>(initialValue: T, equal?: ValueEqualityFn<T>): [SignalGetter<T>, SignalSetter<T>, SignalUpdater<T>] {\n  const node: SignalNode<T> = Object.create(SIGNAL_NODE);\n  node.value = initialValue;\n  if (equal !== undefined) {\n    node.equal = equal;\n  }\n  const getter = (() => signalGetFn(node)) as SignalGetter<T>;\n  (getter as any)[SIGNAL] = node;\n  if (typeof ngDevMode !== 'undefined' && ngDevMode) {\n    const debugName = node.debugName ? ' (' + node.debugName + ')' : '';\n    getter.toString = () => `[Signal${debugName}: ${node.value}]`;\n  }\n\n  runPostProducerCreatedFn(node);\n  const set = (newValue: T) => signalSetFn(node, newValue);\n  const update = (updateFn: (value: T) => T) => signalUpdateFn(node, updateFn);\n  return [getter, set, update];\n}\n\nexport function setPostSignalSetFn(fn: ReactiveHookFn | null): ReactiveHookFn | null {\n  const prev = postSignalSetFn;\n  postSignalSetFn = fn;\n  return prev;\n}\n\nexport function signalGetFn<T>(node: SignalNode<T>): T {\n  producerAccessed(node);\n  return node.value;\n}\n\nexport function signalSetFn<T>(node: SignalNode<T>, newValue: T) {\n  if (!producerUpdatesAllowed()) {\n    throwInvalidWriteToSignalError(node);\n  }\n\n  if (!node.equal(node.value, newValue)) {\n    node.value = newValue;\n    signalValueChanged(node);\n  }\n}\n\nexport function signalUpdateFn<T>(node: SignalNode<T>, updater: (value: T) => T): void {\n  if (!producerUpdatesAllowed()) {\n    throwInvalidWriteToSignalError(node);\n  }\n\n  signalSetFn(node, updater(node.value));\n}\n\nexport function runPostSignalSetFn<T>(node: SignalNode<T>): void {\n  postSignalSetFn?.(node);\n}\n\n// Note: Using an IIFE here to ensure that the spread assignment is not considered\n// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.\n// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.\nexport const SIGNAL_NODE: SignalNode<unknown> = /* @__PURE__ */ (() => ({\n  ...REACTIVE_NODE,\n  equal: defaultEquals,\n  value: undefined,\n  kind: 'signal',\n}))();\n\nfunction signalValueChanged<T>(node: SignalNode<T>): void {\n  node.version++;\n  producerIncrementEpoch();\n  producerNotifyConsumers(node);\n  postSignalSetFn?.(node);\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.dev/license\n */\n\nimport { COMPUTING, ERRORED, UNSET } from './computed';\nimport { defaultEquals, ValueEqualityFn } from './equality';\nimport {\n  consumerAfterComputation,\n  consumerBeforeComputation,\n  producerAccessed,\n  producerMarkClean,\n  producerUpdateValueVersion,\n  REACTIVE_NODE,\n  ReactiveNode,\n  runPostProducerCreatedFn,\n  SIGNAL,\n} from './graph';\nimport { signalSetFn, signalUpdateFn } from './signal';\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.\ndeclare const ngDevMode: boolean | undefined;\n\nexport type ComputationFn<S, D> = (source: S, previous?: { source: S; value: D }) => D;\n\nexport interface LinkedSignalNode<S, D> extends ReactiveNode {\n  /**\n   * Value of the source signal that was used to derive the computed value.\n   */\n  sourceValue: S;\n\n  /**\n   * Current state value, or one of the sentinel values (`UNSET`, `COMPUTING`,\n   * `ERROR`).\n   */\n  value: D;\n\n  /**\n   * If `value` is `ERRORED`, the error caught from the last computation attempt which will\n   * be re-thrown.\n   */\n  error: unknown;\n\n  /**\n   * The source function represents reactive dependency based on which the linked state is reset.\n   */\n  source: () => S;\n\n  /**\n   * The computation function which will produce a new value based on the source and, optionally - previous values.\n   */\n  computation: ComputationFn<S, D>;\n\n  equal: ValueEqualityFn<D>;\n}\n\nexport type LinkedSignalGetter<S, D> = (() => D) & {\n  [SIGNAL]: LinkedSignalNode<S, D>;\n};\n\nexport function createLinkedSignal<S, D>(sourceFn: () => S, computationFn: ComputationFn<S, D>, equalityFn?: ValueEqualityFn<D>): LinkedSignalGetter<S, D> {\n  const node: LinkedSignalNode<S, D> = Object.create(LINKED_SIGNAL_NODE);\n\n  node.source = sourceFn;\n  node.computation = computationFn;\n  if (equalityFn != undefined) {\n    node.equal = equalityFn;\n  }\n\n  const linkedSignalGetter = () => {\n    // Check if the value needs updating before returning it.\n    producerUpdateValueVersion(node);\n\n    // Record that someone looked at this signal.\n    producerAccessed(node);\n\n    if (node.value === ERRORED) {\n      throw node.error;\n    }\n\n    return node.value;\n  };\n\n  const getter = linkedSignalGetter as LinkedSignalGetter<S, D>;\n  getter[SIGNAL] = node;\n  if (typeof ngDevMode !== 'undefined' && ngDevMode) {\n    const debugName = node.debugName ? ' (' + node.debugName + ')' : '';\n    getter.toString = () => `[LinkedSignal${debugName}: ${node.value}]`;\n  }\n\n  runPostProducerCreatedFn(node);\n\n  return getter;\n}\n\nexport function linkedSignalSetFn<S, D>(node: LinkedSignalNode<S, D>, newValue: D) {\n  producerUpdateValueVersion(node);\n  signalSetFn(node, newValue);\n  producerMarkClean(node);\n}\n\nexport function linkedSignalUpdateFn<S, D>(node: LinkedSignalNode<S, D>, updater: (value: D) => D): void {\n  producerUpdateValueVersion(node);\n  signalUpdateFn(node, updater);\n  producerMarkClean(node);\n}\n\n// Note: Using an IIFE here to ensure that the spread assignment is not considered\n// a side-effect, ending up preserving `LINKED_SIGNAL_NODE` and `REACTIVE_NODE`.\n// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.\nexport const LINKED_SIGNAL_NODE: object = /* @__PURE__ */ (() => ({\n  ...REACTIVE_NODE,\n  value: UNSET,\n  dirty: true,\n  error: null,\n  equal: defaultEquals,\n  kind: 'linkedSignal',\n\n  producerMustRecompute(node: LinkedSignalNode<unknown, unknown>): boolean {\n    // Force a recomputation if there's no current value, or if the current value is in the\n    // process of being calculated (which should throw an error).\n    return node.value === UNSET || node.value === COMPUTING;\n  },\n\n  producerRecomputeValue(node: LinkedSignalNode<unknown, unknown>): void {\n    if (node.value === COMPUTING) {\n      // Our computation somehow led to a cyclic read of itself.\n      throw new Error(typeof ngDevMode !== 'undefined' && ngDevMode ? 'Detected cycle in computations.' : '');\n    }\n\n    const oldValue = node.value;\n    node.value = COMPUTING;\n\n    const prevConsumer = consumerBeforeComputation(node);\n    let newValue: unknown;\n    try {\n      const newSourceValue = node.source();\n      const prev =\n        oldValue === UNSET || oldValue === ERRORED\n          ? undefined\n          : {\n              source: node.sourceValue,\n              value: oldValue,\n            };\n      newValue = node.computation(newSourceValue, prev);\n      node.sourceValue = newSourceValue;\n    } catch (err) {\n      newValue = ERRORED;\n      node.error = err;\n    } finally {\n      consumerAfterComputation(node, prevConsumer);\n    }\n\n    if (oldValue !== UNSET && newValue !== ERRORED && node.equal(oldValue, newValue)) {\n      // No change to `valueVersion` - old and new values are\n      // semantically equivalent.\n      node.value = oldValue;\n      return;\n    }\n\n    node.value = newValue;\n    node.version++;\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.dev/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 */\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.dev/license\n */\n\nimport { SIGNAL } from '../../../primitives/signals';\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 * @publicApi 17.0\n */\nexport type Signal<T> = (() => T) & {\n  [SIGNAL]: unknown;\n};\n\n/**\n * Checks if the given `value` is a reactive `Signal`.\n *\n * @publicApi 17.0\n */\nexport function isSignal(value: unknown): value is Signal<unknown> {\n  return typeof value === 'function' && (value as Signal<unknown>)[SIGNAL] !== undefined;\n}\n\n/**\n * A comparison function which can determine if two values are equal.\n */\nexport type ValueEqualityFn<T> = (a: T, b: T) => boolean;\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.dev/license\n */\n\nimport { createComputed } from '../../../primitives/signals';\n\nimport { Signal, ValueEqualityFn } from './api';\n\n/**\n * Options passed to the `computed` creation function.\n */\nexport interface CreateComputedOptions<T> {\n  /**\n   * A comparison function which defines equality for computed values.\n   */\n  equal?: ValueEqualityFn<T>;\n\n  /**\n   * A debug name for the computed signal. Used in Angular DevTools to identify the signal.\n   */\n  debugName?: string;\n}\n\n/**\n * Create a computed `Signal` which derives a reactive value from an expression.\n */\nexport function computed<T>(computation: () => T, options?: CreateComputedOptions<T>): Signal<T> {\n  const getter = createComputed(computation, options?.equal);\n\n  if (false) {\n  }\n\n  return getter;\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.dev/license\n */\n\nimport { createSignal, SIGNAL, SignalGetter, SignalNode } from '../../../primitives/signals';\n\nimport { isSignal, Signal, ValueEqualityFn } from './api';\n\n/** Symbol used distinguish `WritableSignal` from other non-writable signals and functions. */\nexport const ɵWRITABLE_SIGNAL: unique symbol = /* @__PURE__ */ Symbol('WRITABLE_SIGNAL');\n\n/**\n * A `Signal` with a value that can be mutated via a setter interface.\n *\n * @publicApi 17.0\n */\nexport interface WritableSignal<T> extends Signal<T> {\n  [ɵWRITABLE_SIGNAL]: T;\n\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   * Returns a readonly version of this signal. Readonly signals can be accessed to read their value\n   * but can't be changed using set or update methods. The readonly signals do _not_ have\n   * any built-in mechanism that would prevent deep-mutation of their value.\n   */\n  asReadonly(): Signal<T>;\n}\n\n/**\n * Utility function used during template type checking to extract the value from a `WritableSignal`.\n * @codeGenApi\n */\nexport function ɵunwrapWritableSignal<T>(value: T | { [ɵWRITABLE_SIGNAL]: T }): T {\n  // Note: the function uses `WRITABLE_SIGNAL` as a brand instead of `WritableSignal<T>`,\n  // because the latter incorrectly unwraps non-signal getter functions.\n  return null!;\n}\n\n/**\n * Options passed to the `signal` creation function.\n */\nexport interface CreateSignalOptions<T> {\n  /**\n   * A comparison function which defines equality for signal values.\n   */\n  equal?: ValueEqualityFn<T>;\n\n  /**\n   * A debug name for the signal. Used in Angular DevTools to identify the signal.\n   */\n  debugName?: string;\n}\n\n/**\n * Create a `Signal` that can be set or updated directly.\n */\nexport function signal<T>(initialValue: T, options?: CreateSignalOptions<T>): WritableSignal<T> {\n  const [get, set, update] = createSignal(initialValue, options?.equal);\n\n  const signalFn = get as SignalGetter<T> & WritableSignal<T>;\n  const node = signalFn[SIGNAL];\n\n  signalFn.set = set;\n  signalFn.update = update;\n  signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn as any) as () => Signal<T>;\n\n  if (false) {\n  }\n\n  return signalFn as WritableSignal<T>;\n}\n\nexport function signalAsReadonlyFn<T>(this: SignalGetter<T>): Signal<T> {\n  const node = this[SIGNAL] as SignalNode<T> & { readonlyFn?: Signal<T> };\n  if (node.readonlyFn === undefined) {\n    const readonlyFn = () => this();\n    (readonlyFn as any)[SIGNAL] = node;\n    node.readonlyFn = readonlyFn as Signal<T>;\n  }\n  return node.readonlyFn;\n}\n\n/**\n * Checks if the given `value` is a writeable signal.\n */\nexport function isWritableSignal(value: unknown): value is WritableSignal<unknown> {\n  return isSignal(value) && typeof (value as any).set === 'function';\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.dev/license\n */\n\nimport { ComputationFn, createLinkedSignal, LinkedSignalGetter, LinkedSignalNode, linkedSignalSetFn, linkedSignalUpdateFn, SIGNAL } from '../../../primitives/signals';\nimport { Signal, ValueEqualityFn } from './api';\nimport { signalAsReadonlyFn, WritableSignal } from './signal';\n\nconst identityFn = <T>(v: T) => v;\n\n/**\n * Creates a writable signal whose value is initialized and reset by the linked, reactive computation.\n *\n * @publicApi 20.0\n */\nexport function linkedSignal<D>(computation: () => D, options?: { equal?: ValueEqualityFn<NoInfer<D>> }): WritableSignal<D>;\n\n/**\n * Creates a writable signal whose value is initialized and reset by the linked, reactive computation.\n * This is an advanced API form where the computation has access to the previous value of the signal and the computation result.\n *\n * Note: The computation is reactive, meaning the linked signal will automatically update whenever any of the signals used within the computation change.\n *\n * @publicApi 20.0\n */\nexport function linkedSignal<S, D>(options: {\n  source: () => S;\n  computation: (source: NoInfer<S>, previous?: { source: NoInfer<S>; value: NoInfer<D> }) => D;\n  equal?: ValueEqualityFn<NoInfer<D>>;\n}): WritableSignal<D>;\n\nexport function linkedSignal<S, D>(\n  optionsOrComputation:\n    | {\n        source: () => S;\n        computation: ComputationFn<S, D>;\n        equal?: ValueEqualityFn<D>;\n      }\n    | (() => D),\n  options?: { equal?: ValueEqualityFn<D> },\n): WritableSignal<D> {\n  if (typeof optionsOrComputation === 'function') {\n    const getter = createLinkedSignal<D, D>(optionsOrComputation, identityFn<D>, options?.equal) as LinkedSignalGetter<D, D> & WritableSignal<D>;\n    return upgradeLinkedSignalGetter(getter);\n  } else {\n    const getter = createLinkedSignal<S, D>(optionsOrComputation.source, optionsOrComputation.computation, optionsOrComputation.equal);\n    return upgradeLinkedSignalGetter(getter);\n  }\n}\n\nfunction upgradeLinkedSignalGetter<S, D>(getter: LinkedSignalGetter<S, D>): WritableSignal<D> {\n  if (false) {\n  }\n\n  const node = getter[SIGNAL] as LinkedSignalNode<S, D>;\n  const upgradedGetter = getter as LinkedSignalGetter<S, D> & WritableSignal<D>;\n\n  upgradedGetter.set = (newValue: D) => linkedSignalSetFn(node, newValue);\n  upgradedGetter.update = (updateFn: (value: D) => D) => linkedSignalUpdateFn(node, updateFn);\n  upgradedGetter.asReadonly = signalAsReadonlyFn.bind(getter as any) as () => Signal<D>;\n\n  return upgradedGetter;\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.dev/license\n */\n\nimport { untracked as untrackedPrimitive } from '../../../primitives/signals';\n\n/**\n * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function\n * can, optionally, return a value.\n */\nexport function untracked<T>(nonReactiveReadsFn: () => T): T {\n  return untrackedPrimitive(nonReactiveReadsFn);\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.dev/license\n */\n\nimport { getActiveConsumer } from '../../../primitives/signals';\n\nimport { RuntimeError, RuntimeErrorCode } from '../../errors';\n\n/**\n * Asserts that the current stack frame is not within a reactive context. Useful\n * to disallow certain code from running inside a reactive context (see {@link /api/core/rxjs/toSignal toSignal})\n *\n * @param debugFn a reference to the function making the assertion (used for the error message).\n *\n * @publicApi\n */\nexport function assertNotInReactiveContext(debugFn: Function, extraContext?: string): void {\n  // Taking a `Function` instead of a string name here prevents the un-minified name of the function\n  // from being retained in the bundle regardless of minification.\n  if (getActiveConsumer() !== null) {\n    throw new RuntimeError(RuntimeErrorCode.ASSERTION_NOT_INSIDE_REACTIVE_CONTEXT, undefined as any);\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.dev/license\n */\n\nimport { EnvironmentInjector } from '../di';\n\nconst EXECUTE_CALLBACK_IF_ALREADY_DESTROYED = false;\n\n/**\n * `DestroyRef` lets you set callbacks to run for any cleanup or destruction behavior.\n * The scope of this destruction depends on where `DestroyRef` is injected. If `DestroyRef`\n * is injected in a component or directive, the callbacks run when that component or\n * directive is destroyed. Otherwise the callbacks run when a corresponding injector is destroyed.\n *\n * @publicApi\n */\nexport abstract class DestroyRef {\n  // Here the `DestroyRef` acts primarily as a DI token. There are (currently) types of objects that\n  // can be returned from the injector when asking for this token:\n  // - `NodeInjectorDestroyRef` when retrieved from a node injector;\n  // - `EnvironmentInjector` when retrieved from an environment injector\n\n  /**\n   * Registers a destroy callback in a given lifecycle scope.  Returns a cleanup function that can\n   * be invoked to unregister the callback.\n   *\n   * @usageNotes\n   * ### Example\n   * ```ts\n   * const destroyRef = inject(DestroyRef);\n   *\n   * // register a destroy callback\n   * const unregisterFn = destroyRef.onDestroy(() => doSomethingOnDestroy());\n   *\n   * // stop the destroy callback from executing if needed\n   * unregisterFn();\n   * ```\n   */\n  abstract onDestroy(callback: () => void): () => void;\n\n  /** @internal */\n  abstract get destroyed(): boolean;\n\n  /**\n   * @internal\n   * @nocollapse\n   */\n\n  /**\n   * @internal\n   * @nocollapse\n   */\n  static __NG_ENV_ID__: (injector: EnvironmentInjector) => DestroyRef = (injector) => injector;\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.dev/license\n */\n\nexport function noop(...args: any[]): any {\n  // Do nothing.\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.dev/license\n */\n\nimport { InjectionToken } from '../../di/injection_token';\n\nexport const enum NotificationSource {\n  // Change detection needs to run in order to synchronize application state\n  // with the DOM when the following notifications are received:\n  // This operation indicates that a subtree needs to be traversed during change detection.\n  MarkAncestorsForTraversal,\n  // A component/directive gets a new input.\n  SetInput,\n  // Defer block state updates need change detection to fully render the state.\n  DeferBlockStateUpdate,\n  // Debugging tools updated state and have requested change detection.\n  DebugApplyChanges,\n  // ChangeDetectorRef.markForCheck indicates the component is dirty/needs to refresh.\n  MarkForCheck,\n\n  // Bound listener callbacks execute and can update state without causing other notifications from\n  // above.\n  Listener,\n\n  // Custom elements do sometimes require checking directly.\n  CustomElement,\n\n  // The following notifications do not require views to be refreshed\n  // but we should execute render hooks:\n  // Render hooks are guaranteed to execute with the schedulers timing.\n  RenderHook,\n  // Views might be created outside and manipulated in ways that\n  // we cannot be aware of. When a view is attached, Angular now \"knows\"\n  // about it and we now know that DOM might have changed (and we should\n  // run render hooks). If the attached view is dirty, the `MarkAncestorsForTraversal`\n  // notification should also be received.\n  ViewAttached,\n  // When DOM removal happens, render hooks may be interested in the new\n  // DOM state but we do not need to refresh any views unless. If change\n  // detection is required after DOM removal, another notification should\n  // be received (i.e. `markForCheck`).\n  ViewDetachedFromDOM,\n  // Applying animations might result in new DOM state and should rerun render hooks\n  AsyncAnimationsLoaded,\n  // The scheduler is notified when a pending task is removed via the public API.\n  // This allows us to make stability async, delayed until the next application tick.\n  PendingTaskRemoved,\n  // An `effect()` outside of the view tree became dirty and might need to run.\n  RootEffect,\n  // An `effect()` within the view tree became dirty.\n  ViewEffect,\n}\n\n/**\n * Injectable that is notified when an `LView` is made aware of changes to application state.\n */\nexport abstract class ChangeDetectionScheduler {\n  abstract notify(source: NotificationSource): void;\n  abstract runningTick: boolean;\n}\n\n/** Token used to indicate if zoneless was enabled via provideZonelessChangeDetection(). */\nexport const ZONELESS_ENABLED = new InjectionToken<boolean>('', { providedIn: 'root', factory: () => false });\n\n/** Token used to indicate `provideZonelessChangeDetection` was used. */\nexport const PROVIDED_ZONELESS = new InjectionToken<boolean>('', { providedIn: 'root', factory: () => false });\n\nexport const ZONELESS_SCHEDULER_DISABLED = new InjectionToken<boolean>('');\n\n// TODO(atscott): Remove in v19. Scheduler should be done with runOutsideAngular.\nexport const SCHEDULE_IN_ROOT_ZONE = new InjectionToken<boolean>('');\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.dev/license\n */\n\nimport { ɵɵdefineInjectable } from '../../di/interface/defs';\n\n/**\n * Abstraction that encompasses any kind of effect that can be scheduled.\n */\nexport interface SchedulableEffect {\n  run(): void;\n  zone: {\n    run<T>(fn: () => T): T;\n  } | null;\n  dirty: boolean;\n}\n\n/**\n * A scheduler which manages the execution of effects.\n */\nexport abstract class EffectScheduler {\n  abstract add(e: SchedulableEffect): void;\n\n  /**\n   * Schedule the given effect to be executed at a later time.\n   *\n   * It is an error to attempt to execute any effects synchronously during a scheduling operation.\n   */\n  abstract schedule(e: SchedulableEffect): void;\n\n  /**\n   * Run any scheduled effects.\n   */\n  abstract flush(): void;\n\n  /** Remove a scheduled effect */\n  abstract remove(e: SchedulableEffect): void;\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ /* @__PURE__ */ ɵɵdefineInjectable({\n    token: EffectScheduler,\n    providedIn: 'root',\n    factory: () => new ZoneAwareEffectScheduler(),\n  });\n}\n\n/**\n * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue\n * when.\n */\nexport class ZoneAwareEffectScheduler implements EffectScheduler {\n  private dirtyEffectCount = 0;\n  private queues = new Map<Zone | null, Set<SchedulableEffect>>();\n\n  add(handle: SchedulableEffect): void {\n    this.enqueue(handle);\n    this.schedule(handle);\n  }\n\n  schedule(handle: SchedulableEffect): void {\n    if (!handle.dirty) {\n      return;\n    }\n    this.dirtyEffectCount++;\n  }\n\n  remove(handle: SchedulableEffect): void {\n    const zone = handle.zone as Zone | null;\n    const queue = this.queues.get(zone)!;\n    if (!queue.has(handle)) {\n      return;\n    }\n\n    queue.delete(handle);\n    if (handle.dirty) {\n      this.dirtyEffectCount--;\n    }\n  }\n\n  private enqueue(handle: SchedulableEffect): void {\n    const zone = handle.zone as Zone | null;\n    if (!this.queues.has(zone)) {\n      this.queues.set(zone, new Set());\n    }\n\n    const queue = this.queues.get(zone)!;\n    if (queue.has(handle)) {\n      return;\n    }\n    queue.add(handle);\n  }\n\n  /**\n   * Run all scheduled effects.\n   *\n   * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no\n   * ordering guarantee between effects scheduled in different zones.\n   */\n  flush(): void {\n    while (this.dirtyEffectCount > 0) {\n      let ranOneEffect = false;\n      for (const [zone, queue] of this.queues) {\n        // `zone` here must be defined.\n        if (zone === null) {\n          ranOneEffect ||= this.flushQueue(queue);\n        } else {\n          ranOneEffect ||= zone.run(() => this.flushQueue(queue));\n        }\n      }\n\n      // Safeguard against infinite looping if somehow our dirty effect count gets out of sync with\n      // the dirty flag across all the effects.\n      if (!ranOneEffect) {\n        this.dirtyEffectCount = 0;\n      }\n    }\n  }\n\n  private flushQueue(queue: Set<SchedulableEffect>): boolean {\n    let ranOneEffect = false;\n    for (const handle of queue) {\n      if (!handle.dirty) {\n        continue;\n      }\n      this.dirtyEffectCount--;\n      ranOneEffect = true;\n\n      // TODO: what happens if this throws an error?\n      handle.run();\n    }\n    return ranOneEffect;\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.dev/license\n */\n\nimport {\n  REACTIVE_NODE,\n  ReactiveNode,\n  SIGNAL,\n  consumerAfterComputation,\n  consumerBeforeComputation,\n  consumerDestroy,\n  consumerPollProducersForChange,\n  isInNotificationPhase,\n  setActiveConsumer,\n} from '../../../primitives/signals';\nimport { inject } from '../../di/injector_compatibility';\nimport { Injector } from '../../di/injector';\nimport { assertNotInReactiveContext } from './asserts';\nimport { assertInInjectionContext } from '../../di/contextual';\nimport { DestroyRef } from '../../linker/destroy_ref';\nimport { noop } from '../../util/noop';\nimport { ChangeDetectionScheduler, NotificationSource } from '../../change_detection/scheduling/zoneless_scheduling';\nimport { EffectScheduler, SchedulableEffect } from './root_effect_scheduler';\n\n/**\n * A global reactive effect, which can be manually destroyed.\n *\n * @publicApi 20.0\n */\nexport interface EffectRef {\n  /**\n   * Shut down the effect, removing it from any upcoming scheduled executions.\n   */\n  destroy(): void;\n}\n\nexport class EffectRefImpl implements EffectRef {\n  [SIGNAL]: EffectNode;\n\n  constructor(node: EffectNode) {\n    this[SIGNAL] = node;\n  }\n\n  destroy(): void {\n    this[SIGNAL].destroy();\n  }\n}\n\n/**\n * Options passed to the `effect` function.\n *\n * @publicApi 20.0\n */\nexport interface CreateEffectOptions {\n  /**\n   * The `Injector` in which to create the effect.\n   *\n   * If this is not provided, the current [injection context](guide/di/dependency-injection-context)\n   * will be used instead (via `inject`).\n   */\n  injector?: Injector;\n\n  /**\n   * Whether the `effect` should require manual cleanup.\n   *\n   * If this is `false` (the default) the effect will automatically register itself to be cleaned up\n   * with the current `DestroyRef`.\n   *\n   * If this is `true` and you want to use the effect outside an injection context, you still\n   * need to provide an `Injector` to the effect.\n   */\n  manualCleanup?: boolean;\n\n  /**\n   * @deprecated no longer required, signal writes are allowed by default.\n   */\n  allowSignalWrites?: boolean;\n\n  /**\n   * A debug name for the effect. Used in Angular DevTools to identify the effect.\n   */\n  debugName?: string;\n}\n\n/**\n * An effect can, optionally, register a cleanup function. If registered, the cleanup is executed\n * before the next effect run. The cleanup function makes it possible to \"cancel\" any work that the\n * previous effect run might have started.\n *\n * @publicApi 20.0\n */\nexport type EffectCleanupFn = () => void;\n\n/**\n * A callback passed to the effect function that makes it possible to register cleanup logic.\n *\n * @publicApi 20.0\n */\nexport type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;\n\n/**\n * Registers an \"effect\" that will be scheduled & executed whenever the signals that it reads\n * changes.\n *\n * Angular has two different kinds of effect: component effects and root effects. Component effects\n * are created when `effect()` is called from a component, directive, or within a service of a\n * component/directive. Root effects are created when `effect()` is called from outside the\n * component tree, such as in a root service.\n *\n * The two effect types differ in their timing. Component effects run as a component lifecycle\n * event during Angular's synchronization (change detection) process, and can safely read input\n * signals or create/destroy views that depend on component state. Root effects run as microtasks\n * and have no connection to the component tree or change detection.\n *\n * `effect()` must be run in injection context, unless the `injector` option is manually specified.\n *\n * @publicApi 20.0\n */\nexport function effect(effectFn: (onCleanup: EffectCleanupRegisterFn) => void, options?: CreateEffectOptions): EffectRef {\n  ngDevMode && assertNotInReactiveContext(effect, 'Call `effect` outside of a reactive context. For example, schedule the ' + 'effect inside the component constructor.');\n\n  if (ngDevMode && !options?.injector) {\n    assertInInjectionContext(effect);\n  }\n\n  if (ngDevMode && options?.allowSignalWrites !== undefined) {\n    console.warn(`The 'allowSignalWrites' flag is deprecated and no longer impacts effect() (writes are always allowed)`);\n  }\n\n  const injector = options?.injector ?? inject(Injector);\n  const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;\n\n  let node: EffectNode;\n\n  const notifier = injector.get(ChangeDetectionScheduler);\n  node = createRootEffect(effectFn, injector.get(EffectScheduler), notifier);\n  node.injector = injector;\n\n  if (destroyRef !== null) {\n    // If we need to register for cleanup, do that here.\n    node.onDestroyFn = destroyRef.onDestroy(() => node.destroy());\n  }\n\n  const effectRef = new EffectRefImpl(node);\n\n  return effectRef;\n}\n\nexport interface EffectNode extends ReactiveNode, SchedulableEffect {\n  hasRun: boolean;\n  cleanupFns: EffectCleanupFn[] | undefined;\n  injector: Injector;\n  notifier: ChangeDetectionScheduler;\n\n  onDestroyFn: () => void;\n  fn: (cleanupFn: EffectCleanupRegisterFn) => void;\n  run(): void;\n  destroy(): void;\n  maybeCleanup(): void;\n}\n\nexport interface RootEffectNode extends EffectNode {\n  scheduler: EffectScheduler;\n}\n\nexport const BASE_EFFECT_NODE: Omit<EffectNode, 'fn' | 'destroy' | 'injector' | 'notifier'> = /* @__PURE__ */ (() => ({\n  ...REACTIVE_NODE,\n  consumerIsAlwaysLive: true,\n  consumerAllowSignalWrites: true,\n  dirty: true,\n  hasRun: false,\n  cleanupFns: undefined,\n  zone: null,\n  kind: 'effect',\n  onDestroyFn: noop,\n  run(this: EffectNode): void {\n    this.dirty = false;\n\n    if (ngDevMode && isInNotificationPhase()) {\n      throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);\n    }\n\n    if (this.hasRun && !consumerPollProducersForChange(this)) {\n      return;\n    }\n    this.hasRun = true;\n\n    const registerCleanupFn: EffectCleanupRegisterFn = (cleanupFn) => (this.cleanupFns ??= []).push(cleanupFn);\n\n    const prevNode = consumerBeforeComputation(this);\n\n    // We clear `setIsRefreshingViews` so that `markForCheck()` within the body of an effect will\n    // cause CD to reach the component in question.\n\n    try {\n      this.maybeCleanup();\n      this.fn(registerCleanupFn);\n    } finally {\n      consumerAfterComputation(this, prevNode);\n    }\n  },\n\n  maybeCleanup(this: EffectNode): void {\n    if (!this.cleanupFns?.length) {\n      return;\n    }\n    const prevConsumer = setActiveConsumer(null);\n    try {\n      // Attempt to run the cleanup functions. Regardless of failure or success, we consider\n      // cleanup \"completed\" and clear the list for the next run of the effect. Note that an error\n      // from the cleanup function will still crash the current run of the effect.\n      while (this.cleanupFns.length) {\n        this.cleanupFns.pop()!();\n      }\n    } finally {\n      this.cleanupFns = [];\n      setActiveConsumer(prevConsumer);\n    }\n  },\n}))();\n\nexport const ROOT_EFFECT_NODE: Omit<RootEffectNode, 'fn' | 'scheduler' | 'notifier' | 'injector'> = /* @__PURE__ */ (() => ({\n  ...BASE_EFFECT_NODE,\n  consumerMarkedDirty(this: RootEffectNode) {\n    this.scheduler.schedule(this);\n    this.notifier.notify(NotificationSource.RootEffect);\n  },\n  destroy(this: RootEffectNode) {\n    consumerDestroy(this);\n    this.onDestroyFn();\n    this.maybeCleanup();\n    this.scheduler.remove(this);\n  },\n}))();\n\nexport function createRootEffect(fn: (onCleanup: EffectCleanupRegisterFn) => void, scheduler: EffectScheduler, notifier: ChangeDetectionScheduler): RootEffectNode {\n  const node = Object.create(ROOT_EFFECT_NODE) as RootEffectNode;\n  node.fn = fn;\n  node.scheduler = scheduler;\n  node.notifier = notifier;\n  node.zone = typeof Zone !== 'undefined' ? Zone.current : null;\n  node.scheduler.add(node);\n  node.notifier.notify(NotificationSource.RootEffect);\n  return node;\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.dev/license\n */\n\nimport { noop } from './noop';\n\n/**\n * Gets a scheduling function that runs the callback after the first of setTimeout and\n * requestAnimationFrame resolves.\n *\n * - `requestAnimationFrame` ensures that change detection runs ahead of a browser repaint.\n * This ensures that the create and update passes of a change detection always happen\n * in the same frame.\n * - When the browser is resource-starved, `rAF` can execute _before_ a `setTimeout` because\n * rendering is a very high priority process. This means that `setTimeout` cannot guarantee\n * same-frame create and update pass, when `setTimeout` is used to schedule the update phase.\n * - While `rAF` gives us the desirable same-frame updates, it has two limitations that\n * prevent it from being used alone. First, it does not run in background tabs, which would\n * prevent Angular from initializing an application when opened in a new tab (for example).\n * Second, repeated calls to requestAnimationFrame will execute at the refresh rate of the\n * hardware (~16ms for a 60Hz display). This would cause significant slowdown of tests that\n * are written with several updates and asserts in the form of \"update; await stable; assert;\".\n * - Both `setTimeout` and `rAF` are able to \"coalesce\" several events from a single user\n * interaction into a single change detection. Importantly, this reduces view tree traversals when\n * compared to an alternative timing mechanism like `queueMicrotask`, where change detection would\n * then be interleaves between each event.\n *\n * By running change detection after the first of `setTimeout` and `rAF` to execute, we get the\n * best of both worlds.\n *\n * @returns a function to cancel the scheduled callback\n */\nexport function scheduleCallbackWithRafRace(callback: Function): () => void {\n  let timeoutId: number;\n  let animationFrameId: number;\n  function cleanup() {\n    callback = noop;\n    try {\n      if (animationFrameId !== undefined && typeof cancelAnimationFrame === 'function') {\n        cancelAnimationFrame(animationFrameId);\n      }\n      if (timeoutId !== undefined) {\n        clearTimeout(timeoutId);\n      }\n    } catch {\n      // Clearing/canceling can fail in tests due to the timing of functions being patched and unpatched\n      // Just ignore the errors - we protect ourselves from this issue by also making the callback a no-op.\n    }\n  }\n  timeoutId = setTimeout(() => {\n    callback();\n    cleanup();\n  }) as unknown as number;\n  if (typeof requestAnimationFrame === 'function') {\n    animationFrameId = requestAnimationFrame(() => {\n      callback();\n      cleanup();\n    });\n  }\n\n  return () => cleanup();\n}\n\nexport function scheduleCallbackWithMicrotask(callback: Function): () => void {\n  queueMicrotask(() => callback());\n\n  return () => {\n    callback = noop;\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.dev/license\n */\n\nimport { inject } from '../../di/injector_compatibility';\nimport { scheduleCallbackWithRafRace } from '../../util/callback_scheduler';\n\nimport { ChangeDetectionScheduler, NotificationSource } from './zoneless_scheduling';\nimport { EffectScheduler } from 'src/import/render3/reactivity/root_effect_scheduler';\n\nexport class ChangeDetectionSchedulerImpl implements ChangeDetectionScheduler {\n  runningTick = false;\n  #rootEffectScheduler = inject(EffectScheduler);\n  private cancelScheduledCallback: null | (() => void) = null;\n\n  notify(source: NotificationSource): void {\n    this.cancelScheduledCallback = scheduleCallbackWithRafRace(() => {\n      this.#rootEffectScheduler.flush();\n    });\n  }\n  private cleanup() {\n    this.runningTick = false;\n    this.cancelScheduledCallback?.();\n    this.cancelScheduledCallback = null;\n  }\n  ngOnDestroy() {\n    this.cleanup();\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.dev/license\n */\n\nimport { BehaviorSubject, Observable } from 'rxjs';\n\nimport { inject } from './di/injector_compatibility';\nimport { ɵɵdefineInjectable } from './di/interface/defs';\nimport { OnDestroy } from './interface/lifecycle_hooks';\nimport { ChangeDetectionScheduler, NotificationSource } from './change_detection/scheduling/zoneless_scheduling';\nimport { INTERNAL_APPLICATION_ERROR_HANDLER } from './error_handler';\n\n/**\n * Internal implementation of the pending tasks service.\n */\nexport class PendingTasksInternal implements OnDestroy {\n  private taskId = 0;\n  private pendingTasks = new Set<number>();\n  private destroyed = false;\n\n  private pendingTask = new BehaviorSubject<boolean>(false);\n\n  get hasPendingTasks(): boolean {\n    // Accessing the value of a closed `BehaviorSubject` throws an error.\n    return this.destroyed ? false : this.pendingTask.value;\n  }\n\n  /**\n   * In case the service is about to be destroyed, return a self-completing observable.\n   * Otherwise, return the observable that emits the current state of pending tasks.\n   */\n  get hasPendingTasksObservable(): Observable<boolean> {\n    if (this.destroyed) {\n      // Manually creating the observable pulls less symbols from RxJS than `of(false)`.\n      return new Observable<boolean>((subscriber) => {\n        subscriber.next(false);\n        subscriber.complete();\n      });\n    }\n\n    return this.pendingTask;\n  }\n\n  add(): number {\n    // Emitting a value to a closed subject throws an error.\n    if (!this.hasPendingTasks && !this.destroyed) {\n      this.pendingTask.next(true);\n    }\n    const taskId = this.taskId++;\n    this.pendingTasks.add(taskId);\n    return taskId;\n  }\n\n  has(taskId: number): boolean {\n    return this.pendingTasks.has(taskId);\n  }\n\n  remove(taskId: number): void {\n    this.pendingTasks.delete(taskId);\n    if (this.pendingTasks.size === 0 && this.hasPendingTasks) {\n      this.pendingTask.next(false);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.pendingTasks.clear();\n    if (this.hasPendingTasks) {\n      this.pendingTask.next(false);\n    }\n    // We call `unsubscribe()` to release observers, as users may forget to\n    // unsubscribe manually when subscribing to `isStable`. We do not call\n    // `complete()` because it is unsafe; if someone subscribes using the `first`\n    // operator and the observable completes before emitting a value,\n    // RxJS will throw an error.\n    this.destroyed = true;\n    this.pendingTask.unsubscribe();\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ /* @__PURE__ */ ɵɵdefineInjectable({\n    token: PendingTasksInternal,\n    providedIn: 'root',\n    factory: () => new PendingTasksInternal(),\n  });\n}\n\n/**\n * Service that keeps track of pending tasks contributing to the stableness of Angular\n * application. While several existing Angular services (ex.: `HttpClient`) will internally manage\n * tasks influencing stability, this API gives control over stability to library and application\n * developers for specific cases not covered by Angular internals.\n *\n * The concept of stability comes into play in several important scenarios:\n * - SSR process needs to wait for the application stability before serializing and sending rendered\n * HTML;\n * - tests might want to delay assertions until the application becomes stable;\n *\n * @usageNotes\n * ```ts\n * const pendingTasks = inject(PendingTasks);\n * const taskCleanup = pendingTasks.add();\n * // do work that should block application's stability and then:\n * taskCleanup();\n * ```\n *\n * @publicApi 20.0\n */\nexport class PendingTasks {\n  private readonly internalPendingTasks = inject(PendingTasksInternal);\n  private readonly scheduler = inject(ChangeDetectionScheduler);\n  private readonly errorHandler = inject(INTERNAL_APPLICATION_ERROR_HANDLER);\n  /**\n   * Adds a new task that should block application's stability.\n   * @returns A cleanup function that removes a task when called.\n   */\n  add(): () => void {\n    const taskId = this.internalPendingTasks.add();\n    return () => {\n      if (!this.internalPendingTasks.has(taskId)) {\n        // This pending task has already been cleared.\n        return;\n      }\n      // Notifying the scheduler will hold application stability open until the next tick.\n      this.scheduler.notify(NotificationSource.PendingTaskRemoved);\n      this.internalPendingTasks.remove(taskId);\n    };\n  }\n\n  /**\n   * Runs an asynchronous function and blocks the application's stability until the function completes.\n   *\n   * ```ts\n   * pendingTasks.run(async () => {\n   *   const userData = await fetch('/api/user');\n   *   this.userData.set(userData);\n   * });\n   * ```\n   *\n   * @param fn The asynchronous function to execute\n   * @developerPreview 19.0\n   */\n  run(fn: () => Promise<unknown>): void {\n    const removeTask = this.add();\n    fn().catch(this.errorHandler).finally(removeTask);\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ /* @__PURE__ */ ɵɵdefineInjectable({\n    token: PendingTasks,\n    providedIn: 'root',\n    factory: () => new PendingTasks(),\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.dev/license\n */\n\nimport { InjectionToken } from './di/injection_token';\nimport { inject } from './di/injector_compatibility';\nimport { EnvironmentInjector } from './di/r3_injector';\n\n/**\n * Provides a hook for centralized exception handling.\n *\n * The default implementation of `ErrorHandler` prints error messages to the `console`. To\n * intercept error handling, write a custom exception handler that replaces this default as\n * appropriate for your app.\n *\n * @usageNotes\n * ### Example\n *\n * ```ts\n * class MyErrorHandler implements ErrorHandler {\n *   handleError(error) {\n *     // do something with the exception\n *   }\n * }\n *\n * // Provide in standalone apps\n * bootstrapApplication(AppComponent, {\n *   providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]\n * })\n *\n * // Provide in module-based apps\n * @NgModule({\n *   providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]\n * })\n * class MyModule {}\n * ```\n *\n * @publicApi\n */\nexport class ErrorHandler {\n  /**\n   * @internal\n   */\n  _console: Console = console;\n\n  handleError(error: any): void {\n    this._console.error('ERROR', error);\n  }\n}\n\n/**\n * `InjectionToken` used to configure how to call the `ErrorHandler`.\n */\nexport const INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken<(e: any) => void>('', {\n  providedIn: 'root',\n  factory: () => {\n    // The user's error handler may depend on things that create a circular dependency\n    // so we inject it lazily.\n    const injector = inject(EnvironmentInjector);\n    let userErrorHandler: ErrorHandler;\n    return (e: unknown) => {\n      userErrorHandler ??= injector.get(ErrorHandler);\n      userErrorHandler.handleError(e);\n    };\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.dev/license\n */\n\nimport { untracked } from '../render3/reactivity/untracked';\nimport { computed } from '../render3/reactivity/computed';\nimport { signal, signalAsReadonlyFn, WritableSignal } from '../render3/reactivity/signal';\nimport { Signal } from '../render3/reactivity/api';\nimport { effect, EffectRef } from '../render3/reactivity/effect';\nimport { ResourceOptions, ResourceStatus, WritableResource, Resource, ResourceRef, ResourceStreamingLoader, StreamingResourceOptions, ResourceStreamItem, ResourceLoaderParams } from './api';\n\nimport { ValueEqualityFn } from '../../primitives/signals';\n\nimport { Injector } from '../di/injector';\nimport { inject } from '../di/injector_compatibility';\nimport { PendingTasks } from '../pending_tasks';\nimport { linkedSignal } from '../render3/reactivity/linked_signal';\nimport { DestroyRef } from '../linker/destroy_ref';\n\n/**\n * Whether a `Resource.value()` should throw an error when the resource is in the error state.\n *\n * This internal flag is being used to gradually roll out this behavior.\n */\nconst RESOURCE_VALUE_THROWS_ERRORS_DEFAULT = true;\n\n/**\n * Constructs a `Resource` that projects a reactive request to an asynchronous operation defined by\n * a loader function, which exposes the result of the loading operation via signals.\n *\n * Note that `resource` is intended for _read_ operations, not operations which perform mutations.\n * `resource` will cancel in-progress loads via the `AbortSignal` when destroyed or when a new\n * request object becomes available, which could prematurely abort mutations.\n *\n * @experimental 19.0\n */\nexport function resource<T, R>(options: ResourceOptions<T, R> & { defaultValue: NoInfer<T> }): ResourceRef<T>;\n\n/**\n * Constructs a `Resource` that projects a reactive request to an asynchronous operation defined by\n * a loader function, which exposes the result of the loading operation via signals.\n *\n * Note that `resource` is intended for _read_ operations, not operations which perform mutations.\n * `resource` will cancel in-progress loads via the `AbortSignal` when destroyed or when a new\n * request object becomes available, which could prematurely abort mutations.\n *\n * @experimental 19.0\n */\nexport function resource<T, R>(options: ResourceOptions<T, R>): ResourceRef<T | undefined>;\nexport function resource<T, R>(options: ResourceOptions<T, R>): ResourceRef<T | undefined> {\n  if (false) {\n  }\n\n  const oldNameForParams = (options as ResourceOptions<T, R> & { request: ResourceOptions<T, R>['params'] }).request;\n  const params = (options.params ?? oldNameForParams ?? (() => null)) as () => R;\n  return new ResourceImpl<T | undefined, R>(\n    params,\n    getLoader(options),\n    options.defaultValue,\n    options.equal ? wrapEqualityFn(options.equal) : undefined,\n    options.injector ?? inject(Injector),\n    RESOURCE_VALUE_THROWS_ERRORS_DEFAULT,\n  );\n}\n\ntype ResourceInternalStatus = 'idle' | 'loading' | 'resolved' | 'local';\n\n/**\n * Internal state of a resource.\n */\ninterface ResourceProtoState<T> {\n  extRequest: WrappedRequest;\n\n  // For simplicity, status is internally tracked as a subset of the public status enum.\n  // Reloading and Error statuses are projected from Loading and Resolved based on other state.\n  status: ResourceInternalStatus;\n}\n\ninterface ResourceState<T> extends ResourceProtoState<T> {\n  previousStatus: ResourceStatus;\n  stream: Signal<ResourceStreamItem<T>> | undefined;\n}\n\ntype WrappedRequest = { request: unknown; reload: number };\n\n/**\n * Base class which implements `.value` as a `WritableSignal` by delegating `.set` and `.update`.\n */\nabstract class BaseWritableResource<T> implements WritableResource<T> {\n  readonly value: WritableSignal<T>;\n  abstract readonly status: Signal<ResourceStatus>;\n  abstract readonly error: Signal<Error | undefined>;\n\n  abstract reload(): boolean;\n\n  constructor(value: Signal<T>) {\n    this.value = value as WritableSignal<T>;\n    this.value.set = this.set.bind(this);\n    this.value.update = this.update.bind(this);\n    this.value.asReadonly = signalAsReadonlyFn;\n  }\n\n  abstract set(value: T): void;\n\n  private readonly isError = computed(() => this.status() === 'error');\n\n  update(updateFn: (value: T) => T): void {\n    this.set(updateFn(untracked(this.value)));\n  }\n\n  readonly isLoading = computed(() => this.status() === 'loading' || this.status() === 'reloading');\n\n  hasValue(): this is ResourceRef<Exclude<T, undefined>> {\n    // Note: we specifically read `isError()` instead of `status()` here to avoid triggering\n    // reactive consumers which read `hasValue()`. This way, if `hasValue()` is used inside of an\n    // effect, it doesn't cause the effect to rerun on every status change.\n    if (this.isError()) {\n      return false;\n    }\n\n    return this.value() !== undefined;\n  }\n\n  asReadonly(): Resource<T> {\n    return this;\n  }\n}\n\n/**\n * Implementation for `resource()` which uses a `linkedSignal` to manage the resource's state.\n */\nexport class ResourceImpl<T, R> extends BaseWritableResource<T> implements ResourceRef<T> {\n  private readonly pendingTasks: PendingTasks;\n\n  /**\n   * The current state of the resource. Status, value, and error are derived from this.\n   */\n  private readonly state: WritableSignal<ResourceState<T>>;\n\n  /**\n   * Combines the current request with a reload counter which allows the resource to be reloaded on\n   * imperative command.\n   */\n  protected readonly extRequest: WritableSignal<WrappedRequest>;\n  private readonly effectRef: EffectRef;\n\n  private pendingController: AbortController | undefined;\n  private resolvePendingTask: (() => void) | undefined = undefined;\n  private destroyed = false;\n  private unregisterOnDestroy: () => void;\n\n  constructor(\n    request: () => R,\n    private readonly loaderFn: ResourceStreamingLoader<T, R>,\n    defaultValue: T,\n    private readonly equal: ValueEqualityFn<T> | undefined,\n    injector: Injector,\n    throwErrorsFromValue: boolean = RESOURCE_VALUE_THROWS_ERRORS_DEFAULT,\n  ) {\n    super(\n      // Feed a computed signal for the value to `BaseWritableResource`, which will upgrade it to a\n      // `WritableSignal` that delegates to `ResourceImpl.set`.\n      computed(\n        () => {\n          const streamValue = this.state().stream?.();\n\n          if (!streamValue) {\n            return defaultValue;\n          }\n\n          // Prevents `hasValue()` from throwing an error when a reload happened in the error state\n          if (this.state().status === 'loading' && this.error()) {\n            return defaultValue;\n          }\n\n          if (!isResolved(streamValue)) {\n            if (throwErrorsFromValue) {\n              throw new ResourceValueError(this.error()!);\n            } else {\n              return defaultValue;\n            }\n          }\n\n          return streamValue.value;\n        },\n        { equal },\n      ),\n    );\n\n    // Extend `request()` to include a writable reload signal.\n    this.extRequest = linkedSignal({\n      source: request,\n      computation: (request) => ({ request, reload: 0 }),\n    });\n\n    // The main resource state is managed in a `linkedSignal`, which allows the resource to change\n    // state instantaneously when the request signal changes.\n    this.state = linkedSignal<WrappedRequest, ResourceState<T>>({\n      // Whenever the request changes,\n      source: this.extRequest,\n      // Compute the state of the resource given a change in status.\n      computation: (extRequest, previous) => {\n        const status = extRequest.request === undefined ? 'idle' : 'loading';\n        if (!previous) {\n          return {\n            extRequest,\n            status,\n            previousStatus: 'idle',\n            stream: undefined,\n          };\n        } else {\n          return {\n            extRequest,\n            status,\n            previousStatus: projectStatusOfState(previous.value),\n            // If the request hasn't changed, keep the previous stream.\n            stream: previous.value.extRequest.request === extRequest.request ? previous.value.stream : undefined,\n          };\n        }\n      },\n    });\n\n    this.effectRef = effect(this.loadEffect.bind(this), {\n      injector,\n      manualCleanup: true,\n    });\n\n    this.pendingTasks = injector.get(PendingTasks);\n\n    // Cancel any pending request when the resource itself is destroyed.\n    this.unregisterOnDestroy = injector.get(DestroyRef).onDestroy(() => this.destroy());\n  }\n\n  override readonly status = computed(() => projectStatusOfState(this.state()));\n\n  override readonly error = computed(() => {\n    const stream = this.state().stream?.();\n    return stream && !isResolved(stream) ? stream.error : undefined;\n  });\n\n  /**\n   * Called either directly via `WritableResource.set` or via `.value.set()`.\n   */\n  override set(value: T): void {\n    if (this.destroyed) {\n      return;\n    }\n\n    const current = untracked(this.value);\n    const state = untracked(this.state);\n\n    if (state.status === 'local' && (this.equal ? this.equal(current, value) : current === value)) {\n      return;\n    }\n\n    // Enter Local state with the user-defined value.\n    this.state.set({\n      extRequest: state.extRequest,\n      status: 'local',\n      previousStatus: 'local',\n      stream: signal({ value }),\n    });\n\n    // We're departing from whatever state the resource was in previously, so cancel any in-progress\n    // loading operations.\n    this.abortInProgressLoad();\n  }\n\n  override reload(): boolean {\n    // We don't want to restart in-progress loads.\n    const { status } = untracked(this.state);\n    if (status === 'idle' || status === 'loading') {\n      return false;\n    }\n\n    // Increment the request reload to trigger the `state` linked signal to switch us to `Reload`\n    this.extRequest.update(({ request, reload }) => ({ request, reload: reload + 1 }));\n    return true;\n  }\n\n  destroy(): void {\n    this.destroyed = true;\n    this.unregisterOnDestroy();\n    this.effectRef.destroy();\n    this.abortInProgressLoad();\n\n    // Destroyed resources enter Idle state.\n    this.state.set({\n      extRequest: { request: undefined, reload: 0 },\n      status: 'idle',\n      previousStatus: 'idle',\n      stream: undefined,\n    });\n  }\n\n  private async loadEffect(): Promise<void> {\n    const extRequest = this.extRequest();\n\n    // Capture the previous status before any state transitions. Note that this is `untracked` since\n    // we do not want the effect to depend on the state of the resource, only on the request.\n    const { status: currentStatus, previousStatus } = untracked(this.state);\n\n    if (extRequest.request === undefined) {\n      // Nothing to load (and we should already be in a non-loading state).\n      return;\n    } else if (currentStatus !== 'loading') {\n      // We're not in a loading or reloading state, so this loading request is stale.\n      return;\n    }\n\n    // Cancel any previous loading attempts.\n    this.abortInProgressLoad();\n\n    // Capturing _this_ load's pending task in a local variable is important here. We may attempt to\n    // resolve it twice:\n    //\n    //  1. when the loading function promise resolves/rejects\n    //  2. when cancelling the loading operation\n    //\n    // After the loading operation is cancelled, `this.resolvePendingTask` no longer represents this\n    // particular task, but this `await` may eventually resolve/reject. Thus, when we cancel in\n    // response to (1) below, we need to cancel the locally saved task.\n    let resolvePendingTask: (() => void) | undefined = (this.resolvePendingTask = this.pendingTasks.add());\n\n    const { signal: abortSignal } = (this.pendingController = new AbortController());\n\n    try {\n      // The actual loading is run through `untracked` - only the request side of `resource` is\n      // reactive. This avoids any confusion with signals tracking or not tracking depending on\n      // which side of the `await` they are.\n      const stream = await untracked(() =>\n        this.loaderFn({\n          params: extRequest.request as Exclude<R, undefined>,\n          // TODO(alxhub): cleanup after g3 removal of `request` alias.\n          request: extRequest.request as Exclude<R, undefined>,\n          abortSignal,\n          previous: {\n            status: previousStatus,\n          },\n        } as ResourceLoaderParams<R>),\n      );\n\n      // If this request has been aborted, or the current request no longer\n      // matches this load, then we should ignore this resolution.\n      if (abortSignal.aborted || untracked(this.extRequest) !== extRequest) {\n        return;\n      }\n\n      this.state.set({\n        extRequest,\n        status: 'resolved',\n        previousStatus: 'resolved',\n        stream,\n      });\n    } catch (err) {\n      if (abortSignal.aborted || untracked(this.extRequest) !== extRequest) {\n        return;\n      }\n\n      this.state.set({\n        extRequest,\n        status: 'resolved',\n        previousStatus: 'error',\n        stream: signal({ error: encapsulateResourceError(err) }),\n      });\n    } finally {\n      // Resolve the pending task now that the resource has a value.\n      resolvePendingTask?.();\n      resolvePendingTask = undefined;\n    }\n  }\n\n  private abortInProgressLoad(): void {\n    untracked(() => this.pendingController?.abort());\n    this.pendingController = undefined;\n\n    // Once the load is aborted, we no longer want to block stability on its resolution.\n    this.resolvePendingTask?.();\n    this.resolvePendingTask = undefined;\n  }\n}\n\n/**\n * Wraps an equality function to handle either value being `undefined`.\n */\nfunction wrapEqualityFn<T>(equal: ValueEqualityFn<T>): ValueEqualityFn<T | undefined> {\n  return (a, b) => (a === undefined || b === undefined ? a === b : equal(a, b));\n}\n\nfunction getLoader<T, R>(options: ResourceOptions<T, R>): ResourceStreamingLoader<T, R> {\n  if (isStreamingResourceOptions(options)) {\n    return options.stream;\n  }\n\n  return async (params) => {\n    try {\n      return signal({ value: await options.loader(params) });\n    } catch (err) {\n      return signal({ error: encapsulateResourceError(err) });\n    }\n  };\n}\n\nfunction isStreamingResourceOptions<T, R>(options: ResourceOptions<T, R>): options is StreamingResourceOptions<T, R> {\n  return !!(options as StreamingResourceOptions<T, R>).stream;\n}\n\n/**\n * Project from a state with `ResourceInternalStatus` to the user-facing `ResourceStatus`\n */\nfunction projectStatusOfState(state: ResourceState<unknown>): ResourceStatus {\n  switch (state.status) {\n    case 'loading':\n      return state.extRequest.reload === 0 ? 'loading' : 'reloading';\n    case 'resolved':\n      return isResolved(state.stream!()) ? 'resolved' : 'error';\n    default:\n      return state.status;\n  }\n}\n\nfunction isResolved<T>(state: ResourceStreamItem<T>): state is { value: T } {\n  return (state as { error: unknown }).error === undefined;\n}\n\nexport function encapsulateResourceError(error: unknown): Error {\n  if (error instanceof Error) {\n    return error;\n  }\n\n  return new ResourceWrappedError(error);\n}\n\nclass ResourceValueError extends Error {\n  constructor(error: Error) {\n    super(error.message, { cause: error });\n  }\n}\n\nclass ResourceWrappedError extends Error {\n  constructor(error: unknown) {\n    super(String(error), { cause: error });\n  }\n}\n", "import type { InjectableDecorator } from './di/injectable';\nimport { Injector } from './di/injector';\nimport { EnvironmentProviders, Provider } from './di/interface/provider';\nexport { EnvironmentProviders, Provider } from './di/interface/provider';\nimport { getNullInjector, R3Injector } from './di/r3_injector';\nimport { INJECTOR_SCOPE, InjectorScope } from './di/scope';\n\nexport * from './di/injectable';\nexport * from './di/metadata';\nexport * from './di/r3_injector';\nexport * from './di/interface/defs';\nexport * from './di/injector_compatibility';\nexport * from './di/injection_token';\nexport * from './di/null_injector';\nexport * from './di/injector';\nexport * from './di/interface/injector';\nexport * from './di/scope';\nexport * from './render3/instructions/di';\n\nexport * from './core_reactivity_export_internal';\nexport * from './change_detection/scheduling/zoneless_scheduling';\nexport * from './change_detection/scheduling/zoneless_scheduling_impl';\n\nexport * from './resource';\nexport * from './di/provider_token';\nexport * from './error_handler';\nexport * from './pending_tasks';\nexport * from './linker/destroy_ref';\nexport function Injectable(args?: any) {\n  return (constructor: Function) => {};\n}\nexport class StaticInjectOptions {\n  static injectOptions: Parameters<InjectableDecorator>[0];\n}\nexport class RootStaticInjectOptions {\n  static injectOptions: Parameters<InjectableDecorator>[0] = {\n    providedIn: 'root',\n  };\n}\n\nexport function createInjector(options: { providers: Array<Provider | EnvironmentProviders>; parent: Injector; name?: string; scopes?: Set<InjectorScope> }) {\n  return new R3Injector(options.providers, options.parent ?? getNullInjector(), options.name ?? '', options.scopes ?? new Set([]));\n}\nexport function createRootInjector(options: { providers: Array<Provider | EnvironmentProviders>; name?: string; scopes?: Set<InjectorScope> }) {\n  return new R3Injector(\n    [\n      ...options.providers,\n      {\n        provide: INJECTOR_SCOPE,\n        useValue: 'root',\n      },\n    ],\n    getNullInjector(),\n    options.name ?? '',\n    options.scopes ?? new Set(['environment']),\n  );\n}\n"],
  "mappings": "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",
  "names": ["DecoratorFlags", "InternalInjectFlags", "computed", "untracked", "NotificationSource", "untracked", "request", "createInjector"]
}