@angular/compiler-cli 15.2.0 → 16.0.0-next.0

package/ngcc/src/packages/configuration.d.ts

@@ -1,222 +0,0 @@
-import { AbsoluteFsPath, PathManipulation, ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-import { PackageJsonFormatPropertiesMap } from './entry_point';
-/**
- * The format of a project level configuration file.
- */
-export interface NgccProjectConfig {
-    /**
-     * The packages that are configured by this project config.
-     */
-    packages?: {
-        [packagePath: string]: RawNgccPackageConfig | undefined;
-    };
-    /**
-     * Options that control how locking the process is handled.
-     */
-    locking?: ProcessLockingConfiguration;
-    /**
-     * Name of hash algorithm used to generate hashes of the configuration.
-     *
-     * Defaults to `sha256`.
-     */
-    hashAlgorithm?: string;
-}
-/**
- * Options that control how locking the process is handled.
- */
-export interface ProcessLockingConfiguration {
-    /**
-     * The number of times the AsyncLocker will attempt to lock the process before failing.
-     * Defaults to 500.
-     */
-    retryAttempts?: number;
-    /**
-     * The number of milliseconds between attempts to lock the process.
-     * Defaults to 500ms.
-     * */
-    retryDelay?: number;
-}
-/**
- * The raw format of a package level configuration (as it appears in configuration files).
- */
-export interface RawNgccPackageConfig {
-    /**
-     * The entry-points to configure for this package.
-     *
-     * In the config file the keys are paths relative to the package path.
-     */
-    entryPoints?: {
-        [entryPointPath: string]: NgccEntryPointConfig;
-    };
-    /**
-     * A collection of regexes that match deep imports to ignore, for this package, rather than
-     * displaying a warning.
-     */
-    ignorableDeepImportMatchers?: RegExp[];
-}
-/**
- * Configuration options for an entry-point.
- *
- * The existence of a configuration for a path tells ngcc that this should be considered for
- * processing as an entry-point.
- */
-export interface NgccEntryPointConfig {
-    /** Do not process (or even acknowledge the existence of) this entry-point, if true. */
-    ignore?: boolean;
-    /**
-     * This property, if provided, holds values that will override equivalent properties in an
-     * entry-point's package.json file.
-     */
-    override?: PackageJsonFormatPropertiesMap;
-    /**
-     * Normally, ngcc will skip compilation of entrypoints that contain imports that can't be resolved
-     * or understood. If this option is specified, ngcc will proceed with compiling the entrypoint
-     * even in the face of such missing dependencies.
-     */
-    ignoreMissingDependencies?: boolean;
-    /**
-     * Enabling this option for an entrypoint tells ngcc that deep imports might be used for the files
-     * it contains, and that it should generate private re-exports alongside the NgModule of all the
-     * directives/pipes it makes available in support of those imports.
-     */
-    generateDeepReexports?: boolean;
-}
-interface VersionedPackageConfig extends RawNgccPackageConfig {
-    versionRange: string;
-}
-/**
- * The internal representation of a configuration file. Configured packages are transformed into
- * `ProcessedNgccPackageConfig` when a certain version is requested.
- */
-export declare class PartiallyProcessedConfig {
-    /**
-     * The packages that are configured by this project config, keyed by package name.
-     */
-    packages: Map<string, VersionedPackageConfig[]>;
-    /**
-     * Options that control how locking the process is handled.
-     */
-    locking: ProcessLockingConfiguration;
-    /**
-     * Name of hash algorithm used to generate hashes of the configuration.
-     *
-     * Defaults to `sha256`.
-     */
-    hashAlgorithm: string;
-    constructor(projectConfig: NgccProjectConfig);
-    private splitNameAndVersion;
-    /**
-     * Registers the configuration for a particular version of the provided package.
-     */
-    private addPackageConfig;
-    /**
-     * Finds the configuration for a particular version of the provided package.
-     */
-    findPackageConfig(packageName: string, version: string | null): VersionedPackageConfig | null;
-    /**
-     * Converts the configuration into a JSON representation that is used to compute a hash of the
-     * configuration.
-     */
-    toJson(): string;
-}
-/**
- * The default configuration for ngcc.
- *
- * This is the ultimate fallback configuration that ngcc will use if there is no configuration
- * for a package at the package level or project level.
- *
- * This configuration is for packages that are "dead" - i.e. no longer maintained and so are
- * unlikely to be fixed to work with ngcc, nor provide a package level config of their own.
- *
- * The fallback process for looking up configuration is:
- *
- * Project -> Package -> Default
- *
- * If a package provides its own configuration then that would override this default one.
- *
- * Also application developers can always provide configuration at their project level which
- * will override everything else.
- *
- * Note that the fallback is package based not entry-point based.
- * For example, if a there is configuration for a package at the project level this will replace all
- * entry-point configurations that may have been provided in the package level or default level
- * configurations, even if the project level configuration does not provide for a given entry-point.
- */
-export declare const DEFAULT_NGCC_CONFIG: NgccProjectConfig;
-/**
- * The processed package level configuration as a result of processing a raw package level config.
- */
-export declare class ProcessedNgccPackageConfig implements Omit<RawNgccPackageConfig, 'entryPoints'> {
-    /**
-     * The absolute path to this instance of the package.
-     * Note that there may be multiple instances of a package inside a project in nested
-     * `node_modules/`. For example, one at `<project-root>/node_modules/some-package/` and one at
-     * `<project-root>/node_modules/other-package/node_modules/some-package/`.
-     */
-    packagePath: AbsoluteFsPath;
-    /**
-     * The entry-points to configure for this package.
-     *
-     * In contrast to `RawNgccPackageConfig`, the paths are absolute and take the path of the specific
-     * instance of the package into account.
-     */
-    entryPoints: Map<AbsoluteFsPath, NgccEntryPointConfig>;
-    /**
-     * A collection of regexes that match deep imports to ignore, for this package, rather than
-     * displaying a warning.
-     */
-    ignorableDeepImportMatchers: RegExp[];
-    constructor(fs: PathManipulation, packagePath: AbsoluteFsPath, { entryPoints, ignorableDeepImportMatchers, }: RawNgccPackageConfig);
-}
-/**
- * Ngcc has a hierarchical configuration system that lets us "fix up" packages that do not
- * work with ngcc out of the box.
- *
- * There are three levels at which configuration can be declared:
- *
- * * Default level - ngcc comes with built-in configuration for well known cases.
- * * Package level - a library author publishes a configuration with their package to fix known
- *   issues.
- * * Project level - the application developer provides a configuration that fixes issues specific
- *   to the libraries used in their application.
- *
- * Ngcc will match configuration based on the package name but also on its version. This allows
- * configuration to provide different fixes to different version ranges of a package.
- *
- * * Package level configuration is specific to the package version where the configuration is
- *   found.
- * * Default and project level configuration should provide version ranges to ensure that the
- *   configuration is only applied to the appropriate versions of a package.
- *
- * When getting a configuration for a package (via `getConfig()`) the caller should provide the
- * version of the package in question, if available. If it is not provided then the first available
- * configuration for a package is returned.
- */
-export declare class NgccConfiguration {
-    private fs;
-    private defaultConfig;
-    private projectConfig;
-    private cache;
-    readonly hash: string;
-    readonly hashAlgorithm: string;
-    constructor(fs: ReadonlyFileSystem, baseDir: AbsoluteFsPath);
-    /**
-     * Get the configuration options for locking the ngcc process.
-     */
-    getLockingConfig(): Required<ProcessLockingConfiguration>;
-    /**
-     * Get a configuration for the given `version` of a package at `packagePath`.
-     *
-     * @param packageName The name of the package whose config we want.
-     * @param packagePath The path to the package whose config we want.
-     * @param version The version of the package whose config we want, or `null` if the package's
-     * package.json did not exist or was invalid.
-     */
-    getPackageConfig(packageName: string, packagePath: AbsoluteFsPath, version: string | null): ProcessedNgccPackageConfig;
-    private getRawPackageConfig;
-    private loadProjectConfig;
-    private loadPackageConfig;
-    private evalSrcFile;
-    private computeHash;
-}
-export {};

package/ngcc/src/packages/entry_point.d.ts

@@ -1,109 +0,0 @@
-import { AbsoluteFsPath, ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { JsonObject } from '../utils';
-import { NgccConfiguration } from './configuration';
-/**
- * The possible values for the format of an entry-point.
- */
-export type EntryPointFormat = 'esm5' | 'esm2015' | 'umd' | 'commonjs';
-/**
- * An object containing information about an entry-point, including paths
- * to each of the possible entry-point formats.
- */
-export interface EntryPoint extends JsonObject {
-    /** The name of the entry-point (e.g. `@angular/core` or `@angular/common/http`). */
-    name: string;
-    /** The path to this entry point. */
-    path: AbsoluteFsPath;
-    /**
-     * The name of the package that contains this entry-point (e.g. `@angular/core` or
-     * `@angular/common`).
-     */
-    packageName: string;
-    /** The path to the package that contains this entry-point. */
-    packagePath: AbsoluteFsPath;
-    /** The URL of the repository. */
-    repositoryUrl: string;
-    /** The parsed package.json file for this entry-point. */
-    packageJson: EntryPointPackageJson;
-    /** The path to a typings (.d.ts) file for this entry-point. */
-    typings: AbsoluteFsPath;
-    /** Is this EntryPoint compiled with the Angular View Engine compiler? */
-    compiledByAngular: boolean;
-    /** Should ngcc ignore missing dependencies and process this entrypoint anyway? */
-    ignoreMissingDependencies: boolean;
-    /** Should ngcc generate deep re-exports for this entrypoint? */
-    generateDeepReexports: boolean;
-}
-export interface PackageJsonFormatPropertiesMap {
-    browser?: string;
-    fesm2015?: string;
-    fesm5?: string;
-    es2015?: string;
-    esm2015?: string;
-    esm5?: string;
-    main?: string;
-    module?: string;
-    types?: string;
-    typings?: string;
-}
-export type PackageJsonFormatProperties = keyof PackageJsonFormatPropertiesMap;
-/**
- * The properties that may be loaded from the `package.json` file.
- */
-export interface EntryPointPackageJson extends JsonObject, PackageJsonFormatPropertiesMap {
-    name: string;
-    version?: string;
-    scripts?: Record<string, string>;
-    repository?: string | {
-        url: string;
-    };
-    __processed_by_ivy_ngcc__?: Record<string, string>;
-}
-export type EntryPointJsonProperty = Exclude<PackageJsonFormatProperties, 'types' | 'typings'>;
-export declare const SUPPORTED_FORMAT_PROPERTIES: EntryPointJsonProperty[];
-/**
- * The path does not represent an entry-point, i.e. there is no package.json at the path and there
- * is no config to force an entry-point.
- */
-export declare const NO_ENTRY_POINT = "no-entry-point";
-/**
- * The path represents an entry-point that is `ignored` by an ngcc config.
- */
-export declare const IGNORED_ENTRY_POINT = "ignored-entry-point";
-/**
- * The path has a package.json, but it is not a valid entry-point for ngcc processing.
- */
-export declare const INCOMPATIBLE_ENTRY_POINT = "incompatible-entry-point";
-/**
- * The result of calling `getEntryPointInfo()`.
- *
- * This will be an `EntryPoint` object if an Angular entry-point was identified;
- * Otherwise it will be a flag indicating one of:
- * * NO_ENTRY_POINT - the path is not an entry-point or ngcc is configured to ignore it
- * * INCOMPATIBLE_ENTRY_POINT - the path was a non-processable entry-point that should be searched
- * for sub-entry-points
- */
-export type GetEntryPointResult = EntryPoint | typeof IGNORED_ENTRY_POINT | typeof INCOMPATIBLE_ENTRY_POINT | typeof NO_ENTRY_POINT;
-/**
- * Try to create an entry-point from the given paths and properties.
- *
- * @param packagePath the absolute path to the containing npm package
- * @param entryPointPath the absolute path to the potential entry-point.
- * @returns
- * - An entry-point if it is valid and not ignored.
- * - `NO_ENTRY_POINT` when there is no package.json at the path and there is no config to force an
- *   entry-point,
- * - `IGNORED_ENTRY_POINT` when the entry-point is ignored by an ngcc config.
- * - `INCOMPATIBLE_ENTRY_POINT` when there is a package.json but it is not a valid Angular compiled
- *   entry-point.
- */
-export declare function getEntryPointInfo(fs: ReadonlyFileSystem, config: NgccConfiguration, logger: Logger, packagePath: AbsoluteFsPath, entryPointPath: AbsoluteFsPath): GetEntryPointResult;
-export declare function isEntryPoint(result: GetEntryPointResult): result is EntryPoint;
-/**
- * Convert a package.json property into an entry-point format.
- *
- * @param property The property to convert to a format.
- * @returns An entry-point format or `undefined` if none match the given property.
- */
-export declare function getEntryPointFormat(fs: ReadonlyFileSystem, entryPoint: EntryPoint, property: EntryPointJsonProperty): EntryPointFormat | undefined;

package/ngcc/src/packages/entry_point_bundle.d.ts

@@ -1,46 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import ts from 'typescript';
-import { AbsoluteFsPath, FileSystem } from '../../../src/ngtsc/file_system';
-import { DtsProcessing } from '../execution/tasks/api';
-import { PathMappings } from '../path_mappings';
-import { BundleProgram } from './bundle_program';
-import { EntryPoint, EntryPointFormat } from './entry_point';
-import { SharedFileCache } from './source_file_cache';
-/**
- * A bundle of files and paths (and TS programs) that correspond to a particular
- * format of a package entry-point.
- */
-export interface EntryPointBundle {
-    entryPoint: EntryPoint;
-    format: EntryPointFormat;
-    isCore: boolean;
-    isFlatCore: boolean;
-    rootDirs: AbsoluteFsPath[];
-    src: BundleProgram;
-    dts: BundleProgram | null;
-    dtsProcessing: DtsProcessing;
-    enableI18nLegacyMessageIdFormat: boolean;
-}
-/**
- * Get an object that describes a formatted bundle for an entry-point.
- * @param fs The current file-system being used.
- * @param entryPoint The entry-point that contains the bundle.
- * @param sharedFileCache The cache to use for source files that are shared across all entry-points.
- * @param moduleResolutionCache The module resolution cache to use.
- * @param formatPath The path to the source files for this bundle.
- * @param isCore This entry point is the Angular core package.
- * @param format The underlying format of the bundle.
- * @param dtsProcessing Whether to transform the typings along with this bundle.
- * @param pathMappings An optional set of mappings to use when compiling files.
- * @param mirrorDtsFromSrc If true then the `dts` program will contain additional files that
- * were guessed by mapping the `src` files to `dts` files.
- * @param enableI18nLegacyMessageIdFormat Whether to render legacy message ids for i18n messages in
- * component templates.
- */
-export declare function makeEntryPointBundle(fs: FileSystem, entryPoint: EntryPoint, sharedFileCache: SharedFileCache, moduleResolutionCache: ts.ModuleResolutionCache, formatPath: string, isCore: boolean, format: EntryPointFormat, dtsProcessing: DtsProcessing, pathMappings?: PathMappings, mirrorDtsFromSrc?: boolean, enableI18nLegacyMessageIdFormat?: boolean): EntryPointBundle;

package/ngcc/src/packages/entry_point_manifest.d.ts

@@ -1,79 +0,0 @@
-import { AbsoluteFsPath, FileSystem, PathSegment } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { EntryPointWithDependencies } from '../dependencies/dependency_host';
-import { NgccConfiguration } from './configuration';
-import { PackageJsonFormatProperties } from './entry_point';
-/**
- * Manages reading and writing a manifest file that contains a list of all the entry-points that
- * were found below a given basePath.
- *
- * This is a super-set of the entry-points that are actually processed for a given run of ngcc,
- * since some may already be processed, or excluded if they do not have the required format.
- */
-export declare class EntryPointManifest {
-    private fs;
-    private config;
-    private logger;
-    constructor(fs: FileSystem, config: NgccConfiguration, logger: Logger);
-    /**
-     * Try to get the entry-point info from a manifest file for the given `basePath` if it exists and
-     * is not out of date.
-     *
-     * Reasons for the manifest to be out of date are:
-     *
-     * * the file does not exist
-     * * the ngcc version has changed
-     * * the package lock-file (i.e. yarn.lock or package-lock.json) has changed
-     * * the project configuration has changed
-     * * one or more entry-points in the manifest are not valid
-     *
-     * @param basePath The path that would contain the entry-points and the manifest file.
-     * @returns an array of entry-point information for all entry-points found below the given
-     * `basePath` or `null` if the manifest was out of date.
-     */
-    readEntryPointsUsingManifest(basePath: AbsoluteFsPath): EntryPointWithDependencies[] | null;
-    /**
-     * Write a manifest file at the given `basePath`.
-     *
-     * The manifest includes the current ngcc version and hashes of the package lock-file and current
-     * project config. These will be used to check whether the manifest file is out of date. See
-     * `readEntryPointsUsingManifest()`.
-     *
-     * @param basePath The path where the manifest file is to be written.
-     * @param entryPoints A collection of entry-points to record in the manifest.
-     */
-    writeEntryPointManifest(basePath: AbsoluteFsPath, entryPoints: EntryPointWithDependencies[]): void;
-    private getEntryPointManifestPath;
-    private computeLockFileHash;
-}
-/**
- * A specialized implementation of the `EntryPointManifest` that can be used to invalidate the
- * current manifest file.
- *
- * It always returns `null` from the `readEntryPointsUsingManifest()` method, which forces a new
- * manifest to be created, which will overwrite the current file when `writeEntryPointManifest()`
- * is called.
- */
-export declare class InvalidatingEntryPointManifest extends EntryPointManifest {
-    readEntryPointsUsingManifest(_basePath: AbsoluteFsPath): EntryPointWithDependencies[] | null;
-}
-export type EntryPointPaths = [
-    string,
-    string,
-    Array<AbsoluteFsPath>?,
-    Array<AbsoluteFsPath | PathSegment>?,
-    Array<AbsoluteFsPath>?
-];
-/**
- * The JSON format of the manifest file that is written to disk.
- */
-export interface EntryPointManifestFile {
-    ngccVersion: string;
-    configFileHash: string;
-    lockFileHash: string;
-    entryPointPaths: EntryPointPaths[];
-}
-/** The JSON format of the entrypoint properties. */
-export type NewEntryPointPropertiesMap = {
-    [Property in PackageJsonFormatProperties as `${Property}_ivy_ngcc`]?: string;
-};

package/ngcc/src/packages/ngcc_compiler_host.d.ts

@@ -1,36 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import ts from 'typescript';
-import { AbsoluteFsPath, FileSystem, NgtscCompilerHost } from '../../../src/ngtsc/file_system';
-import { EntryPointFileCache } from './source_file_cache';
-/**
- * Represents a compiler host that resolves a module import as a JavaScript source file if
- * available, instead of the .d.ts typings file that would have been resolved by TypeScript. This
- * is necessary for packages that have their typings in the same directory as the sources, which
- * would otherwise let TypeScript prefer the .d.ts file instead of the JavaScript source file.
- */
-export declare class NgccSourcesCompilerHost extends NgtscCompilerHost {
-    private cache;
-    private moduleResolutionCache;
-    protected packagePath: AbsoluteFsPath;
-    constructor(fs: FileSystem, options: ts.CompilerOptions, cache: EntryPointFileCache, moduleResolutionCache: ts.ModuleResolutionCache, packagePath: AbsoluteFsPath);
-    getSourceFile(fileName: string, languageVersion: ts.ScriptTarget): ts.SourceFile | undefined;
-    resolveModuleNames(moduleNames: string[], containingFile: string, reusedNames?: string[], redirectedReference?: ts.ResolvedProjectReference): Array<ts.ResolvedModule | undefined>;
-}
-/**
- * A compiler host implementation that is used for the typings program. It leverages the entry-point
- * cache for source files and module resolution, as these results can be reused across the sources
- * program.
- */
-export declare class NgccDtsCompilerHost extends NgtscCompilerHost {
-    private cache;
-    private moduleResolutionCache;
-    constructor(fs: FileSystem, options: ts.CompilerOptions, cache: EntryPointFileCache, moduleResolutionCache: ts.ModuleResolutionCache);
-    getSourceFile(fileName: string, languageVersion: ts.ScriptTarget): ts.SourceFile | undefined;
-    resolveModuleNames(moduleNames: string[], containingFile: string, reusedNames?: string[], redirectedReference?: ts.ResolvedProjectReference): Array<ts.ResolvedModule | undefined>;
-}

package/ngcc/src/packages/patch_ts_expando_initializer.d.ts

@@ -1,41 +0,0 @@
-/**
- * Consider the following ES5 code that may have been generated for a class:
- *
- * ```
- * var A = (function(){
- *   function A() {}
- *   return A;
- * }());
- * A.staticProp = true;
- * ```
- *
- * Here, TypeScript marks the symbol for "A" as a so-called "expando symbol", which causes
- * "staticProp" to be added as an export of the "A" symbol.
- *
- * In the example above, symbol "A" has been assigned some flags to indicate that it represents a
- * class. Due to this flag, the symbol is considered an expando symbol and as such, "staticProp" is
- * stored in `ts.Symbol.exports`.
- *
- * A problem arises when "A" is not at the top-level, i.e. in UMD bundles. In that case, the symbol
- * does not have the flag that marks the symbol as a class. Therefore, TypeScript inspects "A"'s
- * initializer expression, which is an IIFE in the above example. Unfortunately however, only IIFEs
- * of the form `(function(){})()` qualify as initializer for an "expando symbol"; the slightly
- * different form seen in the example above, `(function(){}())`, does not. This prevents the "A"
- * symbol from being considered an expando symbol, in turn preventing "staticProp" from being stored
- * in `ts.Symbol.exports`.
- *
- * The logic for identifying symbols as "expando symbols" can be found here:
- * https://github.com/microsoft/TypeScript/blob/v3.4.5/src/compiler/binder.ts#L2656-L2685
- *
- * Notice how the `getExpandoInitializer` function is available on the "ts" namespace in the
- * compiled bundle, so we are able to override this function to accommodate for the alternative
- * IIFE notation. The original implementation can be found at:
- * https://github.com/Microsoft/TypeScript/blob/v3.4.5/src/compiler/utilities.ts#L1864-L1887
- *
- * Issue tracked in https://github.com/microsoft/TypeScript/issues/31778
- *
- * @returns the function to pass to `restoreGetExpandoInitializer` to undo the patch, or null if
- * the issue is known to have been fixed.
- */
-export declare function patchTsGetExpandoInitializer(): unknown;
-export declare function restoreGetExpandoInitializer(originalGetExpandoInitializer: unknown): void;

package/ngcc/src/packages/source_file_cache.d.ts

@@ -1,97 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import ts from 'typescript';
-import { AbsoluteFsPath, ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-/**
- * A cache that holds on to source files that can be shared for processing all entry-points in a
- * single invocation of ngcc. In particular, the following files are shared across all entry-points
- * through this cache:
- *
- * 1. Default library files such as `lib.dom.d.ts` and `lib.es5.d.ts`. These files don't change
- *    and some are very large, so parsing is expensive. Therefore, the parsed `ts.SourceFile`s for
- *    the default library files are cached.
- * 2. The typings of @angular scoped packages. The typing files for @angular packages are typically
- *    used in the entry-points that ngcc processes, so benefit from a single source file cache.
- *    Especially `@angular/core/core.d.ts` is large and expensive to parse repeatedly. In contrast
- *    to default library files, we have to account for these files to be invalidated during a single
- *    invocation of ngcc, as ngcc will overwrite the .d.ts files during its processing.
- *
- * The lifecycle of this cache corresponds with a single invocation of ngcc. Separate invocations,
- * e.g. the CLI's synchronous module resolution fallback will therefore all have their own cache.
- * This allows for the source file cache to be garbage collected once ngcc processing has completed.
- */
-export declare class SharedFileCache {
-    private fs;
-    private sfCache;
-    constructor(fs: ReadonlyFileSystem);
-    /**
-     * Loads a `ts.SourceFile` if the provided `fileName` is deemed appropriate to be cached. To
-     * optimize for memory usage, only files that are generally used in all entry-points are cached.
-     * If `fileName` is not considered to benefit from caching or the requested file does not exist,
-     * then `undefined` is returned.
-     */
-    getCachedSourceFile(fileName: string): ts.SourceFile | undefined;
-    /**
-     * Attempts to load the source file from the cache, or parses the file into a `ts.SourceFile` if
-     * it's not yet cached. This method assumes that the file will not be modified for the duration
-     * that this cache is valid for. If that assumption does not hold, the `getVolatileCachedFile`
-     * method is to be used instead.
-     */
-    private getStableCachedFile;
-    /**
-     * In contrast to `getStableCachedFile`, this method always verifies that the cached source file
-     * is the same as what's stored on disk. This is done for files that are expected to change during
-     * ngcc's processing, such as @angular scoped packages for which the .d.ts files are overwritten
-     * by ngcc. If the contents on disk have changed compared to a previously cached source file, the
-     * content from disk is re-parsed and the cache entry is replaced.
-     */
-    private getVolatileCachedFile;
-}
-/**
- * Determines whether the provided path corresponds with a default library file inside of the
- * typescript package.
- *
- * @param absPath The path for which to determine if it corresponds with a default library file.
- * @param fs The filesystem to use for inspecting the path.
- */
-export declare function isDefaultLibrary(absPath: AbsoluteFsPath, fs: ReadonlyFileSystem): boolean;
-/**
- * Determines whether the provided path corresponds with a .d.ts file inside of an @angular
- * scoped package. This logic only accounts for the .d.ts files in the root, which is sufficient
- * to find the large, flattened entry-point files that benefit from caching.
- *
- * @param absPath The path for which to determine if it corresponds with an @angular .d.ts file.
- * @param fs The filesystem to use for inspecting the path.
- */
-export declare function isAngularDts(absPath: AbsoluteFsPath, fs: ReadonlyFileSystem): boolean;
-/**
- * A cache for processing a single entry-point. This exists to share `ts.SourceFile`s between the
- * source and typing programs that are created for a single program.
- */
-export declare class EntryPointFileCache {
-    private fs;
-    private sharedFileCache;
-    private processSourceText;
-    private readonly sfCache;
-    constructor(fs: ReadonlyFileSystem, sharedFileCache: SharedFileCache, processSourceText: (sourceText: string) => string);
-    /**
-     * Returns and caches a parsed `ts.SourceFile` for the provided `fileName`. If the `fileName` is
-     * cached in the shared file cache, that result is used. Otherwise, the source file is cached
-     * internally. This method returns `undefined` if the requested file does not exist.
-     *
-     * @param fileName The path of the file to retrieve a source file for.
-     * @param languageVersion The language version to use for parsing the file.
-     */
-    getCachedSourceFile(fileName: string, languageVersion: ts.ScriptTarget): ts.SourceFile | undefined;
-}
-/**
- * Creates a `ts.ModuleResolutionCache` that uses the provided filesystem for path operations.
- *
- * @param fs The filesystem to use for path operations.
- */
-export declare function createModuleResolutionCache(fs: ReadonlyFileSystem): ts.ModuleResolutionCache;