@angular/core 19.2.0-next.3 → 19.2.0

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.2.0-next.3
+ * @license Angular v19.2.0
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -14,6 +14,7 @@ import { SignalNode } from '@angular/core/primitives/signals';
 import { Subject } from 'rxjs';
 import { Subscribable } from 'rxjs';
 import { Subscription } from 'rxjs';
+import { ValueEqualityFn as ValueEqualityFn_2 } from '@angular/core/primitives/signals';
 import { ɵProfiler as ɵProfiler_2 } from '@angular/core';
 import { SIGNAL as ɵSIGNAL } from '@angular/core/primitives/signals';
 
@@ -1303,6 +1304,22 @@ export declare interface BaseResourceOptions<T, R> {
     injector?: Injector;
 }
 
+/**
+ * Base class which implements `.value` as a `WritableSignal` by delegating `.set` and `.update`.
+ */
+declare abstract class BaseWritableResource<T> implements WritableResource<T> {
+    readonly value: WritableSignal<T>;
+    abstract readonly status: Signal<ResourceStatus>;
+    abstract readonly error: Signal<unknown>;
+    abstract reload(): boolean;
+    constructor(value: Signal<T>);
+    abstract set(value: T): void;
+    update(updateFn: (value: T) => T): void;
+    readonly isLoading: Signal<boolean>;
+    hasValue(): this is ResourceRef<Exclude<T, undefined>>;
+    asReadonly(): Resource<T>;
+}
+
 
 /**
  * Transforms a value (typically a string) to a boolean.
@@ -3914,6 +3931,27 @@ declare type DirectiveDefList = (ɵDirectiveDef<any> | ɵComponentDef<any>)[];
  */
 declare type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDefList;
 
+/**
+ * Represents a map between a class reference and the index at which its directive is available on
+ * a specific TNode. The value can be either:
+ *   1. A number means that there's only one selector-matched directive on the node and it
+ *      doesn't have any host directives.
+ *   2. An array means that there's a selector-matched directive and it has host directives.
+ *      The array is structured as follows:
+ *        - 0: Index of the selector-matched directive.
+ *        - 1: Start index of the range within which the host directives are defined.
+ *        - 2: End of the host directive range.
+ *
+ * Example:
+ * ```
+ * Map {
+ *   [NoHostDirectives]: 5,
+ *   [HasHostDirectives]: [10, 6, 8],
+ * }
+ * ```
+ */
+declare type DirectiveIndexMap = Map<Type<unknown>, number | [directiveIndex: number, hostDirectivesStart: number, hostDirectivesEnd: number]>;
+
 /**
  * Map of inputs for a given directive/component.
  *
@@ -5191,6 +5229,26 @@ declare interface HostDirectiveDef<T = unknown> {
  */
 declare type HostDirectiveDefs = Map<ɵDirectiveDef<unknown>, HostDirectiveDef>;
 
+/**
+ * Represents inputs coming from a host directive and exposed on a TNode.
+ *
+ * - The key is the public name of an input as it is exposed on the specific node.
+ * - The value is an array where:
+ *   - i+0: Index of the host directive that should be written to.
+ *   - i+1: Public name of the input as it was defined on the host directive before aliasing.
+ */
+declare type HostDirectiveInputs = Record<string, (number | string)[]>;
+
+/**
+ * Represents outputs coming from a host directive and exposed on a TNode.
+ *
+ * - The key is the public name of an output as it is exposed on the specific node.
+ * - The value is an array where:
+ *   - i+0: Index of the host directive on which the output is defined..
+ *   - i+1: Public name of the output as it was defined on the host directive before aliasing.
+ */
+declare type HostDirectiveOutputs = Record<string, (number | string)[]>;
+
 /**
  * Type of the HostListener metadata.
  *
@@ -5680,9 +5738,8 @@ export declare type ImportProvidersSource = Type<unknown> | ModuleWithProviders<
  *
  * Within each sub-array:
  *
- * i+0: attribute name
- * i+1: minified/internal input name
- * i+2: initial value
+ * i+0: public name
+ * i+1: initial value
  *
  * If a directive on a node does not have any input properties
  * that should be set from attributes, its index is set to null
@@ -5703,7 +5760,7 @@ declare type InitialInputData = (InitialInputs | null)[];
  *
  * e.g. ['role-min', 'minified-input', 'button']
  */
