		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -7,2 +7,5 @@ * License: MIT

		import { E as EarlyJsactionDataContainer, a as EventInfo, R as Restriction } from '../../event_dispatcher.d-pVP0-wST.js';
		export { f as EventContract, b as EventContractContainer, c as EventDispatcher, e as EventInfoWrapper, d as EventPhase, r as registerDispatcher } from '../../event_dispatcher.d-pVP0-wST.js';

		declare const Attribute: {
		@@ -33,340 +36,2 @@ /**
		/**
		* Records information about the action that should handle a given `Event`.
		*/
		interface ActionInfo {
		name: string;
		element: Element;
		}
		type ActionInfoInternal = [name: string, element: Element];
		/**
		* Records information for later handling of events. This type is
		* shared, and instances of it are passed, between the eventcontract
		* and the dispatcher jsbinary. Therefore, the fields of this type are
		* referenced by string literals rather than property literals
		* throughout the code.
		*
		* 'targetElement' is the element the action occurred on, 'actionElement'
		* is the element that has the jsaction handler.
		*
		* A null 'actionElement' identifies an EventInfo instance that didn't match a
		* jsaction attribute. This allows us to execute global event handlers with the
		* appropriate event type (including a11y clicks and custom events).
		* The declare portion of this interface creates a set of externs that make sure
		* renaming doesn't happen for EventInfo. This is important since EventInfo
		* is shared across multiple binaries.
		*/
		declare interface EventInfo {
		eventType: string;
		event: Event;
		targetElement: Element;
		/** The element that is the container for this Event. */
		eic: Element;
		timeStamp: number;
		/**
		* The action parsed from the JSAction element.
		*/
		eia?: ActionInfoInternal;
		/**
		* Whether this `Event` is a replay event, meaning no dispatcher was
		* installed when this `Event` was originally dispatched.
		*/
		eirp?: boolean;
		/**
		* Whether this `Event` represents a `keydown` event that should be processed
		* as a `click`. Only used when a11y click events is on.
		*/
		eiack?: boolean;
		/** Whether action resolution has already run on this `EventInfo`. */
		eir?: boolean;
		}
		/**
		* Utility class around an `EventInfo`.
		*
		* This should be used in compilation units that are less sensitive to code
		* size.
		*/
		declare class EventInfoWrapper {
		readonly eventInfo: EventInfo;
		constructor(eventInfo: EventInfo);
		getEventType(): string;
		setEventType(eventType: string): void;
		getEvent(): Event;
		setEvent(event: Event): void;
		getTargetElement(): Element;
		setTargetElement(targetElement: Element): void;
		getContainer(): Element;
		setContainer(container: Element): void;
		getTimestamp(): number;
		setTimestamp(timestamp: number): void;
		getAction(): {
		name: string;
		element: Element;
		} \| undefined;
		setAction(action: ActionInfo \| undefined): void;
		getIsReplay(): boolean \| undefined;
		setIsReplay(replay: boolean): void;
		getResolved(): boolean \| undefined;
		setResolved(resolved: boolean): void;
		clone(): EventInfoWrapper;
		}

		declare interface EarlyJsactionDataContainer {
		_ejsa?: EarlyJsactionData;
		_ejsas?: {
		[appId: string]: EarlyJsactionData \| undefined;
		};
		}
		declare global {
		interface Window {
		_ejsa?: EarlyJsactionData;
		_ejsas?: {
		[appId: string]: EarlyJsactionData \| undefined;
		};
		}
		}
		/**
		* Defines the early jsaction data types.
		*/
		declare interface EarlyJsactionData {
		/** List used to keep track of the early JSAction event types. */
		et: string[];
		/** List used to keep track of the early JSAction capture event types. */
		etc: string[];
		/** Early JSAction handler for all events. */
		h: (event: Event) => void;
		/** Dispatcher handler. Initializes to populating `q`. */
		d: (eventInfo: EventInfo) => void;
		/** List used to push `EventInfo` objects if the dispatcher is not registered. */
		q: EventInfo[];
		/** Container for listening to events. */
		c: HTMLElement;
		}

		/**
		* An `EventContractContainerManager` provides the common interface for managing
		* containers.
		*/
		interface EventContractContainerManager {
		addEventListener(eventType: string, getHandler: (element: Element) => (event: Event) => void, passive?: boolean): void;
		cleanUp(): void;
		}
		/**
		* A class representing a container node and all the event handlers
		* installed on it. Used so that handlers can be cleaned up if the
		* container is removed from the contract.
		*/
		declare class EventContractContainer implements EventContractContainerManager {
		readonly element: Element;
		/**
		* Array of event handlers and their corresponding event types that are
		* installed on this container.
		*
		*/
		private handlerInfos;
		/**
		* @param element The container Element.
		*/
		constructor(element: Element);
		/**
		* Installs the provided installer on the element owned by this container,
		* and maintains a reference to resulting handler in order to remove it
		* later if desired.
		*/
		addEventListener(eventType: string, getHandler: (element: Element) => (event: Event) => void, passive?: boolean): void;
		/**
		* Removes all the handlers installed on this container.
		*/
		cleanUp(): void;
		}

		/**
		* @fileoverview An enum to control who can call certain jsaction APIs.
		*/
		declare enum Restriction {
		I_AM_THE_JSACTION_FRAMEWORK = 0
		}

		/**
		* @fileoverview Implements the local event handling contract. This
		* allows DOM objects in a container that enters into this contract to
		* define event handlers which are executed in a local context.
		*
		* One EventContract instance can manage the contract for multiple
		* containers, which are added using the addContainer() method.
		*
		* Events can be registered using the addEvent() method.
		*
		* A Dispatcher is added using the registerDispatcher() method. Until there is
		* a dispatcher, events are queued. The idea is that the EventContract
		* class is inlined in the HTML of the top level page and instantiated
		* right after the start of <body>. The Dispatcher class is contained
		* in the external deferred js, and instantiated and registered with
		* EventContract when the external javascript in the page loads. The
		* external javascript will also register the jsaction handlers, which
		* then pick up the queued events at the time of registration.
		*
		* Since this class is meant to be inlined in the main page HTML, the
		* size of the binary compiled from this file MUST be kept as small as
		* possible and thus its dependencies to a minimum.
		*/

		/**
		* The API of an EventContract that is safe to call from any compilation unit.
		*/
		declare interface UnrenamedEventContract {
		ecrd(dispatcher: Dispatcher, restriction: Restriction): void;
		}
		/** A function that is called to handle events captured by the EventContract. */
		type Dispatcher = (eventInfo: EventInfo, globalDispatch?: boolean) => void;
		/**
		* A function that handles an event dispatched from the browser.
		*
		* eventType: May differ from `event.type` if JSAction uses a
		* short-hand name or is patching over an non-bubbling event with a bubbling
		* variant.
		* event: The native browser event.
		* container: The container for this dispatch.
		*/
		type EventHandler = (eventType: string, event: Event, container: Element) => void;
		/**
		* EventContract intercepts events in the bubbling phase at the
		* boundary of a container element, and maps them to generic actions
		* which are specified using the custom jsaction attribute in
		* HTML. Behavior of the application is then specified in terms of
		* handler for such actions, cf. jsaction.Dispatcher in dispatcher.js.
		*
		* This has several benefits: (1) No DOM event handlers need to be
		* registered on the specific elements in the UI. (2) The set of
		* events that the application has to handle can be specified in terms
		* of the semantics of the application, rather than in terms of DOM
		* events. (3) Invocation of handlers can be delayed and handlers can
		* be delay loaded in a generic way.
		*/
		declare class EventContract implements UnrenamedEventContract {
		static MOUSE_SPECIAL_SUPPORT: boolean;
		private containerManager;
		/**
		* The DOM events which this contract covers. Used to prevent double
		* registration of event types. The value of the map is the
		* internally created DOM event handler function that handles the
		* DOM events. See addEvent().
		*
		*/
		private eventHandlers;
		private browserEventTypeToExtraEventTypes;
		/**
		* The dispatcher function. Events are passed to this function for
		* handling once it was set using the registerDispatcher() method. This is
		* done because the function is passed from another jsbinary, so passing the
		* instance and invoking the method here would require to leave the method
		* unobfuscated.
		*/
		private dispatcher;
		/**
		* The list of suspended `EventInfo` that will be dispatched
		* as soon as the `Dispatcher` is registered.
		*/
		private queuedEventInfos;
		constructor(containerManager: EventContractContainerManager);
		private handleEvent;
		/**
		* Handle an `EventInfo`.
		*/
		private handleEventInfo;
		/**
		* Enables jsaction handlers to be called for the event type given by
		* name.
		*
		* If the event is already registered, this does nothing.
		*
		* @param prefixedEventType If supplied, this event is used in
		* the actual browser event registration instead of the name that is
		* exposed to jsaction. Use this if you e.g. want users to be able
		* to subscribe to jsaction="transitionEnd:foo" while the underlying
		* event is webkitTransitionEnd in one browser and mozTransitionEnd
		* in another.
		*
		* @param passive A boolean value that, if `true`, indicates that the event
		* handler will never call `preventDefault()`.
		*/
		addEvent(eventType: string, prefixedEventType?: string, passive?: boolean): void;
		/**
		* Gets the queued early events and replay them using the appropriate handler
		* in the provided event contract. Once all the events are replayed, it cleans
		* up the early contract.
		*/
		replayEarlyEvents(earlyJsactionData?: EarlyJsactionData \| undefined): void;
		/**
		* Replays all the early `EventInfo` objects, dispatching them through the normal
		* `EventContract` flow.
		*/
		replayEarlyEventInfos(earlyEventInfos: EventInfo[]): void;
		/**
		* Returns all JSAction event types that have been registered for a given
		* browser event type.
		*/
		private getEventTypesForBrowserEventType;
		/**
		* Returns the event handler function for a given event type.
		*/
		handler(eventType: string): EventHandler \| undefined;
		/**
		* Cleans up the event contract. This resets all of the `EventContract`'s
		* internal state. Users are responsible for not using this `EventContract`
		* after it has been cleaned up.
		*/
		cleanUp(): void;
		/**
		* Register a dispatcher function. Event info of each event mapped to
		* a jsaction is passed for handling to this callback. The queued
		* events are passed as well to the dispatcher for later replaying
		* once the dispatcher is registered. Clears the event queue to null.
		*
		* @param dispatcher The dispatcher function.
		* @param restriction
		*/
		registerDispatcher(dispatcher: Dispatcher, restriction: Restriction): void;
		/**
		* Unrenamed alias for registerDispatcher. Necessary for any codebases that
		* split the `EventContract` and `Dispatcher` code into different compilation
		* units.
		*/
		ecrd(dispatcher: Dispatcher, restriction: Restriction): void;
		}

		/** An internal symbol used to indicate whether propagation should be stopped or not. */
		declare const PROPAGATION_STOPPED_SYMBOL: unique symbol;
		/** Extra event phases beyond what the browser provides. */
		declare const EventPhase: {
		REPLAY: number;
		};
		declare global {
		interface Event {
		[PROPAGATION_STOPPED_SYMBOL]?: boolean;
		}
		}
		/**
		* A dispatcher that uses browser-based `Event` semantics, for example bubbling, `stopPropagation`,
		* `currentTarget`, etc.
		*/
		declare class EventDispatcher {
		private readonly dispatchDelegate;
		private readonly clickModSupport;
		private readonly actionResolver;
		private readonly dispatcher;
		constructor(dispatchDelegate: (event: Event, actionName: string) => void, clickModSupport?: boolean);
		/**
		* The entrypoint for the `EventContract` dispatch.
		*/
		dispatch(eventInfo: EventInfo): void;
		/** Internal method that does basic disaptching. */
		private dispatchToDelegate;
		}
		/**
		* Registers deferred functionality for an EventContract and a Jsaction
		* Dispatcher.
		*/
		declare function registerDispatcher(eventContract: UnrenamedEventContract, dispatcher: EventDispatcher): void;

		/**
		* Whether or not an event type should be registered in the capture phase.
		@@ -399,2 +64,2 @@ * @param eventType

		export { Attribute, type EarlyJsactionDataContainer, EventContract, EventContractContainer, EventDispatcher, EventInfoWrapper, EventPhase, bootstrapAppScopedEarlyEventContract, clearAppScopedEarlyEventContract, getDefaulted as getActionCache, getAppScopedQueuedEventInfos, isCaptureEventType, isEarlyEventType, registerAppScopedDispatcher, registerDispatcher, removeAllAppScopedEventListeners };
		export { Attribute, EarlyJsactionDataContainer, bootstrapAppScopedEarlyEventContract, clearAppScopedEarlyEventContract, getDefaulted as getActionCache, getAppScopedQueuedEventInfos, isCaptureEventType, isEarlyEventType, registerAppScopedDispatcher, removeAllAppScopedEventListeners };

211

primitives/signals/index.d.ts

		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -7,189 +7,6 @@ * License: MIT

		export { s as setAlternateWeakRefImpl } from '../../weak_ref.d-ttyj86RV.js';
		import { R as ReactiveNode, V as ValueEqualityFn, S as SIGNAL, a as SignalNode } from '../../weak_ref.d-Bp6cSy-X.js';
		export { b as REACTIVE_NODE, c as Reactive, t as SIGNAL_NODE, u as SignalGetter, e as consumerAfterComputation, f as consumerBeforeComputation, g as consumerDestroy, h as consumerMarkDirty, i as consumerPollProducersForChange, v as createSignal, d as defaultEquals, j as getActiveConsumer, k as isInNotificationPhase, l as isReactive, p as producerAccessed, m as producerIncrementEpoch, n as producerMarkClean, o as producerNotifyConsumers, q as producerUpdateValueVersion, r as producerUpdatesAllowed, w as runPostSignalSetFn, s as setActiveConsumer, A as setAlternateWeakRefImpl, x as setPostSignalSetFn, y as signalSetFn, z as signalUpdateFn } from '../../weak_ref.d-Bp6cSy-X.js';

		/**
		* A comparison function which can determine if two values are equal.
		*/
		type ValueEqualityFn<T> = (a: T, b: T) => boolean;
		/**
		* The default equality function used for `signal` and `computed`, which uses referential equality.
		*/
		declare function defaultEquals<T>(a: T, b: T): boolean;

		type Version = number & {
		__brand: 'Version';
		};
		/**
		* Symbol used to tell `Signal`s apart from other functions.
		*
		* This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
		*/
		declare const SIGNAL: unique symbol;
		declare function setActiveConsumer(consumer: ReactiveNode \| null): ReactiveNode \| null;
		declare function getActiveConsumer(): ReactiveNode \| null;
		declare function isInNotificationPhase(): boolean;
		interface Reactive {
		[SIGNAL]: ReactiveNode;
		}
		declare function isReactive(value: unknown): value is Reactive;
		declare const REACTIVE_NODE: ReactiveNode;
		/**
		* A producer and/or consumer which participates in the reactive graph.
		*
		* Producer `ReactiveNode`s which are accessed when a consumer `ReactiveNode` is the
		* `activeConsumer` are tracked as dependencies of that consumer.
		*
		* Certain consumers are also tracked as "live" consumers and create edges in the other direction,
		* from producer to consumer. These edges are used to propagate change notifications when a
		* producer's value is updated.
		*
		* A `ReactiveNode` may be both a producer and consumer.
		*/
		interface ReactiveNode {
		/**
		* Version of the value that this node produces.
		*
		* This is incremented whenever a new value is produced by this node which is not equal to the
		* previous value (by whatever definition of equality is in use).
		*/
		version: Version;
		/**
		* Epoch at which this node is verified to be clean.
		*
		* This allows skipping of some polling operations in the case where no signals have been set
		* since this node was last read.
		*/
		lastCleanEpoch: Version;
		/**
		* Whether this node (in its consumer capacity) is dirty.
		*
		* Only live consumers become dirty, when receiving a change notification from a dependency
		* producer.
		*/
		dirty: boolean;
		/**
		* Producers which are dependencies of this consumer.
		*
		* Uses the same indices as the `producerLastReadVersion` and `producerIndexOfThis` arrays.
		*/
		producerNode: ReactiveNode[] \| undefined;
		/**
		* `Version` of the value last read by a given producer.
		*
		* Uses the same indices as the `producerNode` and `producerIndexOfThis` arrays.
		*/
		producerLastReadVersion: Version[] \| undefined;
		/**
		* Index of `this` (consumer) in each producer's `liveConsumers` array.
		*
		* This value is only meaningful if this node is live (`liveConsumers.length > 0`). Otherwise
		* these indices are stale.
		*
		* Uses the same indices as the `producerNode` and `producerLastReadVersion` arrays.
		*/
		producerIndexOfThis: number[] \| undefined;
		/**
		* Index into the producer arrays that the next dependency of this node as a consumer will use.
		*
		* This index is zeroed before this node as a consumer begins executing. When a producer is read,
		* it gets inserted into the producers arrays at this index. There may be an existing dependency
		* in this location which may or may not match the incoming producer, depending on whether the
		* same producers were read in the same order as the last computation.
		*/
		nextProducerIndex: number;
		/**
		* Array of consumers of this producer that are "live" (they require push notifications).
		*
		* `liveConsumerNode.length` is effectively our reference count for this node.
		*/
		liveConsumerNode: ReactiveNode[] \| undefined;
		/**
		* Index of `this` (producer) in each consumer's `producerNode` array.
		*
		* Uses the same indices as the `liveConsumerNode` array.
		*/
		liveConsumerIndexOfThis: number[] \| undefined;
		/**
		* Whether writes to signals are allowed when this consumer is the `activeConsumer`.
		*
		* This is used to enforce guardrails such as preventing writes to writable signals in the
		* computation function of computed signals, which is supposed to be pure.
		*/
		consumerAllowSignalWrites: boolean;
		readonly consumerIsAlwaysLive: boolean;
		/**
		* Tracks whether producers need to recompute their value independently of the reactive graph (for
		* example, if no initial value has been computed).
		*/
		producerMustRecompute(node: unknown): boolean;
		producerRecomputeValue(node: unknown): void;
		consumerMarkedDirty(node: unknown): void;
		/**
		* Called when a signal is read within this consumer.
		*/
		consumerOnSignalRead(node: unknown): void;
		/**
		* A debug name for the reactive node. Used in Angular DevTools to identify the node.
		*/
		debugName?: string;
		/**
		* Kind of node. Example: 'signal', 'computed', 'input', 'effect'.
		*
		* ReactiveNode has this as 'unknown' by default, but derived node types should override this to
		* make available the kind of signal that particular instance of a ReactiveNode represents.
		*
		* Used in Angular DevTools to identify the kind of signal.
		*/
		kind: string;
		}
		/**
		* Called by implementations when a producer's signal is read.
		*/
		declare function producerAccessed(node: ReactiveNode): void;
		/**
		* Increment the global epoch counter.
		*
		* Called by source producers (that is, not computeds) whenever their values change.
		*/
		declare function producerIncrementEpoch(): void;
		/**
		* Ensure this producer's `version` is up-to-date.
		*/
		declare function producerUpdateValueVersion(node: ReactiveNode): void;
		/**
		* Propagate a dirty notification to live consumers of this producer.
		*/
		declare function producerNotifyConsumers(node: ReactiveNode): void;
		/**
		* Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
		* based on the current consumer context.
		*/
		declare function producerUpdatesAllowed(): boolean;
		declare function consumerMarkDirty(node: ReactiveNode): void;
		declare function producerMarkClean(node: ReactiveNode): void;
		/**
		* Prepare this consumer to run a computation in its reactive context.
		*
		* Must be called by subclasses which represent reactive computations, before those computations
		* begin.
		*/
		declare function consumerBeforeComputation(node: ReactiveNode \| null): ReactiveNode \| null;
		/**
		* Finalize this consumer's state after a reactive computation has run.
		*
		* Must be called by subclasses which represent reactive computations, after those computations
		* have finished.
		*/
		declare function consumerAfterComputation(node: ReactiveNode \| null, prevConsumer: ReactiveNode \| null): void;
		/**
		* Determine whether this consumer has any dependencies which have changed since the last time
		* they were read.
		*/
		declare function consumerPollProducersForChange(node: ReactiveNode): boolean;
		/**
		* Disconnect this consumer from the graph.
		*/
		declare function consumerDestroy(node: ReactiveNode): void;

		/**
		* A computation, which derives a value from a declarative reactive expression.
		@@ -260,22 +77,2 @@ *

		interface SignalNode<T> extends ReactiveNode {
		value: T;
		equal: ValueEqualityFn<T>;
		}
		type SignalBaseGetter<T> = (() => T) & {
		readonly [SIGNAL]: unknown;
		};
		interface SignalGetter<T> extends SignalBaseGetter<T> {
		readonly [SIGNAL]: SignalNode<T>;
		}
		/**
		* Create a `Signal` that can be set or updated directly.
		*/
		declare function createSignal<T>(initialValue: T, equal?: ValueEqualityFn<T>): SignalGetter<T>;
		declare function setPostSignalSetFn(fn: (() => void) \| null): (() => void) \| null;
		declare function signalSetFn<T>(node: SignalNode<T>, newValue: T): void;
		declare function signalUpdateFn<T>(node: SignalNode<T>, updater: (value: T) => T): void;
		declare function runPostSignalSetFn(): void;
		declare const SIGNAL_NODE: SignalNode<unknown>;

		declare function setThrowInvalidWriteToSignalError(fn: <T>(node: SignalNode<T>) => never): void;
		@@ -325,2 +122,2 @@

		export { type ComputationFn, type ComputedNode, type LinkedSignalGetter, type LinkedSignalNode, REACTIVE_NODE, type Reactive, type ReactiveNode, SIGNAL, SIGNAL_NODE, type SignalGetter, type SignalNode, type ValueEqualityFn, type Watch, type WatchCleanupFn, type WatchCleanupRegisterFn, consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, createComputed, createLinkedSignal, createSignal, createWatch, defaultEquals, getActiveConsumer, isInNotificationPhase, isReactive, linkedSignalSetFn, linkedSignalUpdateFn, producerAccessed, producerIncrementEpoch, producerMarkClean, producerNotifyConsumers, producerUpdateValueVersion, producerUpdatesAllowed, runPostSignalSetFn, setActiveConsumer, setPostSignalSetFn, setThrowInvalidWriteToSignalError, signalSetFn, signalUpdateFn, untracked };
		export { type ComputationFn, type ComputedNode, type LinkedSignalGetter, type LinkedSignalNode, ReactiveNode, SIGNAL, SignalNode, ValueEqualityFn, type Watch, type WatchCleanupFn, type WatchCleanupRegisterFn, createComputed, createLinkedSignal, createWatch, linkedSignalSetFn, linkedSignalUpdateFn, setThrowInvalidWriteToSignalError, untracked };

rxjs-interop/index.d.ts

		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -4,0 +4,0 @@ * License: MIT

schematics/bundles/apply_import_manager-BynuozbO.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/cleanup-unused-imports.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/compiler_host-DzM2hemp.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/explicit-standalone-flag.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/imports-CIX-JgAN.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/index-BPqwMr5d.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -20,3 +20,3 @@ * License: MIT
		*/
		new checker.Version('19.2.3');
		new checker.Version('19.2.4');

		@@ -23,0 +23,0 @@ var LogLevel;

schematics/bundles/index-CPpyW--c.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/inject-migration.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/leading_space-D9nQ8UQC.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/ng_decorators-DznZ5jMl.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/nodes-B16H9JUd.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/output-migration.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/pending-tasks.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/project_paths-CXXqWSoY.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/project_tsconfig_paths-CDVxT6Ov.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/property_name-BBwFuqMe.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/provide-initializer.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/route-lazy-loading.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/self-closing-tags-migration.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/signal-queries-migration.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

schematics/bundles/signals.js

		'use strict';
		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -5,0 +5,0 @@ * License: MIT

testing/index.d.ts

		/**
		* @license Angular v19.2.3
		* @license Angular v19.2.4
		* (c) 2010-2025 Google LLC. https://angular.io/
		@@ -9,3 +9,3 @@ * License: MIT
		export { ɵDeferBlockBehavior as DeferBlockBehavior, ɵDeferBlockState as DeferBlockState } from '@angular/core';
		import { a as Navigation, c as NavigationHistoryEntry, d as NavigationNavigateOptions, g as NavigationResult, e as NavigationOptions, N as NavigateEvent, b as NavigationCurrentEntryChangeEvent, h as NavigationTransition, i as NavigationUpdateCurrentEntryOptions, f as NavigationReloadOptions } from '../navigation_types.d-u4EOrrdZ.js';
		import { N as Navigation, a as NavigationHistoryEntry, b as NavigationNavigateOptions, c as NavigationResult, d as NavigationOptions, e as NavigateEvent, f as NavigationCurrentEntryChangeEvent, g as NavigationTransition, h as NavigationUpdateCurrentEntryOptions, i as NavigationReloadOptions } from '../navigation_types.d-DgDrF5rp.js';

		@@ -12,0 +12,0 @@ /**

fesm2022/weak_ref-DrMdAIDh.mjs

fesm2022/weak_ref-DrMdAIDh.mjs.map

navigation_types.d-u4EOrrdZ.d.ts

weak_ref.d-ttyj86RV.d.ts

fesm2022/core.mjs