{
  "version": 3,
  "sources": ["../src/import/di/interface/provider.ts", "../src/import/errors.ts", "../src/import/render3/definition_factory.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/render3/errors_di.ts", "../src/import/di/interface/injector.ts", "../src/import/di/inject_switch.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/watch.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/di/contextual.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/patch.ts", "../src/import/error_handler.ts", "../src/import/pending_tasks.ts", "../src/import/render3/reactivity/microtask_effect.ts", "../src/import/render3/reactivity/effect.ts", "../src/import/util/callback_scheduler.ts", "../src/import/change_detection/scheduling/zoneless_scheduling_impl.ts", "../src/import/resource/api.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 =\n  | ValueProvider\n  | ExistingProvider\n  | StaticClassProvider\n  | ConstructorProvider\n  | FactoryProvider\n  | 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 =\n  | TypeProvider\n  | ValueProvider\n  | ClassProvider\n  | ConstructorProvider\n  | ExistingProvider\n  | FactoryProvider\n  | 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(\n  value: Provider | EnvironmentProviders | InternalEnvironmentProviders,\n): 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\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\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\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  // 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\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>(\n  code: T,\n  message: null | false | string,\n): 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  const fullCode = `NG0${Math.abs(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>(\n  type: any,\n  throwNotFound?: boolean,\n): 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\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  throw Error('Could not find renamed property on target object.');\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 = getClosureSafeProperty({\n  ɵfac: getClosureSafeProperty,\n});\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 = getClosureSafeProperty({\n  __NG_ENV_ID__: getClosureSafeProperty,\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 * 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 (\n    str.substring(0, halfLimit) + '...' + str.substring(str.length - halfLimit)\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';\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({\n  __forward_ref__: getClosureSafeProperty,\n});\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 *   standalone: true,\n *   imports: [ChildComponent],\n *   selector: 'app-parent',\n *   template: `<app-child [hideParent]=\"hideParent\"></app-child>`,\n * })\n * export class ParentComponent {\n *   @Input() hideParent: boolean;\n * }\n *\n *\n * @Component({\n *   standalone: true,\n *   imports: [CommonModule, forwardRef(() => ParentComponent)],\n *   selector: 'app-child',\n *   template: `<app-parent *ngIf=\"!hideParent\"></app-parent>`,\n * })\n * export class ChildComponent {\n *   @Input() hideParent: 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 (\n    typeof fn === 'function' &&\n    fn.hasOwnProperty(__forward_ref__) &&\n    fn.__forward_ref__ === forwardRef\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';\nimport { getClosureSafeProperty } from '../../util/property';\n\nimport {\n  ClassProvider,\n  ConstructorProvider,\n  EnvironmentProviders,\n  ExistingProvider,\n  FactoryProvider,\n  StaticClassProvider,\n  ValueProvider,\n} 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:\n    | InjectorType<any>\n    | 'root'\n    | 'platform'\n    | 'any'\n    | 'environment'\n    | 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: (\n    | Type<any>\n    | ValueProvider\n    | ExistingProvider\n    | FactoryProvider\n    | ConstructorProvider\n    | StaticClassProvider\n    | ClassProvider\n    | EnvironmentProviders\n    | any[]\n  )[];\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?: (\n    | Type<any>\n    | ValueProvider\n    | ExistingProvider\n    | FactoryProvider\n    | ConstructorProvider\n    | StaticClassProvider\n    | ClassProvider\n    | EnvironmentProviders\n    | any[]\n  )[];\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: {\n  token: unknown;\n  providedIn?: Type<any> | 'root' | 'platform' | 'any' | 'environment' | null;\n  factory: () => T;\n}): 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: {\n  providers?: any[];\n  imports?: any[];\n}): 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>(\n  type: any,\n): ɵɵInjectableDeclaration<T> | null {\n  return (\n    getOwnDefinition(type, NG_PROV_DEF) || {\n      token: type,\n      factory: () => new type(),\n      ...type.injectOptions,\n    }\n  );\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>(\n  type: any,\n  field: string,\n): ɵɵInjectableDeclaration<T> | 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>(\n  type: any,\n): ɵɵInjectableDeclaration<T> | null {\n  const def = type && (type[NG_PROV_DEF] || null);\n\n  if (def) {\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) || false)\n    ? (type as any)[NG_INJ_DEF]\n    : null;\n}\n\nexport const NG_PROV_DEF = getClosureSafeProperty({\n  ɵprov: getClosureSafeProperty,\n});\nexport const NG_INJ_DEF = getClosureSafeProperty({\n  ɵinj: getClosureSafeProperty,\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 { ɵɵ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      // 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<\n  ReadonlyArray<() => 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\nimport type { ProviderToken } from '../di';\nimport { RuntimeError, RuntimeErrorCode } from '../errors';\n\n/** Throws an error when a token is not found in DI. */\nexport function throwProviderNotFoundError(\n  token: ProviderToken<unknown>,\n  injectorName?: string,\n): never {\n  const errorMessage = null;\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\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 * Injection flags for DI.\n *\n * @publicApi\n * @deprecated use an options object for [`inject`](api/core/inject) instead.\n */\nexport enum InjectFlags {\n  // TODO(alxhub): make this 'const' (and remove `InternalInjectFlags` enum) when ngc no longer\n  // writes exports of it into ngfactory files.\n\n  /** Check self and check parent injector if needed */\n  Default = 0b0000,\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/**\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  /** 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/**\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 { InjectFlags } 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:\n  | (<T>(token: ProviderToken<T>, flags?: InjectFlags) => T | null)\n  | undefined;\nexport function getInjectImplementation() {\n  return _injectImplementation;\n}\n\n/**\n * Sets the current inject implementation.\n */\nexport function setInjectImplementation(\n  impl:\n    | (<T>(token: ProviderToken<T>, flags?: InjectFlags) => T | null)\n    | undefined,\n): (<T>(token: ProviderToken<T>, flags?: InjectFlags) => 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>(\n  token: ProviderToken<T>,\n  notFoundValue: T | undefined,\n  flags: InjectFlags,\n): T | null {\n  const injectableDef: ɵɵInjectableDeclaration<T> | null =\n    getInjectableDef(token);\n  if (injectableDef && injectableDef.providedIn == 'root') {\n    return injectableDef.value === undefined\n      ? (injectableDef.value = injectableDef.factory())\n      : injectableDef.value;\n  }\n  if (flags & InjectFlags.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 { 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 {\n  DecoratorFlags,\n  InjectFlags,\n  InjectOptions,\n  InternalInjectFlags,\n} from './interface/injector';\nimport { ProviderToken } from './provider_token';\n\nconst _THROW_IF_NOT_FOUND = {};\nexport const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\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\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 * 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(\n  injector: Injector | null | undefined,\n): Injector | undefined | null {\n  const former = _currentInjector;\n  _currentInjector = injector;\n  return former;\n}\n\nexport function injectInjectorOnly<T>(token: ProviderToken<T>): T;\nexport function injectInjectorOnly<T>(\n  token: ProviderToken<T>,\n  flags?: InjectFlags,\n): T | null;\nexport function injectInjectorOnly<T>(\n  token: ProviderToken<T>,\n  flags = InjectFlags.Default,\n): T | null {\n  if (_currentInjector === undefined) {\n    throw new RuntimeError(RuntimeErrorCode.MISSING_INJECTION_CONTEXT, null);\n  } else if (_currentInjector === null) {\n    return injectRootLimpMode(token, undefined, flags);\n  } else {\n    const value = _currentInjector.get(\n      token,\n      flags & InjectFlags.Optional ? null : undefined,\n      flags,\n    );\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>(\n  token: ProviderToken<T>,\n  flags?: InjectFlags,\n): T | null;\n\nexport function ɵɵinject<T>(\n  token: ProviderToken<T>,\n  flags?: InjectFlags,\n): string | null;\nexport function ɵɵinject<T>(\n  token: ProviderToken<T>,\n  flags = InjectFlags.Default,\n): T | null {\n  return (getInjectImplementation() || injectInjectorOnly)(\n    resolveForwardRef(token as Type<T>),\n    flags,\n  );\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, null);\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 flags Control how injection is executed. The flags correspond to injection strategies that\n *     can be specified with 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 * @publicApi\n * @deprecated prefer an options object instead of `InjectFlags`\n */\nexport function inject<T>(\n  token: ProviderToken<T>,\n  flags?: InjectFlags,\n): T | null;\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>(\n  token: ProviderToken<T>,\n  options: InjectOptions & { optional?: false },\n): 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>(\n  token: ProviderToken<T>,\n  options: InjectOptions,\n): 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>(\n  token: ProviderToken<T>,\n  flags: InjectFlags | InjectOptions = InjectFlags.Default,\n) {\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(flags));\n}\n\n// Converts object-based DI flags (`InjectOptions`) to bit flags (`InjectFlags`).\nexport function convertToBitFlags(\n  flags: InjectOptions | InjectFlags | undefined,\n): InjectFlags | 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 &&\n      InternalInjectFlags.SkipSelf) as number)) as InjectFlags;\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, null);\n      }\n      let type: Type<any> | undefined = undefined;\n      let flags: InjectFlags = InjectFlags.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(\n  decorator: any,\n  flag: InternalInjectFlags | DecoratorFlags,\n): 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(\n  e: any,\n  token: any,\n  injectorErrorName: string,\n  source: string | null,\n): 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    '\\n' + e.message,\n    tokenPath,\n    injectorErrorName,\n    source,\n  );\n  e[NG_TOKEN_PATH] = tokenPath;\n  e[NG_TEMP_TOKEN_PATH] = null;\n  throw e;\n}\n\nexport function formatError(\n  text: string,\n  obj: any,\n  injectorErrorName: string,\n  source: string | null = null,\n): string {\n  text =\n    text && text.charAt(0) === '\\n' && text.charAt(1) == NO_NEW_LINE\n      ? text.slice(2)\n      : 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(\n          key +\n            ':' +\n            (typeof value === 'string'\n              ? JSON.stringify(value)\n              : stringify(value)),\n        );\n      }\n    }\n    context = `{${parts.join(', ')}}`;\n  }\n  return `${injectorErrorName}${source ? '(' + source + ')' : ''}[${context}]: ${text.replace(\n    NEW_LINE,\n    '\\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 { 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<\n  ReadonlyArray<Type<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 { 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 Error(\n        `NullInjectorError: No provider for ${stringify(token)}!`,\n      );\n      error.name = 'NullInjectorError';\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, InjectorTypeWithProviders } from './interface/defs';\nimport {\n  ClassProvider,\n  ConstructorProvider,\n  EnvironmentProviders,\n  ExistingProvider,\n  FactoryProvider,\n  InternalEnvironmentProviders,\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 */\nexport function makeEnvironmentProviders(\n  providers: (Provider | EnvironmentProviders)[],\n): 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(\n  initializerFn: () => void,\n): 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 =\n  | Type<unknown>\n  | ModuleWithProviders<unknown>\n  | Array<ImportProvidersSource>;\n\ntype WalkProviderTreeVisitor = (\n  provider: SingleProvider,\n  container: Type<unknown> | InjectorType<unknown>,\n) => void;\n\n/**\n * Collects providers from all NgModules and standalone components, including transitively imported\n * ones.\n *\n * Providers extracted via `importProvidersFrom` are only usable in an application injector or\n * another environment injector (such as a route injector). They should not be used in component\n * providers.\n *\n * More information about standalone components can be found in [this\n * guide](guide/components/importing).\n *\n * @usageNotes\n * The results of the `importProvidersFrom` call can be used in the `bootstrapApplication` call:\n *\n * ```ts\n * await bootstrapApplication(RootComponent, {\n *   providers: [\n *     importProvidersFrom(NgModuleOne, NgModuleTwo)\n *   ]\n * });\n * ```\n *\n * You can also use the `importProvidersFrom` results in the `providers` field of a route, when a\n * standalone component is used:\n *\n * ```ts\n * export const ROUTES: Route[] = [\n *   {\n *     path: 'foo',\n *     providers: [\n *       importProvidersFrom(NgModuleOne, NgModuleTwo)\n *     ],\n *     component: YourStandaloneComponent\n *   }\n * ];\n * ```\n *\n * @returns Collected providers from the specified list of types.\n * @publicApi\n */\nexport function importProvidersFrom(\n  ...sources: ImportProvidersSource[]\n): EnvironmentProviders {\n  return {\n    ɵproviders: internalImportProvidersFrom(true, sources),\n    ɵfromNgModule: true,\n  } as InternalEnvironmentProviders;\n}\n\nexport function internalImportProvidersFrom(\n  checkForStandaloneCmp: boolean,\n  ...sources: ImportProvidersSource[]\n): Provider[] {\n  const providersOut: SingleProvider[] = [];\n  const dedup = new Set<Type<unknown>>(); // already seen types\n  let injectorTypesWithProviders:\n    | InjectorTypeWithProviders<unknown>[]\n    | undefined;\n\n  const collectProviders: WalkProviderTreeVisitor = (provider) => {\n    providersOut.push(provider);\n  };\n\n  // Collect all providers from `ModuleWithProviders` types.\n  if (injectorTypesWithProviders !== undefined) {\n    processInjectorTypesWithProviders(\n      injectorTypesWithProviders,\n      collectProviders,\n    );\n  }\n\n  return providersOut;\n}\n\n/**\n * Collects all providers from the list of `ModuleWithProviders` and appends them to the provided\n * array.\n */\nfunction processInjectorTypesWithProviders(\n  typesWithProviders: InjectorTypeWithProviders<unknown>[],\n  visitor: WalkProviderTreeVisitor,\n): void {\n  for (let i = 0; i < typesWithProviders.length; i++) {\n    const { ngModule, providers } = typesWithProviders[i];\n  }\n}\n\n/**\n * Internal type for a single provider in a deep provider array.\n */\nexport type SingleProvider =\n  | TypeProvider\n  | ValueProvider\n  | ClassProvider\n  | ConstructorProvider\n  | ExistingProvider\n  | FactoryProvider\n  | StaticClassProvider;\n\nexport const USE_VALUE = 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(\n  value: SingleProvider,\n): value is ExistingProvider {\n  return !!(value && (value as ExistingProvider).useExisting);\n}\n\nexport function isFactoryProvider(\n  value: SingleProvider,\n): 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';\n\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 {\n  catchInjectorError,\n  convertToBitFlags,\n  injectArgs,\n  NG_TEMP_TOKEN_PATH,\n  setCurrentInjector,\n  THROW_IF_NOT_FOUND,\n  ɵɵinject,\n} from './injector_compatibility';\nimport { INJECTOR } from './injector_token';\nimport {\n  getInheritedInjectableDef,\n  getInjectableDef,\n  InjectorType,\n  ɵɵInjectableDeclaration,\n} from './interface/defs';\nimport { InjectFlags, InjectOptions } from './interface/injector';\nimport {\n  ClassProvider,\n  ConstructorProvider,\n  EnvironmentProviders,\n  InternalEnvironmentProviders,\n  isEnvironmentProviders,\n  Provider,\n  StaticClassProvider,\n} from './interface/provider';\nimport { INJECTOR_DEF_TYPES } from './internal_tokens';\nimport { NullInjector } from './null_injector';\nimport {\n  isExistingProvider,\n  isFactoryProvider,\n  isTypeProvider,\n  isValueProvider,\n  SingleProvider,\n} from './provider_collection';\nimport { ProviderToken } from './provider_token';\nimport { INJECTOR_SCOPE, InjectorScope } from './scope';\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 */\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>(\n    token: ProviderToken<T>,\n    notFoundValue: null | undefined,\n    options: InjectOptions,\n  ): 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>(\n    token: ProviderToken<T>,\n    notFoundValue?: T,\n    options?: InjectOptions,\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   * @deprecated use object-based flags (`InjectOptions`) instead.\n   */\n  abstract get<T>(\n    token: ProviderToken<T>,\n    notFoundValue?: T,\n    flags?: InjectFlags,\n  ): T;\n  /**\n   * @deprecated from v4.0.0 use ProviderToken<T>\n   * @suppress {duplicate}\n   */\n  abstract get(token: any, 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  /**\n   * @internal\n   */\n  abstract onDestroy(callback: () => void): () => void;\n}\n\nexport class R3Injector extends EnvironmentInjector {\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  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(\n      providers as Array<Provider | InternalEnvironmentProviders>,\n      (provider) => this.processProvider(provider),\n    );\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(\n      INJECTOR_SCOPE,\n    ) 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(\n      this.get(INJECTOR_DEF_TYPES, EMPTY_ARRAY, InjectFlags.Self),\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    }\n  }\n\n  override get<T>(\n    token: ProviderToken<T>,\n    notFoundValue: any = THROW_IF_NOT_FOUND,\n    flags: InjectFlags | InjectOptions = InjectFlags.Default,\n  ): T {\n    assertNotDestroyed(this);\n\n    if (token.hasOwnProperty(NG_ENV_ID)) {\n      return (token as any)[NG_ENV_ID](this);\n    }\n\n    flags = convertToBitFlags(flags) as InjectFlags;\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 & InjectFlags.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(\n              injectableDefOrInjectorDefFactory(token),\n              NOT_YET,\n            );\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 & InjectFlags.Self)\n        ? this.parent\n        : 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 =\n        flags & InjectFlags.Optional && notFoundValue === THROW_IF_NOT_FOUND\n          ? null\n          : notFoundValue;\n      return nextInjector.get(token, notFoundValue);\n    } catch (e: any) {\n      if (e.name === 'NullInjectorError') {\n        const path: any[] = (e[NG_TEMP_TOKEN_PATH] =\n          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    }\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(\n        ENVIRONMENT_INITIALIZER,\n        EMPTY_ARRAY,\n        InjectFlags.Self,\n      );\n      if (false) {\n      }\n      for (const initializer of initializers) {\n        initializer();\n      }\n    } finally {\n      setCurrentInjector(previousInjector);\n      setInjectImplementation(previousInjectImplementation);\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)\n      ? provider\n      : 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 (false) {\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 (\n        typeof record.value === 'object' &&\n        record.value &&\n        hasOnDestroy(record.value)\n      ) {\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(\n  token: ProviderToken<any>,\n): 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 =\n    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, null);\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, null);\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, null);\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(\n  provider: SingleProvider,\n  ngModuleType?: InjectorType<any>,\n  providers?: any[],\n): () => any {\n  let factory: (() => any) | undefined = undefined;\n  if (false) {\n  }\n\n  if (isTypeProvider(provider)) {\n    const unwrappedProvider = resolveForwardRef(provider);\n    return (\n      getFactoryDef(unwrappedProvider) ||\n      injectableDefOrInjectorDefFactory(unwrappedProvider)\n    );\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(\n        provider &&\n          ((provider as StaticClassProvider | ClassProvider).useClass ||\n            provider.provide),\n      );\n      if (false) {\n      }\n      if (hasDeps(provider)) {\n        factory = () => new classRef(...injectArgs(provider.deps));\n      } else {\n        return (\n          getFactoryDef(classRef) || injectableDefOrInjectorDefFactory(classRef)\n        );\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, null);\n  }\n}\n\nfunction makeRecord<T>(\n  factory: (() => T) | undefined,\n  value: T | {},\n  multi: boolean = false,\n): Record<T> {\n  return {\n    factory: factory,\n    value: value,\n    multi: multi ? [] : undefined,\n  };\n}\n\nfunction hasDeps(\n  value: ClassProvider | ConstructorProvider | StaticClassProvider,\n): value is ClassProvider & { deps: any[] } {\n  return !!(value as any).deps;\n}\n\nfunction hasOnDestroy(value: any): value is OnDestroy {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    typeof (value as OnDestroy).ngOnDestroy === 'function'\n  );\n}\n\nfunction couldBeInjectableType(value: any): value is ProviderToken<any> {\n  return (\n    typeof value === 'function' ||\n    (typeof value === 'object' && value instanceof InjectionToken)\n  );\n}\n\nfunction forEachSingleProvider(\n  providers: Array<Provider | EnvironmentProviders>,\n  fn: (provider: SingleProvider) => void,\n): 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  (\n    target: object,\n    propertyKey?: string | symbol,\n    parameterIndex?: number,\n  ): 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(\n  name: string,\n  props?: (...args: any[]) => any,\n  parentClass?: any,\n): any {\n  return noSideEffects(() => {\n    const metaCtor = makeMetadataCtor(props);\n    function ParamDecoratorFactory(\n      this: unknown | typeof ParamDecoratorFactory,\n      ...args: any[]\n    ): 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   * 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(\n    makeParamDecorator('Optional'),\n    InternalInjectFlags.Optional,\n  );\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(\n    makeParamDecorator('SkipSelf'),\n    InternalInjectFlags.SkipSelf,\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 { EMPTY_ARRAY } from '../util/empty';\nimport { stringify } from '../util/stringify';\n\nimport type { Injector } from './injector';\nimport type { Provider, StaticProvider } from './interface/provider';\nimport { importProvidersFrom } from './provider_collection';\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(\n  defType: /* InjectorType<any> */ any,\n  parent: Injector | null = null,\n  additionalProviders: Array<Provider | StaticProvider> | null = null,\n  name?: string,\n): Injector {\n  const injector = createInjectorWithoutInjectorInstances(\n    defType,\n    parent,\n    additionalProviders,\n    name,\n  );\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 = [\n    additionalProviders || EMPTY_ARRAY,\n    importProvidersFrom(defType),\n  ];\n  name = name || (typeof defType === 'object' ? undefined : stringify(defType));\n\n  return new R3Injector(\n    providers,\n    parent || getNullInjector(),\n    name || null,\n    scopes,\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 { 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 { InjectFlags, 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   * Internal note on the `options?: InjectOptions|InjectFlags` override of the `get`\n   * method: consider dropping the `InjectFlags` part in one of the major versions.\n   * It can **not** be done in minor/patch, since it's breaking for custom injectors\n   * that only implement the old `InjectorFlags` interface.\n   */\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>(\n    token: ProviderToken<T>,\n    notFoundValue: null | undefined,\n    options: InjectOptions,\n  ): 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>(\n    token: ProviderToken<T>,\n    notFoundValue?: T,\n    options?: InjectOptions | InjectFlags,\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   * @deprecated use object-based flags (`InjectOptions`) instead.\n   */\n  abstract get<T>(\n    token: ProviderToken<T>,\n    notFoundValue?: T,\n    flags?: InjectFlags,\n  ): T;\n  /**\n   * @deprecated from v4.0.0 use ProviderToken<T>\n   * @suppress {duplicate}\n   */\n  abstract get(token: any, 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: {\n    providers: Array<Provider | StaticProvider>;\n    parent?: Injector;\n    name?: string;\n  }): Injector;\n\n  static create(\n    options:\n      | StaticProvider[]\n      | {\n          providers: Array<Provider | StaticProvider>;\n          parent?: Injector;\n          name?: string;\n        },\n    parent?: Injector,\n  ): 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 * @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\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 = /* @__PURE__ */ Symbol('SIGNAL');\n\nexport function setActiveConsumer(\n  consumer: ReactiveNode | null,\n): 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(\n      typeof ngDevMode !== 'undefined' && ngDevMode\n        ? `Assertion error: signal read during notification phase`\n        : '',\n    );\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 (\n    idx < activeConsumer.producerNode.length &&\n    activeConsumer.producerNode[idx] !== node\n  ) {\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(\n        staleProducer,\n        activeConsumer.producerIndexOfThis[idx],\n      );\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)\n      ? producerAddLiveConsumer(node, activeConsumer, idx)\n      : 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 (\n    !node.producerMustRecompute(node) &&\n    !consumerPollProducersForChange(node)\n  ) {\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(\n  node: ReactiveNode | null,\n): 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(\n  node: ReactiveNode | null,\n  prevConsumer: ReactiveNode | null,\n): void {\n  setActiveConsumer(prevConsumer);\n\n  if (\n    !node ||\n    node.producerNode === undefined ||\n    node.producerIndexOfThis === undefined ||\n    node.producerLastReadVersion === undefined\n  ) {\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(\n        node.producerNode[i],\n        node.producerIndexOfThis[i],\n      );\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(\n        node.producerNode[i],\n        node.producerIndexOfThis[i],\n      );\n    }\n  }\n\n  // Truncate all the arrays to drop all connection from this node to the graph.\n  node.producerNode.length =\n    node.producerLastReadVersion.length =\n    node.producerIndexOfThis.length =\n      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(\n  node: ReactiveNode,\n  consumer: ReactiveNode,\n  indexOfThis: number,\n): 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(\n        node.producerNode[i],\n        node,\n        i,\n      );\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(\n  node: ReactiveNode,\n  idx: number,\n): void {\n  assertProducerNode(node);\n\n  if (\n    typeof ngDevMode !== 'undefined' &&\n    ngDevMode &&\n    idx >= node.liveConsumerNode.length\n  ) {\n    throw new Error(\n      `Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`,\n    );\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(\n        node.producerNode[i],\n        node.producerIndexOfThis[i],\n      );\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", "/**\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} from './graph';\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): ComputedGetter<T> {\n  const node: ComputedNode<T> = Object.create(COMPUTED_NODE);\n  node.computation = computation;\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  (computed as ComputedGetter<T>)[SIGNAL] = node;\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('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 =\n        oldValue !== UNSET &&\n        oldValue !== ERRORED &&\n        newValue !== ERRORED &&\n        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 =\n  defaultThrowError;\n\nexport function throwInvalidWriteToSignalError<T>(node: SignalNode<T>) {\n  throwInvalidWriteToSignalErrorFn(node);\n}\n\nexport function setThrowInvalidWriteToSignalError(\n  fn: <T>(node: SignalNode<T>) => never,\n): 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 {\n  producerAccessed,\n  producerIncrementEpoch,\n  producerNotifyConsumers,\n  producerUpdatesAllowed,\n  REACTIVE_NODE,\n  ReactiveNode,\n  SIGNAL,\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 * If set, called after `WritableSignal`s are updated.\n *\n * This hook can be used to achieve various effects, such as running effects synchronously as part\n * of setting a signal.\n */\nlet postSignalSetFn: (() => void) | null = null;\n\nexport interface SignalNode<T> extends ReactiveNode {\n  value: T;\n  equal: ValueEqualityFn<T>;\n}\n\nexport type SignalBaseGetter<T> = (() => T) & { readonly [SIGNAL]: unknown };\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 * Create a `Signal` that can be set or updated directly.\n */\nexport function createSignal<T>(initialValue: T): SignalGetter<T> {\n  const node: SignalNode<T> = Object.create(SIGNAL_NODE);\n  node.value = initialValue;\n  const getter = (() => {\n    producerAccessed(node);\n    return node.value;\n  }) as SignalGetter<T>;\n  (getter as any)[SIGNAL] = node;\n  return getter;\n}\n\nexport function setPostSignalSetFn(\n  fn: (() => void) | null,\n): (() => void) | null {\n  const prev = postSignalSetFn;\n  postSignalSetFn = fn;\n  return prev;\n}\n\nexport function signalGetFn<T>(this: SignalNode<T>): T {\n  producerAccessed(this);\n  return this.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>(\n  node: SignalNode<T>,\n  updater: (value: T) => T,\n): void {\n  if (!producerUpdatesAllowed()) {\n    throwInvalidWriteToSignalError(node);\n  }\n\n  signalSetFn(node, updater(node.value));\n}\n\nexport function runPostSignalSetFn(): void {\n  postSignalSetFn?.();\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?.();\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  SIGNAL,\n} from './graph';\nimport { signalSetFn, signalUpdateFn } from './signal';\n\nexport type ComputationFn<S, D> = (\n  source: S,\n  previous?: { source: S; value: D },\n) => 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>(\n  sourceFn: () => S,\n  computationFn: ComputationFn<S, D>,\n  equalityFn?: ValueEqualityFn<D>,\n): 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\n  return getter;\n}\n\nexport function linkedSignalSetFn<S, D>(\n  node: LinkedSignalNode<S, D>,\n  newValue: D,\n) {\n  producerUpdateValueVersion(node);\n  signalSetFn(node, newValue);\n  producerMarkClean(node);\n}\n\nexport function linkedSignalUpdateFn<S, D>(\n  node: LinkedSignalNode<S, D>,\n  updater: (value: D) => D,\n): 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 = /* @__PURE__ */ (() => ({\n  ...REACTIVE_NODE,\n  value: UNSET,\n  dirty: true,\n  error: null,\n  equal: defaultEquals,\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('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 (\n      oldValue !== UNSET &&\n      newValue !== ERRORED &&\n      node.equal(oldValue, newValue)\n    ) {\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 {\n  consumerAfterComputation,\n  consumerBeforeComputation,\n  consumerDestroy,\n  consumerMarkDirty,\n  consumerPollProducersForChange,\n  isInNotificationPhase,\n  REACTIVE_NODE,\n  ReactiveNode,\n  SIGNAL,\n} from './graph';\n\n/**\n * A cleanup function that can be optionally registered from the watch logic. If registered, the\n * cleanup logic runs before the next watch execution.\n */\nexport type WatchCleanupFn = () => void;\n\n/**\n * A callback passed to the watch function that makes it possible to register cleanup logic.\n */\nexport type WatchCleanupRegisterFn = (cleanupFn: WatchCleanupFn) => void;\n\nexport interface Watch {\n  notify(): void;\n\n  /**\n   * Execute the reactive expression in the context of this `Watch` consumer.\n   *\n   * Should be called by the user scheduling algorithm when the provided\n   * `schedule` hook is called by `Watch`.\n   */\n  run(): void;\n\n  cleanup(): void;\n\n  /**\n   * Destroy the watcher:\n   * - disconnect it from the reactive graph;\n   * - mark it as destroyed so subsequent run and notify operations are noop.\n   */\n  destroy(): void;\n\n  [SIGNAL]: WatchNode;\n}\nexport interface WatchNode extends ReactiveNode {\n  hasRun: boolean;\n  fn: ((onCleanup: WatchCleanupRegisterFn) => void) | null;\n  schedule: ((watch: Watch) => void) | null;\n  cleanupFn: WatchCleanupFn;\n  ref: Watch;\n}\n\nexport function createWatch(\n  fn: (onCleanup: WatchCleanupRegisterFn) => void,\n  schedule: (watch: Watch) => void,\n  allowSignalWrites: boolean,\n): Watch {\n  const node: WatchNode = Object.create(WATCH_NODE);\n  if (allowSignalWrites) {\n    node.consumerAllowSignalWrites = true;\n  }\n\n  node.fn = fn;\n  node.schedule = schedule;\n\n  const registerOnCleanup = (cleanupFn: WatchCleanupFn) => {\n    node.cleanupFn = cleanupFn;\n  };\n\n  function isWatchNodeDestroyed(node: WatchNode) {\n    return node.fn === null && node.schedule === null;\n  }\n\n  function destroyWatchNode(node: WatchNode) {\n    if (!isWatchNodeDestroyed(node)) {\n      consumerDestroy(node); // disconnect watcher from the reactive graph\n      node.cleanupFn();\n\n      // nullify references to the integration functions to mark node as destroyed\n      node.fn = null;\n      node.schedule = null;\n      node.cleanupFn = NOOP_CLEANUP_FN;\n    }\n  }\n\n  const run = () => {\n    if (node.fn === null) {\n      // trying to run a destroyed watch is noop\n      return;\n    }\n\n    if (isInNotificationPhase()) {\n      throw new Error(\n        `Schedulers cannot synchronously execute watches while scheduling.`,\n      );\n    }\n\n    node.dirty = false;\n    if (node.hasRun && !consumerPollProducersForChange(node)) {\n      return;\n    }\n    node.hasRun = true;\n\n    const prevConsumer = consumerBeforeComputation(node);\n    try {\n      node.cleanupFn();\n      node.cleanupFn = NOOP_CLEANUP_FN;\n      node.fn(registerOnCleanup);\n    } finally {\n      consumerAfterComputation(node, prevConsumer);\n    }\n  };\n\n  node.ref = {\n    notify: () => consumerMarkDirty(node),\n    run,\n    cleanup: () => node.cleanupFn(),\n    destroy: () => destroyWatchNode(node),\n    [SIGNAL]: node,\n  };\n\n  return node.ref;\n}\n\nconst NOOP_CLEANUP_FN: WatchCleanupFn = () => {};\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 WATCH_NODE: Partial<WatchNode> = /* @__PURE__ */ (() => ({\n  ...REACTIVE_NODE,\n  consumerIsAlwaysLive: true,\n  consumerAllowSignalWrites: false,\n  consumerMarkedDirty: (node: WatchNode) => {\n    if (node.schedule !== null) {\n      node.schedule(node.ref);\n    }\n  },\n  hasRun: false,\n  cleanupFn: NOOP_CLEANUP_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 { SIGNAL } from '@angular/core/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 */\nexport type Signal<T> = (() => T) & {\n  [SIGNAL]: unknown;\n};\n\n/**\n * Checks if the given `value` is a reactive `Signal`.\n */\nexport function isSignal(value: unknown): value is Signal<unknown> {\n  return (\n    typeof value === 'function' &&\n    (value as Signal<unknown>)[SIGNAL] !== undefined\n  );\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, SIGNAL } from '@angular/core/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>(\n  computation: () => T,\n  options?: CreateComputedOptions<T>,\n): Signal<T> {\n  const getter = createComputed(computation);\n  if (options?.equal) {\n    getter[SIGNAL].equal = options.equal;\n  }\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 {\n  createSignal,\n  SIGNAL,\n  SignalGetter,\n  SignalNode,\n  signalSetFn,\n  signalUpdateFn,\n} from '@angular/core/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 = /* @__PURE__ */ Symbol('WRITABLE_SIGNAL');\n\n/**\n * A `Signal` with a value that can be mutated via a setter interface.\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>(\n  value: T | { [ɵWRITABLE_SIGNAL]: T },\n): 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>(\n  initialValue: T,\n  options?: CreateSignalOptions<T>,\n): WritableSignal<T> {\n  const signalFn = createSignal(initialValue) as SignalGetter<T> &\n    WritableSignal<T>;\n  const node = signalFn[SIGNAL];\n  if (options?.equal) {\n    node.equal = options.equal;\n  }\n\n  signalFn.set = (newValue: T) => signalSetFn(node, newValue);\n  signalFn.update = (updateFn: (value: T) => T) =>\n    signalUpdateFn(node, updateFn);\n  signalFn.asReadonly = signalAsReadonlyFn.bind(\n    signalFn as any,\n  ) 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(\n  value: unknown,\n): 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 { signalAsReadonlyFn, WritableSignal } from './signal';\nimport { Signal, ValueEqualityFn } from './api';\nimport {\n  ComputationFn,\n  createLinkedSignal,\n  LinkedSignalGetter,\n  LinkedSignalNode,\n  SIGNAL,\n  linkedSignalSetFn,\n  linkedSignalUpdateFn,\n} from '@angular/core/primitives/signals';\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 * @developerPreview\n */\nexport function linkedSignal<D>(\n  computation: () => D,\n  options?: { equal?: ValueEqualityFn<NoInfer<D>> },\n): 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 * @developerPreview\n */\nexport function linkedSignal<S, D>(options: {\n  source: () => S;\n  computation: (\n    source: NoInfer<S>,\n    previous?: { source: NoInfer<S>; value: NoInfer<D> },\n  ) => 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>(\n      optionsOrComputation,\n      identityFn<D>,\n      options?.equal,\n    ) as LinkedSignalGetter<D, D> & WritableSignal<D>;\n    return upgradeLinkedSignalGetter(getter);\n  } else {\n    const getter = createLinkedSignal<S, D>(\n      optionsOrComputation.source,\n      optionsOrComputation.computation,\n      optionsOrComputation.equal,\n    );\n    return upgradeLinkedSignalGetter(getter);\n  }\n}\n\nfunction upgradeLinkedSignalGetter<S, D>(\n  getter: LinkedSignalGetter<S, D>,\n): 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) =>\n    linkedSignalUpdateFn(node, updateFn);\n  upgradedGetter.asReadonly = signalAsReadonlyFn.bind(\n    getter as any,\n  ) 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 { setActiveConsumer } from '@angular/core/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  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 { getActiveConsumer } from '@angular/core/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 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(\n  debugFn: Function,\n  extraContext?: string,\n): 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(\n      RuntimeErrorCode.ASSERTION_NOT_INSIDE_REACTIVE_CONTEXT,\n      null,\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 { RuntimeError, RuntimeErrorCode } from '../errors';\n\nimport {\n  getInjectImplementation,\n  setInjectImplementation,\n} from './inject_switch';\nimport type { Injector } from './injector';\nimport {\n  getCurrentInjector,\n  setCurrentInjector,\n} from './injector_compatibility';\nimport { assertNotDestroyed, R3Injector } from './r3_injector';\n\n/**\n * Runs the given function in the [context](guide/di/dependency-injection-context) of the given\n * `Injector`.\n *\n * Within the function's stack frame, [`inject`](api/core/inject) can be used to inject dependencies\n * from the given `Injector`. Note that `inject` is only usable synchronously, and cannot be used in\n * any asynchronous callbacks or after any `await` points.\n *\n * @param injector the injector which will satisfy calls to [`inject`](api/core/inject) while `fn`\n *     is executing\n * @param fn the closure to be run in the context of `injector`\n * @returns the return value of the function, if any\n * @publicApi\n */\nexport function runInInjectionContext<ReturnT>(\n  injector: Injector,\n  fn: () => ReturnT,\n): ReturnT {\n  if (injector instanceof R3Injector) {\n    assertNotDestroyed(injector);\n  }\n\n  if (false) {\n  }\n  const prevInjector = setCurrentInjector(injector);\n  const previousInjectImplementation = setInjectImplementation(undefined);\n  try {\n    return fn();\n  } finally {\n    setCurrentInjector(prevInjector);\n\n    setInjectImplementation(previousInjectImplementation);\n  }\n}\n\n/**\n * Whether the current stack frame is inside an injection context.\n */\nexport function isInInjectionContext(): boolean {\n  return (\n    getInjectImplementation() !== undefined || getCurrentInjector() != null\n  );\n}\n/**\n * Asserts that the current stack frame is within an [injection\n * context](guide/di/dependency-injection-context) and has access to `inject`.\n *\n * @param debugFn a reference to the function making the assertion (used for the error message).\n *\n * @publicApi\n */\nexport function assertInInjectionContext(debugFn: Function): void {\n  // Taking a `Function` instead of a string name here prevents the unminified name of the function\n  // from being retained in the bundle regardless of minification.\n  if (!isInInjectionContext()) {\n    throw new RuntimeError(RuntimeErrorCode.MISSING_INJECTION_CONTEXT, null);\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\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  /**\n   * @internal\n   * @nocollapse\n   */\n\n  /**\n   * @internal\n   * @nocollapse\n   */\n  static __NG_ENV_ID__: (injector: EnvironmentInjector) => DestroyRef = (\n    injector,\n  ) => 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>(\n  typeof ngDevMode === 'undefined' || ngDevMode ? 'Zoneless enabled' : '',\n  { providedIn: 'root', factory: () => false },\n);\n\n/** Token used to indicate `provideExperimentalZonelessChangeDetection` was used. */\nexport const PROVIDED_ZONELESS = new InjectionToken<boolean>(\n  typeof ngDevMode === 'undefined' || ngDevMode ? 'Zoneless provided' : '',\n  { providedIn: 'root', factory: () => false },\n);\n\nexport const ZONELESS_SCHEDULER_DISABLED = new InjectionToken<boolean>(\n  typeof ngDevMode === 'undefined' || ngDevMode ? 'scheduler disabled' : '',\n);\n\n// TODO(atscott): Remove in v19. Scheduler should be done with runOutsideAngular.\nexport const SCHEDULE_IN_ROOT_ZONE = new InjectionToken<boolean>(\n  typeof ngDevMode === 'undefined' || ngDevMode\n    ? 'run changes outside zone in root'\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 { ɵɵ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}\n\n/**\n * A scheduler which manages the execution of effects.\n */\nexport abstract class EffectScheduler {\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 queuedEffectCount = 0;\n  private queues = new Map<Zone | null, Set<SchedulableEffect>>();\n\n  schedule(handle: SchedulableEffect): void {\n    this.enqueue(handle);\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    this.queuedEffectCount--;\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    this.queuedEffectCount++;\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.queuedEffectCount > 0) {\n      for (const [zone, queue] of this.queues) {\n        // `zone` here must be defined.\n        if (zone === null) {\n          this.flushQueue(queue);\n        } else {\n          zone.run(() => this.flushQueue(queue));\n        }\n      }\n    }\n  }\n\n  private flushQueue(queue: Set<SchedulableEffect>): void {\n    for (const handle of queue) {\n      queue.delete(handle);\n      this.queuedEffectCount--;\n\n      // TODO: what happens if this throws an error?\n      handle.run();\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 * Controls whether effects use the legacy `microtaskEffect` by default.\n */\nexport const USE_MICROTASK_EFFECT_BY_DEFAULT = false;\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 * 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 * @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 } from 'rxjs';\n\nimport { inject } from './di/injector_compatibility';\nimport { ɵɵdefineInjectable } from './di/interface/defs';\nimport { OnDestroy } from './interface/lifecycle_hooks';\nimport {\n  ChangeDetectionScheduler,\n  NotificationSource,\n} from './change_detection/scheduling/zoneless_scheduling';\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 get _hasPendingTasks() {\n    return this.hasPendingTasks.value;\n  }\n  hasPendingTasks = new BehaviorSubject<boolean>(false);\n\n  add(): number {\n    if (!this._hasPendingTasks) {\n      this.hasPendingTasks.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.hasPendingTasks.next(false);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.pendingTasks.clear();\n    if (this._hasPendingTasks) {\n      this.hasPendingTasks.next(false);\n    }\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\n * @developerPreview\n */\nexport class PendingTasks {\n  private internalPendingTasks = inject(PendingTasksInternal);\n  private scheduler = inject(ChangeDetectionScheduler);\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   * Application stability is at least delayed until the next tick after the `run` method resolves\n   * so it is safe to make additional updates to application state that would require UI synchronization:\n   *\n   * ```ts\n   * const userData = await pendingTasks.run(() => fetch('/api/user'));\n   * this.userData.set(userData);\n   * ```\n   *\n   * @param fn The asynchronous function to execute\n   */\n  async run<T>(fn: () => Promise<T>): Promise<T> {\n    const removeTask = this.add();\n    try {\n      return await fn();\n    } finally {\n      removeTask();\n    }\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 {\n  createWatch,\n  Watch,\n  WatchCleanupRegisterFn,\n} from '@angular/core/primitives/signals';\n\nimport { Injector } from '../../di/injector';\nimport { inject } from '../../di/injector_compatibility';\nimport { ɵɵdefineInjectable } from '../../di/interface/defs';\nimport { ErrorHandler } from '../../error_handler';\nimport { DestroyRef } from '../../linker/destroy_ref';\n\nimport type {\n  CreateEffectOptions,\n  EffectCleanupRegisterFn,\n  EffectRef,\n} from './effect';\nimport {\n  type SchedulableEffect,\n  ZoneAwareEffectScheduler,\n} from './root_effect_scheduler';\nimport { assertInInjectionContext } from '../../di';\nimport { PendingTasksInternal } from '../../pending_tasks';\n\nexport class MicrotaskEffectScheduler extends ZoneAwareEffectScheduler {\n  private readonly pendingTasks = inject(PendingTasksInternal);\n  private taskId: number | null = null;\n\n  override schedule(effect: SchedulableEffect): void {\n    // Check whether there are any pending effects _before_ queueing in the base class.\n    super.schedule(effect);\n    if (this.taskId === null) {\n      this.taskId = this.pendingTasks.add();\n      queueMicrotask(() => this.flush());\n    }\n  }\n\n  override flush(): void {\n    try {\n      super.flush();\n    } finally {\n      if (this.taskId !== null) {\n        this.pendingTasks.remove(this.taskId);\n        this.taskId = null;\n      }\n    }\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ /* @__PURE__ */ ɵɵdefineInjectable({\n    token: MicrotaskEffectScheduler,\n    providedIn: 'root',\n    factory: () => new MicrotaskEffectScheduler(),\n  });\n}\n\n/**\n * Core reactive node for an Angular effect.\n *\n * `EffectHandle` combines the reactive graph's `Watch` base node for effects with the framework's\n * scheduling abstraction (`MicrotaskEffectScheduler`) as well as automatic cleanup via `DestroyRef`\n * if available/requested.\n */\nclass EffectHandle implements EffectRef, SchedulableEffect {\n  unregisterOnDestroy: (() => void) | undefined;\n  readonly watcher: Watch;\n\n  constructor(\n    private scheduler: MicrotaskEffectScheduler,\n    private effectFn: (onCleanup: EffectCleanupRegisterFn) => void,\n    public zone: Zone | null,\n    destroyRef: DestroyRef | null,\n    private injector: Injector,\n    allowSignalWrites: boolean,\n  ) {\n    this.watcher = createWatch(\n      (onCleanup) => this.runEffect(onCleanup),\n      () => this.schedule(),\n      allowSignalWrites,\n    );\n    this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());\n  }\n\n  private runEffect(onCleanup: WatchCleanupRegisterFn): void {\n    try {\n      this.effectFn(onCleanup);\n    } catch (err) {\n      // Inject the `ErrorHandler` here in order to avoid circular DI error\n      // if the effect is used inside of a custom `ErrorHandler`.\n      const errorHandler = this.injector.get(ErrorHandler, null, {\n        optional: true,\n      });\n      errorHandler?.handleError(err);\n    }\n  }\n\n  run(): void {\n    this.watcher.run();\n  }\n\n  private schedule(): void {\n    this.scheduler.schedule(this);\n  }\n\n  destroy(): void {\n    this.watcher.destroy();\n    this.unregisterOnDestroy?.();\n\n    // Note: if the effect is currently scheduled, it's not un-scheduled, and so the scheduler will\n    // retain a reference to it. Attempting to execute it will be a no-op.\n  }\n}\n\n// Just used for the name for the debug error below.\nfunction effect() {}\n\n/**\n * Create a global `Effect` for the given reactive function.\n */\nexport function microtaskEffect(\n  effectFn: (onCleanup: EffectCleanupRegisterFn) => void,\n  options?: CreateEffectOptions,\n): EffectRef {\n  !options?.injector && assertInInjectionContext(effect);\n\n  const injector = options?.injector ?? inject(Injector);\n  const destroyRef =\n    options?.manualCleanup !== true ? injector.get(DestroyRef) : null;\n\n  const handle = new EffectHandle(\n    injector.get(MicrotaskEffectScheduler),\n    effectFn,\n    typeof Zone === 'undefined' ? null : Zone.current,\n    destroyRef,\n    injector,\n    options?.allowSignalWrites ?? false,\n  );\n\n  // Effects need to be marked dirty manually to trigger their initial run. The timing of this\n  // marking matters, because the effects may read signals that track component inputs, which are\n  // only available after those components have had their first update pass.\n  //\n  // We inject `ChangeDetectorRef` optionally, to determine whether this effect is being created in\n  // the context of a component or not. If it is, then we check whether the component has already\n  // run its update pass, and defer the effect's initial scheduling until the update pass if it\n  // hasn't already run.\n  handle.watcher.notify();\n\n  return handle;\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} from '@angular/core/primitives/signals';\nimport { InjectionToken } from '../../di/injection_token';\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 {\n  ChangeDetectionScheduler,\n  NotificationSource,\n} from '../../change_detection/scheduling/zoneless_scheduling';\nimport { EffectScheduler, SchedulableEffect } from './root_effect_scheduler';\nimport { USE_MICROTASK_EFFECT_BY_DEFAULT } from './patch';\nimport { microtaskEffect } from './microtask_effect';\n\nlet useMicrotaskEffectsByDefault = USE_MICROTASK_EFFECT_BY_DEFAULT;\n\n/**\n * Toggle the flag on whether to use microtask effects (for testing).\n */\nexport function setUseMicrotaskEffectsByDefault(value: boolean): boolean {\n  const prev = useMicrotaskEffectsByDefault;\n  useMicrotaskEffectsByDefault = value;\n  return prev;\n}\n\n/**\n * A global reactive effect, which can be manually destroyed.\n *\n * @developerPreview\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 * @developerPreview\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  manualCleanup?: boolean;\n\n  /**\n   * Always create a root effect (which is scheduled as a microtask) regardless of whether `effect`\n   * is called within a component.\n   */\n  forceRoot?: true;\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 * @developerPreview\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 * @developerPreview\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, or when the `forceRoot` option is provided.\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 * @developerPreview\n */\nexport function effect(\n  effectFn: (onCleanup: EffectCleanupRegisterFn) => void,\n  options?: CreateEffectOptions,\n): EffectRef {\n  if (useMicrotaskEffectsByDefault) {\n    if (ngDevMode && options?.forceRoot) {\n      throw new Error(\n        `Cannot use 'forceRoot' option with microtask effects on`,\n      );\n    }\n\n    return microtaskEffect(effectFn, options);\n  }\n\n  ngDevMode &&\n    assertNotInReactiveContext(\n      effect,\n      'Call `effect` outside of a reactive context. For example, schedule the ' +\n        'effect inside the component constructor.',\n    );\n\n  !options?.injector && assertInInjectionContext(effect);\n\n  if (ngDevMode && options?.allowSignalWrites !== undefined) {\n    console.warn(\n      `The 'allowSignalWrites' flag is deprecated and no longer impacts effect() (writes are always allowed)`,\n    );\n  }\n\n  const injector = options?.injector ?? inject(Injector);\n  const destroyRef =\n    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\n/**\n * Not public API, which guarantees `EffectScheduler` only ever comes from the application root\n * injector.\n */\nexport const APP_EFFECT_SCHEDULER = /* @__PURE__ */ new InjectionToken('', {\n  providedIn: 'root',\n  factory: () => inject(EffectScheduler),\n});\n\nexport const BASE_EFFECT_NODE: Omit<\n  EffectNode,\n  'fn' | 'destroy' | 'injector' | 'notifier'\n> = /* @__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(\n        `Schedulers cannot synchronously execute watches while scheduling.`,\n      );\n    }\n\n    if (this.hasRun && !consumerPollProducersForChange(this)) {\n      return;\n    }\n    this.hasRun = true;\n\n    const registerCleanupFn: EffectCleanupRegisterFn = (cleanupFn) =>\n      (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    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    }\n  },\n}))();\n\nexport const ROOT_EFFECT_NODE: Omit<\n  RootEffectNode,\n  'fn' | 'scheduler' | 'notifier' | 'injector'\n> = /* @__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(\n  fn: (onCleanup: EffectCleanupRegisterFn) => void,\n  scheduler: EffectScheduler,\n  notifier: ChangeDetectionScheduler,\n): 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.schedule(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 (\n        animationFrameId !== undefined &&\n        typeof cancelAnimationFrame === 'function'\n      ) {\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 {\n  ChangeDetectionScheduler,\n  NotificationSource,\n} 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 { Injector } from '../di/injector';\nimport { Signal, ValueEqualityFn } from '../render3/reactivity/api';\nimport { WritableSignal } from '../render3/reactivity/signal';\n\n/**\n * Status of a `Resource`.\n *\n * @experimental\n */\nexport enum ResourceStatus {\n  /**\n   * The resource has no valid request and will not perform any loading.\n   *\n   * `value()` will be `undefined`.\n   */\n  Idle,\n\n  /**\n   * Loading failed with an error.\n   *\n   * `value()` will be `undefined`.\n   */\n  Error,\n\n  /**\n   * The resource is currently loading a new value as a result of a change in its `request`.\n   *\n   * `value()` will be `undefined`.\n   */\n  Loading,\n\n  /**\n   * The resource is currently reloading a fresh value for the same request.\n   *\n   * `value()` will continue to return the previously fetched value during the reloading operation.\n   */\n  Reloading,\n\n  /**\n   * Loading has completed and the resource has the value returned from the loader.\n   */\n  Resolved,\n\n  /**\n   * The resource's value was set locally via `.set()` or `.update()`.\n   */\n  Local,\n}\n\n/**\n * A Resource is an asynchronous dependency (for example, the results of an API call) that is\n * managed and delivered through signals.\n *\n * The usual way of creating a `Resource` is through the `resource` function, but various other APIs\n * may present `Resource` instances to describe their own concepts.\n *\n * @experimental\n */\nexport interface Resource<T> {\n  /**\n   * The current value of the `Resource`, or `undefined` if there is no current value.\n   */\n  readonly value: Signal<T>;\n\n  /**\n   * The current status of the `Resource`, which describes what the resource is currently doing and\n   * what can be expected of its `value`.\n   */\n  readonly status: Signal<ResourceStatus>;\n\n  /**\n   * When in the `error` state, this returns the last known error from the `Resource`.\n   */\n  readonly error: Signal<unknown>;\n\n  /**\n   * Whether this resource is loading a new value (or reloading the existing one).\n   */\n  readonly isLoading: Signal<boolean>;\n\n  /**\n   * Whether this resource has a valid current value.\n   *\n   * This function is reactive.\n   */\n  hasValue(): this is Resource<Exclude<T, undefined>>;\n\n  /**\n   * Instructs the resource to re-load any asynchronous dependency it may have.\n   *\n   * Note that the resource will not enter its reloading state until the actual backend request is\n   * made.\n   *\n   * @returns true if a reload was initiated, false if a reload was unnecessary or unsupported\n   */\n  reload(): boolean;\n}\n\n/**\n * A `Resource` with a mutable value.\n *\n * Overwriting the value of a resource sets it to the 'local' state.\n *\n * @experimental\n */\nexport interface WritableResource<T> extends Resource<T> {\n  readonly value: WritableSignal<T>;\n  hasValue(): this is WritableResource<Exclude<T, undefined>>;\n\n  /**\n   * Convenience wrapper for `value.set`.\n   */\n  set(value: T): void;\n\n  /**\n   * Convenience wrapper for `value.update`.\n   */\n  update(updater: (value: T) => T): void;\n  asReadonly(): Resource<T>;\n}\n\n/**\n * A `WritableResource` created through the `resource` function.\n *\n * @experimental\n */\nexport interface ResourceRef<T> extends WritableResource<T> {\n  hasValue(): this is ResourceRef<Exclude<T, undefined>>;\n\n  /**\n   * Manually destroy the resource, which cancels pending requests and returns it to `idle` state.\n   */\n  destroy(): void;\n}\n\n/**\n * Parameter to a `ResourceLoader` which gives the request and other options for the current loading\n * operation.\n *\n * @experimental\n */\nexport interface ResourceLoaderParams<R> {\n  request: Exclude<NoInfer<R>, undefined>;\n  abortSignal: AbortSignal;\n  previous: {\n    status: ResourceStatus;\n  };\n}\n\n/**\n * Loading function for a `Resource`.\n *\n * @experimental\n */\nexport type ResourceLoader<T, R> = (\n  param: ResourceLoaderParams<R>,\n) => PromiseLike<T>;\n\n/**\n * Streaming loader for a `Resource`.\n *\n * @experimental\n */\nexport type ResourceStreamingLoader<T, R> = (\n  param: ResourceLoaderParams<R>,\n) => PromiseLike<Signal<ResourceStreamItem<T>>>;\n\n/**\n * Options to the `resource` function, for creating a resource.\n *\n * @experimental\n */\nexport interface BaseResourceOptions<T, R> {\n  /**\n   * A reactive function which determines the request to be made. Whenever the request changes, the\n   * loader will be triggered to fetch a new value for the resource.\n   *\n   * If a request function isn't provided, the loader won't rerun unless the resource is reloaded.\n   */\n  request?: () => R;\n\n  /**\n   * The value which will be returned from the resource when a server value is unavailable, such as\n   * when the resource is still loading, or in an error state.\n   */\n  defaultValue?: NoInfer<T>;\n\n  /**\n   * Equality function used to compare the return value of the loader.\n   */\n  equal?: ValueEqualityFn<T>;\n\n  /**\n   * Overrides the `Injector` used by `resource`.\n   */\n  injector?: Injector;\n}\n\n/**\n * Options to the `resource` function, for creating a resource.\n *\n * @experimental\n */\nexport interface PromiseResourceOptions<T, R>\n  extends BaseResourceOptions<T, R> {\n  /**\n   * Loading function which returns a `Promise` of the resource's value for a given request.\n   */\n  loader: ResourceLoader<T, R>;\n\n  /**\n   * Cannot specify `stream` and `loader` at the same time.\n   */\n  stream?: never;\n}\n\n/**\n * Options to the `resource` function, for creating a resource.\n *\n * @experimental\n */\nexport interface StreamingResourceOptions<T, R>\n  extends BaseResourceOptions<T, R> {\n  /**\n   * Loading function which returns a `Promise` of a signal of the resource's value for a given\n   * request, which can change over time as new values are received from a stream.\n   */\n  stream: ResourceStreamingLoader<T, R>;\n\n  /**\n   * Cannot specify `stream` and `loader` at the same time.\n   */\n  loader?: never;\n}\n\n/**\n * @experimental\n */\nexport type ResourceOptions<T, R> =\n  | PromiseResourceOptions<T, R>\n  | StreamingResourceOptions<T, R>;\n\n/**\n * @experimental\n */\nexport type ResourceStreamItem<T> = { value: T } | { error: 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 { untracked } from '../render3/reactivity/untracked';\nimport { computed } from '../render3/reactivity/computed';\nimport {\n  signal,\n  signalAsReadonlyFn,\n  WritableSignal,\n} from '../render3/reactivity/signal';\nimport { Signal } from '../render3/reactivity/api';\nimport { effect, EffectRef } from '../render3/reactivity/effect';\nimport {\n  ResourceOptions,\n  ResourceStatus,\n  WritableResource,\n  Resource,\n  ResourceRef,\n  ResourceStreamingLoader,\n  StreamingResourceOptions,\n  ResourceStreamItem,\n} from './api';\n\nimport { ValueEqualityFn } from '@angular/core/primitives/signals';\n\nimport { Injector } from '../di/injector';\nimport { assertInInjectionContext } from '../di/contextual';\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 * 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\n */\nexport function resource<T, R>(\n  options: ResourceOptions<T, R> & { defaultValue: NoInfer<T> },\n): 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\n */\nexport function resource<T, R>(\n  options: ResourceOptions<T, R>,\n): ResourceRef<T | undefined>;\nexport function resource<T, R>(\n  options: ResourceOptions<T, R>,\n): ResourceRef<T | undefined> {\n  options?.injector || assertInInjectionContext(resource);\n  const request = (options.request ?? (() => null)) as () => R;\n  return new ResourceImpl<T | undefined, R>(\n    request,\n    getLoader(options),\n    options.defaultValue,\n    options.equal ? wrapEqualityFn(options.equal) : undefined,\n    options.injector ?? inject(Injector),\n  );\n}\n\ntype ResourceInternalStatus =\n  | ResourceStatus.Idle\n  | ResourceStatus.Loading\n  | ResourceStatus.Resolved\n  | ResourceStatus.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<unknown>;\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  update(updateFn: (value: T) => T): void {\n    this.set(updateFn(untracked(this.value)));\n  }\n\n  readonly isLoading = computed(\n    () =>\n      this.status() === ResourceStatus.Loading ||\n      this.status() === ResourceStatus.Reloading,\n  );\n\n  hasValue(): this is ResourceRef<Exclude<T, undefined>> {\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>\n  extends BaseWritableResource<T>\n  implements ResourceRef<T>\n{\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\n  constructor(\n    request: () => R,\n    private readonly loaderFn: ResourceStreamingLoader<T, R>,\n    private readonly defaultValue: T,\n    private readonly equal: ValueEqualityFn<T> | undefined,\n    injector: Injector,\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          return streamValue && isResolved(streamValue)\n            ? streamValue.value\n            : this.defaultValue;\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 =\n          extRequest.request === undefined\n            ? ResourceStatus.Idle\n            : ResourceStatus.Loading;\n        if (!previous) {\n          return {\n            extRequest,\n            status,\n            previousStatus: ResourceStatus.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:\n              previous.value.extRequest.request === extRequest.request\n                ? previous.value.stream\n                : 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    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 (\n      state.status === ResourceStatus.Local &&\n      (this.equal ? this.equal(current, value) : current === value)\n    ) {\n      return;\n    }\n\n    // Enter Local state with the user-defined value.\n    this.state.set({\n      extRequest: state.extRequest,\n      status: ResourceStatus.Local,\n      previousStatus: ResourceStatus.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 === ResourceStatus.Idle || status === ResourceStatus.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 }) => ({\n      request,\n      reload: reload + 1,\n    }));\n    return true;\n  }\n\n  destroy(): void {\n    this.destroyed = true;\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: ResourceStatus.Idle,\n      previousStatus: ResourceStatus.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 !== ResourceStatus.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 =\n      (this.resolvePendingTask = this.pendingTasks.add());\n\n    const { signal: abortSignal } = (this.pendingController =\n      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          request: extRequest.request as Exclude<R, undefined>,\n          abortSignal,\n          previous: {\n            status: previousStatus,\n          },\n        }),\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: ResourceStatus.Resolved,\n        previousStatus: ResourceStatus.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: ResourceStatus.Resolved,\n        previousStatus: ResourceStatus.Error,\n        stream: signal({ error: 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>(\n  equal: ValueEqualityFn<T>,\n): ValueEqualityFn<T | undefined> {\n  return (a, b) => (a === undefined || b === undefined ? a === b : equal(a, b));\n}\n\nfunction getLoader<T, R>(\n  options: ResourceOptions<T, R>,\n): 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: err });\n    }\n  };\n}\n\nfunction isStreamingResourceOptions<T, R>(\n  options: ResourceOptions<T, R>,\n): 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 ResourceStatus.Loading:\n      return state.extRequest.reload === 0\n        ? ResourceStatus.Loading\n        : ResourceStatus.Reloading;\n    case ResourceStatus.Resolved:\n      return isResolved(untracked(state.stream!))\n        ? ResourceStatus.Resolved\n        : ResourceStatus.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", "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 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: {\n  providers: Array<Provider | EnvironmentProviders>;\n  parent: Injector;\n  name?: string;\n  scopes?: Set<InjectorScope>;\n}) {\n  return new R3Injector(\n    options.providers,\n    options.parent ?? getNullInjector(),\n    options.name ?? '',\n    options.scopes ?? new Set([]),\n  );\n}\nexport function createRootInjector(options: {\n  providers: Array<Provider | EnvironmentProviders>;\n  name?: string;\n  scopes?: Set<InjectorScope>;\n}) {\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([]),\n  );\n}\n"],
  "mappings": ";AAsXO,SAAS,uBACd,OACuC;AACvC,SAAO,SAAS,CAAC,CAAE,MAAuC;AAC5D;;;AC/NO,IAAM,eAAN,cAAgE,MAAM;AAAA,EAC3E,YACS,MACP,SACA;AACA,UAAM,mBAAsB,MAAM,OAAO,CAAC;AAHnC;AAAA,EAIT;AACF;AAMO,SAAS,mBACd,MACA,SACQ;AAIR,QAAM,WAAW,MAAM,KAAK,IAAI,IAAI,CAAC;AAErC,QAAM,eAAe,GAAG,QAAQ,GAAG,UAAU,OAAO,UAAU,EAAE;AAEhE,MAAI,OAAO;AAAA,EACX;AACA,SAAO;AACT;;;AC1JO,SAAS,cACd,MACA,eACqB;AACrB,SAAO,MAAM,IAAI,KAAK;AACxB;;;ACzBO,SAAS,uBAA0B,0BAAqC;AAC7E,aAAW,OAAO,0BAA0B;AAC1C,QAAI,yBAAyB,GAAG,MAAO,wBAAgC;AACrE,aAAO;AAAA,IACT;AAAA,EACF;AACA,QAAM,MAAM,mDAAmD;AACjE;;;ACNO,IAAM,iBAAiB,uBAAuB;AAAA,EACnD,MAAM;AACR,CAAC;AAUM,IAAM,YAAY,uBAAuB;AAAA,EAC9C,eAAe;AACjB,CAAC;;;ACPM,IAAM,cAAqB,CAAC;AAGnC,IAAI,OAAO;AACX;;;ACZO,SAAS,UAAU,OAAoB;AAC5C,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,WAAO,IAAI,MAAM,IAAI,SAAS,EAAE,KAAK,IAAI,CAAC;AAAA,EAC5C;AAEA,MAAI,SAAS,MAAM;AACjB,WAAO,KAAK;AAAA,EACd;AAEA,QAAM,OAAO,MAAM,kBAAkB,MAAM;AAC3C,MAAI,MAAM;AACR,WAAO,GAAG,IAAI;AAAA,EAChB;AAEA,QAAM,SAAS,MAAM,SAAS;AAE9B,MAAI,UAAU,MAAM;AAClB,WAAO,KAAK;AAAA,EACd;AAEA,QAAM,eAAe,OAAO,QAAQ,IAAI;AACxC,SAAO,gBAAgB,IAAI,OAAO,MAAM,GAAG,YAAY,IAAI;AAC7D;;;ACTA,IAAM,kBAAkB,uBAAuB;AAAA,EAC7C,iBAAiB;AACnB,CAAC;AAyCM,SAAS,WAAW,cAAuC;AAChE,EAAM,aAAc,kBAAkB;AACtC,EAAM,aAAc,WAAW,WAAY;AACzC,WAAO,UAAU,KAAK,CAAC;AAAA,EACzB;AACA,SAAwB;AAC1B;AAeO,SAAS,kBAAqB,MAAY;AAC/C,SAAO,aAAa,IAAI,IAAI,KAAK,IAAI;AACvC;AAGO,SAAS,aAAa,IAA0B;AACrD,SACE,OAAO,OAAO,cACd,GAAG,eAAe,eAAe,KACjC,GAAG,oBAAoB;AAE3B;;;ACuEO,SAAS,mBAAsB,MAI1B;AACV,SAAO;AAAA,IACL,OAAO,KAAK;AAAA,IACZ,YAAa,KAAK,cAAsB;AAAA,IACxC,SAAS,KAAK;AAAA,IACd,OAAO;AAAA,EACT;AACF;AAmBO,SAAS,iBAAiB,SAGrB;AACV,SAAO,EAAE,WAAW,QAAQ,aAAa,CAAC,GAAG,SAAS,QAAQ,WAAW,CAAC,EAAE;AAC9E;AAQO,SAAS,iBACd,MACmC;AACnC,SACE,iBAAiB,MAAM,WAAW,KAAK;AAAA,IACrC,OAAO;AAAA,IACP,SAAS,MAAM,IAAI,KAAK;AAAA,IACxB,GAAG,KAAK;AAAA,EACV;AAEJ;AAEO,SAAS,aAAa,MAAoB;AAC/C,SAAO,iBAAiB,IAAI,MAAM;AACpC;AAMA,SAAS,iBACP,MACA,OACmC;AACnC,SAAO,KAAK,eAAe,KAAK,IAAI,KAAK,KAAK,IAAI;AACpD;AAUO,SAAS,0BACd,MACmC;AACnC,QAAM,MAAM,SAAS,KAAK,WAAW,KAAK;AAE1C,MAAI,KAAK;AACP,WAAO;AAAA,EACT,OAAO;AACL,WAAO;AAAA,EACT;AACF;AAOO,SAAS,eAAkB,MAAoC;AACpE,SAAO,SAAS,KAAK,eAAe,UAAU,KAAK,SAC9C,KAAa,UAAU,IACxB;AACN;AAEO,IAAM,cAAc,uBAAuB;AAAA,EAChD,OAAO;AACT,CAAC;AACM,IAAM,aAAa,uBAAuB;AAAA,EAC/C,MAAM;AACR,CAAC;;;ACzNM,IAAM,iBAAN,MAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAY7B,YACY,OACV,SAIA;AALU;AAMV,SAAK,QAAQ;AACb,QAAI,OAAO,YAAY,UAAU;AAAA,IAGjC,WAAW,YAAY,QAAW;AAChC,WAAK,QAAQ,mBAAmB;AAAA,QAC9B,OAAO;AAAA,QACP,YAAY,QAAQ,cAAc;AAAA,QAClC,SAAS,QAAQ;AAAA,MACnB,CAAC;AAAA,IACH;AAAA,EACF;AAAA;AAAA,EA5BS,iBAAiB;AAAA,EAEjB;AAAA;AAAA;AAAA;AAAA,EA+BT,IAAI,QAAkC;AACpC,WAAO;AAAA,EACT;AAAA,EAEA,WAAmB;AACjB,WAAO,kBAAkB,KAAK,KAAK;AAAA,EACrC;AACF;;;AC/EO,IAAM,0BAA0B,IAAI,eAEzC,EAAE;;;ACbG,SAAS,2BACd,OACA,cACO;AACP,QAAM,eAAe;AACrB,QAAM,IAAI,4CAAkD,YAAY;AAC1E;;;ACLO,IAAW,iBAAX,kBAAWA,oBAAX;AACL,EAAAA,gCAAA,YAAS,MAAT;AADgB,SAAAA;AAAA,GAAA;AAUX,IAAK,cAAL,kBAAKC,iBAAL;AAKL,EAAAA,0BAAA,aAAU,KAAV;AAGA,EAAAA,0BAAA,UAAO,KAAP;AAGA,EAAAA,0BAAA,cAAW,KAAX;AAGA,EAAAA,0BAAA,cAAW,KAAX;AAdU,SAAAA;AAAA,GAAA;AAyBL,IAAW,sBAAX,kBAAWC,yBAAX;AAEL,EAAAA,0CAAA,aAAU,KAAV;AAGA,EAAAA,0CAAA,UAAO,KAAP;AAGA,EAAAA,0CAAA,cAAW,KAAX;AAGA,EAAAA,0CAAA,cAAW,KAAX;AAXgB,SAAAA;AAAA,GAAA;;;ACzBlB,IAAI;AAGG,SAAS,0BAA0B;AACxC,SAAO;AACT;AAKO,SAAS,wBACd,MAG6E;AAC7E,QAAM,WAAW;AACjB,0BAAwB;AACxB,SAAO;AACT;AASO,SAAS,mBACd,OACA,eACA,OACU;AACV,QAAM,gBACJ,iBAAiB,KAAK;AACxB,MAAI,iBAAiB,cAAc,cAAc,QAAQ;AACvD,WAAO,cAAc,UAAU,SAC1B,cAAc,QAAQ,cAAc,QAAQ,IAC7C,cAAc;AAAA,EACpB;AACA,MAAI,yBAA8B,QAAO;AACzC,MAAI,kBAAkB,OAAW,QAAO;AACxC,6BAA2B,OAAO,UAAU;AAC9C;;;ACzCA,IAAM,sBAAsB,CAAC;AACtB,IAAM,qBAAqB;AAOlC,IAAM,oBAAoB;AAEnB,IAAM,qBAAqB;AAClC,IAAM,gBAAgB;AACtB,IAAM,WAAW;AACjB,IAAM,cAAc;AACb,IAAM,SAAS;AAQtB,IAAI,mBAAgD;AAE7C,SAAS,qBAAkD;AAChE,SAAO;AACT;AAEO,SAAS,mBACd,UAC6B;AAC7B,QAAM,SAAS;AACf,qBAAmB;AACnB,SAAO;AACT;AAOO,SAAS,mBACd,OACA,yBACU;AACV,MAAI,qBAAqB,QAAW;AAClC,UAAM,IAAI,mDAAyD,IAAI;AAAA,EACzE,WAAW,qBAAqB,MAAM;AACpC,WAAO,mBAAmB,OAAO,QAAW,KAAK;AAAA,EACnD,OAAO;AACL,UAAM,QAAQ,iBAAiB;AAAA,MAC7B;AAAA,MACA,2BAA+B,OAAO;AAAA,MACtC;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACF;AAsBO,SAAS,SACd,OACA,yBACU;AACV,UAAQ,wBAAwB,KAAK;AAAA,IACnC,kBAAkB,KAAgB;AAAA,IAClC;AAAA,EACF;AACF;AAWO,SAAS,oBAAoB,OAAqB;AACvD,QAAM,IAAI,mDAA0D,IAAI;AAC1E;AA+IO,SAAS,OACd,OACA,yBACA;AAGA,SAAO,SAAS,OAAc,kBAAkB,KAAK,CAAC;AACxD;AAGO,SAAS,kBACd,OACyB;AACzB,MAAI,OAAO,UAAU,eAAe,OAAO,UAAU,UAAU;AAC7D,WAAO;AAAA,EACT;AAKA;AAAA,GACI,MAAM,gCACR,KACE,MAAM,yBACN,MAAM;AAEZ;AAEO,SAAS,WAAW,OAA8C;AACvE,QAAM,OAAc,CAAC;AACrB,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,UAAM,MAAM,kBAAkB,MAAM,CAAC,CAAC;AACtC,QAAI,MAAM,QAAQ,GAAG,GAAG;AACtB,UAAI,IAAI,WAAW,GAAG;AACpB,cAAM,IAAI,6CAAoD,IAAI;AAAA,MACpE;AACA,UAAI,OAA8B;AAClC,UAAI;AAEJ,eAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,cAAM,OAAO,IAAI,CAAC;AAClB,cAAM,OAAO,cAAc,IAAI;AAC/B,YAAI,OAAO,SAAS,UAAU;AAE5B,cAAI,0BAAgC;AAClC,mBAAO,KAAK;AAAA,UACd,OAAO;AACL,qBAAS;AAAA,UACX;AAAA,QACF,OAAO;AACL,iBAAO;AAAA,QACT;AAAA,MACF;AAEA,WAAK,KAAK,SAAS,MAAO,KAAK,CAAC;AAAA,IAClC,OAAO;AACL,WAAK,KAAK,SAAS,GAAG,CAAC;AAAA,IACzB;AAAA,EACF;AACA,SAAO;AACT;AAYO,SAAS,iBACd,WACA,MACK;AACL,YAAU,iBAAiB,IAAI;AAC/B,YAAU,UAAU,iBAAiB,IAAI;AACzC,SAAO;AACT;AAOO,SAAS,cAAc,OAAgC;AAC5D,SAAO,MAAM,iBAAiB;AAChC;AAEO,SAAS,mBACd,GACA,OACA,mBACA,QACO;AACP,QAAM,YAAmB,EAAE,kBAAkB;AAC7C,MAAI,MAAM,MAAM,GAAG;AACjB,cAAU,QAAQ,MAAM,MAAM,CAAC;AAAA,EACjC;AACA,IAAE,UAAU;AAAA,IACV,OAAO,EAAE;AAAA,IACT;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,IAAE,aAAa,IAAI;AACnB,IAAE,kBAAkB,IAAI;AACxB,QAAM;AACR;AAEO,SAAS,YACd,MACA,KACA,mBACA,SAAwB,MAChB;AACR,SACE,QAAQ,KAAK,OAAO,CAAC,MAAM,QAAQ,KAAK,OAAO,CAAC,KAAK,cACjD,KAAK,MAAM,CAAC,IACZ;AACN,MAAI,UAAU,UAAU,GAAG;AAC3B,MAAI,MAAM,QAAQ,GAAG,GAAG;AACtB,cAAU,IAAI,IAAI,SAAS,EAAE,KAAK,MAAM;AAAA,EAC1C,WAAW,OAAO,QAAQ,UAAU;AAClC,UAAM,QAAkB,CAAC;AACzB,eAAW,OAAO,KAAK;AACrB,UAAI,IAAI,eAAe,GAAG,GAAG;AAC3B,cAAM,QAAQ,IAAI,GAAG;AACrB,cAAM;AAAA,UACJ,MACE,OACC,OAAO,UAAU,WACd,KAAK,UAAU,KAAK,IACpB,UAAU,KAAK;AAAA,QACvB;AAAA,MACF;AAAA,IACF;AACA,cAAU,IAAI,MAAM,KAAK,IAAI,CAAC;AAAA,EAChC;AACA,SAAO,GAAG,iBAAiB,GAAG,SAAS,MAAM,SAAS,MAAM,EAAE,IAAI,OAAO,MAAM,KAAK;AAAA,IAClF;AAAA,IACA;AAAA,EACF,CAAC;AACH;;;ACxYO,IAAM,WAAW,IAAI;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAIF;;;ACbO,IAAM,qBAAqB,IAAI,eAEpC,EAAE;;;ACFG,IAAM,eAAN,MAAuC;AAAA,EAC5C,IAAI,OAAY,gBAAqB,oBAAyB;AAC5D,QAAI,kBAAkB,oBAAoB;AACxC,YAAM,QAAQ,IAAI;AAAA,QAChB,sCAAsC,UAAU,KAAK,CAAC;AAAA,MACxD;AACA,YAAM,OAAO;AACb,YAAM;AAAA,IACR;AACA,WAAO;AAAA,EACT;AACF;;;AC+GO,SAAS,uBACX,SACmB;AACtB,SAAO;AAAA,IACL,YAAY,4BAA4B,MAAM,OAAO;AAAA,IACrD,eAAe;AAAA,EACjB;AACF;AAEO,SAAS,4BACd,0BACG,SACS;AACZ,QAAM,eAAiC,CAAC;AACxC,QAAM,QAAQ,oBAAI,IAAmB;AACrC,MAAI;AAIJ,QAAM,mBAA4C,CAAC,aAAa;AAC9D,iBAAa,KAAK,QAAQ;AAAA,EAC5B;AAGA,MAAI,+BAA+B,QAAW;AAC5C;AAAA,MACE;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAMA,SAAS,kCACP,oBACA,SACM;AACN,WAAS,IAAI,GAAG,IAAI,mBAAmB,QAAQ,KAAK;AAClD,UAAM,EAAE,UAAU,UAAU,IAAI,mBAAmB,CAAC;AAAA,EACtD;AACF;AAcO,IAAM,YAAY,uBAAsC;AAAA,EAC7D,SAAS;AAAA,EACT,UAAU;AACZ,CAAC;AAEM,SAAS,gBAAgB,OAA+C;AAC7E,SAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,aAAa;AACrE;AAEO,SAAS,mBACd,OAC2B;AAC3B,SAAO,CAAC,EAAE,SAAU,MAA2B;AACjD;AAEO,SAAS,kBACd,OAC0B;AAC1B,SAAO,CAAC,EAAE,SAAU,MAA0B;AAChD;AAEO,SAAS,eAAe,OAA8C;AAC3E,SAAO,OAAO,UAAU;AAC1B;;;ACvMO,IAAM,iBAAiB,IAAI,eAAqC,EAAE;;;ACgDzE,IAAM,UAAU,CAAC;AASjB,IAAM,WAAW,CAAC;AAKlB,IAAI,gBAAsC;AAEnC,SAAS,kBAA4B;AAC1C,MAAI,kBAAkB,QAAW;AAC/B,oBAAgB,IAAI,aAAa;AAAA,EACnC;AACA,SAAO;AACT;AAgBO,IAAe,sBAAf,MAAuD;AAqE9D;AAEO,IAAM,aAAN,cAAyB,oBAAoB;AAAA,EAyBlD,YACE,WACS,QACA,QACA,QACT;AACA,UAAM;AAJG;AACA;AACA;AAIT;AAAA,MACE;AAAA,MACA,CAAC,aAAa,KAAK,gBAAgB,QAAQ;AAAA,IAC7C;AAGA,SAAK,QAAQ,IAAI,UAAU,WAAW,QAAW,IAAI,CAAC;AAGtD,QAAI,OAAO,IAAI,aAAa,GAAG;AAC7B,WAAK,QAAQ,IAAI,qBAAqB,WAAW,QAAW,IAAI,CAAC;AAAA,IACnE;AAIA,UAAM,SAAS,KAAK,QAAQ;AAAA,MAC1B;AAAA,IACF;AACA,QAAI,UAAU,QAAQ,OAAO,OAAO,UAAU,UAAU;AACtD,WAAK,OAAO,IAAI,OAAO,KAAsB;AAAA,IAC/C;AAEA,SAAK,mBAAmB,IAAI;AAAA,MAC1B,KAAK,IAAI,oBAAoB,yBAA6B;AAAA,IAC5D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EApDQ,UAAU,oBAAI,IAA4C;AAAA;AAAA;AAAA;AAAA,EAK1D,oBAAoB,oBAAI,IAAe;AAAA,EAEvC,kBAAqC,CAAC;AAAA;AAAA;AAAA;AAAA,EAK9C,IAAI,YAAqB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA,EACQ,aAAa;AAAA,EAEb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA2CC,UAAgB;AACvB,uBAAmB,IAAI;AAGvB,SAAK,aAAa;AAElB,QAAI;AAEF,iBAAW,WAAW,KAAK,mBAAmB;AAC5C,gBAAQ,YAAY;AAAA,MACtB;AACA,YAAM,iBAAiB,KAAK;AAG5B,WAAK,kBAAkB,CAAC;AACxB,iBAAW,QAAQ,gBAAgB;AACjC,aAAK;AAAA,MACP;AAAA,IACF,UAAE;AAEA,WAAK,QAAQ,MAAM;AACnB,WAAK,kBAAkB,MAAM;AAC7B,WAAK,iBAAiB,MAAM;AAAA,IAC9B;AAAA,EACF;AAAA,EAES,UAAU,UAAkC;AACnD,uBAAmB,IAAI;AACvB,SAAK,gBAAgB,KAAK,QAAQ;AAClC,WAAO,MAAM,KAAK,gBAAgB,QAAQ;AAAA,EAC5C;AAAA,EAES,aAAsB,IAA4B;AACzD,uBAAmB,IAAI;AAEvB,UAAM,mBAAmB,mBAAmB,IAAI;AAChD,UAAM,+BAA+B,wBAAwB,MAAS;AAEtE,QAAI,OAAO;AAAA,IACX;AAEA,QAAI;AACF,aAAO,GAAG;AAAA,IACZ,UAAE;AACA,yBAAmB,gBAAgB;AACnC,8BAAwB,4BAA4B;AAAA,IACtD;AAAA,EACF;AAAA,EAES,IACP,OACA,gBAAqB,oBACrB,yBACG;AACH,uBAAmB,IAAI;AAEvB,QAAI,MAAM,eAAe,SAAS,GAAG;AACnC,aAAQ,MAAc,SAAS,EAAE,IAAI;AAAA,IACvC;AAEA,YAAQ,kBAAkB,KAAK;AAG/B,QAAI,OAAO;AAAA,IACX;AACA,UAAM,mBAAmB,mBAAmB,IAAI;AAChD,UAAM,+BAA+B,wBAAwB,MAAS;AACtE,QAAI;AAEF,UAAI,EAAE,2BAA+B;AAEnC,YAAI,SAAuC,KAAK,QAAQ,IAAI,KAAK;AACjE,YAAI,WAAW,QAAW;AAGxB,gBAAM,MAAM,sBAAsB,KAAK,KAAK,iBAAiB,KAAK;AAClE,cAAI,OAAO,KAAK,qBAAqB,GAAG,GAAG;AAIzC,gBAAI,OAAO;AAAA,YACX;AAEA,qBAAS;AAAA,cACP,kCAAkC,KAAK;AAAA,cACvC;AAAA,YACF;AAAA,UACF,OAAO;AACL,qBAAS;AAAA,UACX;AACA,eAAK,QAAQ,IAAI,OAAO,MAAM;AAAA,QAChC;AAEA,YAAI,UAAU,MAAkC;AAC9C,iBAAO,KAAK,QAAQ,OAAO,MAAM;AAAA,QACnC;AAAA,MACF;AAIA,YAAM,eAAe,EAAE,wBACnB,KAAK,SACL,gBAAgB;AAGpB,sBACE,4BAAgC,kBAAkB,qBAC9C,OACA;AACN,aAAO,aAAa,IAAI,OAAO,aAAa;AAAA,IAC9C,SAAS,GAAQ;AACf,UAAI,EAAE,SAAS,qBAAqB;AAClC,cAAM,OAAe,EAAE,kBAAkB,IACvC,EAAE,kBAAkB,KAAK,CAAC;AAC5B,aAAK,QAAQ,UAAU,KAAK,CAAC;AAC7B,YAAI,kBAAkB;AAEpB,gBAAM;AAAA,QACR,OAAO;AAEL,iBAAO,mBAAmB,GAAG,OAAO,mBAAmB,KAAK,MAAM;AAAA,QACpE;AAAA,MACF,OAAO;AACL,cAAM;AAAA,MACR;AAAA,IACF,UAAE;AAEA,8BAAwB,4BAA4B;AACpD,yBAAmB,gBAAgB;AAAA,IACrC;AAAA,EACF;AAAA;AAAA,EAGA,8BAA8B;AAC5B,UAAM,mBAAmB,mBAAmB,IAAI;AAChD,UAAM,+BAA+B,wBAAwB,MAAS;AACtE,QAAI,OAAO;AAAA,IACX;AAEA,QAAI;AACF,YAAM,eAAe,KAAK;AAAA,QACxB;AAAA,QACA;AAAA;AAAA,MAEF;AACA,UAAI,OAAO;AAAA,MACX;AACA,iBAAW,eAAe,cAAc;AACtC,oBAAY;AAAA,MACd;AAAA,IACF,UAAE;AACA,yBAAmB,gBAAgB;AACnC,8BAAwB,4BAA4B;AAAA,IACtD;AAAA,EACF;AAAA,EAES,WAAW;AAClB,UAAM,SAAmB,CAAC;AAC1B,UAAM,UAAU,KAAK;AACrB,eAAW,SAAS,QAAQ,KAAK,GAAG;AAClC,aAAO,KAAK,UAAU,KAAK,CAAC;AAAA,IAC9B;AACA,WAAO,cAAc,OAAO,KAAK,IAAI,CAAC;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA,EAKQ,gBAAgB,UAAgC;AAGtD,eAAW,kBAAkB,QAAQ;AACrC,QAAI,QAAa,eAAe,QAAQ,IACpC,WACA,kBAAkB,YAAY,SAAS,OAAO;AAGlD,UAAM,SAAS,iBAAiB,QAAQ;AACxC,QAAI,OAAO;AAAA,IACX;AAEA,QAAI,CAAC,eAAe,QAAQ,KAAK,SAAS,UAAU,MAAM;AAGxD,UAAI,cAAc,KAAK,QAAQ,IAAI,KAAK;AACxC,UAAI,aAAa;AAEf,YAAI,OAAO;AAAA,QACX;AAAA,MACF,OAAO;AACL,sBAAc,WAAW,QAAW,SAAS,IAAI;AACjD,oBAAY,UAAU,MAAM,WAAW,YAAa,KAAM;AAC1D,aAAK,QAAQ,IAAI,OAAO,WAAW;AAAA,MACrC;AACA,cAAQ;AACR,kBAAY,MAAO,KAAK,QAAQ;AAAA,IAClC,OAAO;AACL,UAAI,OAAO;AAAA,MACX;AAAA,IACF;AACA,SAAK,QAAQ,IAAI,OAAO,MAAM;AAAA,EAChC;AAAA,EAEQ,QAAW,OAAyB,QAAsB;AAChE,QAAI;AACF,UAAI,OAAO;AAAA,MACX,WAAW,OAAO,UAAU,SAAS;AACnC,eAAO,QAAQ;AAEf,YAAI,OAAO;AAAA,QACX,OAAO;AACL,iBAAO,QAAQ,OAAO,QAAS;AAAA,QACjC;AAAA,MACF;AACA,UACE,OAAO,OAAO,UAAU,YACxB,OAAO,SACP,aAAa,OAAO,KAAK,GACzB;AACA,aAAK,kBAAkB,IAAI,OAAO,KAAK;AAAA,MACzC;AACA,aAAO,OAAO;AAAA,IAChB,UAAE;AAAA,IACF;AAAA,EACF;AAAA,EAEQ,qBAAqB,KAA4C;AACvE,QAAI,CAAC,IAAI,YAAY;AACnB,aAAO;AAAA,IACT;AACA,UAAM,aAAa,kBAAkB,IAAI,UAAU;AACnD,QAAI,OAAO,eAAe,UAAU;AAClC,aAAO,eAAe,SAAS,KAAK,OAAO,IAAI,UAAU;AAAA,IAC3D,OAAO;AACL,aAAO,KAAK,iBAAiB,IAAI,UAAU;AAAA,IAC7C;AAAA,EACF;AAAA,EAEQ,gBAAgB,UAA4B;AAClD,UAAM,eAAe,KAAK,gBAAgB,QAAQ,QAAQ;AAC1D,QAAI,iBAAiB,IAAI;AACvB,WAAK,gBAAgB,OAAO,cAAc,CAAC;AAAA,IAC7C;AAAA,EACF;AACF;AAEA,SAAS,kCACP,OACgB;AAEhB,QAAM,gBAAgB,iBAAiB,KAAK;AAC5C,QAAM,UACJ,kBAAkB,OAAO,cAAc,UAAU,cAAc,KAAK;AAEtE,MAAI,YAAY,MAAM;AACpB,WAAO;AAAA,EACT;AAIA,MAAI,iBAAiB,gBAAgB;AACnC,UAAM,IAAI,gDAAuD,IAAI;AAAA,EACvE;AAGA,MAAI,iBAAiB,UAAU;AAC7B,WAAO,gCAAgC,KAAK;AAAA,EAC9C;AAGA,QAAM,IAAI,gDAAuD,IAAI;AACvE;AAEA,SAAS,gCAAgC,OAAiB;AAExD,QAAM,cAAc,MAAM;AAC1B,MAAI,cAAc,GAAG;AACnB,UAAM,IAAI,gDAAuD,IAAI;AAAA,EACvE;AAOA,QAAM,yBAAyB,0BAA0B,KAAK;AAC9D,MAAI,2BAA2B,MAAM;AACnC,WAAO,MAAM,uBAAuB,QAAQ,KAAkB;AAAA,EAChE,OAAO;AACL,WAAO,MAAM,IAAK,MAAoB;AAAA,EACxC;AACF;AAEA,SAAS,iBAAiB,UAAuC;AAC/D,MAAI,gBAAgB,QAAQ,GAAG;AAC7B,WAAO,WAAW,QAAW,SAAS,QAAQ;AAAA,EAChD,OAAO;AACL,UAAM,UAAmC,kBAAkB,QAAQ;AACnE,WAAO,WAAW,SAAS,OAAO;AAAA,EACpC;AACF;AAOO,SAAS,kBACd,UACA,cACA,WACW;AACX,MAAI,UAAmC;AACvC,MAAI,OAAO;AAAA,EACX;AAEA,MAAI,eAAe,QAAQ,GAAG;AAC5B,UAAM,oBAAoB,kBAAkB,QAAQ;AACpD,WACE,cAAc,iBAAiB,KAC/B,kCAAkC,iBAAiB;AAAA,EAEvD,OAAO;AACL,QAAI,gBAAgB,QAAQ,GAAG;AAC7B,gBAAU,MAAM,kBAAkB,SAAS,QAAQ;AAAA,IACrD,WAAW,kBAAkB,QAAQ,GAAG;AACtC,gBAAU,MAAM,SAAS,WAAW,GAAG,WAAW,SAAS,QAAQ,CAAC,CAAC,CAAC;AAAA,IACxE,WAAW,mBAAmB,QAAQ,GAAG;AACvC,gBAAU,MAAM,SAAS,kBAAkB,SAAS,WAAW,CAAC;AAAA,IAClE,OAAO;AACL,YAAM,WAAW;AAAA,QACf,aACI,SAAiD,YACjD,SAAS;AAAA,MACf;AACA,UAAI,OAAO;AAAA,MACX;AACA,UAAI,QAAQ,QAAQ,GAAG;AACrB,kBAAU,MAAM,IAAI,SAAS,GAAG,WAAW,SAAS,IAAI,CAAC;AAAA,MAC3D,OAAO;AACL,eACE,cAAc,QAAQ,KAAK,kCAAkC,QAAQ;AAAA,MAEzE;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAEO,SAAS,mBAAmB,UAA4B;AAC7D,MAAI,SAAS,WAAW;AACtB,UAAM,IAAI,mDAA0D,IAAI;AAAA,EAC1E;AACF;AAEA,SAAS,WACP,SACA,OACA,QAAiB,OACN;AACX,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,OAAO,QAAQ,CAAC,IAAI;AAAA,EACtB;AACF;AAEA,SAAS,QACP,OAC0C;AAC1C,SAAO,CAAC,CAAE,MAAc;AAC1B;AAEA,SAAS,aAAa,OAAgC;AACpD,SACE,UAAU,QACV,OAAO,UAAU,YACjB,OAAQ,MAAoB,gBAAgB;AAEhD;AAEA,SAAS,sBAAsB,OAAyC;AACtE,SACE,OAAO,UAAU,cAChB,OAAO,UAAU,YAAY,iBAAiB;AAEnD;AAEA,SAAS,sBACP,WACA,IACM;AACN,aAAW,YAAY,WAAW;AAChC,QAAI,MAAM,QAAQ,QAAQ,GAAG;AAC3B,4BAAsB,UAAU,EAAE;AAAA,IACpC,WAAW,YAAY,uBAAuB,QAAQ,GAAG;AACvD,4BAAsB,SAAS,YAAY,EAAE;AAAA,IAC/C,OAAO;AACL,SAAG,QAA0B;AAAA,IAC/B;AAAA,EACF;AACF;;;AC/mBO,SAAS,cAAiB,IAAgB;AAC/C,SAAO,EAAE,UAAU,GAAG,EAAE,SAAS;AACnC;;;ACyBA,SAAS,iBAAiB,OAAsC;AAC9D,SAAO,SAAS,QAAmB,MAAa;AAC9C,QAAI,OAAO;AACT,YAAM,SAAS,MAAM,GAAG,IAAI;AAC5B,iBAAW,YAAY,QAAQ;AAC7B,aAAK,QAAQ,IAAI,OAAO,QAAQ;AAAA,MAClC;AAAA,IACF;AAAA,EACF;AACF;AAEO,SAAS,mBACd,MACA,OACA,aACK;AACL,SAAO,cAAc,MAAM;AACzB,UAAM,WAAW,iBAAiB,KAAK;AACvC,aAAS,yBAEJ,MACE;AACL,eAAS,MAAM,MAAM,IAAI;AACzB,aAAO;AAAA,IACT;AACA,QAAI,aAAa;AAAA,IACjB;AAEA,WAAO;AAAA,EACT,CAAC;AACH;;;ACjBO,IAAM,SAA0B;AAAA;AAAA,EAErC,mBAAmB,UAAU,CAAC,WAAgB,EAAE,MAAM,EAAE;AAAA;AAAA;AAG1D;AAyCO,IAAM;AAAA;AAAA;AAAA,EAGX;AAAA,IACE,mBAAmB,UAAU;AAAA;AAAA,EAE/B;AAAA;AA4CK,IAAM;AAAA;AAAA;AAAA,EAGX,iBAAiB,mBAAmB,MAAM,eAA2B;AAAA;AA2ChE,IAAM;AAAA;AAAA;AAAA,EAGX;AAAA,IACE,mBAAmB,UAAU;AAAA;AAAA,EAE/B;AAAA;;;ACzLK,SAAS,eACd,SACA,SAA0B,MAC1B,sBAA+D,MAC/D,MACU;AACV,QAAM,WAAW;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,WAAS,4BAA4B;AACrC,SAAO;AACT;AAOO,SAAS,uCACd,SACA,SAA0B,MAC1B,sBAA+D,MAC/D,MACA,SAAS,oBAAI,IAAmB,GACpB;AACZ,QAAM,YAAY;AAAA,IAChB,uBAAuB;AAAA,IACvB,oBAAoB,OAAO;AAAA,EAC7B;AACA,SAAO,SAAS,OAAO,YAAY,WAAW,SAAY,UAAU,OAAO;AAE3E,SAAO,IAAI;AAAA,IACT;AAAA,IACA,UAAU,gBAAgB;AAAA,IAC1B,QAAQ;AAAA,IACR;AAAA,EACF;AACF;;;AClBO,IAAe,WAAf,MAAe,UAAS;AAAA,EAC7B,OAAO,qBAAqB;AAAA,EAC5B,OAAO,OAAiC,oBAAI,aAAa;AAAA,EAiFzD,OAAO,OACL,SAOA,QACU;AACV,QAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,aAAO,eAAe,EAAE,MAAM,GAAG,GAAG,QAAQ,SAAS,EAAE;AAAA,IACzD,OAAO;AACL,YAAM,OAAO,QAAQ,QAAQ;AAC7B,aAAO,eAAe,EAAE,KAAK,GAAG,QAAQ,QAAQ,QAAQ,WAAW,IAAI;AAAA,IACzE;AAAA,EACF;AAAA;AAAA,EAGA,OAAO;AAAA;AAAA,IAAkD,mCAAmB;AAAA,MAC1E,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,SAAS,MAAM,SAAS,QAAQ;AAAA,IAClC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMD,OAAO;AACT;;;ACvIO,SAAS,mBAA0B;AACxC,QAAM,MAAM;AACZ,QAAM,IAAI,MAAM,GAAG;AACrB;;;ACPO,SAAS,cAAiB,GAAM,GAAM;AAC3C,SAAO,OAAO,GAAG,GAAG,CAAC;AACvB;;;ACDA,IAAI,iBAAsC;AAC1C,IAAI,sBAAsB;AAO1B,IAAI,QAAiB;AAOd,IAAM,SAAyB,uBAAO,QAAQ;AAE9C,SAAS,kBACd,UACqB;AACrB,QAAM,OAAO;AACb,mBAAiB;AACjB,SAAO;AACT;AAEO,SAAS,oBAAyC;AACvD,SAAO;AACT;AAEO,SAAS,wBAAiC;AAC/C,SAAO;AACT;AAUO,IAAM,gBAA8B;AAAA,EACzC,SAAS;AAAA,EACT,gBAAgB;AAAA,EAChB,OAAO;AAAA,EACP,cAAc;AAAA,EACd,yBAAyB;AAAA,EACzB,qBAAqB;AAAA,EACrB,mBAAmB;AAAA,EACnB,kBAAkB;AAAA,EAClB,yBAAyB;AAAA,EACzB,2BAA2B;AAAA,EAC3B,sBAAsB;AAAA,EACtB,MAAM;AAAA,EACN,uBAAuB,MAAM;AAAA,EAC7B,wBAAwB,MAAM;AAAA,EAAC;AAAA,EAC/B,qBAAqB,MAAM;AAAA,EAAC;AAAA,EAC5B,sBAAsB,MAAM;AAAA,EAAC;AAC/B;AA4IO,SAAS,iBAAiB,MAA0B;AACzD,MAAI,qBAAqB;AACvB,UAAM,IAAI;AAAA,MAC4B,QAChC,2DACA;AAAA,IACN;AAAA,EACF;AAEA,MAAI,mBAAmB,MAAM;AAE3B;AAAA,EACF;AAEA,iBAAe,qBAAqB,IAAI;AAGxC,QAAM,MAAM,eAAe;AAE3B,qBAAmB,cAAc;AAEjC,MACE,MAAM,eAAe,aAAa,UAClC,eAAe,aAAa,GAAG,MAAM,MACrC;AAQA,QAAI,eAAe,cAAc,GAAG;AAClC,YAAM,gBAAgB,eAAe,aAAa,GAAG;AACrD;AAAA,QACE;AAAA,QACA,eAAe,oBAAoB,GAAG;AAAA,MACxC;AAAA,IAIF;AAAA,EACF;AAEA,MAAI,eAAe,aAAa,GAAG,MAAM,MAAM;AAE7C,mBAAe,aAAa,GAAG,IAAI;AAInC,mBAAe,oBAAoB,GAAG,IAAI,eAAe,cAAc,IACnE,wBAAwB,MAAM,gBAAgB,GAAG,IACjD;AAAA,EACN;AACA,iBAAe,wBAAwB,GAAG,IAAI,KAAK;AACrD;AAOO,SAAS,yBAA+B;AAC7C;AACF;AAKO,SAAS,2BAA2B,MAA0B;AACnE,MAAI,eAAe,IAAI,KAAK,CAAC,KAAK,OAAO;AAGvC;AAAA,EACF;AAEA,MAAI,CAAC,KAAK,SAAS,KAAK,mBAAmB,OAAO;AAIhD;AAAA,EACF;AAEA,MACE,CAAC,KAAK,sBAAsB,IAAI,KAChC,CAAC,+BAA+B,IAAI,GACpC;AAGA,sBAAkB,IAAI;AACtB;AAAA,EACF;AAEA,OAAK,uBAAuB,IAAI;AAGhC,oBAAkB,IAAI;AACxB;AAKO,SAAS,wBAAwB,MAA0B;AAChE,MAAI,KAAK,qBAAqB,QAAW;AACvC;AAAA,EACF;AAGA,QAAM,OAAO;AACb,wBAAsB;AACtB,MAAI;AACF,eAAW,YAAY,KAAK,kBAAkB;AAC5C,UAAI,CAAC,SAAS,OAAO;AACnB,0BAAkB,QAAQ;AAAA,MAC5B;AAAA,IACF;AAAA,EACF,UAAE;AACA,0BAAsB;AAAA,EACxB;AACF;AAMO,SAAS,yBAAkC;AAChD,SAAO,gBAAgB,8BAA8B;AACvD;AAEO,SAAS,kBAAkB,MAA0B;AAC1D,OAAK,QAAQ;AACb,0BAAwB,IAAI;AAC5B,OAAK,sBAAsB,IAAI;AACjC;AAEO,SAAS,kBAAkB,MAA0B;AAC1D,OAAK,QAAQ;AACb,OAAK,iBAAiB;AACxB;AAQO,SAAS,0BACd,MACqB;AACrB,WAAS,KAAK,oBAAoB;AAClC,SAAO,kBAAkB,IAAI;AAC/B;AAQO,SAAS,yBACd,MACA,cACM;AACN,oBAAkB,YAAY;AAE9B,MACE,CAAC,QACD,KAAK,iBAAiB,UACtB,KAAK,wBAAwB,UAC7B,KAAK,4BAA4B,QACjC;AACA;AAAA,EACF;AAEA,MAAI,eAAe,IAAI,GAAG;AAGxB,aAAS,IAAI,KAAK,mBAAmB,IAAI,KAAK,aAAa,QAAQ,KAAK;AACtE;AAAA,QACE,KAAK,aAAa,CAAC;AAAA,QACnB,KAAK,oBAAoB,CAAC;AAAA,MAC5B;AAAA,IACF;AAAA,EACF;AAKA,SAAO,KAAK,aAAa,SAAS,KAAK,mBAAmB;AACxD,SAAK,aAAa,IAAI;AACtB,SAAK,wBAAwB,IAAI;AACjC,SAAK,oBAAoB,IAAI;AAAA,EAC/B;AACF;AAMO,SAAS,+BAA+B,MAA6B;AAC1E,qBAAmB,IAAI;AAGvB,WAAS,IAAI,GAAG,IAAI,KAAK,aAAa,QAAQ,KAAK;AACjD,UAAM,WAAW,KAAK,aAAa,CAAC;AACpC,UAAM,cAAc,KAAK,wBAAwB,CAAC;AAIlD,QAAI,gBAAgB,SAAS,SAAS;AACpC,aAAO;AAAA,IACT;AAIA,+BAA2B,QAAQ;AAInC,QAAI,gBAAgB,SAAS,SAAS;AACpC,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;AAKO,SAAS,gBAAgB,MAA0B;AACxD,qBAAmB,IAAI;AACvB,MAAI,eAAe,IAAI,GAAG;AAExB,aAAS,IAAI,GAAG,IAAI,KAAK,aAAa,QAAQ,KAAK;AACjD;AAAA,QACE,KAAK,aAAa,CAAC;AAAA,QACnB,KAAK,oBAAoB,CAAC;AAAA,MAC5B;AAAA,IACF;AAAA,EACF;AAGA,OAAK,aAAa,SAChB,KAAK,wBAAwB,SAC7B,KAAK,oBAAoB,SACvB;AACJ,MAAI,KAAK,kBAAkB;AACzB,SAAK,iBAAiB,SAAS,KAAK,wBAAyB,SAAS;AAAA,EACxE;AACF;AAQA,SAAS,wBACP,MACA,UACA,aACQ;AACR,qBAAmB,IAAI;AACvB,MAAI,KAAK,iBAAiB,WAAW,KAAK,eAAe,IAAI,GAAG;AAE9D,aAAS,IAAI,GAAG,IAAI,KAAK,aAAa,QAAQ,KAAK;AACjD,WAAK,oBAAoB,CAAC,IAAI;AAAA,QAC5B,KAAK,aAAa,CAAC;AAAA,QACnB;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,OAAK,wBAAwB,KAAK,WAAW;AAC7C,SAAO,KAAK,iBAAiB,KAAK,QAAQ,IAAI;AAChD;AAKA,SAAS,kCACP,MACA,KACM;AACN,qBAAmB,IAAI;AAEvB,MAEE,OAEA;AACA,UAAM,IAAI;AAAA,MACR,0CAA0C,GAAG,wBAAwB,KAAK,iBAAiB,MAAM;AAAA,IACnG;AAAA,EACF;AAEA,MAAI,KAAK,iBAAiB,WAAW,KAAK,eAAe,IAAI,GAAG;AAI9D,aAAS,IAAI,GAAG,IAAI,KAAK,aAAa,QAAQ,KAAK;AACjD;AAAA,QACE,KAAK,aAAa,CAAC;AAAA,QACnB,KAAK,oBAAoB,CAAC;AAAA,MAC5B;AAAA,IACF;AAAA,EACF;AAIA,QAAM,UAAU,KAAK,iBAAiB,SAAS;AAC/C,OAAK,iBAAiB,GAAG,IAAI,KAAK,iBAAiB,OAAO;AAC1D,OAAK,wBAAwB,GAAG,IAAI,KAAK,wBAAwB,OAAO;AAGxE,OAAK,iBAAiB;AACtB,OAAK,wBAAwB;AAI7B,MAAI,MAAM,KAAK,iBAAiB,QAAQ;AACtC,UAAM,cAAc,KAAK,wBAAwB,GAAG;AACpD,UAAM,WAAW,KAAK,iBAAiB,GAAG;AAC1C,uBAAmB,QAAQ;AAC3B,aAAS,oBAAoB,WAAW,IAAI;AAAA,EAC9C;AACF;AAEA,SAAS,eAAe,MAA6B;AACnD,SAAO,KAAK,yBAAyB,MAAM,kBAAkB,UAAU,KAAK;AAC9E;AAEA,SAAS,mBAAmB,MAAkD;AAC5E,OAAK,iBAAiB,CAAC;AACvB,OAAK,wBAAwB,CAAC;AAC9B,OAAK,4BAA4B,CAAC;AACpC;AAEA,SAAS,mBAAmB,MAAkD;AAC5E,OAAK,qBAAqB,CAAC;AAC3B,OAAK,4BAA4B,CAAC;AACpC;AAEA,SAAS,eAAe,MAA0C;AAChE,SAAO,KAAK,iBAAiB;AAC/B;;;AC5fO,SAAS,eAAkB,aAAyC;AACzE,QAAM,OAAwB,OAAO,OAAO,aAAa;AACzD,OAAK,cAAc;AAEnB,QAAMC,YAAW,MAAM;AAErB,+BAA2B,IAAI;AAG/B,qBAAiB,IAAI;AAErB,QAAI,KAAK,UAAU,SAAS;AAC1B,YAAM,KAAK;AAAA,IACb;AAEA,WAAO,KAAK;AAAA,EACd;AACA,EAACA,UAA+B,MAAM,IAAI;AAC1C,SAAOA;AACT;AAMO,IAAM,QAA6B,uBAAO,OAAO;AAOjD,IAAM,YAAiC,uBAAO,WAAW;AAOzD,IAAM,UAA+B,uBAAO,SAAS;AAK5D,IAAM,gBAAiC,wBAAO;AAAA,EAC5C,GAAG;AAAA,EACH,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP,MAAM;AAAA,EAEN,sBAAsB,MAAsC;AAG1D,WAAO,KAAK,UAAU,SAAS,KAAK,UAAU;AAAA,EAChD;AAAA,EAEA,uBAAuB,MAAmC;AACxD,QAAI,KAAK,UAAU,WAAW;AAE5B,YAAM,IAAI,MAAM,iCAAiC;AAAA,IACnD;AAEA,UAAM,WAAW,KAAK;AACtB,SAAK,QAAQ;AAEb,UAAM,eAAe,0BAA0B,IAAI;AACnD,QAAI;AACJ,QAAI,WAAW;AACf,QAAI;AACF,iBAAW,KAAK,YAAY;AAG5B,wBAAkB,IAAI;AACtB,iBACE,aAAa,SACb,aAAa,WACb,aAAa,WACb,KAAK,MAAM,UAAU,QAAQ;AAAA,IACjC,SAAS,KAAK;AACZ,iBAAW;AACX,WAAK,QAAQ;AAAA,IACf,UAAE;AACA,+BAAyB,MAAM,YAAY;AAAA,IAC7C;AAEA,QAAI,UAAU;AAGZ,WAAK,QAAQ;AACb;AAAA,IACF;AAEA,SAAK,QAAQ;AACb,SAAK;AAAA,EACP;AACF,IAAI;;;AC5IJ,SAAS,oBAA2B;AAClC,QAAM,IAAI,MAAM;AAClB;AAEA,IAAI,mCACF;AAEK,SAAS,+BAAkC,MAAqB;AACrE,mCAAiC,IAAI;AACvC;;;ACWA,IAAI,kBAAuC;AAkBpC,SAAS,aAAgB,cAAkC;AAChE,QAAM,OAAsB,OAAO,OAAO,WAAW;AACrD,OAAK,QAAQ;AACb,QAAM,SAAU,MAAM;AACpB,qBAAiB,IAAI;AACrB,WAAO,KAAK;AAAA,EACd;AACA,EAAC,OAAe,MAAM,IAAI;AAC1B,SAAO;AACT;AAeO,SAAS,YAAe,MAAqB,UAAa;AAC/D,MAAI,CAAC,uBAAuB,GAAG;AAC7B,mCAA+B,IAAI;AAAA,EACrC;AAEA,MAAI,CAAC,KAAK,MAAM,KAAK,OAAO,QAAQ,GAAG;AACrC,SAAK,QAAQ;AACb,uBAAmB,IAAI;AAAA,EACzB;AACF;AAEO,SAAS,eACd,MACA,SACM;AACN,MAAI,CAAC,uBAAuB,GAAG;AAC7B,mCAA+B,IAAI;AAAA,EACrC;AAEA,cAAY,MAAM,QAAQ,KAAK,KAAK,CAAC;AACvC;AASO,IAAM,cAAoD,wBAAO;AAAA,EACtE,GAAG;AAAA,EACH,OAAO;AAAA,EACP,OAAO;AAAA,EACP,MAAM;AACR,IAAI;AAEJ,SAAS,mBAAsB,MAA2B;AACxD,OAAK;AACL,yBAAuB;AACvB,0BAAwB,IAAI;AAC5B,oBAAkB;AACpB;;;ACnDO,SAAS,mBACd,UACA,eACA,YAC0B;AAC1B,QAAM,OAA+B,OAAO,OAAO,kBAAkB;AAErE,OAAK,SAAS;AACd,OAAK,cAAc;AACnB,MAAI,cAAc,QAAW;AAC3B,SAAK,QAAQ;AAAA,EACf;AAEA,QAAM,qBAAqB,MAAM;AAE/B,+BAA2B,IAAI;AAG/B,qBAAiB,IAAI;AAErB,QAAI,KAAK,UAAU,SAAS;AAC1B,YAAM,KAAK;AAAA,IACb;AAEA,WAAO,KAAK;AAAA,EACd;AAEA,QAAM,SAAS;AACf,SAAO,MAAM,IAAI;AAEjB,SAAO;AACT;AAEO,SAAS,kBACd,MACA,UACA;AACA,6BAA2B,IAAI;AAC/B,cAAY,MAAM,QAAQ;AAC1B,oBAAkB,IAAI;AACxB;AAEO,SAAS,qBACd,MACA,SACM;AACN,6BAA2B,IAAI;AAC/B,iBAAe,MAAM,OAAO;AAC5B,oBAAkB,IAAI;AACxB;AAKO,IAAM,qBAAsC,wBAAO;AAAA,EACxD,GAAG;AAAA,EACH,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EAEP,sBAAsB,MAAmD;AAGvE,WAAO,KAAK,UAAU,SAAS,KAAK,UAAU;AAAA,EAChD;AAAA,EAEA,uBAAuB,MAAgD;AACrE,QAAI,KAAK,UAAU,WAAW;AAE5B,YAAM,IAAI,MAAM,iCAAiC;AAAA,IACnD;AAEA,UAAM,WAAW,KAAK;AACtB,SAAK,QAAQ;AAEb,UAAM,eAAe,0BAA0B,IAAI;AACnD,QAAI;AACJ,QAAI;AACF,YAAM,iBAAiB,KAAK,OAAO;AACnC,YAAM,OACJ,aAAa,SAAS,aAAa,UAC/B,SACA;AAAA,QACE,QAAQ,KAAK;AAAA,QACb,OAAO;AAAA,MACT;AACN,iBAAW,KAAK,YAAY,gBAAgB,IAAI;AAChD,WAAK,cAAc;AAAA,IACrB,SAAS,KAAK;AACZ,iBAAW;AACX,WAAK,QAAQ;AAAA,IACf,UAAE;AACA,+BAAyB,MAAM,YAAY;AAAA,IAC7C;AAEA,QACE,aAAa,SACb,aAAa,WACb,KAAK,MAAM,UAAU,QAAQ,GAC7B;AAGA,WAAK,QAAQ;AACb;AAAA,IACF;AAEA,SAAK,QAAQ;AACb,SAAK;AAAA,EACP;AACF,IAAI;;;AC/GG,SAAS,YACd,IACA,UACA,mBACO;AACP,QAAM,OAAkB,OAAO,OAAO,UAAU;AAChD,MAAI,mBAAmB;AACrB,SAAK,4BAA4B;AAAA,EACnC;AAEA,OAAK,KAAK;AACV,OAAK,WAAW;AAEhB,QAAM,oBAAoB,CAAC,cAA8B;AACvD,SAAK,YAAY;AAAA,EACnB;AAEA,WAAS,qBAAqBC,OAAiB;AAC7C,WAAOA,MAAK,OAAO,QAAQA,MAAK,aAAa;AAAA,EAC/C;AAEA,WAAS,iBAAiBA,OAAiB;AACzC,QAAI,CAAC,qBAAqBA,KAAI,GAAG;AAC/B,sBAAgBA,KAAI;AACpB,MAAAA,MAAK,UAAU;AAGf,MAAAA,MAAK,KAAK;AACV,MAAAA,MAAK,WAAW;AAChB,MAAAA,MAAK,YAAY;AAAA,IACnB;AAAA,EACF;AAEA,QAAM,MAAM,MAAM;AAChB,QAAI,KAAK,OAAO,MAAM;AAEpB;AAAA,IACF;AAEA,QAAI,sBAAsB,GAAG;AAC3B,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAEA,SAAK,QAAQ;AACb,QAAI,KAAK,UAAU,CAAC,+BAA+B,IAAI,GAAG;AACxD;AAAA,IACF;AACA,SAAK,SAAS;AAEd,UAAM,eAAe,0BAA0B,IAAI;AACnD,QAAI;AACF,WAAK,UAAU;AACf,WAAK,YAAY;AACjB,WAAK,GAAG,iBAAiB;AAAA,IAC3B,UAAE;AACA,+BAAyB,MAAM,YAAY;AAAA,IAC7C;AAAA,EACF;AAEA,OAAK,MAAM;AAAA,IACT,QAAQ,MAAM,kBAAkB,IAAI;AAAA,IACpC;AAAA,IACA,SAAS,MAAM,KAAK,UAAU;AAAA,IAC9B,SAAS,MAAM,iBAAiB,IAAI;AAAA,IACpC,CAAC,MAAM,GAAG;AAAA,EACZ;AAEA,SAAO,KAAK;AACd;AAEA,IAAM,kBAAkC,MAAM;AAAC;AAK/C,IAAM,aAAkD,wBAAO;AAAA,EAC7D,GAAG;AAAA,EACH,sBAAsB;AAAA,EACtB,2BAA2B;AAAA,EAC3B,qBAAqB,CAAC,SAAoB;AACxC,QAAI,KAAK,aAAa,MAAM;AAC1B,WAAK,SAAS,KAAK,GAAG;AAAA,IACxB;AAAA,EACF;AAAA,EACA,QAAQ;AAAA,EACR,WAAW;AACb,IAAI;;;AC5HG,SAAS,SAAS,OAA0C;AACjE,SACE,OAAO,UAAU,cAChB,MAA0B,MAAM,MAAM;AAE3C;;;ACAO,SAAS,SACd,aACA,SACW;AACX,QAAM,SAAS,eAAe,WAAW;AACzC,MAAI,SAAS,OAAO;AAClB,WAAO,MAAM,EAAE,QAAQ,QAAQ;AAAA,EACjC;AAEA,MAAI,OAAO;AAAA,EACX;AAEA,SAAO;AACT;;;ACQO,SAAS,sBACd,OACG;AAGH,SAAO;AACT;AAoBO,SAAS,OACd,cACA,SACmB;AACnB,QAAM,WAAW,aAAa,YAAY;AAE1C,QAAM,OAAO,SAAS,MAAM;AAC5B,MAAI,SAAS,OAAO;AAClB,SAAK,QAAQ,QAAQ;AAAA,EACvB;AAEA,WAAS,MAAM,CAAC,aAAgB,YAAY,MAAM,QAAQ;AAC1D,WAAS,SAAS,CAAC,aACjB,eAAe,MAAM,QAAQ;AAC/B,WAAS,aAAa,mBAAmB;AAAA,IACvC;AAAA,EACF;AAEA,MAAI,OAAO;AAAA,EACX;AAEA,SAAO;AACT;AAEO,SAAS,qBAAwD;AACtE,QAAM,OAAO,KAAK,MAAM;AACxB,MAAI,KAAK,eAAe,QAAW;AACjC,UAAM,aAAa,MAAM,KAAK;AAC9B,IAAC,WAAmB,MAAM,IAAI;AAC9B,SAAK,aAAa;AAAA,EACpB;AACA,SAAO,KAAK;AACd;;;ACzFA,IAAM,aAAa,CAAI,MAAS;AA6BzB,SAAS,aACd,sBAOA,SACmB;AACnB,MAAI,OAAO,yBAAyB,YAAY;AAC9C,UAAM,SAAS;AAAA,MACb;AAAA,MACA;AAAA,MACA,SAAS;AAAA,IACX;AACA,WAAO,0BAA0B,MAAM;AAAA,EACzC,OAAO;AACL,UAAM,SAAS;AAAA,MACb,qBAAqB;AAAA,MACrB,qBAAqB;AAAA,MACrB,qBAAqB;AAAA,IACvB;AACA,WAAO,0BAA0B,MAAM;AAAA,EACzC;AACF;AAEA,SAAS,0BACP,QACmB;AACnB,MAAI,OAAO;AAAA,EACX;AAEA,QAAM,OAAO,OAAO,MAAM;AAC1B,QAAM,iBAAiB;AAEvB,iBAAe,MAAM,CAAC,aAAgB,kBAAkB,MAAM,QAAQ;AACtE,iBAAe,SAAS,CAAC,aACvB,qBAAqB,MAAM,QAAQ;AACrC,iBAAe,aAAa,mBAAmB;AAAA,IAC7C;AAAA,EACF;AAEA,SAAO;AACT;;;AC/EO,SAAS,UAAa,oBAAgC;AAC3D,QAAM,eAAe,kBAAkB,IAAI;AAG3C,MAAI;AACF,WAAO,mBAAmB;AAAA,EAC5B,UAAE;AACA,sBAAkB,YAAY;AAAA,EAChC;AACF;;;ACHO,SAAS,2BACd,SACA,cACM;AAGN,MAAI,kBAAkB,MAAM,MAAM;AAChC,UAAM,IAAI;AAAA;AAAA,MAER;AAAA,IACF;AAAA,EACF;AACF;;;AC2BO,SAAS,uBAAgC;AAC9C,SACE,wBAAwB,MAAM,UAAa,mBAAmB,KAAK;AAEvE;AASO,SAAS,yBAAyB,SAAyB;AAGhE,MAAI,CAAC,qBAAqB,GAAG;AAC3B,UAAM,IAAI,mDAAyD,IAAI;AAAA,EACzE;AACF;;;AC5DO,IAAe,aAAf,MAA0B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiC/B,OAAO,gBAA+D,CACpE,aACG;AACP;;;AC9CO,SAAS,QAAQ,MAAkB;AAE1C;;;ACAO,IAAW,qBAAX,kBAAWC,wBAAX;AAIL,EAAAA,wCAAA;AAEA,EAAAA,wCAAA;AAEA,EAAAA,wCAAA;AAEA,EAAAA,wCAAA;AAEA,EAAAA,wCAAA;AAIA,EAAAA,wCAAA;AAGA,EAAAA,wCAAA;AAKA,EAAAA,wCAAA;AAMA,EAAAA,wCAAA;AAKA,EAAAA,wCAAA;AAEA,EAAAA,wCAAA;AAGA,EAAAA,wCAAA;AAEA,EAAAA,wCAAA;AAEA,EAAAA,wCAAA;AA5CgB,SAAAA;AAAA,GAAA;AAkDX,IAAe,2BAAf,MAAwC;AAG/C;AAGO,IAAM,mBAAmB,IAAI;AAAA,EACE,QAAY,qBAAqB;AAAA,EACrE,EAAE,YAAY,QAAQ,SAAS,MAAM,MAAM;AAC7C;AAGO,IAAM,oBAAoB,IAAI;AAAA,EACC,QAAY,sBAAsB;AAAA,EACtE,EAAE,YAAY,QAAQ,SAAS,MAAM,MAAM;AAC7C;AAEO,IAAM,8BAA8B,IAAI;AAAA,EACT,QAAY,uBAAuB;AACzE;AAGO,IAAM,wBAAwB,IAAI;AAAA,EACH,QAChC,qCACA;AACN;;;AC/DO,IAAe,kBAAf,MAAe,iBAAgB;AAAA;AAAA,EAiBpC,OAAO;AAAA;AAAA,IAAkD,mCAAmB;AAAA,MAC1E,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,SAAS,MAAM,IAAI,yBAAyB;AAAA,IAC9C,CAAC;AAAA;AACH;AAMO,IAAM,2BAAN,MAA0D;AAAA,EACvD,oBAAoB;AAAA,EACpB,SAAS,oBAAI,IAAyC;AAAA,EAE9D,SAAS,QAAiC;AACxC,SAAK,QAAQ,MAAM;AAAA,EACrB;AAAA,EAEA,OAAO,QAAiC;AACtC,UAAM,OAAO,OAAO;AACpB,UAAM,QAAQ,KAAK,OAAO,IAAI,IAAI;AAClC,QAAI,CAAC,MAAM,IAAI,MAAM,GAAG;AACtB;AAAA,IACF;AAEA,UAAM,OAAO,MAAM;AACnB,SAAK;AAAA,EACP;AAAA,EAEQ,QAAQ,QAAiC;AAC/C,UAAM,OAAO,OAAO;AACpB,QAAI,CAAC,KAAK,OAAO,IAAI,IAAI,GAAG;AAC1B,WAAK,OAAO,IAAI,MAAM,oBAAI,IAAI,CAAC;AAAA,IACjC;AAEA,UAAM,QAAQ,KAAK,OAAO,IAAI,IAAI;AAClC,QAAI,MAAM,IAAI,MAAM,GAAG;AACrB;AAAA,IACF;AACA,SAAK;AACL,UAAM,IAAI,MAAM;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,QAAc;AACZ,WAAO,KAAK,oBAAoB,GAAG;AACjC,iBAAW,CAAC,MAAM,KAAK,KAAK,KAAK,QAAQ;AAEvC,YAAI,SAAS,MAAM;AACjB,eAAK,WAAW,KAAK;AAAA,QACvB,OAAO;AACL,eAAK,IAAI,MAAM,KAAK,WAAW,KAAK,CAAC;AAAA,QACvC;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAEQ,WAAW,OAAqC;AACtD,eAAW,UAAU,OAAO;AAC1B,YAAM,OAAO,MAAM;AACnB,WAAK;AAGL,aAAO,IAAI;AAAA,IACb;AAAA,EACF;AACF;;;ACrGO,IAAM,kCAAkC;;;AC4BxC,IAAM,eAAN,MAAmB;AAAA;AAAA;AAAA;AAAA,EAIxB,WAAoB;AAAA,EAEpB,YAAY,OAAkB;AAC5B,SAAK,SAAS,MAAM,SAAS,KAAK;AAAA,EACpC;AACF;;;ACxCA,SAAS,uBAAuB;AAazB,IAAM,uBAAN,MAAM,sBAA0C;AAAA,EAC7C,SAAS;AAAA,EACT,eAAe,oBAAI,IAAY;AAAA,EACvC,IAAY,mBAAmB;AAC7B,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EACA,kBAAkB,IAAI,gBAAyB,KAAK;AAAA,EAEpD,MAAc;AACZ,QAAI,CAAC,KAAK,kBAAkB;AAC1B,WAAK,gBAAgB,KAAK,IAAI;AAAA,IAChC;AACA,UAAM,SAAS,KAAK;AACpB,SAAK,aAAa,IAAI,MAAM;AAC5B,WAAO;AAAA,EACT;AAAA,EAEA,IAAI,QAAyB;AAC3B,WAAO,KAAK,aAAa,IAAI,MAAM;AAAA,EACrC;AAAA,EAEA,OAAO,QAAsB;AAC3B,SAAK,aAAa,OAAO,MAAM;AAC/B,QAAI,KAAK,aAAa,SAAS,KAAK,KAAK,kBAAkB;AACzD,WAAK,gBAAgB,KAAK,KAAK;AAAA,IACjC;AAAA,EACF;AAAA,EAEA,cAAoB;AAClB,SAAK,aAAa,MAAM;AACxB,QAAI,KAAK,kBAAkB;AACzB,WAAK,gBAAgB,KAAK,KAAK;AAAA,IACjC;AAAA,EACF;AAAA;AAAA,EAGA,OAAO;AAAA;AAAA,IAAkD,mCAAmB;AAAA,MAC1E,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,SAAS,MAAM,IAAI,sBAAqB;AAAA,IAC1C,CAAC;AAAA;AACH;AAwBO,IAAM,eAAN,MAAM,cAAa;AAAA,EAChB,uBAAuB,OAAO,oBAAoB;AAAA,EAClD,YAAY,OAAO,wBAAwB;AAAA;AAAA;AAAA;AAAA;AAAA,EAKnD,MAAkB;AAChB,UAAM,SAAS,KAAK,qBAAqB,IAAI;AAC7C,WAAO,MAAM;AACX,UAAI,CAAC,KAAK,qBAAqB,IAAI,MAAM,GAAG;AAE1C;AAAA,MACF;AAEA,WAAK,UAAU,kCAA4C;AAC3D,WAAK,qBAAqB,OAAO,MAAM;AAAA,IACzC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBA,MAAM,IAAO,IAAkC;AAC7C,UAAM,aAAa,KAAK,IAAI;AAC5B,QAAI;AACF,aAAO,MAAM,GAAG;AAAA,IAClB,UAAE;AACA,iBAAW;AAAA,IACb;AAAA,EACF;AAAA;AAAA,EAGA,OAAO;AAAA;AAAA,IAAkD,mCAAmB;AAAA,MAC1E,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,SAAS,MAAM,IAAI,cAAa;AAAA,IAClC,CAAC;AAAA;AACH;;;AC7GO,IAAM,2BAAN,MAAM,kCAAiC,yBAAyB;AAAA,EACpD,eAAe,OAAO,oBAAoB;AAAA,EACnD,SAAwB;AAAA,EAEvB,SAASC,SAAiC;AAEjD,UAAM,SAASA,OAAM;AACrB,QAAI,KAAK,WAAW,MAAM;AACxB,WAAK,SAAS,KAAK,aAAa,IAAI;AACpC,qBAAe,MAAM,KAAK,MAAM,CAAC;AAAA,IACnC;AAAA,EACF;AAAA,EAES,QAAc;AACrB,QAAI;AACF,YAAM,MAAM;AAAA,IACd,UAAE;AACA,UAAI,KAAK,WAAW,MAAM;AACxB,aAAK,aAAa,OAAO,KAAK,MAAM;AACpC,aAAK,SAAS;AAAA,MAChB;AAAA,IACF;AAAA,EACF;AAAA;AAAA,EAGA,OAAO;AAAA;AAAA,IAAkD,mCAAmB;AAAA,MAC1E,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,SAAS,MAAM,IAAI,0BAAyB;AAAA,IAC9C,CAAC;AAAA;AACH;AASA,IAAM,eAAN,MAA2D;AAAA,EAIzD,YACU,WACA,UACD,MACP,YACQ,UACR,mBACA;AANQ;AACA;AACD;AAEC;AAGR,SAAK,UAAU;AAAA,MACb,CAAC,cAAc,KAAK,UAAU,SAAS;AAAA,MACvC,MAAM,KAAK,SAAS;AAAA,MACpB;AAAA,IACF;AACA,SAAK,sBAAsB,YAAY,UAAU,MAAM,KAAK,QAAQ,CAAC;AAAA,EACvE;AAAA,EAjBA;AAAA,EACS;AAAA,EAkBD,UAAU,WAAyC;AACzD,QAAI;AACF,WAAK,SAAS,SAAS;AAAA,IACzB,SAAS,KAAK;AAGZ,YAAM,eAAe,KAAK,SAAS,IAAI,cAAc,MAAM;AAAA,QACzD,UAAU;AAAA,MACZ,CAAC;AACD,oBAAc,YAAY,GAAG;AAAA,IAC/B;AAAA,EACF;AAAA,EAEA,MAAY;AACV,SAAK,QAAQ,IAAI;AAAA,EACnB;AAAA,EAEQ,WAAiB;AACvB,SAAK,UAAU,SAAS,IAAI;AAAA,EAC9B;AAAA,EAEA,UAAgB;AACd,SAAK,QAAQ,QAAQ;AACrB,SAAK,sBAAsB;AAAA,EAI7B;AACF;AAGA,SAAS,SAAS;AAAC;AAKZ,SAAS,gBACd,UACA,SACW;AACX,GAAC,SAAS,YAAY,yBAAyB,MAAM;AAErD,QAAM,WAAW,SAAS,YAAY,OAAO,QAAQ;AACrD,QAAM,aACJ,SAAS,kBAAkB,OAAO,SAAS,IAAI,UAAU,IAAI;AAE/D,QAAM,SAAS,IAAI;AAAA,IACjB,SAAS,IAAI,wBAAwB;AAAA,IACrC;AAAA,IACA,OAA8B,OAAO,SAAK;AAAA,IAC1C;AAAA,IACA;AAAA,IACA,SAAS,qBAAqB;AAAA,EAChC;AAUA,SAAO,QAAQ,OAAO;AAEtB,SAAO;AACT;;;AC5HA,IAAI,+BAA+B;AAuB5B,IAAM,gBAAN,MAAyC;AAAA,EAC9C,CAAC,MAAM;AAAA,EAEP,YAAY,MAAkB;AAC5B,SAAK,MAAM,IAAI;AAAA,EACjB;AAAA,EAEA,UAAgB;AACd,SAAK,MAAM,EAAE,QAAQ;AAAA,EACvB;AACF;AA2EO,SAASC,QACd,UACA,SACW;AACX,MAAI,8BAA8B;AAChC,QAAI,OAAiC;AACnC,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAEA,WAAO,gBAAgB,UAAU,OAAO;AAAA,EAC1C;AASA,GAAC,SAAS,YAAY,yBAAyBA,OAAM;AAErD,MAAI,OAAuD;AACzD,YAAQ;AAAA,MACN;AAAA,IACF;AAAA,EACF;AAEA,QAAM,WAAW,SAAS,YAAY,OAAO,QAAQ;AACrD,QAAM,aACJ,SAAS,kBAAkB,OAAO,SAAS,IAAI,UAAU,IAAI;AAE/D,MAAI;AAEJ,QAAM,WAAW,SAAS,IAAI,wBAAwB;AACtD,SAAO,iBAAiB,UAAU,SAAS,IAAI,eAAe,GAAG,QAAQ;AACzE,OAAK,WAAW;AAEhB,MAAI,eAAe,MAAM;AAEvB,SAAK,cAAc,WAAW,UAAU,MAAM,KAAK,QAAQ,CAAC;AAAA,EAC9D;AAEA,QAAM,YAAY,IAAI,cAAc,IAAI;AAExC,SAAO;AACT;AA4BO,IAAM,mBAGQ,wBAAO;AAAA,EAC1B,GAAG;AAAA,EACH,sBAAsB;AAAA,EACtB,2BAA2B;AAAA,EAC3B,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,YAAY;AAAA,EACZ,MAAM;AAAA,EACN,MAAM;AAAA,EACN,aAAa;AAAA,EACb,MAA4B;AAC1B,SAAK,QAAQ;AAEb,QAAI,OAAsC;AACxC,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAEA,QAAI,KAAK,UAAU,CAAC,+BAA+B,IAAI,GAAG;AACxD;AAAA,IACF;AACA,SAAK,SAAS;AAEd,UAAM,oBAA6C,CAAC,eACjD,KAAK,eAAe,CAAC,GAAG,KAAK,SAAS;AAEzC,UAAM,WAAW,0BAA0B,IAAI;AAK/C,QAAI;AACF,WAAK,aAAa;AAClB,WAAK,GAAG,iBAAiB;AAAA,IAC3B,UAAE;AACA,+BAAyB,MAAM,QAAQ;AAAA,IACzC;AAAA,EACF;AAAA,EAEA,eAAqC;AACnC,QAAI,CAAC,KAAK,YAAY,QAAQ;AAC5B;AAAA,IACF;AACA,QAAI;AAIF,aAAO,KAAK,WAAW,QAAQ;AAC7B,aAAK,WAAW,IAAI,EAAG;AAAA,MACzB;AAAA,IACF,UAAE;AACA,WAAK,aAAa,CAAC;AAAA,IACrB;AAAA,EACF;AACF,IAAI;AAEG,IAAM,mBAGQ,wBAAO;AAAA,EAC1B,GAAG;AAAA,EACH,sBAA0C;AACxC,SAAK,UAAU,SAAS,IAAI;AAC5B,SAAK,SAAS,0BAAoC;AAAA,EACpD;AAAA,EACA,UAA8B;AAC5B,oBAAgB,IAAI;AACpB,SAAK,YAAY;AACjB,SAAK,aAAa;AAClB,SAAK,UAAU,OAAO,IAAI;AAAA,EAC5B;AACF,IAAI;AAEG,SAAS,iBACd,IACA,WACA,UACgB;AAChB,QAAM,OAAO,OAAO,OAAO,gBAAgB;AAC3C,OAAK,KAAK;AACV,OAAK,YAAY;AACjB,OAAK,WAAW;AAChB,OAAK,OAAO,QAA8B,SAAK,UAAU;AACzD,OAAK,UAAU,SAAS,IAAI;AAC5B,OAAK,SAAS,0BAAoC;AAClD,SAAO;AACT;;;AC9QO,SAAS,4BAA4B,UAAgC;AAC1E,MAAI;AACJ,MAAI;AACJ,WAAS,UAAU;AACjB,eAAW;AACX,QAAI;AACF,UACE,qBAAqB,UACrB,OAAO,yBAAyB,YAChC;AACA,6BAAqB,gBAAgB;AAAA,MACvC;AACA,UAAI,cAAc,QAAW;AAC3B,qBAAa,SAAS;AAAA,MACxB;AAAA,IACF,QAAQ;AAAA,IAGR;AAAA,EACF;AACA,cAAY,WAAW,MAAM;AAC3B,aAAS;AACT,YAAQ;AAAA,EACV,CAAC;AACD,MAAI,OAAO,0BAA0B,YAAY;AAC/C,uBAAmB,sBAAsB,MAAM;AAC7C,eAAS;AACT,cAAQ;AAAA,IACV,CAAC;AAAA,EACH;AAEA,SAAO,MAAM,QAAQ;AACvB;;;ACnDO,IAAM,+BAAN,MAAuE;AAAA,EAC5E,cAAc;AAAA,EACd,uBAAuB,OAAO,eAAe;AAAA,EACrC,0BAA+C;AAAA,EAEvD,OAAO,QAAkC;AACvC,SAAK,0BAA0B,4BAA4B,MAAM;AAC/D,WAAK,qBAAqB,MAAM;AAAA,IAClC,CAAC;AAAA,EACH;AAAA,EACQ,UAAU;AAChB,SAAK,cAAc;AACnB,SAAK,0BAA0B;AAC/B,SAAK,0BAA0B;AAAA,EACjC;AAAA,EACA,cAAc;AACZ,SAAK,QAAQ;AAAA,EACf;AACF;;;AClBO,IAAK,iBAAL,kBAAKC,oBAAL;AAML,EAAAA,gCAAA;AAOA,EAAAA,gCAAA;AAOA,EAAAA,gCAAA;AAOA,EAAAA,gCAAA;AAKA,EAAAA,gCAAA;AAKA,EAAAA,gCAAA;AArCU,SAAAA;AAAA,GAAA;;;AC+CL,SAAS,SACd,SAC4B;AAC5B,WAAS,YAAY,yBAAyB,QAAQ;AACtD,QAAM,UAAW,QAAQ,YAAY,MAAM;AAC3C,SAAO,IAAI;AAAA,IACT;AAAA,IACA,UAAU,OAAO;AAAA,IACjB,QAAQ;AAAA,IACR,QAAQ,QAAQ,eAAe,QAAQ,KAAK,IAAI;AAAA,IAChD,QAAQ,YAAY,OAAO,QAAQ;AAAA,EACrC;AACF;AA6BA,IAAe,uBAAf,MAAsE;AAAA,EAC3D;AAAA,EAKT,YAAY,OAAkB;AAC5B,SAAK,QAAQ;AACb,SAAK,MAAM,MAAM,KAAK,IAAI,KAAK,IAAI;AACnC,SAAK,MAAM,SAAS,KAAK,OAAO,KAAK,IAAI;AACzC,SAAK,MAAM,aAAa;AAAA,EAC1B;AAAA,EAIA,OAAO,UAAiC;AACtC,SAAK,IAAI,SAAS,UAAU,KAAK,KAAK,CAAC,CAAC;AAAA,EAC1C;AAAA,EAES,YAAY;AAAA,IACnB,MACE,KAAK,OAAO,yBACZ,KAAK,OAAO;AAAA,EAChB;AAAA,EAEA,WAAuD;AACrD,WAAO,KAAK,MAAM,MAAM;AAAA,EAC1B;AAAA,EAEA,aAA0B;AACxB,WAAO;AAAA,EACT;AACF;AAKO,IAAM,eAAN,cACG,qBAEV;AAAA,EAmBE,YACE,SACiB,UACA,cACA,OACjB,UACA;AACA;AAAA;AAAA;AAAA,MAGE;AAAA,QACE,MAAM;AACJ,gBAAM,cAAc,KAAK,MAAM,EAAE,SAAS;AAC1C,iBAAO,eAAe,WAAW,WAAW,IACxC,YAAY,QACZ,KAAK;AAAA,QACX;AAAA,QACA,EAAE,MAAM;AAAA,MACV;AAAA,IACF;AAjBiB;AACA;AACA;AAkBjB,SAAK,aAAa,aAAa;AAAA,MAC7B,QAAQ;AAAA,MACR,aAAa,CAACC,cAAa,EAAE,SAAAA,UAAS,QAAQ,EAAE;AAAA,IAClD,CAAC;AAID,SAAK,QAAQ,aAA+C;AAAA;AAAA,MAE1D,QAAQ,KAAK;AAAA;AAAA,MAEb,aAAa,CAAC,YAAY,aAAa;AACrC,cAAM,SACJ,WAAW,YAAY;AAGzB,YAAI,CAAC,UAAU;AACb,iBAAO;AAAA,YACL;AAAA,YACA;AAAA,YACA;AAAA,YACA,QAAQ;AAAA,UACV;AAAA,QACF,OAAO;AACL,iBAAO;AAAA,YACL;AAAA,YACA;AAAA,YACA,gBAAgB,qBAAqB,SAAS,KAAK;AAAA;AAAA,YAEnD,QACE,SAAS,MAAM,WAAW,YAAY,WAAW,UAC7C,SAAS,MAAM,SACf;AAAA,UACR;AAAA,QACF;AAAA,MACF;AAAA,IACF,CAAC;AAED,SAAK,YAAYC,QAAO,KAAK,WAAW,KAAK,IAAI,GAAG;AAAA,MAClD;AAAA,MACA,eAAe;AAAA,IACjB,CAAC;AAED,SAAK,eAAe,SAAS,IAAI,YAAY;AAG7C,aAAS,IAAI,UAAU,EAAE,UAAU,MAAM,KAAK,QAAQ,CAAC;AAAA,EACzD;AAAA,EAvFiB;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA;AAAA,EAME;AAAA,EACF;AAAA,EAET;AAAA,EACA,qBAA+C;AAAA,EAC/C,YAAY;AAAA,EAyEF,SAAS,SAAS,MAAM,qBAAqB,KAAK,MAAM,CAAC,CAAC;AAAA,EAE1D,QAAQ,SAAS,MAAM;AACvC,UAAM,SAAS,KAAK,MAAM,EAAE,SAAS;AACrC,WAAO,UAAU,CAAC,WAAW,MAAM,IAAI,OAAO,QAAQ;AAAA,EACxD,CAAC;AAAA;AAAA;AAAA;AAAA,EAKQ,IAAI,OAAgB;AAC3B,QAAI,KAAK,WAAW;AAClB;AAAA,IACF;AAEA,UAAM,UAAU,UAAU,KAAK,KAAK;AACpC,UAAM,QAAQ,UAAU,KAAK,KAAK;AAElC,QACE,MAAM,6BACL,KAAK,QAAQ,KAAK,MAAM,SAAS,KAAK,IAAI,YAAY,QACvD;AACA;AAAA,IACF;AAGA,SAAK,MAAM,IAAI;AAAA,MACb,YAAY,MAAM;AAAA,MAClB;AAAA,MACA;AAAA,MACA,QAAQ,OAAO,EAAE,MAAM,CAAC;AAAA,IAC1B,CAAC;AAID,SAAK,oBAAoB;AAAA,EAC3B;AAAA,EAES,SAAkB;AAEzB,UAAM,EAAE,OAAO,IAAI,UAAU,KAAK,KAAK;AACvC,QAAI,2BAAkC,4BAAmC;AACvE,aAAO;AAAA,IACT;AAGA,SAAK,WAAW,OAAO,CAAC,EAAE,SAAS,OAAO,OAAO;AAAA,MAC/C;AAAA,MACA,QAAQ,SAAS;AAAA,IACnB,EAAE;AACF,WAAO;AAAA,EACT;AAAA,EAEA,UAAgB;AACd,SAAK,YAAY;AACjB,SAAK,UAAU,QAAQ;AACvB,SAAK,oBAAoB;AAGzB,SAAK,MAAM,IAAI;AAAA,MACb,YAAY,EAAE,SAAS,QAAW,QAAQ,EAAE;AAAA,MAC5C;AAAA,MACA;AAAA,MACA,QAAQ;AAAA,IACV,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,aAA4B;AACxC,UAAM,aAAa,KAAK,WAAW;AAInC,UAAM,EAAE,QAAQ,eAAe,eAAe,IAAI,UAAU,KAAK,KAAK;AAEtE,QAAI,WAAW,YAAY,QAAW;AAEpC;AAAA,IACF,WAAW,mCAA0C;AAEnD;AAAA,IACF;AAGA,SAAK,oBAAoB;AAWzB,QAAI,qBACD,KAAK,qBAAqB,KAAK,aAAa,IAAI;AAEnD,UAAM,EAAE,QAAQ,YAAY,IAAK,KAAK,oBACpC,IAAI,gBAAgB;AAEtB,QAAI;AAIF,YAAM,SAAS,MAAM;AAAA,QAAU,MAC7B,KAAK,SAAS;AAAA,UACZ,SAAS,WAAW;AAAA,UACpB;AAAA,UACA,UAAU;AAAA,YACR,QAAQ;AAAA,UACV;AAAA,QACF,CAAC;AAAA,MACH;AAIA,UAAI,YAAY,WAAW,UAAU,KAAK,UAAU,MAAM,YAAY;AACpE;AAAA,MACF;AAEA,WAAK,MAAM,IAAI;AAAA,QACb;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH,SAAS,KAAK;AACZ,UAAI,YAAY,WAAW,UAAU,KAAK,UAAU,MAAM,YAAY;AACpE;AAAA,MACF;AAEA,WAAK,MAAM,IAAI;AAAA,QACb;AAAA,QACA;AAAA,QACA;AAAA,QACA,QAAQ,OAAO,EAAE,OAAO,IAAI,CAAC;AAAA,MAC/B,CAAC;AAAA,IACH,UAAE;AAEA,2BAAqB;AACrB,2BAAqB;AAAA,IACvB;AAAA,EACF;AAAA,EAEQ,sBAA4B;AAClC,cAAU,MAAM,KAAK,mBAAmB,MAAM,CAAC;AAC/C,SAAK,oBAAoB;AAGzB,SAAK,qBAAqB;AAC1B,SAAK,qBAAqB;AAAA,EAC5B;AACF;AAKA,SAAS,eACP,OACgC;AAChC,SAAO,CAAC,GAAG,MAAO,MAAM,UAAa,MAAM,SAAY,MAAM,IAAI,MAAM,GAAG,CAAC;AAC7E;AAEA,SAAS,UACP,SAC+B;AAC/B,MAAI,2BAA2B,OAAO,GAAG;AACvC,WAAO,QAAQ;AAAA,EACjB;AAEA,SAAO,OAAO,WAAW;AACvB,QAAI;AACF,aAAO,OAAO,EAAE,OAAO,MAAM,QAAQ,OAAO,MAAM,EAAE,CAAC;AAAA,IACvD,SAAS,KAAK;AACZ,aAAO,OAAO,EAAE,OAAO,IAAI,CAAC;AAAA,IAC9B;AAAA,EACF;AACF;AAEA,SAAS,2BACP,SAC2C;AAC3C,SAAO,CAAC,CAAE,QAA2C;AACvD;AAKA,SAAS,qBAAqB,OAA+C;AAC3E,UAAQ,MAAM,QAAQ;AAAA,IACpB;AACE,aAAO,MAAM,WAAW,WAAW;AAAA,IAGrC;AACE,aAAO,WAAW,UAAU,MAAM,MAAO,CAAC;AAAA,IAG5C;AACE,aAAO,MAAM;AAAA,EACjB;AACF;AAEA,SAAS,WAAc,OAAqD;AAC1E,SAAQ,MAA6B,UAAU;AACjD;;;AC/ZO,IAAM,sBAAN,MAA0B;AAAA,EAC/B,OAAO;AACT;AACO,IAAM,0BAAN,MAA8B;AAAA,EACnC,OAAO,gBAAoD;AAAA,IACzD,YAAY;AAAA,EACd;AACF;AAEO,SAASC,gBAAe,SAK5B;AACD,SAAO,IAAI;AAAA,IACT,QAAQ;AAAA,IACR,QAAQ,UAAU,gBAAgB;AAAA,IAClC,QAAQ,QAAQ;AAAA,IAChB,QAAQ,UAAU,oBAAI,IAAI,CAAC,CAAC;AAAA,EAC9B;AACF;AACO,SAAS,mBAAmB,SAIhC;AACD,SAAO,IAAI;AAAA,IACT;AAAA,MACE,GAAG,QAAQ;AAAA,MACX;AAAA,QACE,SAAS;AAAA,QACT,UAAU;AAAA,MACZ;AAAA,IACF;AAAA,IACA,gBAAgB;AAAA,IAChB,QAAQ,QAAQ;AAAA,IAChB,QAAQ,UAAU,oBAAI,IAAI,CAAC,CAAC;AAAA,EAC9B;AACF;",
  "names": ["DecoratorFlags", "InjectFlags", "InternalInjectFlags", "computed", "node", "NotificationSource", "effect", "effect", "ResourceStatus", "request", "effect", "createInjector"]
}