-declare type InitialInputs = (string | InputFlags)[];
+declare type InitialInputs = string[];
 
 /**
  * Type of the Inject metadata.
@@ -7599,6 +7656,35 @@ declare const MULTIPLIER = "x";
 
 declare const NATIVE = 7;
 
+declare interface NavigateEventInit extends EventInit {
+    navigationType?: ɵNavigationTypeString;
+    canIntercept?: boolean;
+    userInitiated?: boolean;
+    hashChange?: boolean;
+    destination: ɵNavigationDestination;
+    signal: AbortSignal;
+    formData?: FormData | null;
+    downloadRequest?: string | null;
+    info?: unknown;
+}
+
+declare interface NavigationCurrentEntryChangeEventInit extends EventInit {
+    navigationType?: ɵNavigationTypeString | null;
+    from: ɵNavigationHistoryEntry;
+}
+
+
+declare interface NavigationEventMap {
+    navigate: ɵNavigateEvent;
+    navigatesuccess: Event;
+    navigateerror: ErrorEvent;
+    currententrychange: ɵNavigationCurrentEntryChangeEvent;
+}
+
+declare interface NavigationHistoryEntryEventMap {
+    dispose: Event;
+}
+
 declare const NEXT = 4;
 
 declare interface NgGlobalPublishUtils {
@@ -8142,37 +8228,28 @@ export declare interface NgZoneOptions {
 export declare const NO_ERRORS_SCHEMA: SchemaMetadata;
 
 /**
- * Store the runtime input for all directives applied to a node.
- *
- * This allows efficiently setting the same input on a directive that
- * might apply to multiple directives.
+ * Maps the public names of inputs applied to a specific node to the index of the
+ * directive instance to which the input value should be written, for example:
  *
- * i+0: directive instance index
- * i+1: privateName
- * i+2: input flags
- *
- * e.g.
  * ```
  * {
- *   "publicName": [0, 'change-minified', <bit-input-flags>]
+ *   "publicName": [0, 5]
  * }
  * ```
  */
-declare type NodeInputBindings = Record<string, (number | string | InputFlags)[]>;
+declare type NodeInputBindings = Record<string, number[]>;
 
 /**
- * Store the runtime output names for all the directives.
- *
- * i+0: directive instance index
- * i+1: privateName
+ * Maps the public names of outputs available on a specific node to the index
+ * of the directive instance that defines the output, for example:
  *
- * e.g.
  * ```
  * {
- *   "publicName": [0, 'change-minified']
+ *   "publicName": [0, 5]
  * }
+ * ```
  */
-declare type NodeOutputBindings = Record<string, (number | string)[]>;
+declare type NodeOutputBindings = Record<string, number[]>;
 
 declare const NODES = "n";
 
@@ -11072,17 +11149,29 @@ declare interface TNode {
      */
     localNames: (string | number)[] | null;
     /** Information about input properties that need to be set once from attribute data. */
-    initialInputs: InitialInputData | null | undefined;
+    initialInputs: InitialInputData | null;
     /**
      * Input data for all directives on this node. `null` means that there are no directives with
      * inputs on this node.
      */
     inputs: NodeInputBindings | null;
+    /**
+     * Input data for host directives applied to the node.
+     */
+    hostDirectiveInputs: HostDirectiveInputs | null;
     /**
      * Output data for all directives on this node. `null` means that there are no directives with
      * outputs on this node.
      */
     outputs: NodeOutputBindings | null;
+    /**
+     * Input data for host directives applied to the node.
+     */
+    hostDirectiveOutputs: HostDirectiveOutputs | null;
+    /**
+     * Mapping between directive classes applied to the node and their indexes.
+     */
+    directiveToIndex: DirectiveIndexMap | null;
     /**
      * The TView attached to this node.
      *
@@ -12761,6 +12850,11 @@ export declare abstract class ViewRef extends ChangeDetectorRef {
     abstract onDestroy(callback: Function): void;
 }
 
+declare type WrappedRequest = {
+    request: unknown;
+    reload: number;
+};
+
 /**
  * A `Resource` with a mutable value.
  *
@@ -13458,20 +13552,11 @@ export declare interface ɵDirectiveDef<T> {
      * A dictionary mapping the inputs' public name to their minified property names
      * (along with flags if there are any).
      */
-    readonly inputs: {
-        [P in keyof T]?: string | [minifiedName: string, flags: InputFlags];
-    };
-    /**
-     * A dictionary mapping the private names of inputs to their transformation functions.
-     * Note: the private names are used for the keys, rather than the public ones, because public
-     * names can be re-aliased in host directives which would invalidate the lookup.
-     *
-     * Note: Signal inputs will not have transforms captured here. This is because their
-     * transform function is already integrated into the `InputSignal`.
-     */
-    readonly inputTransforms: {
-        [classPropertyName: string]: InputTransformFunction;
-    } | null;
+    readonly inputs: Record<string, [
+    minifiedName: string,
+    flags: InputFlags,
+    transform: InputTransformFunction | null
+    ]>;
     /**
      * Contains the raw input information produced by the compiler. Can be
      * used to do further processing after the `inputs` have been inverted.
@@ -13489,9 +13574,7 @@ export declare interface ɵDirectiveDef<T> {
      * are their aliases if any, or their original unminified property names
      * (as in `@Output('alias') propertyName: any;`).
      */
-    readonly outputs: {
-        [P in keyof T]?: string;
-    };
+    readonly outputs: Record<string, string>;
     /**
      * Function to create and refresh content queries associated with a given directive.
      */
@@ -14118,6 +14201,108 @@ export declare class ɵMicrotaskEffectScheduler extends ZoneAwareEffectScheduler
     static ɵprov: unknown;
 }
 
+export declare class ɵNavigateEvent extends Event {
+    constructor(type: string, eventInit?: NavigateEventInit);
+    readonly navigationType: ɵNavigationTypeString;
+    readonly canIntercept: boolean;
+    readonly userInitiated: boolean;
+    readonly hashChange: boolean;
+    readonly destination: ɵNavigationDestination;
+    readonly signal: AbortSignal;
+    readonly formData: FormData | null;
+    readonly downloadRequest: string | null;
+    readonly info?: unknown;
+    intercept(options?: ɵNavigationInterceptOptions): void;
+    scroll(): void;
+}
+
+export declare class ɵNavigation extends EventTarget {
+    entries(): ɵNavigationHistoryEntry[];
+    readonly currentEntry: ɵNavigationHistoryEntry | null;
+    updateCurrentEntry(options: ɵNavigationUpdateCurrentEntryOptions): void;
+    readonly transition: ɵNavigationTransition | null;
+    readonly canGoBack: boolean;
+    readonly canGoForward: boolean;
+    navigate(url: string, options?: ɵNavigationNavigateOptions): ɵNavigationResult;
+    reload(options?: ɵNavigationReloadOptions): ɵNavigationResult;
+    traverseTo(key: string, options?: ɵNavigationOptions): ɵNavigationResult;
+    back(options?: ɵNavigationOptions): ɵNavigationResult;
+    forward(options?: ɵNavigationOptions): ɵNavigationResult;
+    onnavigate: ((this: ɵNavigation, ev: ɵNavigateEvent) => any) | null;
+    onnavigatesuccess: ((this: ɵNavigation, ev: Event) => any) | null;
+    onnavigateerror: ((this: ɵNavigation, ev: ErrorEvent) => any) | null;
+    oncurrententrychange: ((this: ɵNavigation, ev: ɵNavigationCurrentEntryChangeEvent) => any) | null;
+    addEventListener<K extends keyof NavigationEventMap>(type: K, listener: (this: ɵNavigation, ev: NavigationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof NavigationEventMap>(type: K, listener: (this: ɵNavigation, ev: NavigationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+
+export declare class ɵNavigationCurrentEntryChangeEvent extends Event {
+    constructor(type: string, eventInit?: NavigationCurrentEntryChangeEventInit);
+    readonly navigationType: ɵNavigationTypeString | null;
+    readonly from: ɵNavigationHistoryEntry;
+}
+
+export declare class ɵNavigationDestination {
+    readonly url: string;
+    readonly key: string | null;
+    readonly id: string | null;
+    readonly index: number;
+    readonly sameDocument: boolean;
+    getState(): unknown;
+}
+
+export declare class ɵNavigationHistoryEntry extends EventTarget {
+    readonly key: string;
+    readonly id: string;
+    readonly url: string | null;
+    readonly index: number;
+    readonly sameDocument: boolean;
+    getState(): unknown;
+    ondispose: ((this: ɵNavigationHistoryEntry, ev: Event) => any) | null;
+    addEventListener<K extends keyof NavigationHistoryEntryEventMap>(type: K, listener: (this: ɵNavigationHistoryEntry, ev: NavigationHistoryEntryEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof NavigationHistoryEntryEventMap>(type: K, listener: (this: ɵNavigationHistoryEntry, ev: NavigationHistoryEntryEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+
+export declare interface ɵNavigationInterceptOptions {
+    handler?: () => Promise<void>;
+    focusReset?: 'after-transition' | 'manual';
+    scroll?: 'after-transition' | 'manual';
+}
+
+export declare interface ɵNavigationNavigateOptions extends ɵNavigationOptions {
+    state?: unknown;
+    history?: 'auto' | 'push' | 'replace';
+}
+
+export declare interface ɵNavigationOptions {
+    info?: unknown;
+}
+
+export declare interface ɵNavigationReloadOptions extends ɵNavigationOptions {
+    state?: unknown;
+}
+
+export declare interface ɵNavigationResult {
+    committed: Promise<ɵNavigationHistoryEntry>;
+    finished: Promise<ɵNavigationHistoryEntry>;
+}
+
+export declare class ɵNavigationTransition {
+    readonly navigationType: ɵNavigationTypeString;
+    readonly from: ɵNavigationHistoryEntry;
+    readonly finished: Promise<void>;
+}
+
+export declare type ɵNavigationTypeString = 'reload' | 'push' | 'replace' | 'traverse';
+
+export declare interface ɵNavigationUpdateCurrentEntryOptions {
+    state: unknown;
+}
+
 
 export declare const ɵNG_COMP_DEF: string;
 
@@ -14670,6 +14855,40 @@ export declare function ɵresolveComponentResources(resourceResolver: (url: stri
     text(): Promise<string>;
 }>): Promise<void>;
 
+/**
+ * Implementation for `resource()` which uses a `linkedSignal` to manage the resource's state.
+ */
+export declare class ɵResourceImpl<T, R> extends BaseWritableResource<T> implements ResourceRef<T> {
+    private readonly loaderFn;
+    private readonly defaultValue;
+    private readonly equal;
+    private readonly pendingTasks;
+    /**
+     * The current state of the resource. Status, value, and error are derived from this.
+     */
+    private readonly state;
+    /**
+     * Combines the current request with a reload counter which allows the resource to be reloaded on
+     * imperative command.
+     */
+    protected readonly extRequest: WritableSignal<WrappedRequest>;
+    private readonly effectRef;
+    private pendingController;
+    private resolvePendingTask;
+    private destroyed;
+    constructor(request: () => R, loaderFn: ResourceStreamingLoader<T, R>, defaultValue: T, equal: ValueEqualityFn_2<T> | undefined, injector: Injector);
+    readonly status: Signal<ResourceStatus>;
+    readonly error: Signal<unknown>;
+    /**
+     * Called either directly via `WritableResource.set` or via `.value.set()`.
+     */
+    set(value: T): void;
+    reload(): boolean;
+    destroy(): void;
+    private loadEffect;
+    private abortInProgressLoad;
+}
+
 export declare function ɵrestoreComponentResolutionQueue(queue: Map<Type<any>, Component>): void;
 
 /**
@@ -16881,16 +17100,6 @@ export declare interface ɵɵInjectorDef<T> {
     imports: (InjectorType<any> | InjectorTypeWithProviders<any>)[];
 }
 
-/**
- * Decorates the directive definition with support for input transform functions.
- *
- * If the directive uses inheritance, the feature should be included before the
- * `InheritDefinitionFeature` to ensure that the `inputTransforms` field is populated.
- *
- * @codeGenApi
- */
-export declare function ɵɵInputTransformsFeature<T>(definition: ɵDirectiveDef<T>): void;
-
 /**
  * Throws an error indicating that a factory function could not be generated by the compiler for a
  * particular class.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/core",
-  "version": "19.2.0-next.3",
+  "version": "19.2.0",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",

package/primitives/event-dispatch/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.2.0-next.3
+ * @license Angular v19.2.0
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */

package/primitives/signals/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.2.0-next.3
+ * @license Angular v19.2.0
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -280,7 +280,7 @@ export declare function setAlternateWeakRefImpl(impl: unknown): void;
 
 export declare function setPostSignalSetFn(fn: (() => void) | null): (() => void) | null;
 
-export declare function setThrowInvalidWriteToSignalError(fn: () => never): void;
+export declare function setThrowInvalidWriteToSignalError(fn: <T>(node: SignalNode<T>) => never): void;
 
 /**
  * Symbol used to tell `Signal`s apart from other functions.

package/rxjs-interop/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.2.0-next.3
+ * @license Angular v19.2.0
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */

package/schematics/bundles/apply_import_manager-a4e62ded.js

@@ -0,0 +1,71 @@
+'use strict';
+/**
+ * @license Angular v19.2.0
+ * (c) 2010-2024 Google LLC. https://angular.io/
+ * License: MIT
+ */
+'use strict';
+
+var ts = require('typescript');
+require('os');
+var checker = require('./checker-2eecc677.js');
+var project_paths = require('./project_paths-64bc3947.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+
+/**
+ * Applies import manager changes, and writes them as replacements the
+ * given result array.
+ */
+function applyImportManagerChanges(importManager, replacements, sourceFiles, info) {
+    const { newImports, updatedImports, deletedImports } = importManager.finalize();
+    const printer = ts__default["default"].createPrinter({});
+    const pathToFile = new Map(sourceFiles.map((s) => [s.fileName, s]));
+    // Capture new imports
+    newImports.forEach((newImports, fileName) => {
+        newImports.forEach((newImport) => {
+            const printedImport = printer.printNode(ts__default["default"].EmitHint.Unspecified, newImport, pathToFile.get(fileName));
+            replacements.push(new project_paths.Replacement(project_paths.projectFile(checker.absoluteFrom(fileName), info), new project_paths.TextUpdate({ position: 0, end: 0, toInsert: `${printedImport}\n` })));
+        });
+    });
+    // Capture updated imports
+    for (const [oldBindings, newBindings] of updatedImports.entries()) {
+        // The import will be generated as multi-line if it already is multi-line,
+        // or if the number of elements significantly increased and it previously
+        // consisted of very few specifiers.
+        const isMultiline = oldBindings.getText().includes('\n') ||
+            (newBindings.elements.length >= 6 && oldBindings.elements.length <= 3);
+        const hasSpaceBetweenBraces = oldBindings.getText().startsWith('{ ');
+        let formatFlags = ts__default["default"].ListFormat.NamedImportsOrExportsElements |
+            ts__default["default"].ListFormat.Indented |
+            ts__default["default"].ListFormat.Braces |
+            ts__default["default"].ListFormat.PreserveLines |
+            (isMultiline ? ts__default["default"].ListFormat.MultiLine : ts__default["default"].ListFormat.SingleLine);
+        if (hasSpaceBetweenBraces) {
+            formatFlags |= ts__default["default"].ListFormat.SpaceBetweenBraces;
+        }
+        else {
+            formatFlags &= ~ts__default["default"].ListFormat.SpaceBetweenBraces;
+        }
+        const printedBindings = printer.printList(formatFlags, newBindings.elements, oldBindings.getSourceFile());
+        replacements.push(new project_paths.Replacement(project_paths.projectFile(oldBindings.getSourceFile(), info), new project_paths.TextUpdate({
+            position: oldBindings.getStart(),
+            end: oldBindings.getEnd(),
+            // TS uses four spaces as indent. We migrate to two spaces as we
+            // assume this to be more common.
+            toInsert: printedBindings.replace(/^ {4}/gm, '  '),
+        })));
+    }
+    // Update removed imports
+    for (const removedImport of deletedImports) {
+        replacements.push(new project_paths.Replacement(project_paths.projectFile(removedImport.getSourceFile(), info), new project_paths.TextUpdate({
+            position: removedImport.getStart(),
+            end: removedImport.getEnd(),
+            toInsert: '',
+        })));
+    }
+}
+
+exports.applyImportManagerChanges = applyImportManagerChanges;

package/schematics/bundles/{checker-32db85a6.js → checker-2eecc677.js}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.2.0-next.3
+ * @license Angular v19.2.0
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2942,10 +2942,6 @@ class Identifiers {
         name: 'ɵɵHostDirectivesFeature',
         moduleName: CORE,
     };
-    static InputTransformsFeatureFeature = {
-        name: 'ɵɵInputTransformsFeature',
-        moduleName: CORE,
-    };
     static ExternalStylesFeature = {
         name: 'ɵɵExternalStylesFeature',
         moduleName: CORE,
@@ -28747,7 +28743,6 @@ function addFeatures(definitionMap, meta) {
     const features = [];
     const providers = meta.providers;
     const viewProviders = meta.viewProviders;
-    const inputKeys = Object.keys(meta.inputs);
     if (providers || viewProviders) {
         const args = [providers || new LiteralArrayExpr([])];
         if (viewProviders) {
@@ -28755,12 +28750,6 @@ function addFeatures(definitionMap, meta) {
         }
         features.push(importExpr(Identifiers.ProvidersFeature).callFn(args));
     }
-    for (const key of inputKeys) {
-        if (meta.inputs[key].transformFunction !== null) {
-            features.push(importExpr(Identifiers.InputTransformsFeatureFeature));
-            break;
-        }
-    }
     // Note: host directives feature needs to be inserted before the
     // inheritance feature to ensure the correct execution order.
     if (meta.hostDirectives?.length) {
@@ -30733,7 +30722,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version('19.2.0-next.3');
+new Version('19.2.0');
 
 const _I18N_ATTR = 'i18n';
 const _I18N_ATTR_PREFIX = 'i18n-';
@@ -32141,7 +32130,7 @@ class NodeJSPathManipulation {
 // G3-ESM-MARKER: G3 uses CommonJS, but externally everything in ESM.
 // CommonJS/ESM interop for determining the current file name and containing dir.
 const isCommonJS = typeof __filename !== 'undefined';
-const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || new URL('checker-32db85a6.js', document.baseURI).href));
+const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || new URL('checker-2eecc677.js', document.baseURI).href));
 const currentFileName = isCommonJS ? __filename : url.fileURLToPath(currentFileUrl);
 /**
  * A wrapper around the Node.js file-system that supports readonly operations and path manipulation.
@@ -32771,6 +32760,11 @@ const patchedReferencedAliasesSymbol = Symbol('patchedReferencedAliases');
  * that have been referenced in a value-position by the transform, such the installed patch can
  * ensure that those import declarations are not elided.
  *
+ * If `null` is returned then the transform operates in an isolated context, i.e. using the
+ * `ts.transform` API. In such scenario there is no information whether an alias declaration
+ * is referenced, so all alias declarations are naturally preserved and explicitly registering
+ * an alias declaration as used isn't necessary.
+ *
  * See below. Note that this uses sourcegraph as the TypeScript checker file doesn't display on
  * Github.
  * https://sourcegraph.com/github.com/microsoft/TypeScript@3eaa7c65f6f076a08a5f7f1946fd0df7c7430259/-/blob/src/compiler/checker.ts#L31219-31257
@@ -32782,6 +32776,11 @@ function loadIsReferencedAliasDeclarationPatch(context) {
         throwIncompatibleTransformationContextError();
     }
     const emitResolver = context.getEmitResolver();
+    if (emitResolver === undefined) {
+        // In isolated `ts.transform` operations no emit resolver is present, return null as `isReferencedAliasDeclaration`
+        // will never be invoked.
+        return null;
+    }
     // The emit resolver may have been patched already, in which case we return the set of referenced
     // aliases that was created when the patch was first applied.
     // See https://github.com/angular/angular/issues/40276.
@@ -32907,7 +32906,7 @@ class DefaultImportTracker {
                         if (clausesToPreserve === null) {
                             clausesToPreserve = loadIsReferencedAliasDeclarationPatch(context);
                         }
-                        clausesToPreserve.add(clause);
+                        clausesToPreserve?.add(clause);
                     }
                 }
                 return sourceFile;
@@ -36104,7 +36103,9 @@ function createTsTransformForImportManager(manager, extraStatementsForFiles) {
         // doesn't drop these thinking they are unused.
         if (reusedOriginalAliasDeclarations.size > 0) {
             const referencedAliasDeclarations = loadIsReferencedAliasDeclarationPatch(ctx);
-            reusedOriginalAliasDeclarations.forEach((aliasDecl) => referencedAliasDeclarations.add(aliasDecl));
+            if (referencedAliasDeclarations !== null) {
+                reusedOriginalAliasDeclarations.forEach((aliasDecl) => referencedAliasDeclarations.add(aliasDecl));
+            }
         }
         // Update the set of affected files to include files that need extra statements to be inserted.
         if (extraStatementsForFiles !== undefined) {