id
int64 0
3.78k
| code
stringlengths 13
37.9k
| declarations
stringlengths 16
64.6k
|
|---|---|---|
3,300 | (data: ExternalItemFunctionData) => Promise<ExternalItemValue> | interface ExternalItemFunctionData {
/**
* The directory in which the request is placed.
*/
context?: string;
/**
* Contextual information.
*/
contextInfo?: import |
3,301 | (warning: WebpackError, compilation: Compilation) => boolean | class WebpackError extends Error {
/**
* Creates an instance of WebpackError.
*/
constructor(message?: string);
details: any;
module: Module;
loc: DependencyLocation;
hideStack: boolean;
chunk: Chunk;
file: string;
serialize(__0: { write: any }): void;
deserialize(__0: { read: any }): void;
/**
* Create .stack property on a target object
*/
static captureStackTrace(
targetObject: object,
constructorOpt?: Function
): void;
/**
* Optional override for formatting stack traces
*/
static prepareStackTrace?: (
err: Error,
stackTraces: NodeJS.CallSite[]
) => any;
static stackTraceLimit: number;
} |
3,302 | (warning: WebpackError, compilation: Compilation) => boolean | class Compilation {
/**
* Creates an instance of Compilation.
*/
constructor(compiler: Compiler, params: CompilationParams);
hooks: Readonly<{
buildModule: SyncHook<[Module]>;
rebuildModule: SyncHook<[Module]>;
failedModule: SyncHook<[Module, WebpackError]>;
succeedModule: SyncHook<[Module]>;
stillValidModule: SyncHook<[Module]>;
addEntry: SyncHook<[Dependency, EntryOptions]>;
failedEntry: SyncHook<[Dependency, EntryOptions, Error]>;
succeedEntry: SyncHook<[Dependency, EntryOptions, Module]>;
dependencyReferencedExports: SyncWaterfallHook<
[(string[] | ReferencedExport)[], Dependency, RuntimeSpec]
>;
executeModule: SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>;
prepareModuleExecution: AsyncParallelHook<
[ExecuteModuleArgument, ExecuteModuleContext]
>;
finishModules: AsyncSeriesHook<[Iterable<Module>]>;
finishRebuildingModule: AsyncSeriesHook<[Module]>;
unseal: SyncHook<[]>;
seal: SyncHook<[]>;
beforeChunks: SyncHook<[]>;
afterChunks: SyncHook<[Iterable<Chunk>]>;
optimizeDependencies: SyncBailHook<[Iterable<Module>], any>;
afterOptimizeDependencies: SyncHook<[Iterable<Module>]>;
optimize: SyncHook<[]>;
optimizeModules: SyncBailHook<[Iterable<Module>], any>;
afterOptimizeModules: SyncHook<[Iterable<Module>]>;
optimizeChunks: SyncBailHook<[Iterable<Chunk>, ChunkGroup[]], any>;
afterOptimizeChunks: SyncHook<[Iterable<Chunk>, ChunkGroup[]]>;
optimizeTree: AsyncSeriesHook<[Iterable<Chunk>, Iterable<Module>]>;
afterOptimizeTree: SyncHook<[Iterable<Chunk>, Iterable<Module>]>;
optimizeChunkModules: AsyncSeriesBailHook<
[Iterable<Chunk>, Iterable<Module>],
any
>;
afterOptimizeChunkModules: SyncHook<[Iterable<Chunk>, Iterable<Module>]>;
shouldRecord: SyncBailHook<[], boolean>;
additionalChunkRuntimeRequirements: SyncHook<
[Chunk, Set<string>, RuntimeRequirementsContext]
>;
runtimeRequirementInChunk: HookMap<
SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], any>
>;
additionalModuleRuntimeRequirements: SyncHook<
[Module, Set<string>, RuntimeRequirementsContext]
>;
runtimeRequirementInModule: HookMap<
SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext], any>
>;
additionalTreeRuntimeRequirements: SyncHook<
[Chunk, Set<string>, RuntimeRequirementsContext]
>;
runtimeRequirementInTree: HookMap<
SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], any>
>;
runtimeModule: SyncHook<[RuntimeModule, Chunk]>;
reviveModules: SyncHook<[Iterable<Module>, any]>;
beforeModuleIds: SyncHook<[Iterable<Module>]>;
moduleIds: SyncHook<[Iterable<Module>]>;
optimizeModuleIds: SyncHook<[Iterable<Module>]>;
afterOptimizeModuleIds: SyncHook<[Iterable<Module>]>;
reviveChunks: SyncHook<[Iterable<Chunk>, any]>;
beforeChunkIds: SyncHook<[Iterable<Chunk>]>;
chunkIds: SyncHook<[Iterable<Chunk>]>;
optimizeChunkIds: SyncHook<[Iterable<Chunk>]>;
afterOptimizeChunkIds: SyncHook<[Iterable<Chunk>]>;
recordModules: SyncHook<[Iterable<Module>, any]>;
recordChunks: SyncHook<[Iterable<Chunk>, any]>;
optimizeCodeGeneration: SyncHook<[Iterable<Module>]>;
beforeModuleHash: SyncHook<[]>;
afterModuleHash: SyncHook<[]>;
beforeCodeGeneration: SyncHook<[]>;
afterCodeGeneration: SyncHook<[]>;
beforeRuntimeRequirements: SyncHook<[]>;
afterRuntimeRequirements: SyncHook<[]>;
beforeHash: SyncHook<[]>;
contentHash: SyncHook<[Chunk]>;
afterHash: SyncHook<[]>;
recordHash: SyncHook<[any]>;
record: SyncHook<[Compilation, any]>;
beforeModuleAssets: SyncHook<[]>;
shouldGenerateChunkAssets: SyncBailHook<[], boolean>;
beforeChunkAssets: SyncHook<[]>;
additionalChunkAssets: FakeHook<
Pick<
AsyncSeriesHook<[Set<Chunk>]>,
"name" | "tap" | "tapAsync" | "tapPromise"
>
>;
additionalAssets: FakeHook<
Pick<AsyncSeriesHook<[]>, "name" | "tap" | "tapAsync" | "tapPromise">
>;
optimizeChunkAssets: FakeHook<
Pick<
AsyncSeriesHook<[Set<Chunk>]>,
"name" | "tap" | "tapAsync" | "tapPromise"
>
>;
afterOptimizeChunkAssets: FakeHook<
Pick<
AsyncSeriesHook<[Set<Chunk>]>,
"name" | "tap" | "tapAsync" | "tapPromise"
>
>;
optimizeAssets: AsyncSeriesHook<
[CompilationAssets],
ProcessAssetsAdditionalOptions
>;
afterOptimizeAssets: SyncHook<[CompilationAssets]>;
processAssets: AsyncSeriesHook<
[CompilationAssets],
ProcessAssetsAdditionalOptions
>;
afterProcessAssets: SyncHook<[CompilationAssets]>;
processAdditionalAssets: AsyncSeriesHook<[CompilationAssets]>;
needAdditionalSeal: SyncBailHook<[], boolean>;
afterSeal: AsyncSeriesHook<[]>;
renderManifest: SyncWaterfallHook<
[RenderManifestEntry[], RenderManifestOptions]
>;
fullHash: SyncHook<[Hash]>;
chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
moduleAsset: SyncHook<[Module, string]>;
chunkAsset: SyncHook<[Chunk, string]>;
assetPath: SyncWaterfallHook<[string, object, AssetInfo]>;
needAdditionalPass: SyncBailHook<[], boolean>;
childCompiler: SyncHook<[Compiler, string, number]>;
log: SyncBailHook<[string, LogEntry], true>;
processWarnings: SyncWaterfallHook<[WebpackError[]]>;
processErrors: SyncWaterfallHook<[WebpackError[]]>;
statsPreset: HookMap<
SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>
>;
statsNormalize: SyncHook<
[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]
>;
statsFactory: SyncHook<[StatsFactory, NormalizedStatsOptions]>;
statsPrinter: SyncHook<[StatsPrinter, NormalizedStatsOptions]>;
get normalModuleLoader(): SyncHook<[object, NormalModule]>;
}>;
name?: string;
startTime: any;
endTime: any;
compiler: Compiler;
resolverFactory: ResolverFactory;
inputFileSystem: InputFileSystem;
fileSystemInfo: FileSystemInfo;
valueCacheVersions: Map<string, string | Set<string>>;
requestShortener: RequestShortener;
compilerPath: string;
logger: WebpackLogger;
options: WebpackOptionsNormalized;
outputOptions: OutputNormalized;
bail: boolean;
profile: boolean;
params: CompilationParams;
mainTemplate: MainTemplate;
chunkTemplate: ChunkTemplate;
runtimeTemplate: RuntimeTemplate;
moduleTemplates: { javascript: ModuleTemplate };
moduleMemCaches?: Map<Module, WeakTupleMap<any, any>>;
moduleMemCaches2?: Map<Module, WeakTupleMap<any, any>>;
moduleGraph: ModuleGraph;
chunkGraph: ChunkGraph;
codeGenerationResults: CodeGenerationResults;
processDependenciesQueue: AsyncQueue<Module, Module, Module>;
addModuleQueue: AsyncQueue<Module, string, Module>;
factorizeQueue: AsyncQueue<
FactorizeModuleOptions,
string,
Module | ModuleFactoryResult
>;
buildQueue: AsyncQueue<Module, Module, Module>;
rebuildQueue: AsyncQueue<Module, Module, Module>;
/**
* Modules in value are building during the build of Module in key.
* Means value blocking key from finishing.
* Needed to detect build cycles.
*/
creatingModuleDuringBuild: WeakMap<Module, Set<Module>>;
entries: Map<string, EntryData>;
globalEntry: EntryData;
entrypoints: Map<string, Entrypoint>;
asyncEntrypoints: Entrypoint[];
chunks: Set<Chunk>;
chunkGroups: ChunkGroup[];
namedChunkGroups: Map<string, ChunkGroup>;
namedChunks: Map<string, Chunk>;
modules: Set<Module>;
records: any;
additionalChunkAssets: string[];
assets: CompilationAssets;
assetsInfo: Map<string, AssetInfo>;
errors: WebpackError[];
warnings: WebpackError[];
children: Compilation[];
logging: Map<string, LogEntry[]>;
dependencyFactories: Map<DepConstructor, ModuleFactory>;
dependencyTemplates: DependencyTemplates;
childrenCounters: object;
usedChunkIds: Set<string | number>;
usedModuleIds: Set<number>;
needAdditionalPass: boolean;
builtModules: WeakSet<Module>;
codeGeneratedModules: WeakSet<Module>;
buildTimeExecutedModules: WeakSet<Module>;
emittedAssets: Set<string>;
comparedForEmitAssets: Set<string>;
fileDependencies: LazySet<string>;
contextDependencies: LazySet<string>;
missingDependencies: LazySet<string>;
buildDependencies: LazySet<string>;
compilationDependencies: { add: (item?: any) => LazySet<string> };
getStats(): Stats;
createStatsOptions(
optionsOrPreset: string | StatsOptions,
context?: CreateStatsOptionsContext
): NormalizedStatsOptions;
createStatsFactory(options?: any): StatsFactory;
createStatsPrinter(options?: any): StatsPrinter;
getCache(name: string): CacheFacade;
getLogger(name: string | (() => string)): WebpackLogger;
addModule(
module: Module,
callback: (err?: null | WebpackError, result?: Module) => void
): void;
/**
* Fetches a module from a compilation by its identifier
*/
getModule(module: Module): Module;
/**
* Attempts to search for a module by its identifier
*/
findModule(identifier: string): undefined | Module;
/**
* Schedules a build of the module object
*/
buildModule(
module: Module,
callback: (err?: null | WebpackError, result?: Module) => void
): void;
processModuleDependencies(
module: Module,
callback: (err?: null | WebpackError, result?: Module) => void
): void;
processModuleDependenciesNonRecursive(module: Module): void;
handleModuleCreation(
__0: HandleModuleCreationOptions,
callback: (err?: null | WebpackError, result?: Module) => void
): void;
addModuleChain(
context: string,
dependency: Dependency,
callback: (err?: null | WebpackError, result?: Module) => void
): void;
addModuleTree(
__0: {
/**
* context string path
*/
context: string;
/**
* dependency used to create Module chain
*/
dependency: Dependency;
/**
* additional context info for the root module
*/
contextInfo?: Partial<ModuleFactoryCreateDataContextInfo>;
},
callback: (err?: null | WebpackError, result?: Module) => void
): void;
addEntry(
context: string,
entry: Dependency,
optionsOrName: string | EntryOptions,
callback: (err?: null | WebpackError, result?: Module) => void
): void;
addInclude(
context: string,
dependency: Dependency,
options: EntryOptions,
callback: (err?: null | WebpackError, result?: Module) => void
): void;
rebuildModule(
module: Module,
callback: (err?: null | WebpackError, result?: Module) => void
): void;
finish(callback?: any): void;
unseal(): void;
seal(callback: (err?: null | WebpackError) => void): void;
reportDependencyErrorsAndWarnings(
module: Module,
blocks: DependenciesBlock[]
): boolean;
codeGeneration(callback?: any): void;
processRuntimeRequirements(__0?: {
/**
* the chunk graph
*/
chunkGraph?: ChunkGraph;
/**
* modules
*/
modules?: Iterable<Module>;
/**
* chunks
*/
chunks?: Iterable<Chunk>;
/**
* codeGenerationResults
*/
codeGenerationResults?: CodeGenerationResults;
/**
* chunkGraphEntries
*/
chunkGraphEntries?: Iterable<Chunk>;
}): void;
addRuntimeModule(
chunk: Chunk,
module: RuntimeModule,
chunkGraph?: ChunkGraph
): void;
/**
* If `module` is passed, `loc` and `request` must also be passed.
*/
addChunkInGroup(
groupOptions: string | ChunkGroupOptions,
module?: Module,
loc?: SyntheticDependencyLocation | RealDependencyLocation,
request?: string
): ChunkGroup;
addAsyncEntrypoint(
options: EntryOptions,
module: Module,
loc: DependencyLocation,
request: string
): Entrypoint;
/**
* This method first looks to see if a name is provided for a new chunk,
* and first looks to see if any named chunks already exist and reuse that chunk instead.
*/
addChunk(name?: string): Chunk;
assignDepth(module: Module): void;
assignDepths(modules: Set<Module>): void;
getDependencyReferencedExports(
dependency: Dependency,
runtime: RuntimeSpec
): (string[] | ReferencedExport)[];
removeReasonsOfDependencyBlock(
module: Module,
block: DependenciesBlockLike
): void;
patchChunksAfterReasonRemoval(module: Module, chunk: Chunk): void;
removeChunkFromDependencies(block: DependenciesBlock, chunk: Chunk): void;
assignRuntimeIds(): void;
sortItemsWithChunkIds(): void;
summarizeDependencies(): void;
createModuleHashes(): void;
createHash(): {
module: Module;
hash: string;
runtime: RuntimeSpec;
runtimes: RuntimeSpec[];
}[];
fullHash?: string;
hash?: string;
emitAsset(file: string, source: Source, assetInfo?: AssetInfo): void;
updateAsset(
file: string,
newSourceOrFunction: Source | ((arg0: Source) => Source),
assetInfoUpdateOrFunction?: AssetInfo | ((arg0?: AssetInfo) => AssetInfo)
): void;
renameAsset(file?: any, newFile?: any): void;
deleteAsset(file: string): void;
getAssets(): Readonly<Asset>[];
getAsset(name: string): undefined | Readonly<Asset>;
clearAssets(): void;
createModuleAssets(): void;
getRenderManifest(options: RenderManifestOptions): RenderManifestEntry[];
createChunkAssets(callback: (err?: null | WebpackError) => void): void;
getPath(
filename: string | ((arg0: PathData, arg1?: AssetInfo) => string),
data?: PathData
): string;
getPathWithInfo(
filename: string | ((arg0: PathData, arg1?: AssetInfo) => string),
data?: PathData
): { path: string; info: AssetInfo };
getAssetPath(
filename: string | ((arg0: PathData, arg1?: AssetInfo) => string),
data: PathData
): string;
getAssetPathWithInfo(
filename: string | ((arg0: PathData, arg1?: AssetInfo) => string),
data: PathData
): { path: string; info: AssetInfo };
getWarnings(): WebpackError[];
getErrors(): WebpackError[];
/**
* This function allows you to run another instance of webpack inside of webpack however as
* a child with different settings and configurations (if desired) applied. It copies all hooks, plugins
* from parent (or top level compiler) and creates a child Compilation
*/
createChildCompiler(
name: string,
outputOptions?: OutputNormalized,
plugins?: (
| ((this: Compiler, compiler: Compiler) => void)
| WebpackPluginInstance
)[]
): Compiler;
executeModule(
module: Module,
options: ExecuteModuleOptions,
callback: (err?: null | WebpackError, result?: ExecuteModuleResult) => void
): void;
checkConstraints(): void;
factorizeModule: {
(
options: FactorizeModuleOptions & { factoryResult?: false },
callback: (err?: null | WebpackError, result?: Module) => void
): void;
(
options: FactorizeModuleOptions & { factoryResult: true },
callback: (
err?: null | WebpackError,
result?: ModuleFactoryResult
) => void
): void;
};
/**
* Add additional assets to the compilation.
*/
static PROCESS_ASSETS_STAGE_ADDITIONAL: number;
/**
* Basic preprocessing of assets.
*/
static PROCESS_ASSETS_STAGE_PRE_PROCESS: number;
/**
* Derive new assets from existing assets.
* Existing assets should not be treated as complete.
*/
static PROCESS_ASSETS_STAGE_DERIVED: number;
/**
* Add additional sections to existing assets, like a banner or initialization code.
*/
static PROCESS_ASSETS_STAGE_ADDITIONS: number;
/**
* Optimize existing assets in a general way.
*/
static PROCESS_ASSETS_STAGE_OPTIMIZE: number;
/**
* Optimize the count of existing assets, e. g. by merging them.
* Only assets of the same type should be merged.
* For assets of different types see PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE.
*/
static PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT: number;
/**
* Optimize the compatibility of existing assets, e. g. add polyfills or vendor-prefixes.
*/
static PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY: number;
/**
* Optimize the size of existing assets, e. g. by minimizing or omitting whitespace.
*/
static PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE: number;
/**
* Add development tooling to assets, e. g. by extracting a SourceMap.
*/
static PROCESS_ASSETS_STAGE_DEV_TOOLING: number;
/**
* Optimize the count of existing assets, e. g. by inlining assets of into other assets.
* Only assets of different types should be inlined.
* For assets of the same type see PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT.
*/
static PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE: number;
/**
* Summarize the list of existing assets
* e. g. creating an assets manifest of Service Workers.
*/
static PROCESS_ASSETS_STAGE_SUMMARIZE: number;
/**
* Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
*/
static PROCESS_ASSETS_STAGE_OPTIMIZE_HASH: number;
/**
* Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
*/
static PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER: number;
/**
* Analyse existing assets.
*/
static PROCESS_ASSETS_STAGE_ANALYSE: number;
/**
* Creating assets for reporting purposes.
*/
static PROCESS_ASSETS_STAGE_REPORT: number;
} |
3,303 | constructor(options: ConsumeSharedPluginOptions) | interface ConsumeSharedPluginOptions {
/**
* Modules that should be consumed from share scope. When provided, property names are used to match requested modules in this compilation.
*/
consumes: Consumes;
/**
* Share scope name used for all consumed modules (defaults to 'default').
*/
shareScope?: string;
} |
3,304 | constructor(options: ConsumeSharedPluginOptions) | interface ConsumeSharedPluginOptions {
/**
* Modules that should be consumed from share scope. When provided, property names are used to match requested modules in this compilation.
*/
consumes: Consumes;
/**
* Share scope name used for all consumed modules (defaults to 'default').
*/
shareScope?: string;
} |
3,305 | constructor(options: ContainerPluginOptions) | interface ContainerPluginOptions {
/**
* Modules that should be exposed by this container. When provided, property name is used as public name, otherwise public name is automatically inferred from request.
*/
exposes: Exposes;
/**
* The filename for this container relative path inside the `output.path` directory.
*/
filename?: string;
/**
* Options for library.
*/
library?: LibraryOptions;
/**
* The name for this container.
*/
name: string;
/**
* The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
*/
runtime?: string | false;
/**
* The name of the share scope which is shared with the host (defaults to 'default').
*/
shareScope?: string;
} |
3,306 | constructor(options: ContainerPluginOptions) | interface ContainerPluginOptions {
/**
* Modules that should be exposed by this container. When provided, property name is used as public name, otherwise public name is automatically inferred from request.
*/
exposes: Exposes;
/**
* The filename for this container relative path inside the `output.path` directory.
*/
filename?: string;
/**
* Options for library.
*/
library?: LibraryOptions;
/**
* The name for this container.
*/
name: string;
/**
* The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
*/
runtime?: EntryRuntime;
/**
* The name of the share scope which is shared with the host (defaults to 'default').
*/
shareScope?: string;
} |
3,307 | constructor(options: ContainerReferencePluginOptions) | interface ContainerReferencePluginOptions {
/**
* The external type of the remote containers.
*/
remoteType: ExternalsType;
/**
* Container locations and request scopes from which modules should be resolved and loaded at runtime. When provided, property name is used as request scope, otherwise request scope is automatically inferred from container location.
*/
remotes: Remotes;
/**
* The name of the share scope shared with all remotes (defaults to 'default').
*/
shareScope?: string;
} |
3,308 | constructor(options: ContainerReferencePluginOptions) | interface ContainerReferencePluginOptions {
/**
* The external type of the remote containers.
*/
remoteType: ExternalsType;
/**
* Container locations and request scopes from which modules should be resolved and loaded at runtime. When provided, property name is used as request scope, otherwise request scope is automatically inferred from container location.
*/
remotes: Remotes;
/**
* The name of the share scope shared with all remotes (defaults to 'default').
*/
shareScope?: string;
} |
3,309 | resolveDependencies(
fs: InputFileSystem,
options: ContextModuleOptions,
callback: (
err?: null | Error,
dependencies?: ContextElementDependency[]
) => any
): void | interface ContextModuleOptions {
mode: ContextMode;
recursive: boolean;
regExp: RegExp;
namespaceObject?: boolean | "strict";
addon?: string;
chunkName?: string;
include?: RegExp;
exclude?: RegExp;
groupOptions?: RawChunkGroupOptions;
typePrefix?: string;
category?: string;
/**
* exports referenced from modules (won't be mangled)
*/
referencedExports?: string[][];
resource: string | false | string[];
resourceQuery?: string;
resourceFragment?: string;
resolveOptions: any;
} |
3,310 | resolveDependencies(
fs: InputFileSystem,
options: ContextModuleOptions,
callback: (
err?: null | Error,
dependencies?: ContextElementDependency[]
) => any
): void | interface InputFileSystem {
readFile: (
arg0: string,
arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: string | Buffer) => void
) => void;
readJson?: (
arg0: string,
arg1: (arg0?: null | Error | NodeJS.ErrnoException, arg1?: any) => void
) => void;
readlink: (
arg0: string,
arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: string | Buffer) => void
) => void;
readdir: (
arg0: string,
arg1: (
arg0?: null | NodeJS.ErrnoException,
arg1?: (string | Buffer)[] | IDirent[]
) => void
) => void;
stat: (
arg0: string,
arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: IStats) => void
) => void;
lstat?: (
arg0: string,
arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: IStats) => void
) => void;
realpath?: (
arg0: string,
arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: string | Buffer) => void
) => void;
purge?: (arg0?: string) => void;
join?: (arg0: string, arg1: string) => string;
relative?: (arg0: string, arg1: string) => string;
dirname?: (arg0: string) => string;
} |
3,311 | addBlock(block: AsyncDependenciesBlock): void | class AsyncDependenciesBlock extends DependenciesBlock {
constructor(
groupOptions: RawChunkGroupOptions & { name?: string } & {
entryOptions?: EntryOptions;
},
loc?: SyntheticDependencyLocation | RealDependencyLocation,
request?: string
);
groupOptions: RawChunkGroupOptions & { name?: string } & {
entryOptions?: EntryOptions;
};
loc?: SyntheticDependencyLocation | RealDependencyLocation;
request?: string;
chunkName: string;
module: any;
} |
3,312 | addDependency(dependency: Dependency): void | class Dependency {
constructor();
weak: boolean;
optional: boolean;
get type(): string;
get category(): string;
loc: DependencyLocation;
setLoc(
startLine?: any,
startColumn?: any,
endLine?: any,
endColumn?: any
): void;
getContext(): undefined | string;
getResourceIdentifier(): null | string;
couldAffectReferencingModule(): boolean | typeof TRANSITIVE;
/**
* Returns the referenced module and export
*/
getReference(moduleGraph: ModuleGraph): never;
/**
* Returns list of exports referenced by this dependency
*/
getReferencedExports(
moduleGraph: ModuleGraph,
runtime: RuntimeSpec
): (string[] | ReferencedExport)[];
getCondition(
moduleGraph: ModuleGraph
):
| null
| false
| ((arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState);
/**
* Returns the exported names
*/
getExports(moduleGraph: ModuleGraph): undefined | ExportsSpec;
/**
* Returns warnings
*/
getWarnings(moduleGraph: ModuleGraph): WebpackError[];
/**
* Returns errors
*/
getErrors(moduleGraph: ModuleGraph): WebpackError[];
/**
* Update the hash
*/
updateHash(hash: Hash, context: UpdateHashContextDependency): void;
/**
* implement this method to allow the occurrence order plugin to count correctly
*/
getNumberOfIdOccurrences(): number;
getModuleEvaluationSideEffectsState(
moduleGraph: ModuleGraph
): ConnectionState;
createIgnoredModule(context: string): Module;
serialize(__0: { write: any }): void;
deserialize(__0: { read: any }): void;
module: any;
get disconnect(): any;
static NO_EXPORTS_REFERENCED: string[][];
static EXPORTS_OBJECT_REFERENCED: string[][];
static TRANSITIVE: typeof TRANSITIVE;
} |
3,313 | removeDependency(dependency: Dependency): void | class Dependency {
constructor();
weak: boolean;
optional: boolean;
get type(): string;
get category(): string;
loc: DependencyLocation;
setLoc(
startLine?: any,
startColumn?: any,
endLine?: any,
endColumn?: any
): void;
getContext(): undefined | string;
getResourceIdentifier(): null | string;
couldAffectReferencingModule(): boolean | typeof TRANSITIVE;
/**
* Returns the referenced module and export
*/
getReference(moduleGraph: ModuleGraph): never;
/**
* Returns list of exports referenced by this dependency
*/
getReferencedExports(
moduleGraph: ModuleGraph,
runtime: RuntimeSpec
): (string[] | ReferencedExport)[];
getCondition(
moduleGraph: ModuleGraph
):
| null
| false
| ((arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState);
/**
* Returns the exported names
*/
getExports(moduleGraph: ModuleGraph): undefined | ExportsSpec;
/**
* Returns warnings
*/
getWarnings(moduleGraph: ModuleGraph): WebpackError[];
/**
* Returns errors
*/
getErrors(moduleGraph: ModuleGraph): WebpackError[];
/**
* Update the hash
*/
updateHash(hash: Hash, context: UpdateHashContextDependency): void;
/**
* implement this method to allow the occurrence order plugin to count correctly
*/
getNumberOfIdOccurrences(): number;
getModuleEvaluationSideEffectsState(
moduleGraph: ModuleGraph
): ConnectionState;
createIgnoredModule(context: string): Module;
serialize(__0: { write: any }): void;
deserialize(__0: { read: any }): void;
module: any;
get disconnect(): any;
static NO_EXPORTS_REFERENCED: string[][];
static EXPORTS_OBJECT_REFERENCED: string[][];
static TRANSITIVE: typeof TRANSITIVE;
} |
3,314 | updateHash(hash: Hash, context: UpdateHashContextDependency): void | interface UpdateHashContextDependency {
chunkGraph: ChunkGraph;
runtime: RuntimeSpec;
runtimeTemplate?: RuntimeTemplate;
} |
3,315 | updateHash(hash: Hash, context: UpdateHashContextDependency): void | class Hash {
constructor();
/**
* Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
*/
update(data: string | Buffer, inputEncoding?: string): Hash;
/**
* Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
*/
digest(encoding?: string): string | Buffer;
} |
3,316 | getReference(moduleGraph: ModuleGraph): never | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,317 | getReferencedExports(
moduleGraph: ModuleGraph,
runtime: RuntimeSpec
): (string[] | ReferencedExport)[] | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,318 | getReferencedExports(
moduleGraph: ModuleGraph,
runtime: RuntimeSpec
): (string[] | ReferencedExport)[] | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,319 | getCondition(
moduleGraph: ModuleGraph
):
| null
| false
| ((arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState) | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,320 | (arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,321 | (arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState | class ModuleGraphConnection {
constructor(
originModule: null | Module,
dependency: null | Dependency,
module: Module,
explanation?: string,
weak?: boolean,
condition?:
| false
| ((arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState)
);
originModule: null | Module;
resolvedOriginModule: null | Module;
dependency: null | Dependency;
resolvedModule: Module;
module: Module;
weak: boolean;
conditional: boolean;
condition: (
arg0: ModuleGraphConnection,
arg1: RuntimeSpec
) => ConnectionState;
explanations: Set<string>;
clone(): ModuleGraphConnection;
addCondition(
condition: (
arg0: ModuleGraphConnection,
arg1: RuntimeSpec
) => ConnectionState
): void;
addExplanation(explanation: string): void;
get explanation(): string;
active: void;
isActive(runtime: RuntimeSpec): boolean;
isTargetActive(runtime: RuntimeSpec): boolean;
getActiveState(runtime: RuntimeSpec): ConnectionState;
setActive(value: boolean): void;
static addConnectionStates: (
a: ConnectionState,
b: ConnectionState
) => ConnectionState;
static TRANSITIVE_ONLY: typeof TRANSITIVE_ONLY;
static CIRCULAR_CONNECTION: typeof CIRCULAR_CONNECTION;
} |
3,322 | getExports(moduleGraph: ModuleGraph): undefined | ExportsSpec | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,323 | getWarnings(moduleGraph: ModuleGraph): WebpackError[] | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,324 | getErrors(moduleGraph: ModuleGraph): WebpackError[] | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,325 | getModuleEvaluationSideEffectsState(
moduleGraph: ModuleGraph
): ConnectionState | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,326 | apply(
dependency: Dependency,
source: ReplaceSource,
templateContext: DependencyTemplateContext
): void | class Dependency {
constructor();
weak: boolean;
optional: boolean;
get type(): string;
get category(): string;
loc: DependencyLocation;
setLoc(
startLine?: any,
startColumn?: any,
endLine?: any,
endColumn?: any
): void;
getContext(): undefined | string;
getResourceIdentifier(): null | string;
couldAffectReferencingModule(): boolean | typeof TRANSITIVE;
/**
* Returns the referenced module and export
*/
getReference(moduleGraph: ModuleGraph): never;
/**
* Returns list of exports referenced by this dependency
*/
getReferencedExports(
moduleGraph: ModuleGraph,
runtime: RuntimeSpec
): (string[] | ReferencedExport)[];
getCondition(
moduleGraph: ModuleGraph
):
| null
| false
| ((arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState);
/**
* Returns the exported names
*/
getExports(moduleGraph: ModuleGraph): undefined | ExportsSpec;
/**
* Returns warnings
*/
getWarnings(moduleGraph: ModuleGraph): WebpackError[];
/**
* Returns errors
*/
getErrors(moduleGraph: ModuleGraph): WebpackError[];
/**
* Update the hash
*/
updateHash(hash: Hash, context: UpdateHashContextDependency): void;
/**
* implement this method to allow the occurrence order plugin to count correctly
*/
getNumberOfIdOccurrences(): number;
getModuleEvaluationSideEffectsState(
moduleGraph: ModuleGraph
): ConnectionState;
createIgnoredModule(context: string): Module;
serialize(__0: { write: any }): void;
deserialize(__0: { read: any }): void;
module: any;
get disconnect(): any;
static NO_EXPORTS_REFERENCED: string[][];
static EXPORTS_OBJECT_REFERENCED: string[][];
static TRANSITIVE: typeof TRANSITIVE;
} |
3,327 | apply(
dependency: Dependency,
source: ReplaceSource,
templateContext: DependencyTemplateContext
): void | interface DependencyTemplateContext {
/**
* the runtime template
*/
runtimeTemplate: RuntimeTemplate;
/**
* the dependency templates
*/
dependencyTemplates: DependencyTemplates;
/**
* the module graph
*/
moduleGraph: ModuleGraph;
/**
* the chunk graph
*/
chunkGraph: ChunkGraph;
/**
* the requirements for runtime
*/
runtimeRequirements: Set<string>;
/**
* current module
*/
module: Module;
/**
* current runtimes, for which code is generated
*/
runtime: RuntimeSpec;
/**
* mutable array of init fragments for the current module
*/
initFragments: InitFragment<GenerateContext>[];
/**
* when in a concatenated module, information about other concatenated modules
*/
concatenationScope?: ConcatenationScope;
/**
* the code generation results
*/
codeGenerationResults: CodeGenerationResults;
} |
3,328 | apply(
dependency: Dependency,
source: ReplaceSource,
templateContext: DependencyTemplateContext
): void | class ReplaceSource extends Source {
constructor(source: Source, name?: string);
replace(start: number, end: number, newValue: string, name?: string): void;
insert(pos: number, newValue: string, name?: string): void;
getName(): string;
original(): string;
getReplacements(): {
start: number;
end: number;
content: string;
insertIndex: number;
name: string;
}[];
} |
3,329 | get(dependency: DependencyConstructor): DependencyTemplate | interface DependencyConstructor {
new (...args: any[]): Dependency;
} |
3,330 | set(
dependency: DependencyConstructor,
dependencyTemplate: DependencyTemplate
): void | class DependencyTemplate {
constructor();
apply(
dependency: Dependency,
source: ReplaceSource,
templateContext: DependencyTemplateContext
): void;
} |
3,331 | set(
dependency: DependencyConstructor,
dependencyTemplate: DependencyTemplate
): void | interface DependencyConstructor {
new (...args: any[]): Dependency;
} |
3,332 | (arg0: Module) => boolean | interface Module {
hot: webpack.Hot;
} |
3,333 | (arg0: Module) => boolean | class Module extends DependenciesBlock {
constructor(type: string, context?: string, layer?: string);
type: string;
context: null | string;
layer: null | string;
needId: boolean;
debugId: number;
resolveOptions: ResolveOptionsWebpackOptions;
factoryMeta?: object;
useSourceMap: boolean;
useSimpleSourceMap: boolean;
buildMeta: BuildMeta;
buildInfo: Record<string, any>;
presentationalDependencies?: Dependency[];
codeGenerationDependencies?: Dependency[];
id: string | number;
get hash(): string;
get renderedHash(): string;
profile: null | ModuleProfile;
index: number;
index2: number;
depth: number;
issuer: null | Module;
get usedExports(): null | boolean | SortableSet<string>;
get optimizationBailout(): (
| string
| ((requestShortener: RequestShortener) => string)
)[];
get optional(): boolean;
addChunk(chunk?: any): boolean;
removeChunk(chunk?: any): void;
isInChunk(chunk?: any): boolean;
isEntryModule(): boolean;
getChunks(): Chunk[];
getNumberOfChunks(): number;
get chunksIterable(): Iterable<Chunk>;
isProvided(exportName: string): null | boolean;
get exportsArgument(): string;
get moduleArgument(): string;
getExportsType(
moduleGraph: ModuleGraph,
strict: boolean
): "namespace" | "default-only" | "default-with-named" | "dynamic";
addPresentationalDependency(presentationalDependency: Dependency): void;
addCodeGenerationDependency(codeGenerationDependency: Dependency): void;
addWarning(warning: WebpackError): void;
getWarnings(): undefined | Iterable<WebpackError>;
getNumberOfWarnings(): number;
addError(error: WebpackError): void;
getErrors(): undefined | Iterable<WebpackError>;
getNumberOfErrors(): number;
/**
* removes all warnings and errors
*/
clearWarningsAndErrors(): void;
isOptional(moduleGraph: ModuleGraph): boolean;
isAccessibleInChunk(
chunkGraph: ChunkGraph,
chunk: Chunk,
ignoreChunk?: Chunk
): boolean;
isAccessibleInChunkGroup(
chunkGraph: ChunkGraph,
chunkGroup: ChunkGroup,
ignoreChunk?: Chunk
): boolean;
hasReasonForChunk(
chunk: Chunk,
moduleGraph: ModuleGraph,
chunkGraph: ChunkGraph
): boolean;
hasReasons(moduleGraph: ModuleGraph, runtime: RuntimeSpec): boolean;
needBuild(
context: NeedBuildContext,
callback: (arg0?: null | WebpackError, arg1?: boolean) => void
): void;
needRebuild(
fileTimestamps: Map<string, null | number>,
contextTimestamps: Map<string, null | number>
): boolean;
invalidateBuild(): void;
identifier(): string;
readableIdentifier(requestShortener: RequestShortener): string;
build(
options: WebpackOptionsNormalized,
compilation: Compilation,
resolver: ResolverWithOptions,
fs: InputFileSystem,
callback: (arg0?: WebpackError) => void
): void;
getSourceTypes(): Set<string>;
source(
dependencyTemplates: DependencyTemplates,
runtimeTemplate: RuntimeTemplate,
type?: string
): Source;
size(type?: string): number;
libIdent(options: LibIdentOptions): null | string;
nameForCondition(): null | string;
getConcatenationBailoutReason(
context: ConcatenationBailoutReasonContext
): undefined | string;
getSideEffectsConnectionState(moduleGraph: ModuleGraph): ConnectionState;
codeGeneration(context: CodeGenerationContext): CodeGenerationResult;
chunkCondition(chunk: Chunk, compilation: Compilation): boolean;
hasChunkCondition(): boolean;
/**
* Assuming this module is in the cache. Update the (cached) module with
* the fresh module from the factory. Usually updates internal references
* and properties.
*/
updateCacheModule(module: Module): void;
/**
* Module should be unsafe cached. Get data that's needed for that.
* This data will be passed to restoreFromUnsafeCache later.
*/
getUnsafeCacheData(): object;
/**
* Assuming this module is in the cache. Remove internal references to allow freeing some memory.
*/
cleanupForCache(): void;
originalSource(): null | Source;
addCacheDependencies(
fileDependencies: LazySet<string>,
contextDependencies: LazySet<string>,
missingDependencies: LazySet<string>,
buildDependencies: LazySet<string>
): void;
get hasEqualsChunks(): any;
get isUsed(): any;
get errors(): any;
get warnings(): any;
used: any;
} |
3,334 | constructor(options: DllPluginOptions) | interface DllPluginOptions {
/**
* Context of requests in the manifest file (defaults to the webpack context).
*/
context?: string;
/**
* If true, only entry points will be exposed (default: true).
*/
entryOnly?: boolean;
/**
* If true, manifest json file (output) will be formatted.
*/
format?: boolean;
/**
* Name of the exposed dll function (external name, use value of 'output.library').
*/
name?: string;
/**
* Absolute path to the manifest json file (output).
*/
path: string;
/**
* Type of the dll bundle (external type, use value of 'output.libraryTarget').
*/
type?: string;
} |
3,335 | constructor(options: DllPluginOptions) | interface DllPluginOptions {
/**
* Context of requests in the manifest file (defaults to the webpack context).
*/
context?: string;
/**
* If true, only entry points will be exposed (default: true).
*/
entryOnly?: boolean;
/**
* If true, manifest json file (output) will be formatted.
*/
format?: boolean;
/**
* Name of the exposed dll function (external name, use value of 'output.library').
*/
name?: string;
/**
* Absolute path to the manifest json file (output).
*/
path: string;
/**
* Type of the dll bundle (external type, use value of 'output.libraryTarget').
*/
type?: string;
} |
3,336 | constructor(options: DllReferencePluginOptions) | type DllReferencePluginOptions =
| {
/**
* Context of requests in the manifest (or content property) as absolute path.
*/
context?: string;
/**
* Extensions used to resolve modules in the dll bundle (only used when using 'scope').
*/
extensions?: string[];
/**
* An object containing content and name or a string to the absolute path of the JSON manifest to be loaded upon compilation.
*/
manifest: string | DllReferencePluginOptionsManifest;
/**
* The name where the dll is exposed (external name, defaults to manifest.name).
*/
name?: string;
/**
* Prefix which is used for accessing the content of the dll.
*/
scope?: string;
/**
* How the dll is exposed (libraryTarget, defaults to manifest.type).
*/
sourceType?:
| "var"
| "assign"
| "this"
| "window"
| "global"
| "commonjs"
| "commonjs2"
| "commonjs-module"
| "amd"
| "amd-require"
| "umd"
| "umd2"
| "jsonp"
| "system";
/**
* The way how the export of the dll bundle is used.
*/
type?: "object" | "require";
}
| {
/**
* The mappings from request to module info.
*/
content: DllReferencePluginOptionsContent;
/**
* Context of requests in the manifest (or content property) as absolute path.
*/
context?: string;
/**
* Extensions used to resolve modules in the dll bundle (only used when using 'scope').
*/
extensions?: string[];
/**
* The name where the dll is exposed (external name).
*/
name: string;
/**
* Prefix which is used for accessing the content of the dll.
*/
scope?: string;
/**
* How the dll is exposed (libraryTarget).
*/
sourceType?:
| "var"
| "assign"
| "this"
| "window"
| "global"
| "commonjs"
| "commonjs2"
| "commonjs-module"
| "amd"
| "amd-require"
| "umd"
| "umd2"
| "jsonp"
| "system";
/**
* The way how the export of the dll bundle is used.
*/
type?: "object" | "require";
}; |
3,337 | constructor(options: DllReferencePluginOptions) | type DllReferencePluginOptions =
| {
/**
* Context of requests in the manifest (or content property) as absolute path.
*/
context?: string;
/**
* Extensions used to resolve modules in the dll bundle (only used when using 'scope').
*/
extensions?: string[];
/**
* An object containing content and name or a string to the absolute path of the JSON manifest to be loaded upon compilation.
*/
manifest: string | DllReferencePluginOptionsManifest;
/**
* The name where the dll is exposed (external name, defaults to manifest.name).
*/
name?: string;
/**
* Prefix which is used for accessing the content of the dll.
*/
scope?: string;
/**
* How the dll is exposed (libraryTarget, defaults to manifest.type).
*/
sourceType?: DllReferencePluginOptionsSourceType;
/**
* The way how the export of the dll bundle is used.
*/
type?: "require" | "object";
}
| {
/**
* The mappings from request to module info.
*/
content: DllReferencePluginOptionsContent;
/**
* Context of requests in the manifest (or content property) as absolute path.
*/
context?: string;
/**
* Extensions used to resolve modules in the dll bundle (only used when using 'scope').
*/
extensions?: string[];
/**
* The name where the dll is exposed (external name).
*/
name: string;
/**
* Prefix which is used for accessing the content of the dll.
*/
scope?: string;
/**
* How the dll is exposed (libraryTarget).
*/
sourceType?: DllReferencePluginOptionsSourceType;
/**
* The way how the export of the dll bundle is used.
*/
type?: "require" | "object";
}; |
3,338 | static setEnabled(compiler: Compiler, type: string): void | class Compiler {
constructor(context: string, options?: WebpackOptionsNormalized);
hooks: Readonly<{
initialize: SyncHook<[]>;
shouldEmit: SyncBailHook<[Compilation], boolean>;
done: AsyncSeriesHook<[Stats]>;
afterDone: SyncHook<[Stats]>;
additionalPass: AsyncSeriesHook<[]>;
beforeRun: AsyncSeriesHook<[Compiler]>;
run: AsyncSeriesHook<[Compiler]>;
emit: AsyncSeriesHook<[Compilation]>;
assetEmitted: AsyncSeriesHook<[string, AssetEmittedInfo]>;
afterEmit: AsyncSeriesHook<[Compilation]>;
thisCompilation: SyncHook<[Compilation, CompilationParams]>;
compilation: SyncHook<[Compilation, CompilationParams]>;
normalModuleFactory: SyncHook<[NormalModuleFactory]>;
contextModuleFactory: SyncHook<[ContextModuleFactory]>;
beforeCompile: AsyncSeriesHook<[CompilationParams]>;
compile: SyncHook<[CompilationParams]>;
make: AsyncParallelHook<[Compilation]>;
finishMake: AsyncParallelHook<[Compilation]>;
afterCompile: AsyncSeriesHook<[Compilation]>;
readRecords: AsyncSeriesHook<[]>;
emitRecords: AsyncSeriesHook<[]>;
watchRun: AsyncSeriesHook<[Compiler]>;
failed: SyncHook<[Error]>;
invalid: SyncHook<[null | string, number]>;
watchClose: SyncHook<[]>;
shutdown: AsyncSeriesHook<[]>;
infrastructureLog: SyncBailHook<[string, string, any[]], true>;
environment: SyncHook<[]>;
afterEnvironment: SyncHook<[]>;
afterPlugins: SyncHook<[Compiler]>;
afterResolvers: SyncHook<[Compiler]>;
entryOption: SyncBailHook<[string, EntryNormalized], boolean>;
}>;
webpack: typeof exports;
name?: string;
parentCompilation?: Compilation;
root: Compiler;
outputPath: string;
watching: Watching;
outputFileSystem: OutputFileSystem;
intermediateFileSystem: IntermediateFileSystem;
inputFileSystem: InputFileSystem;
watchFileSystem: WatchFileSystem;
recordsInputPath: null | string;
recordsOutputPath: null | string;
records: object;
managedPaths: Set<string | RegExp>;
immutablePaths: Set<string | RegExp>;
modifiedFiles: ReadonlySet<string>;
removedFiles: ReadonlySet<string>;
fileTimestamps: ReadonlyMap<string, null | FileSystemInfoEntry | "ignore">;
contextTimestamps: ReadonlyMap<string, null | FileSystemInfoEntry | "ignore">;
fsStartTime: number;
resolverFactory: ResolverFactory;
infrastructureLogger: any;
options: WebpackOptionsNormalized;
context: string;
requestShortener: RequestShortener;
cache: Cache;
moduleMemCaches?: Map<
Module,
{
buildInfo: object;
references: WeakMap<Dependency, Module>;
memCache: WeakTupleMap<any, any>;
}
>;
compilerPath: string;
running: boolean;
idle: boolean;
watchMode: boolean;
getCache(name: string): CacheFacade;
getInfrastructureLogger(name: string | (() => string)): WebpackLogger;
watch(watchOptions: WatchOptions, handler: CallbackFunction<Stats>): Watching;
run(callback: CallbackFunction<Stats>): void;
runAsChild(
callback: (
err?: null | Error,
entries?: Chunk[],
compilation?: Compilation
) => any
): void;
purgeInputFileSystem(): void;
emitAssets(compilation: Compilation, callback: CallbackFunction<void>): void;
emitRecords(callback: CallbackFunction<void>): void;
readRecords(callback: CallbackFunction<void>): void;
createChildCompiler(
compilation: Compilation,
compilerName: string,
compilerIndex: number,
outputOptions?: OutputNormalized,
plugins?: WebpackPluginInstance[]
): Compiler;
isChild(): boolean;
createCompilation(params?: any): Compilation;
newCompilation(params: CompilationParams): Compilation;
createNormalModuleFactory(): NormalModuleFactory;
createContextModuleFactory(): ContextModuleFactory;
newCompilationParams(): {
normalModuleFactory: NormalModuleFactory;
contextModuleFactory: ContextModuleFactory;
};
compile(callback: CallbackFunction<Compilation>): void;
close(callback: CallbackFunction<void>): void;
} |
3,339 | static checkEnabled(compiler: Compiler, type: string): void | class Compiler {
constructor(context: string, options?: WebpackOptionsNormalized);
hooks: Readonly<{
initialize: SyncHook<[]>;
shouldEmit: SyncBailHook<[Compilation], boolean>;
done: AsyncSeriesHook<[Stats]>;
afterDone: SyncHook<[Stats]>;
additionalPass: AsyncSeriesHook<[]>;
beforeRun: AsyncSeriesHook<[Compiler]>;
run: AsyncSeriesHook<[Compiler]>;
emit: AsyncSeriesHook<[Compilation]>;
assetEmitted: AsyncSeriesHook<[string, AssetEmittedInfo]>;
afterEmit: AsyncSeriesHook<[Compilation]>;
thisCompilation: SyncHook<[Compilation, CompilationParams]>;
compilation: SyncHook<[Compilation, CompilationParams]>;
normalModuleFactory: SyncHook<[NormalModuleFactory]>;
contextModuleFactory: SyncHook<[ContextModuleFactory]>;
beforeCompile: AsyncSeriesHook<[CompilationParams]>;
compile: SyncHook<[CompilationParams]>;
make: AsyncParallelHook<[Compilation]>;
finishMake: AsyncParallelHook<[Compilation]>;
afterCompile: AsyncSeriesHook<[Compilation]>;
readRecords: AsyncSeriesHook<[]>;
emitRecords: AsyncSeriesHook<[]>;
watchRun: AsyncSeriesHook<[Compiler]>;
failed: SyncHook<[Error]>;
invalid: SyncHook<[null | string, number]>;
watchClose: SyncHook<[]>;
shutdown: AsyncSeriesHook<[]>;
infrastructureLog: SyncBailHook<[string, string, any[]], true>;
environment: SyncHook<[]>;
afterEnvironment: SyncHook<[]>;
afterPlugins: SyncHook<[Compiler]>;
afterResolvers: SyncHook<[Compiler]>;
entryOption: SyncBailHook<[string, EntryNormalized], boolean>;
}>;
webpack: typeof exports;
name?: string;
parentCompilation?: Compilation;
root: Compiler;
outputPath: string;
watching: Watching;
outputFileSystem: OutputFileSystem;
intermediateFileSystem: IntermediateFileSystem;
inputFileSystem: InputFileSystem;
watchFileSystem: WatchFileSystem;
recordsInputPath: null | string;
recordsOutputPath: null | string;
records: object;
managedPaths: Set<string | RegExp>;
immutablePaths: Set<string | RegExp>;
modifiedFiles: ReadonlySet<string>;
removedFiles: ReadonlySet<string>;
fileTimestamps: ReadonlyMap<string, null | FileSystemInfoEntry | "ignore">;
contextTimestamps: ReadonlyMap<string, null | FileSystemInfoEntry | "ignore">;
fsStartTime: number;
resolverFactory: ResolverFactory;
infrastructureLogger: any;
options: WebpackOptionsNormalized;
context: string;
requestShortener: RequestShortener;
cache: Cache;
moduleMemCaches?: Map<
Module,
{
buildInfo: object;
references: WeakMap<Dependency, Module>;
memCache: WeakTupleMap<any, any>;
}
>;
compilerPath: string;
running: boolean;
idle: boolean;
watchMode: boolean;
getCache(name: string): CacheFacade;
getInfrastructureLogger(name: string | (() => string)): WebpackLogger;
watch(watchOptions: WatchOptions, handler: CallbackFunction<Stats>): Watching;
run(callback: CallbackFunction<Stats>): void;
runAsChild(
callback: (
err?: null | Error,
entries?: Chunk[],
compilation?: Compilation
) => any
): void;
purgeInputFileSystem(): void;
emitAssets(compilation: Compilation, callback: CallbackFunction<void>): void;
emitRecords(callback: CallbackFunction<void>): void;
readRecords(callback: CallbackFunction<void>): void;
createChildCompiler(
compilation: Compilation,
compilerName: string,
compilerIndex: number,
outputOptions?: OutputNormalized,
plugins?: WebpackPluginInstance[]
): Compiler;
isChild(): boolean;
createCompilation(params?: any): Compilation;
newCompilation(params: CompilationParams): Compilation;
createNormalModuleFactory(): NormalModuleFactory;
createContextModuleFactory(): ContextModuleFactory;
newCompilationParams(): {
normalModuleFactory: NormalModuleFactory;
contextModuleFactory: ContextModuleFactory;
};
compile(callback: CallbackFunction<Compilation>): void;
close(callback: CallbackFunction<void>): void;
} |
3,340 | static applyEntryOption(
compiler: Compiler,
context: string,
entry: EntryNormalized
): void | type EntryNormalized =
| (() => Promise<EntryStaticNormalized>)
| EntryStaticNormalized; |
3,341 | static applyEntryOption(
compiler: Compiler,
context: string,
entry: EntryNormalized
): void | type EntryNormalized = EntryDynamicNormalized | EntryStaticNormalized; |
3,342 | static applyEntryOption(
compiler: Compiler,
context: string,
entry: EntryNormalized
): void | class Compiler {
constructor(context: string, options?: WebpackOptionsNormalized);
hooks: Readonly<{
initialize: SyncHook<[]>;
shouldEmit: SyncBailHook<[Compilation], boolean>;
done: AsyncSeriesHook<[Stats]>;
afterDone: SyncHook<[Stats]>;
additionalPass: AsyncSeriesHook<[]>;
beforeRun: AsyncSeriesHook<[Compiler]>;
run: AsyncSeriesHook<[Compiler]>;
emit: AsyncSeriesHook<[Compilation]>;
assetEmitted: AsyncSeriesHook<[string, AssetEmittedInfo]>;
afterEmit: AsyncSeriesHook<[Compilation]>;
thisCompilation: SyncHook<[Compilation, CompilationParams]>;
compilation: SyncHook<[Compilation, CompilationParams]>;
normalModuleFactory: SyncHook<[NormalModuleFactory]>;
contextModuleFactory: SyncHook<[ContextModuleFactory]>;
beforeCompile: AsyncSeriesHook<[CompilationParams]>;
compile: SyncHook<[CompilationParams]>;
make: AsyncParallelHook<[Compilation]>;
finishMake: AsyncParallelHook<[Compilation]>;
afterCompile: AsyncSeriesHook<[Compilation]>;
readRecords: AsyncSeriesHook<[]>;
emitRecords: AsyncSeriesHook<[]>;
watchRun: AsyncSeriesHook<[Compiler]>;
failed: SyncHook<[Error]>;
invalid: SyncHook<[null | string, number]>;
watchClose: SyncHook<[]>;
shutdown: AsyncSeriesHook<[]>;
infrastructureLog: SyncBailHook<[string, string, any[]], true>;
environment: SyncHook<[]>;
afterEnvironment: SyncHook<[]>;
afterPlugins: SyncHook<[Compiler]>;
afterResolvers: SyncHook<[Compiler]>;
entryOption: SyncBailHook<[string, EntryNormalized], boolean>;
}>;
webpack: typeof exports;
name?: string;
parentCompilation?: Compilation;
root: Compiler;
outputPath: string;
watching: Watching;
outputFileSystem: OutputFileSystem;
intermediateFileSystem: IntermediateFileSystem;
inputFileSystem: InputFileSystem;
watchFileSystem: WatchFileSystem;
recordsInputPath: null | string;
recordsOutputPath: null | string;
records: object;
managedPaths: Set<string | RegExp>;
immutablePaths: Set<string | RegExp>;
modifiedFiles: ReadonlySet<string>;
removedFiles: ReadonlySet<string>;
fileTimestamps: ReadonlyMap<string, null | FileSystemInfoEntry | "ignore">;
contextTimestamps: ReadonlyMap<string, null | FileSystemInfoEntry | "ignore">;
fsStartTime: number;
resolverFactory: ResolverFactory;
infrastructureLogger: any;
options: WebpackOptionsNormalized;
context: string;
requestShortener: RequestShortener;
cache: Cache;
moduleMemCaches?: Map<
Module,
{
buildInfo: object;
references: WeakMap<Dependency, Module>;
memCache: WeakTupleMap<any, any>;
}
>;
compilerPath: string;
running: boolean;
idle: boolean;
watchMode: boolean;
getCache(name: string): CacheFacade;
getInfrastructureLogger(name: string | (() => string)): WebpackLogger;
watch(watchOptions: WatchOptions, handler: CallbackFunction<Stats>): Watching;
run(callback: CallbackFunction<Stats>): void;
runAsChild(
callback: (
err?: null | Error,
entries?: Chunk[],
compilation?: Compilation
) => any
): void;
purgeInputFileSystem(): void;
emitAssets(compilation: Compilation, callback: CallbackFunction<void>): void;
emitRecords(callback: CallbackFunction<void>): void;
readRecords(callback: CallbackFunction<void>): void;
createChildCompiler(
compilation: Compilation,
compilerName: string,
compilerIndex: number,
outputOptions?: OutputNormalized,
plugins?: WebpackPluginInstance[]
): Compiler;
isChild(): boolean;
createCompilation(params?: any): Compilation;
newCompilation(params: CompilationParams): Compilation;
createNormalModuleFactory(): NormalModuleFactory;
createContextModuleFactory(): ContextModuleFactory;
newCompilationParams(): {
normalModuleFactory: NormalModuleFactory;
contextModuleFactory: ContextModuleFactory;
};
compile(callback: CallbackFunction<Compilation>): void;
close(callback: CallbackFunction<void>): void;
} |
3,343 | static entryDescriptionToOptions(
compiler: Compiler,
name: string,
desc: EntryDescriptionNormalized
): EntryOptions | interface EntryDescriptionNormalized {
/**
* Enable/disable creating async chunks that are loaded on demand.
*/
asyncChunks?: boolean;
/**
* Base uri for this entry.
*/
baseUri?: string;
/**
* The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
*/
chunkLoading?: string | false;
/**
* The entrypoints that the current entrypoint depend on. They must be loaded when this entrypoint is loaded.
*/
dependOn?: string[];
/**
* Specifies the filename of output files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
*/
filename?: string | ((pathData: PathData, assetInfo?: AssetInfo) => string);
/**
* Module(s) that are loaded upon startup. The last one is exported.
*/
import?: string[];
/**
* Specifies the layer in which modules of this entrypoint are placed.
*/
layer?: null | string;
/**
* Options for library.
*/
library?: LibraryOptions;
/**
* The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
*/
publicPath?: string | ((pathData: PathData, assetInfo?: AssetInfo) => string);
/**
* The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
*/
runtime?: string | false;
/**
* The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
*/
wasmLoading?: string | false;
} |
3,344 | static entryDescriptionToOptions(
compiler: Compiler,
name: string,
desc: EntryDescriptionNormalized
): EntryOptions | interface EntryDescriptionNormalized {
/**
* Enable/disable creating async chunks that are loaded on demand.
*/
asyncChunks?: boolean;
/**
* Base uri for this entry.
*/
baseUri?: string;
/**
* The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
*/
chunkLoading?: ChunkLoading;
/**
* The entrypoints that the current entrypoint depend on. They must be loaded when this entrypoint is loaded.
*/
dependOn?: string[];
/**
* Specifies the filename of output files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
*/
filename?: Filename;
/**
* Module(s) that are loaded upon startup. The last one is exported.
*/
import?: string[];
/**
* Specifies the layer in which modules of this entrypoint are placed.
*/
layer?: Layer;
/**
* Options for library.
*/
library?: LibraryOptions;
/**
* The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
*/
publicPath?: PublicPath;
/**
* The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
*/
runtime?: EntryRuntime;
/**
* The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
*/
wasmLoading?: WasmLoading;
} |
3,345 | static entryDescriptionToOptions(
compiler: Compiler,
name: string,
desc: EntryDescriptionNormalized
): EntryOptions | class Compiler {
constructor(context: string, options?: WebpackOptionsNormalized);
hooks: Readonly<{
initialize: SyncHook<[]>;
shouldEmit: SyncBailHook<[Compilation], boolean>;
done: AsyncSeriesHook<[Stats]>;
afterDone: SyncHook<[Stats]>;
additionalPass: AsyncSeriesHook<[]>;
beforeRun: AsyncSeriesHook<[Compiler]>;
run: AsyncSeriesHook<[Compiler]>;
emit: AsyncSeriesHook<[Compilation]>;
assetEmitted: AsyncSeriesHook<[string, AssetEmittedInfo]>;
afterEmit: AsyncSeriesHook<[Compilation]>;
thisCompilation: SyncHook<[Compilation, CompilationParams]>;
compilation: SyncHook<[Compilation, CompilationParams]>;
normalModuleFactory: SyncHook<[NormalModuleFactory]>;
contextModuleFactory: SyncHook<[ContextModuleFactory]>;
beforeCompile: AsyncSeriesHook<[CompilationParams]>;
compile: SyncHook<[CompilationParams]>;
make: AsyncParallelHook<[Compilation]>;
finishMake: AsyncParallelHook<[Compilation]>;
afterCompile: AsyncSeriesHook<[Compilation]>;
readRecords: AsyncSeriesHook<[]>;
emitRecords: AsyncSeriesHook<[]>;
watchRun: AsyncSeriesHook<[Compiler]>;
failed: SyncHook<[Error]>;
invalid: SyncHook<[null | string, number]>;
watchClose: SyncHook<[]>;
shutdown: AsyncSeriesHook<[]>;
infrastructureLog: SyncBailHook<[string, string, any[]], true>;
environment: SyncHook<[]>;
afterEnvironment: SyncHook<[]>;
afterPlugins: SyncHook<[Compiler]>;
afterResolvers: SyncHook<[Compiler]>;
entryOption: SyncBailHook<[string, EntryNormalized], boolean>;
}>;
webpack: typeof exports;
name?: string;
parentCompilation?: Compilation;
root: Compiler;
outputPath: string;
watching: Watching;
outputFileSystem: OutputFileSystem;
intermediateFileSystem: IntermediateFileSystem;
inputFileSystem: InputFileSystem;
watchFileSystem: WatchFileSystem;
recordsInputPath: null | string;
recordsOutputPath: null | string;
records: object;
managedPaths: Set<string | RegExp>;
immutablePaths: Set<string | RegExp>;
modifiedFiles: ReadonlySet<string>;
removedFiles: ReadonlySet<string>;
fileTimestamps: ReadonlyMap<string, null | FileSystemInfoEntry | "ignore">;
contextTimestamps: ReadonlyMap<string, null | FileSystemInfoEntry | "ignore">;
fsStartTime: number;
resolverFactory: ResolverFactory;
infrastructureLogger: any;
options: WebpackOptionsNormalized;
context: string;
requestShortener: RequestShortener;
cache: Cache;
moduleMemCaches?: Map<
Module,
{
buildInfo: object;
references: WeakMap<Dependency, Module>;
memCache: WeakTupleMap<any, any>;
}
>;
compilerPath: string;
running: boolean;
idle: boolean;
watchMode: boolean;
getCache(name: string): CacheFacade;
getInfrastructureLogger(name: string | (() => string)): WebpackLogger;
watch(watchOptions: WatchOptions, handler: CallbackFunction<Stats>): Watching;
run(callback: CallbackFunction<Stats>): void;
runAsChild(
callback: (
err?: null | Error,
entries?: Chunk[],
compilation?: Compilation
) => any
): void;
purgeInputFileSystem(): void;
emitAssets(compilation: Compilation, callback: CallbackFunction<void>): void;
emitRecords(callback: CallbackFunction<void>): void;
readRecords(callback: CallbackFunction<void>): void;
createChildCompiler(
compilation: Compilation,
compilerName: string,
compilerIndex: number,
outputOptions?: OutputNormalized,
plugins?: WebpackPluginInstance[]
): Compiler;
isChild(): boolean;
createCompilation(params?: any): Compilation;
newCompilation(params: CompilationParams): Compilation;
createNormalModuleFactory(): NormalModuleFactory;
createContextModuleFactory(): ContextModuleFactory;
newCompilationParams(): {
normalModuleFactory: NormalModuleFactory;
contextModuleFactory: ContextModuleFactory;
};
compile(callback: CallbackFunction<Compilation>): void;
close(callback: CallbackFunction<void>): void;
} |
3,346 | setRuntimeChunk(chunk: Chunk): void | class Chunk {
constructor(name?: string, backCompat?: boolean);
id: null | string | number;
ids: null | (string | number)[];
debugId: number;
name: string;
idNameHints: SortableSet<string>;
preventIntegration: boolean;
filenameTemplate:
| null
| string
| ((arg0: PathData, arg1?: AssetInfo) => string);
cssFilenameTemplate:
| null
| string
| ((arg0: PathData, arg1?: AssetInfo) => string);
runtime: RuntimeSpec;
files: Set<string>;
auxiliaryFiles: Set<string>;
rendered: boolean;
hash?: string;
contentHash: Record<string, string>;
renderedHash?: string;
chunkReason?: string;
extraAsync: boolean;
get entryModule(): Module;
hasEntryModule(): boolean;
addModule(module: Module): boolean;
removeModule(module: Module): void;
getNumberOfModules(): number;
get modulesIterable(): Iterable<Module>;
compareTo(otherChunk: Chunk): 0 | 1 | -1;
containsModule(module: Module): boolean;
getModules(): Module[];
remove(): void;
moveModule(module: Module, otherChunk: Chunk): void;
integrate(otherChunk: Chunk): boolean;
canBeIntegrated(otherChunk: Chunk): boolean;
isEmpty(): boolean;
modulesSize(): number;
size(options?: ChunkSizeOptions): number;
integratedSize(otherChunk: Chunk, options: ChunkSizeOptions): number;
getChunkModuleMaps(filterFn: (m: Module) => boolean): ChunkModuleMaps;
hasModuleInGraph(
filterFn: (m: Module) => boolean,
filterChunkFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): boolean;
getChunkMaps(realHash: boolean): ChunkMaps;
hasRuntime(): boolean;
canBeInitial(): boolean;
isOnlyInitial(): boolean;
getEntryOptions(): undefined | EntryOptions;
addGroup(chunkGroup: ChunkGroup): void;
removeGroup(chunkGroup: ChunkGroup): void;
isInGroup(chunkGroup: ChunkGroup): boolean;
getNumberOfGroups(): number;
get groupsIterable(): Iterable<ChunkGroup>;
disconnectFromGroups(): void;
split(newChunk: Chunk): void;
updateHash(hash: Hash, chunkGraph: ChunkGraph): void;
getAllAsyncChunks(): Set<Chunk>;
getAllInitialChunks(): Set<Chunk>;
getAllReferencedChunks(): Set<Chunk>;
getAllReferencedAsyncEntrypoints(): Set<Entrypoint>;
hasAsyncChunks(): boolean;
getChildIdsByOrders(
chunkGraph: ChunkGraph,
filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): Record<string, (string | number)[]>;
getChildrenOfTypeInOrder(
chunkGraph: ChunkGraph,
type: string
): { onChunks: Chunk[]; chunks: Set<Chunk> }[];
getChildIdsByOrdersMap(
chunkGraph: ChunkGraph,
includeDirectChildren?: boolean,
filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): Record<string | number, Record<string, (string | number)[]>>;
} |
3,347 | setEntrypointChunk(chunk: Chunk): void | class Chunk {
constructor(name?: string, backCompat?: boolean);
id: null | string | number;
ids: null | (string | number)[];
debugId: number;
name: string;
idNameHints: SortableSet<string>;
preventIntegration: boolean;
filenameTemplate:
| null
| string
| ((arg0: PathData, arg1?: AssetInfo) => string);
cssFilenameTemplate:
| null
| string
| ((arg0: PathData, arg1?: AssetInfo) => string);
runtime: RuntimeSpec;
files: Set<string>;
auxiliaryFiles: Set<string>;
rendered: boolean;
hash?: string;
contentHash: Record<string, string>;
renderedHash?: string;
chunkReason?: string;
extraAsync: boolean;
get entryModule(): Module;
hasEntryModule(): boolean;
addModule(module: Module): boolean;
removeModule(module: Module): void;
getNumberOfModules(): number;
get modulesIterable(): Iterable<Module>;
compareTo(otherChunk: Chunk): 0 | 1 | -1;
containsModule(module: Module): boolean;
getModules(): Module[];
remove(): void;
moveModule(module: Module, otherChunk: Chunk): void;
integrate(otherChunk: Chunk): boolean;
canBeIntegrated(otherChunk: Chunk): boolean;
isEmpty(): boolean;
modulesSize(): number;
size(options?: ChunkSizeOptions): number;
integratedSize(otherChunk: Chunk, options: ChunkSizeOptions): number;
getChunkModuleMaps(filterFn: (m: Module) => boolean): ChunkModuleMaps;
hasModuleInGraph(
filterFn: (m: Module) => boolean,
filterChunkFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): boolean;
getChunkMaps(realHash: boolean): ChunkMaps;
hasRuntime(): boolean;
canBeInitial(): boolean;
isOnlyInitial(): boolean;
getEntryOptions(): undefined | EntryOptions;
addGroup(chunkGroup: ChunkGroup): void;
removeGroup(chunkGroup: ChunkGroup): void;
isInGroup(chunkGroup: ChunkGroup): boolean;
getNumberOfGroups(): number;
get groupsIterable(): Iterable<ChunkGroup>;
disconnectFromGroups(): void;
split(newChunk: Chunk): void;
updateHash(hash: Hash, chunkGraph: ChunkGraph): void;
getAllAsyncChunks(): Set<Chunk>;
getAllInitialChunks(): Set<Chunk>;
getAllReferencedChunks(): Set<Chunk>;
getAllReferencedAsyncEntrypoints(): Set<Entrypoint>;
hasAsyncChunks(): boolean;
getChildIdsByOrders(
chunkGraph: ChunkGraph,
filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): Record<string, (string | number)[]>;
getChildrenOfTypeInOrder(
chunkGraph: ChunkGraph,
type: string
): { onChunks: Chunk[]; chunks: Set<Chunk> }[];
getChildIdsByOrdersMap(
chunkGraph: ChunkGraph,
includeDirectChildren?: boolean,
filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): Record<string | number, Record<string, (string | number)[]>>;
} |
3,348 | setUsedInUnknownWay(runtime: RuntimeSpec): boolean | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,349 | setUsedWithoutInfo(runtime: RuntimeSpec): boolean | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,350 | (arg0: UsageStateType) => boolean | type UsageStateType = 0 | 1 | 2 | 3 | 4; |
3,351 | setUsed(newValue: UsageStateType, runtime: RuntimeSpec): boolean | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,352 | setUsed(newValue: UsageStateType, runtime: RuntimeSpec): boolean | type UsageStateType = 0 | 1 | 2 | 3 | 4; |
3,353 | getUsed(runtime: RuntimeSpec): UsageStateType | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,354 | getTerminalBinding(
moduleGraph: ModuleGraph,
resolveTargetFilter?: (arg0: {
module: Module;
export?: string[];
}) => boolean
): undefined | ExportsInfo | ExportInfo | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,355 | getTerminalBinding(
moduleGraph: ModuleGraph,
resolveTargetFilter?: (arg0: {
module: Module;
export?: string[];
}) => boolean
): undefined | ExportsInfo | ExportInfo | interface Module {
hot: webpack.Hot;
} |
3,356 | getTerminalBinding(
moduleGraph: ModuleGraph,
resolveTargetFilter?: (arg0: {
module: Module;
export?: string[];
}) => boolean
): undefined | ExportsInfo | ExportInfo | class Module extends DependenciesBlock {
constructor(type: string, context?: string, layer?: string);
type: string;
context: null | string;
layer: null | string;
needId: boolean;
debugId: number;
resolveOptions: ResolveOptionsWebpackOptions;
factoryMeta?: object;
useSourceMap: boolean;
useSimpleSourceMap: boolean;
buildMeta: BuildMeta;
buildInfo: Record<string, any>;
presentationalDependencies?: Dependency[];
codeGenerationDependencies?: Dependency[];
id: string | number;
get hash(): string;
get renderedHash(): string;
profile: null | ModuleProfile;
index: number;
index2: number;
depth: number;
issuer: null | Module;
get usedExports(): null | boolean | SortableSet<string>;
get optimizationBailout(): (
| string
| ((requestShortener: RequestShortener) => string)
)[];
get optional(): boolean;
addChunk(chunk?: any): boolean;
removeChunk(chunk?: any): void;
isInChunk(chunk?: any): boolean;
isEntryModule(): boolean;
getChunks(): Chunk[];
getNumberOfChunks(): number;
get chunksIterable(): Iterable<Chunk>;
isProvided(exportName: string): null | boolean;
get exportsArgument(): string;
get moduleArgument(): string;
getExportsType(
moduleGraph: ModuleGraph,
strict: boolean
): "namespace" | "default-only" | "default-with-named" | "dynamic";
addPresentationalDependency(presentationalDependency: Dependency): void;
addCodeGenerationDependency(codeGenerationDependency: Dependency): void;
addWarning(warning: WebpackError): void;
getWarnings(): undefined | Iterable<WebpackError>;
getNumberOfWarnings(): number;
addError(error: WebpackError): void;
getErrors(): undefined | Iterable<WebpackError>;
getNumberOfErrors(): number;
/**
* removes all warnings and errors
*/
clearWarningsAndErrors(): void;
isOptional(moduleGraph: ModuleGraph): boolean;
isAccessibleInChunk(
chunkGraph: ChunkGraph,
chunk: Chunk,
ignoreChunk?: Chunk
): boolean;
isAccessibleInChunkGroup(
chunkGraph: ChunkGraph,
chunkGroup: ChunkGroup,
ignoreChunk?: Chunk
): boolean;
hasReasonForChunk(
chunk: Chunk,
moduleGraph: ModuleGraph,
chunkGraph: ChunkGraph
): boolean;
hasReasons(moduleGraph: ModuleGraph, runtime: RuntimeSpec): boolean;
needBuild(
context: NeedBuildContext,
callback: (arg0?: null | WebpackError, arg1?: boolean) => void
): void;
needRebuild(
fileTimestamps: Map<string, null | number>,
contextTimestamps: Map<string, null | number>
): boolean;
invalidateBuild(): void;
identifier(): string;
readableIdentifier(requestShortener: RequestShortener): string;
build(
options: WebpackOptionsNormalized,
compilation: Compilation,
resolver: ResolverWithOptions,
fs: InputFileSystem,
callback: (arg0?: WebpackError) => void
): void;
getSourceTypes(): Set<string>;
source(
dependencyTemplates: DependencyTemplates,
runtimeTemplate: RuntimeTemplate,
type?: string
): Source;
size(type?: string): number;
libIdent(options: LibIdentOptions): null | string;
nameForCondition(): null | string;
getConcatenationBailoutReason(
context: ConcatenationBailoutReasonContext
): undefined | string;
getSideEffectsConnectionState(moduleGraph: ModuleGraph): ConnectionState;
codeGeneration(context: CodeGenerationContext): CodeGenerationResult;
chunkCondition(chunk: Chunk, compilation: Compilation): boolean;
hasChunkCondition(): boolean;
/**
* Assuming this module is in the cache. Update the (cached) module with
* the fresh module from the factory. Usually updates internal references
* and properties.
*/
updateCacheModule(module: Module): void;
/**
* Module should be unsafe cached. Get data that's needed for that.
* This data will be passed to restoreFromUnsafeCache later.
*/
getUnsafeCacheData(): object;
/**
* Assuming this module is in the cache. Remove internal references to allow freeing some memory.
*/
cleanupForCache(): void;
originalSource(): null | Source;
addCacheDependencies(
fileDependencies: LazySet<string>,
contextDependencies: LazySet<string>,
missingDependencies: LazySet<string>,
buildDependencies: LazySet<string>
): void;
get hasEqualsChunks(): any;
get isUsed(): any;
get errors(): any;
get warnings(): any;
used: any;
} |
3,357 | findTarget(
moduleGraph: ModuleGraph,
validTargetModuleFilter: (arg0: Module) => boolean
): undefined | false | { module: Module; export?: string[] } | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,358 | findTarget(
moduleGraph: ModuleGraph,
validTargetModuleFilter: (arg0: Module) => boolean
): undefined | false | { module: Module; export?: string[] } | interface Module {
hot: webpack.Hot;
} |
3,359 | findTarget(
moduleGraph: ModuleGraph,
validTargetModuleFilter: (arg0: Module) => boolean
): undefined | false | { module: Module; export?: string[] } | class Module extends DependenciesBlock {
constructor(type: string, context?: string, layer?: string);
type: string;
context: null | string;
layer: null | string;
needId: boolean;
debugId: number;
resolveOptions: ResolveOptionsWebpackOptions;
factoryMeta?: object;
useSourceMap: boolean;
useSimpleSourceMap: boolean;
buildMeta: BuildMeta;
buildInfo: Record<string, any>;
presentationalDependencies?: Dependency[];
codeGenerationDependencies?: Dependency[];
id: string | number;
get hash(): string;
get renderedHash(): string;
profile: null | ModuleProfile;
index: number;
index2: number;
depth: number;
issuer: null | Module;
get usedExports(): null | boolean | SortableSet<string>;
get optimizationBailout(): (
| string
| ((requestShortener: RequestShortener) => string)
)[];
get optional(): boolean;
addChunk(chunk?: any): boolean;
removeChunk(chunk?: any): void;
isInChunk(chunk?: any): boolean;
isEntryModule(): boolean;
getChunks(): Chunk[];
getNumberOfChunks(): number;
get chunksIterable(): Iterable<Chunk>;
isProvided(exportName: string): null | boolean;
get exportsArgument(): string;
get moduleArgument(): string;
getExportsType(
moduleGraph: ModuleGraph,
strict: boolean
): "namespace" | "default-only" | "default-with-named" | "dynamic";
addPresentationalDependency(presentationalDependency: Dependency): void;
addCodeGenerationDependency(codeGenerationDependency: Dependency): void;
addWarning(warning: WebpackError): void;
getWarnings(): undefined | Iterable<WebpackError>;
getNumberOfWarnings(): number;
addError(error: WebpackError): void;
getErrors(): undefined | Iterable<WebpackError>;
getNumberOfErrors(): number;
/**
* removes all warnings and errors
*/
clearWarningsAndErrors(): void;
isOptional(moduleGraph: ModuleGraph): boolean;
isAccessibleInChunk(
chunkGraph: ChunkGraph,
chunk: Chunk,
ignoreChunk?: Chunk
): boolean;
isAccessibleInChunkGroup(
chunkGraph: ChunkGraph,
chunkGroup: ChunkGroup,
ignoreChunk?: Chunk
): boolean;
hasReasonForChunk(
chunk: Chunk,
moduleGraph: ModuleGraph,
chunkGraph: ChunkGraph
): boolean;
hasReasons(moduleGraph: ModuleGraph, runtime: RuntimeSpec): boolean;
needBuild(
context: NeedBuildContext,
callback: (arg0?: null | WebpackError, arg1?: boolean) => void
): void;
needRebuild(
fileTimestamps: Map<string, null | number>,
contextTimestamps: Map<string, null | number>
): boolean;
invalidateBuild(): void;
identifier(): string;
readableIdentifier(requestShortener: RequestShortener): string;
build(
options: WebpackOptionsNormalized,
compilation: Compilation,
resolver: ResolverWithOptions,
fs: InputFileSystem,
callback: (arg0?: WebpackError) => void
): void;
getSourceTypes(): Set<string>;
source(
dependencyTemplates: DependencyTemplates,
runtimeTemplate: RuntimeTemplate,
type?: string
): Source;
size(type?: string): number;
libIdent(options: LibIdentOptions): null | string;
nameForCondition(): null | string;
getConcatenationBailoutReason(
context: ConcatenationBailoutReasonContext
): undefined | string;
getSideEffectsConnectionState(moduleGraph: ModuleGraph): ConnectionState;
codeGeneration(context: CodeGenerationContext): CodeGenerationResult;
chunkCondition(chunk: Chunk, compilation: Compilation): boolean;
hasChunkCondition(): boolean;
/**
* Assuming this module is in the cache. Update the (cached) module with
* the fresh module from the factory. Usually updates internal references
* and properties.
*/
updateCacheModule(module: Module): void;
/**
* Module should be unsafe cached. Get data that's needed for that.
* This data will be passed to restoreFromUnsafeCache later.
*/
getUnsafeCacheData(): object;
/**
* Assuming this module is in the cache. Remove internal references to allow freeing some memory.
*/
cleanupForCache(): void;
originalSource(): null | Source;
addCacheDependencies(
fileDependencies: LazySet<string>,
contextDependencies: LazySet<string>,
missingDependencies: LazySet<string>,
buildDependencies: LazySet<string>
): void;
get hasEqualsChunks(): any;
get isUsed(): any;
get errors(): any;
get warnings(): any;
used: any;
} |
3,360 | getTarget(
moduleGraph: ModuleGraph,
resolveTargetFilter?: (arg0: {
module: Module;
export?: string[];
}) => boolean
): undefined | { module: Module; export?: string[] } | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,361 | getTarget(
moduleGraph: ModuleGraph,
resolveTargetFilter?: (arg0: {
module: Module;
export?: string[];
}) => boolean
): undefined | { module: Module; export?: string[] } | interface Module {
hot: webpack.Hot;
} |
3,362 | getTarget(
moduleGraph: ModuleGraph,
resolveTargetFilter?: (arg0: {
module: Module;
export?: string[];
}) => boolean
): undefined | { module: Module; export?: string[] } | class Module extends DependenciesBlock {
constructor(type: string, context?: string, layer?: string);
type: string;
context: null | string;
layer: null | string;
needId: boolean;
debugId: number;
resolveOptions: ResolveOptionsWebpackOptions;
factoryMeta?: object;
useSourceMap: boolean;
useSimpleSourceMap: boolean;
buildMeta: BuildMeta;
buildInfo: Record<string, any>;
presentationalDependencies?: Dependency[];
codeGenerationDependencies?: Dependency[];
id: string | number;
get hash(): string;
get renderedHash(): string;
profile: null | ModuleProfile;
index: number;
index2: number;
depth: number;
issuer: null | Module;
get usedExports(): null | boolean | SortableSet<string>;
get optimizationBailout(): (
| string
| ((requestShortener: RequestShortener) => string)
)[];
get optional(): boolean;
addChunk(chunk?: any): boolean;
removeChunk(chunk?: any): void;
isInChunk(chunk?: any): boolean;
isEntryModule(): boolean;
getChunks(): Chunk[];
getNumberOfChunks(): number;
get chunksIterable(): Iterable<Chunk>;
isProvided(exportName: string): null | boolean;
get exportsArgument(): string;
get moduleArgument(): string;
getExportsType(
moduleGraph: ModuleGraph,
strict: boolean
): "namespace" | "default-only" | "default-with-named" | "dynamic";
addPresentationalDependency(presentationalDependency: Dependency): void;
addCodeGenerationDependency(codeGenerationDependency: Dependency): void;
addWarning(warning: WebpackError): void;
getWarnings(): undefined | Iterable<WebpackError>;
getNumberOfWarnings(): number;
addError(error: WebpackError): void;
getErrors(): undefined | Iterable<WebpackError>;
getNumberOfErrors(): number;
/**
* removes all warnings and errors
*/
clearWarningsAndErrors(): void;
isOptional(moduleGraph: ModuleGraph): boolean;
isAccessibleInChunk(
chunkGraph: ChunkGraph,
chunk: Chunk,
ignoreChunk?: Chunk
): boolean;
isAccessibleInChunkGroup(
chunkGraph: ChunkGraph,
chunkGroup: ChunkGroup,
ignoreChunk?: Chunk
): boolean;
hasReasonForChunk(
chunk: Chunk,
moduleGraph: ModuleGraph,
chunkGraph: ChunkGraph
): boolean;
hasReasons(moduleGraph: ModuleGraph, runtime: RuntimeSpec): boolean;
needBuild(
context: NeedBuildContext,
callback: (arg0?: null | WebpackError, arg1?: boolean) => void
): void;
needRebuild(
fileTimestamps: Map<string, null | number>,
contextTimestamps: Map<string, null | number>
): boolean;
invalidateBuild(): void;
identifier(): string;
readableIdentifier(requestShortener: RequestShortener): string;
build(
options: WebpackOptionsNormalized,
compilation: Compilation,
resolver: ResolverWithOptions,
fs: InputFileSystem,
callback: (arg0?: WebpackError) => void
): void;
getSourceTypes(): Set<string>;
source(
dependencyTemplates: DependencyTemplates,
runtimeTemplate: RuntimeTemplate,
type?: string
): Source;
size(type?: string): number;
libIdent(options: LibIdentOptions): null | string;
nameForCondition(): null | string;
getConcatenationBailoutReason(
context: ConcatenationBailoutReasonContext
): undefined | string;
getSideEffectsConnectionState(moduleGraph: ModuleGraph): ConnectionState;
codeGeneration(context: CodeGenerationContext): CodeGenerationResult;
chunkCondition(chunk: Chunk, compilation: Compilation): boolean;
hasChunkCondition(): boolean;
/**
* Assuming this module is in the cache. Update the (cached) module with
* the fresh module from the factory. Usually updates internal references
* and properties.
*/
updateCacheModule(module: Module): void;
/**
* Module should be unsafe cached. Get data that's needed for that.
* This data will be passed to restoreFromUnsafeCache later.
*/
getUnsafeCacheData(): object;
/**
* Assuming this module is in the cache. Remove internal references to allow freeing some memory.
*/
cleanupForCache(): void;
originalSource(): null | Source;
addCacheDependencies(
fileDependencies: LazySet<string>,
contextDependencies: LazySet<string>,
missingDependencies: LazySet<string>,
buildDependencies: LazySet<string>
): void;
get hasEqualsChunks(): any;
get isUsed(): any;
get errors(): any;
get warnings(): any;
used: any;
} |
3,363 | moveTarget(
moduleGraph: ModuleGraph,
resolveTargetFilter: (arg0: {
module: Module;
export?: string[];
}) => boolean,
updateOriginalConnection?: (arg0: {
module: Module;
export?: string[];
}) => ModuleGraphConnection
): undefined | { module: Module; export?: string[] } | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,364 | moveTarget(
moduleGraph: ModuleGraph,
resolveTargetFilter: (arg0: {
module: Module;
export?: string[];
}) => boolean,
updateOriginalConnection?: (arg0: {
module: Module;
export?: string[];
}) => ModuleGraphConnection
): undefined | { module: Module; export?: string[] } | interface Module {
hot: webpack.Hot;
} |
3,365 | moveTarget(
moduleGraph: ModuleGraph,
resolveTargetFilter: (arg0: {
module: Module;
export?: string[];
}) => boolean,
updateOriginalConnection?: (arg0: {
module: Module;
export?: string[];
}) => ModuleGraphConnection
): undefined | { module: Module; export?: string[] } | class Module extends DependenciesBlock {
constructor(type: string, context?: string, layer?: string);
type: string;
context: null | string;
layer: null | string;
needId: boolean;
debugId: number;
resolveOptions: ResolveOptionsWebpackOptions;
factoryMeta?: object;
useSourceMap: boolean;
useSimpleSourceMap: boolean;
buildMeta: BuildMeta;
buildInfo: Record<string, any>;
presentationalDependencies?: Dependency[];
codeGenerationDependencies?: Dependency[];
id: string | number;
get hash(): string;
get renderedHash(): string;
profile: null | ModuleProfile;
index: number;
index2: number;
depth: number;
issuer: null | Module;
get usedExports(): null | boolean | SortableSet<string>;
get optimizationBailout(): (
| string
| ((requestShortener: RequestShortener) => string)
)[];
get optional(): boolean;
addChunk(chunk?: any): boolean;
removeChunk(chunk?: any): void;
isInChunk(chunk?: any): boolean;
isEntryModule(): boolean;
getChunks(): Chunk[];
getNumberOfChunks(): number;
get chunksIterable(): Iterable<Chunk>;
isProvided(exportName: string): null | boolean;
get exportsArgument(): string;
get moduleArgument(): string;
getExportsType(
moduleGraph: ModuleGraph,
strict: boolean
): "namespace" | "default-only" | "default-with-named" | "dynamic";
addPresentationalDependency(presentationalDependency: Dependency): void;
addCodeGenerationDependency(codeGenerationDependency: Dependency): void;
addWarning(warning: WebpackError): void;
getWarnings(): undefined | Iterable<WebpackError>;
getNumberOfWarnings(): number;
addError(error: WebpackError): void;
getErrors(): undefined | Iterable<WebpackError>;
getNumberOfErrors(): number;
/**
* removes all warnings and errors
*/
clearWarningsAndErrors(): void;
isOptional(moduleGraph: ModuleGraph): boolean;
isAccessibleInChunk(
chunkGraph: ChunkGraph,
chunk: Chunk,
ignoreChunk?: Chunk
): boolean;
isAccessibleInChunkGroup(
chunkGraph: ChunkGraph,
chunkGroup: ChunkGroup,
ignoreChunk?: Chunk
): boolean;
hasReasonForChunk(
chunk: Chunk,
moduleGraph: ModuleGraph,
chunkGraph: ChunkGraph
): boolean;
hasReasons(moduleGraph: ModuleGraph, runtime: RuntimeSpec): boolean;
needBuild(
context: NeedBuildContext,
callback: (arg0?: null | WebpackError, arg1?: boolean) => void
): void;
needRebuild(
fileTimestamps: Map<string, null | number>,
contextTimestamps: Map<string, null | number>
): boolean;
invalidateBuild(): void;
identifier(): string;
readableIdentifier(requestShortener: RequestShortener): string;
build(
options: WebpackOptionsNormalized,
compilation: Compilation,
resolver: ResolverWithOptions,
fs: InputFileSystem,
callback: (arg0?: WebpackError) => void
): void;
getSourceTypes(): Set<string>;
source(
dependencyTemplates: DependencyTemplates,
runtimeTemplate: RuntimeTemplate,
type?: string
): Source;
size(type?: string): number;
libIdent(options: LibIdentOptions): null | string;
nameForCondition(): null | string;
getConcatenationBailoutReason(
context: ConcatenationBailoutReasonContext
): undefined | string;
getSideEffectsConnectionState(moduleGraph: ModuleGraph): ConnectionState;
codeGeneration(context: CodeGenerationContext): CodeGenerationResult;
chunkCondition(chunk: Chunk, compilation: Compilation): boolean;
hasChunkCondition(): boolean;
/**
* Assuming this module is in the cache. Update the (cached) module with
* the fresh module from the factory. Usually updates internal references
* and properties.
*/
updateCacheModule(module: Module): void;
/**
* Module should be unsafe cached. Get data that's needed for that.
* This data will be passed to restoreFromUnsafeCache later.
*/
getUnsafeCacheData(): object;
/**
* Assuming this module is in the cache. Remove internal references to allow freeing some memory.
*/
cleanupForCache(): void;
originalSource(): null | Source;
addCacheDependencies(
fileDependencies: LazySet<string>,
contextDependencies: LazySet<string>,
missingDependencies: LazySet<string>,
buildDependencies: LazySet<string>
): void;
get hasEqualsChunks(): any;
get isUsed(): any;
get errors(): any;
get warnings(): any;
used: any;
} |
3,366 | setAllKnownExportsUsed(runtime: RuntimeSpec): boolean | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,367 | setUsedForSideEffectsOnly(runtime: RuntimeSpec): boolean | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,368 | isUsed(runtime: RuntimeSpec): boolean | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,369 | isModuleUsed(runtime: RuntimeSpec): boolean | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,370 | getUsedExports(runtime: RuntimeSpec): null | boolean | SortableSet<string> | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,371 | getRelevantExports(runtime: RuntimeSpec): ExportInfo[] | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,372 | getUsageKey(runtime: RuntimeSpec): string | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,373 | isEquallyUsed(runtimeA: RuntimeSpec, runtimeB: RuntimeSpec): boolean | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,374 | updateHash(hash: Hash, runtime: RuntimeSpec): void | class Hash {
constructor();
/**
* Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
*/
update(data: string | Buffer, inputEncoding?: string): Hash;
/**
* Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
*/
digest(encoding?: string): string | Buffer;
} |
3,375 | updateHash(hash: Hash, runtime: RuntimeSpec): void | type RuntimeSpec = undefined | string | SortableSet<string>; |
3,376 | (
data: ExternalItemFunctionData,
callback: (
err?: Error,
result?: string | boolean | string[] | { [index: string]: any }
) => void
) => void | interface ExternalItemFunctionData {
/**
* The directory in which the request is placed.
*/
context?: string;
/**
* Contextual information.
*/
contextInfo?: ModuleFactoryCreateDataContextInfo;
/**
* The category of the referencing dependencies.
*/
dependencyType?: string;
/**
* Get a resolve function with the current resolver options.
*/
getResolve?: (
options?: ResolveOptionsWebpackOptions
) =>
| ((
context: string,
request: string,
callback: (err?: Error, result?: string) => void
) => void)
| ((context: string, request: string) => Promise<string>);
/**
* The request as written by the user in the require/import expression/statement.
*/
request?: string;
} |
3,377 | (
data: ExternalItemFunctionData,
callback: (
err?: Error,
result?: string | boolean | string[] | { [index: string]: any }
) => void
) => void | interface ExternalItemFunctionData {
/**
* The directory in which the request is placed.
*/
context?: string;
/**
* Contextual information.
*/
contextInfo?: import |
3,378 | (
options?: ResolveOptionsWebpackOptions
) =>
| ((
context: string,
request: string,
callback: (err?: Error, result?: string) => void
) => void)
| ((context: string, request: string) => Promise<string>) | interface ResolveOptionsWebpackOptions {
/**
* Redirect module requests.
*/
alias?:
| {
/**
* New request.
*/
alias: string | false | string[];
/**
* Request to be redirected.
*/
name: string;
/**
* Redirect only exact matching request.
*/
onlyModule?: boolean;
}[]
| { [index: string]: string | false | string[] };
/**
* Fields in the description file (usually package.json) which are used to redirect requests inside the module.
*/
aliasFields?: (string | string[])[];
/**
* Extra resolve options per dependency category. Typical categories are "commonjs", "amd", "esm".
*/
byDependency?: { [index: string]: ResolveOptionsWebpackOptions };
/**
* Enable caching of successfully resolved requests (cache entries are revalidated).
*/
cache?: boolean;
/**
* Predicate function to decide which requests should be cached.
*/
cachePredicate?: (request: ResolveRequest) => boolean;
/**
* Include the context information in the cache identifier when caching.
*/
cacheWithContext?: boolean;
/**
* Condition names for exports field entry point.
*/
conditionNames?: string[];
/**
* Filenames used to find a description file (like a package.json).
*/
descriptionFiles?: string[];
/**
* Enforce the resolver to use one of the extensions from the extensions option (User must specify requests without extension).
*/
enforceExtension?: boolean;
/**
* Field names from the description file (usually package.json) which are used to provide entry points of a package.
*/
exportsFields?: string[];
/**
* An object which maps extension to extension aliases.
*/
extensionAlias?: { [index: string]: string | string[] };
/**
* Extensions added to the request when trying to find the file.
*/
extensions?: string[];
/**
* Redirect module requests when normal resolving fails.
*/
fallback?:
| {
/**
* New request.
*/
alias: string | false | string[];
/**
* Request to be redirected.
*/
name: string;
/**
* Redirect only exact matching request.
*/
onlyModule?: boolean;
}[]
| { [index: string]: string | false | string[] };
/**
* Filesystem for the resolver.
*/
fileSystem?: InputFileSystem;
/**
* Treats the request specified by the user as fully specified, meaning no extensions are added and the mainFiles in directories are not resolved (This doesn't affect requests from mainFields, aliasFields or aliases).
*/
fullySpecified?: boolean;
/**
* Field names from the description file (usually package.json) which are used to provide internal request of a package (requests starting with # are considered as internal).
*/
importsFields?: string[];
/**
* Field names from the description file (package.json) which are used to find the default entry point.
*/
mainFields?: (string | string[])[];
/**
* Filenames used to find the default entry point if there is no description file or main field.
*/
mainFiles?: string[];
/**
* Folder names or directory paths where to find modules.
*/
modules?: string[];
/**
* Plugins for the resolver.
*/
plugins?: (ResolvePluginInstance | "...")[];
/**
* Prefer to resolve server-relative URLs (starting with '/') as absolute paths before falling back to resolve in 'resolve.roots'.
*/
preferAbsolute?: boolean;
/**
* Prefer to resolve module requests as relative request and fallback to resolving as module.
*/
preferRelative?: boolean;
/**
* Custom resolver.
*/
resolver?: Resolver;
/**
* A list of resolve restrictions. Resolve results must fulfill all of these restrictions to resolve successfully. Other resolve paths are taken when restrictions are not met.
*/
restrictions?: (string | RegExp)[];
/**
* A list of directories in which requests that are server-relative URLs (starting with '/') are resolved.
*/
roots?: string[];
/**
* Enable resolving symlinks to the original location.
*/
symlinks?: boolean;
/**
* Enable caching of successfully resolved requests (cache entries are not revalidated).
*/
unsafeCache?: boolean | { [index: string]: any };
/**
* Use synchronous filesystem calls for the resolver.
*/
useSyncFileSystemCalls?: boolean;
} |
3,379 | getTypes(module: NormalModule): Set<string> | class NormalModule extends Module {
constructor(__0: NormalModuleCreateData);
request: string;
userRequest: string;
rawRequest: string;
binary: boolean;
parser: Parser;
parserOptions?: Record<string, any>;
generator: Generator;
generatorOptions?: Record<string, any>;
resource: string;
resourceResolveData?: Record<string, any>;
matchResource?: string;
loaders: LoaderItem[];
error?: null | WebpackError;
restoreFromUnsafeCache(
unsafeCacheData?: any,
normalModuleFactory?: any
): void;
createSourceForAsset(
context: string,
name: string,
content: string,
sourceMap?: any,
associatedObjectForCache?: Object
): Source;
getCurrentLoader(loaderContext?: any, index?: any): null | LoaderItem;
createSource(
context: string,
content: string | Buffer,
sourceMap?: any,
associatedObjectForCache?: Object
): Source;
markModuleAsErrored(error: WebpackError): void;
applyNoParseRule(rule?: any, content?: any): any;
shouldPreventParsing(noParseRule?: any, request?: any): any;
static getCompilationHooks(
compilation: Compilation
): NormalModuleCompilationHooks;
static deserialize(context?: any): NormalModule;
} |
3,380 | getSize(module: NormalModule, type?: string): number | class NormalModule extends Module {
constructor(__0: NormalModuleCreateData);
request: string;
userRequest: string;
rawRequest: string;
binary: boolean;
parser: Parser;
parserOptions?: Record<string, any>;
generator: Generator;
generatorOptions?: Record<string, any>;
resource: string;
resourceResolveData?: Record<string, any>;
matchResource?: string;
loaders: LoaderItem[];
error?: null | WebpackError;
restoreFromUnsafeCache(
unsafeCacheData?: any,
normalModuleFactory?: any
): void;
createSourceForAsset(
context: string,
name: string,
content: string,
sourceMap?: any,
associatedObjectForCache?: Object
): Source;
getCurrentLoader(loaderContext?: any, index?: any): null | LoaderItem;
createSource(
context: string,
content: string | Buffer,
sourceMap?: any,
associatedObjectForCache?: Object
): Source;
markModuleAsErrored(error: WebpackError): void;
applyNoParseRule(rule?: any, content?: any): any;
shouldPreventParsing(noParseRule?: any, request?: any): any;
static getCompilationHooks(
compilation: Compilation
): NormalModuleCompilationHooks;
static deserialize(context?: any): NormalModule;
} |
3,381 | generate(module: NormalModule, __1: GenerateContext): Source | interface GenerateContext {
/**
* mapping from dependencies to templates
*/
dependencyTemplates: DependencyTemplates;
/**
* the runtime template
*/
runtimeTemplate: RuntimeTemplate;
/**
* the module graph
*/
moduleGraph: ModuleGraph;
/**
* the chunk graph
*/
chunkGraph: ChunkGraph;
/**
* the requirements for runtime
*/
runtimeRequirements: Set<string>;
/**
* the runtime
*/
runtime: RuntimeSpec;
/**
* when in concatenated module, information about other concatenated modules
*/
concatenationScope?: ConcatenationScope;
/**
* code generation results of other modules (need to have a codeGenerationDependency to use that)
*/
codeGenerationResults?: CodeGenerationResults;
/**
* which kind of code should be generated
*/
type: string;
/**
* get access to the code generation data
*/
getData?: () => Map<string, any>;
} |
3,382 | generate(module: NormalModule, __1: GenerateContext): Source | class NormalModule extends Module {
constructor(__0: NormalModuleCreateData);
request: string;
userRequest: string;
rawRequest: string;
binary: boolean;
parser: Parser;
parserOptions?: Record<string, any>;
generator: Generator;
generatorOptions?: Record<string, any>;
resource: string;
resourceResolveData?: Record<string, any>;
matchResource?: string;
loaders: LoaderItem[];
error?: null | WebpackError;
restoreFromUnsafeCache(
unsafeCacheData?: any,
normalModuleFactory?: any
): void;
createSourceForAsset(
context: string,
name: string,
content: string,
sourceMap?: any,
associatedObjectForCache?: Object
): Source;
getCurrentLoader(loaderContext?: any, index?: any): null | LoaderItem;
createSource(
context: string,
content: string | Buffer,
sourceMap?: any,
associatedObjectForCache?: Object
): Source;
markModuleAsErrored(error: WebpackError): void;
applyNoParseRule(rule?: any, content?: any): any;
shouldPreventParsing(noParseRule?: any, request?: any): any;
static getCompilationHooks(
compilation: Compilation
): NormalModuleCompilationHooks;
static deserialize(context?: any): NormalModule;
} |
3,383 | getConcatenationBailoutReason(
module: NormalModule,
context: ConcatenationBailoutReasonContext
): undefined | string | interface ConcatenationBailoutReasonContext {
/**
* the module graph
*/
moduleGraph: ModuleGraph;
/**
* the chunk graph
*/
chunkGraph: ChunkGraph;
} |
3,384 | getConcatenationBailoutReason(
module: NormalModule,
context: ConcatenationBailoutReasonContext
): undefined | string | class NormalModule extends Module {
constructor(__0: NormalModuleCreateData);
request: string;
userRequest: string;
rawRequest: string;
binary: boolean;
parser: Parser;
parserOptions?: Record<string, any>;
generator: Generator;
generatorOptions?: Record<string, any>;
resource: string;
resourceResolveData?: Record<string, any>;
matchResource?: string;
loaders: LoaderItem[];
error?: null | WebpackError;
restoreFromUnsafeCache(
unsafeCacheData?: any,
normalModuleFactory?: any
): void;
createSourceForAsset(
context: string,
name: string,
content: string,
sourceMap?: any,
associatedObjectForCache?: Object
): Source;
getCurrentLoader(loaderContext?: any, index?: any): null | LoaderItem;
createSource(
context: string,
content: string | Buffer,
sourceMap?: any,
associatedObjectForCache?: Object
): Source;
markModuleAsErrored(error: WebpackError): void;
applyNoParseRule(rule?: any, content?: any): any;
shouldPreventParsing(noParseRule?: any, request?: any): any;
static getCompilationHooks(
compilation: Compilation
): NormalModuleCompilationHooks;
static deserialize(context?: any): NormalModule;
} |
3,385 | updateHash(hash: Hash, __1: UpdateHashContextGenerator): void | class Hash {
constructor();
/**
* Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
*/
update(data: string | Buffer, inputEncoding?: string): Hash;
/**
* Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
*/
digest(encoding?: string): string | Buffer;
} |
3,386 | updateHash(hash: Hash, __1: UpdateHashContextGenerator): void | interface UpdateHashContextGenerator {
/**
* the module
*/
module: NormalModule;
chunkGraph: ChunkGraph;
runtime: RuntimeSpec;
runtimeTemplate?: RuntimeTemplate;
} |
3,387 | (
arg0: Chunk
) => string | ((arg0: PathData, arg1?: AssetInfo) => string) | class Chunk {
constructor(name?: string, backCompat?: boolean);
id: null | string | number;
ids: null | (string | number)[];
debugId: number;
name: string;
idNameHints: SortableSet<string>;
preventIntegration: boolean;
filenameTemplate:
| null
| string
| ((arg0: PathData, arg1?: AssetInfo) => string);
cssFilenameTemplate:
| null
| string
| ((arg0: PathData, arg1?: AssetInfo) => string);
runtime: RuntimeSpec;
files: Set<string>;
auxiliaryFiles: Set<string>;
rendered: boolean;
hash?: string;
contentHash: Record<string, string>;
renderedHash?: string;
chunkReason?: string;
extraAsync: boolean;
get entryModule(): Module;
hasEntryModule(): boolean;
addModule(module: Module): boolean;
removeModule(module: Module): void;
getNumberOfModules(): number;
get modulesIterable(): Iterable<Module>;
compareTo(otherChunk: Chunk): 0 | 1 | -1;
containsModule(module: Module): boolean;
getModules(): Module[];
remove(): void;
moveModule(module: Module, otherChunk: Chunk): void;
integrate(otherChunk: Chunk): boolean;
canBeIntegrated(otherChunk: Chunk): boolean;
isEmpty(): boolean;
modulesSize(): number;
size(options?: ChunkSizeOptions): number;
integratedSize(otherChunk: Chunk, options: ChunkSizeOptions): number;
getChunkModuleMaps(filterFn: (m: Module) => boolean): ChunkModuleMaps;
hasModuleInGraph(
filterFn: (m: Module) => boolean,
filterChunkFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): boolean;
getChunkMaps(realHash: boolean): ChunkMaps;
hasRuntime(): boolean;
canBeInitial(): boolean;
isOnlyInitial(): boolean;
getEntryOptions(): undefined | EntryOptions;
addGroup(chunkGroup: ChunkGroup): void;
removeGroup(chunkGroup: ChunkGroup): void;
isInGroup(chunkGroup: ChunkGroup): boolean;
getNumberOfGroups(): number;
get groupsIterable(): Iterable<ChunkGroup>;
disconnectFromGroups(): void;
split(newChunk: Chunk): void;
updateHash(hash: Hash, chunkGraph: ChunkGraph): void;
getAllAsyncChunks(): Set<Chunk>;
getAllInitialChunks(): Set<Chunk>;
getAllReferencedChunks(): Set<Chunk>;
getAllReferencedAsyncEntrypoints(): Set<Entrypoint>;
hasAsyncChunks(): boolean;
getChildIdsByOrders(
chunkGraph: ChunkGraph,
filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): Record<string, (string | number)[]>;
getChildrenOfTypeInOrder(
chunkGraph: ChunkGraph,
type: string
): { onChunks: Chunk[]; chunks: Set<Chunk> }[];
getChildIdsByOrdersMap(
chunkGraph: ChunkGraph,
includeDirectChildren?: boolean,
filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): Record<string | number, Record<string, (string | number)[]>>;
} |
3,388 | (
arg0: Chunk
) => string | ((arg0: PathData, arg1?: AssetInfo) => string) | class Chunk {
constructor(name?: string, backCompat?: boolean);
id: null | string | number;
ids: null | (string | number)[];
debugId: number;
name: string;
idNameHints: SortableSet<string>;
preventIntegration: boolean;
filenameTemplate:
| null
| string
| ((arg0: PathData, arg1?: AssetInfo) => string);
cssFilenameTemplate:
| null
| string
| ((arg0: PathData, arg1?: AssetInfo) => string);
runtime: RuntimeSpec;
files: Set<string>;
auxiliaryFiles: Set<string>;
rendered: boolean;
hash?: string;
contentHash: Record<string, string>;
renderedHash?: string;
chunkReason?: string;
extraAsync: boolean;
get entryModule(): Module;
hasEntryModule(): boolean;
addModule(module: Module): boolean;
removeModule(module: Module): void;
getNumberOfModules(): number;
get modulesIterable(): Iterable<Module>;
compareTo(otherChunk: Chunk): 0 | 1 | -1;
containsModule(module: Module): boolean;
getModules(): Module[];
remove(): void;
moveModule(module: Module, otherChunk: Chunk): void;
integrate(otherChunk: Chunk): boolean;
canBeIntegrated(otherChunk: Chunk): boolean;
isEmpty(): boolean;
modulesSize(): number;
size(options?: ChunkSizeOptions): number;
integratedSize(otherChunk: Chunk, options: ChunkSizeOptions): number;
getChunkModuleMaps(filterFn: (m: Module) => boolean): ChunkModuleMaps;
hasModuleInGraph(
filterFn: (m: Module) => boolean,
filterChunkFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): boolean;
getChunkMaps(realHash: boolean): ChunkMaps;
hasRuntime(): boolean;
canBeInitial(): boolean;
isOnlyInitial(): boolean;
getEntryOptions(): undefined | EntryOptions;
addGroup(chunkGroup: ChunkGroup): void;
removeGroup(chunkGroup: ChunkGroup): void;
isInGroup(chunkGroup: ChunkGroup): boolean;
getNumberOfGroups(): number;
get groupsIterable(): Iterable<ChunkGroup>;
disconnectFromGroups(): void;
split(newChunk: Chunk): void;
updateHash(hash: Hash, chunkGraph: ChunkGraph): void;
getAllAsyncChunks(): Set<Chunk>;
getAllInitialChunks(): Set<Chunk>;
getAllReferencedChunks(): Set<Chunk>;
getAllReferencedAsyncEntrypoints(): Set<Entrypoint>;
hasAsyncChunks(): boolean;
getChildIdsByOrders(
chunkGraph: ChunkGraph,
filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): Record<string, (string | number)[]>;
getChildrenOfTypeInOrder(
chunkGraph: ChunkGraph,
type: string
): { onChunks: Chunk[]; chunks: Set<Chunk> }[];
getChildIdsByOrdersMap(
chunkGraph: ChunkGraph,
includeDirectChildren?: boolean,
filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): Record<string | number, Record<string, (string | number)[]>>;
} |
3,389 | getImportVar(moduleGraph: ModuleGraph): string | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,390 | getLinkingErrors(
moduleGraph: ModuleGraph,
ids: string[],
additionalMessage: string
): undefined | WebpackError[] | class ModuleGraph {
constructor();
setParents(
dependency: Dependency,
block: DependenciesBlock,
module: Module,
indexInBlock?: number
): void;
getParentModule(dependency: Dependency): Module;
getParentBlock(dependency: Dependency): DependenciesBlock;
getParentBlockIndex(dependency: Dependency): number;
setResolvedModule(
originModule: Module,
dependency: Dependency,
module: Module
): void;
updateModule(dependency: Dependency, module: Module): void;
removeConnection(dependency: Dependency): void;
addExplanation(dependency: Dependency, explanation: string): void;
cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;
removeModuleAttributes(module: Module): void;
removeAllModuleAttributes(): void;
moveModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
copyOutgoingModuleConnections(
oldModule: Module,
newModule: Module,
filterConnection: (arg0: ModuleGraphConnection) => boolean
): void;
addExtraReason(module: Module, explanation: string): void;
getResolvedModule(dependency: Dependency): Module;
getConnection(dependency: Dependency): undefined | ModuleGraphConnection;
getModule(dependency: Dependency): Module;
getOrigin(dependency: Dependency): Module;
getResolvedOrigin(dependency: Dependency): Module;
getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;
getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
getIncomingConnectionsByOriginModule(
module: Module
): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getOutgoingConnectionsByModule(
module: Module
): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
getProfile(module: Module): null | ModuleProfile;
setProfile(module: Module, profile: null | ModuleProfile): void;
getIssuer(module: Module): null | Module;
setIssuer(module: Module, issuer: null | Module): void;
setIssuerIfUnset(module: Module, issuer: null | Module): void;
getOptimizationBailout(
module: Module
): (string | ((requestShortener: RequestShortener) => string))[];
getProvidedExports(module: Module): null | true | string[];
isExportProvided(
module: Module,
exportName: string | string[]
): null | boolean;
getExportsInfo(module: Module): ExportsInfo;
getExportInfo(module: Module, exportName: string): ExportInfo;
getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;
getUsedExports(
module: Module,
runtime: RuntimeSpec
): null | boolean | SortableSet<string>;
getPreOrderIndex(module: Module): number;
getPostOrderIndex(module: Module): number;
setPreOrderIndex(module: Module, index: number): void;
setPreOrderIndexIfUnset(module: Module, index: number): boolean;
setPostOrderIndex(module: Module, index: number): void;
setPostOrderIndexIfUnset(module: Module, index: number): boolean;
getDepth(module: Module): number;
setDepth(module: Module, depth: number): void;
setDepthIfLower(module: Module, depth: number): boolean;
isAsync(module: Module): boolean;
setAsync(module: Module): void;
getMeta(thing?: any): Object;
getMetaIfExisting(thing?: any): Object;
freeze(cacheStage?: string): void;
unfreeze(): void;
cached<T extends any[], V>(
fn: (moduleGraph: ModuleGraph, ...args: T) => V,
...args: T
): V;
setModuleMemCaches(
moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
): void;
dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
static getModuleGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ModuleGraph;
static setModuleGraphForModule(
module: Module,
moduleGraph: ModuleGraph
): void;
static clearModuleGraphForModule(module: Module): void;
static ModuleGraphConnection: typeof ModuleGraphConnection;
} |
3,391 | static getImportEmittedRuntime(
module: Module,
referencedModule: Module
): undefined | string | boolean | SortableSet<string> | interface Module {
hot: webpack.Hot;
} |
3,392 | static getImportEmittedRuntime(
module: Module,
referencedModule: Module
): undefined | string | boolean | SortableSet<string> | class Module extends DependenciesBlock {
constructor(type: string, context?: string, layer?: string);
type: string;
context: null | string;
layer: null | string;
needId: boolean;
debugId: number;
resolveOptions: ResolveOptionsWebpackOptions;
factoryMeta?: object;
useSourceMap: boolean;
useSimpleSourceMap: boolean;
buildMeta: BuildMeta;
buildInfo: Record<string, any>;
presentationalDependencies?: Dependency[];
codeGenerationDependencies?: Dependency[];
id: string | number;
get hash(): string;
get renderedHash(): string;
profile: null | ModuleProfile;
index: number;
index2: number;
depth: number;
issuer: null | Module;
get usedExports(): null | boolean | SortableSet<string>;
get optimizationBailout(): (
| string
| ((requestShortener: RequestShortener) => string)
)[];
get optional(): boolean;
addChunk(chunk?: any): boolean;
removeChunk(chunk?: any): void;
isInChunk(chunk?: any): boolean;
isEntryModule(): boolean;
getChunks(): Chunk[];
getNumberOfChunks(): number;
get chunksIterable(): Iterable<Chunk>;
isProvided(exportName: string): null | boolean;
get exportsArgument(): string;
get moduleArgument(): string;
getExportsType(
moduleGraph: ModuleGraph,
strict: boolean
): "namespace" | "default-only" | "default-with-named" | "dynamic";
addPresentationalDependency(presentationalDependency: Dependency): void;
addCodeGenerationDependency(codeGenerationDependency: Dependency): void;
addWarning(warning: WebpackError): void;
getWarnings(): undefined | Iterable<WebpackError>;
getNumberOfWarnings(): number;
addError(error: WebpackError): void;
getErrors(): undefined | Iterable<WebpackError>;
getNumberOfErrors(): number;
/**
* removes all warnings and errors
*/
clearWarningsAndErrors(): void;
isOptional(moduleGraph: ModuleGraph): boolean;
isAccessibleInChunk(
chunkGraph: ChunkGraph,
chunk: Chunk,
ignoreChunk?: Chunk
): boolean;
isAccessibleInChunkGroup(
chunkGraph: ChunkGraph,
chunkGroup: ChunkGroup,
ignoreChunk?: Chunk
): boolean;
hasReasonForChunk(
chunk: Chunk,
moduleGraph: ModuleGraph,
chunkGraph: ChunkGraph
): boolean;
hasReasons(moduleGraph: ModuleGraph, runtime: RuntimeSpec): boolean;
needBuild(
context: NeedBuildContext,
callback: (arg0?: null | WebpackError, arg1?: boolean) => void
): void;
needRebuild(
fileTimestamps: Map<string, null | number>,
contextTimestamps: Map<string, null | number>
): boolean;
invalidateBuild(): void;
identifier(): string;
readableIdentifier(requestShortener: RequestShortener): string;
build(
options: WebpackOptionsNormalized,
compilation: Compilation,
resolver: ResolverWithOptions,
fs: InputFileSystem,
callback: (arg0?: WebpackError) => void
): void;
getSourceTypes(): Set<string>;
source(
dependencyTemplates: DependencyTemplates,
runtimeTemplate: RuntimeTemplate,
type?: string
): Source;
size(type?: string): number;
libIdent(options: LibIdentOptions): null | string;
nameForCondition(): null | string;
getConcatenationBailoutReason(
context: ConcatenationBailoutReasonContext
): undefined | string;
getSideEffectsConnectionState(moduleGraph: ModuleGraph): ConnectionState;
codeGeneration(context: CodeGenerationContext): CodeGenerationResult;
chunkCondition(chunk: Chunk, compilation: Compilation): boolean;
hasChunkCondition(): boolean;
/**
* Assuming this module is in the cache. Update the (cached) module with
* the fresh module from the factory. Usually updates internal references
* and properties.
*/
updateCacheModule(module: Module): void;
/**
* Module should be unsafe cached. Get data that's needed for that.
* This data will be passed to restoreFromUnsafeCache later.
*/
getUnsafeCacheData(): object;
/**
* Assuming this module is in the cache. Remove internal references to allow freeing some memory.
*/
cleanupForCache(): void;
originalSource(): null | Source;
addCacheDependencies(
fileDependencies: LazySet<string>,
contextDependencies: LazySet<string>,
missingDependencies: LazySet<string>,
buildDependencies: LazySet<string>
): void;
get hasEqualsChunks(): any;
get isUsed(): any;
get errors(): any;
get warnings(): any;
used: any;
} |
3,393 | (arg0: Hash) => void | class Hash {
constructor();
/**
* Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
*/
update(data: string | Buffer, inputEncoding?: string): Hash;
/**
* Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
*/
digest(encoding?: string): string | Buffer;
} |
3,394 | constructor(options?: HashedModuleIdsPluginOptions) | interface HashedModuleIdsPluginOptions {
/**
* The context directory for creating names.
*/
context?: string;
/**
* The encoding to use when generating the hash, defaults to 'base64'. All encodings from Node.JS' hash.digest are supported.
*/
hashDigest?: "latin1" | "hex" | "base64";
/**
* The prefix length of the hash digest to use, defaults to 4.
*/
hashDigestLength?: number;
/**
* The hashing algorithm to use, defaults to 'md4'. All functions from Node.JS' crypto.createHash are supported.
*/
hashFunction?: string | typeof Hash;
} |
3,395 | constructor(options?: HashedModuleIdsPluginOptions) | interface HashedModuleIdsPluginOptions {
/**
* The context directory for creating names.
*/
context?: string;
/**
* The encoding to use when generating the hash, defaults to 'base64'. All encodings from Node.JS' hash.digest are supported.
*/
hashDigest?: "hex" | "latin1" | "base64";
/**
* The prefix length of the hash digest to use, defaults to 4.
*/
hashDigestLength?: number;
/**
* The hashing algorithm to use, defaults to 'md4'. All functions from Node.JS' crypto.createHash are supported.
*/
hashFunction?: HashFunction;
} |
3,396 | static getParserHooks(parser: JavascriptParser): HMRJavascriptParserHooks | class JavascriptParser extends Parser {
constructor(sourceType?: "module" | "auto" | "script");
hooks: Readonly<{
evaluateTypeof: HookMap<
SyncBailHook<
[UnaryExpression],
undefined | null | BasicEvaluatedExpression
>
>;
evaluate: HookMap<
SyncBailHook<[Expression], undefined | null | BasicEvaluatedExpression>
>;
evaluateIdentifier: HookMap<
SyncBailHook<
[ThisExpression | MemberExpression | MetaProperty | Identifier],
undefined | null | BasicEvaluatedExpression
>
>;
evaluateDefinedIdentifier: HookMap<
SyncBailHook<
[ThisExpression | MemberExpression | Identifier],
undefined | null | BasicEvaluatedExpression
>
>;
evaluateNewExpression: HookMap<
SyncBailHook<[NewExpression], undefined | null | BasicEvaluatedExpression>
>;
evaluateCallExpression: HookMap<
SyncBailHook<
[CallExpression],
undefined | null | BasicEvaluatedExpression
>
>;
evaluateCallExpressionMember: HookMap<
SyncBailHook<
[CallExpression, undefined | BasicEvaluatedExpression],
undefined | null | BasicEvaluatedExpression
>
>;
isPure: HookMap<
SyncBailHook<
[
(
| UnaryExpression
| ThisExpression
| ArrayExpression
| ObjectExpression
| FunctionExpression
| ArrowFunctionExpression
| YieldExpression
| SimpleLiteral
| RegExpLiteral
| BigIntLiteral
| UpdateExpression
| BinaryExpression
| AssignmentExpression
| LogicalExpression
| MemberExpression
| ConditionalExpression
| SimpleCallExpression
| NewExpression
| SequenceExpression
| TemplateLiteral
| TaggedTemplateExpression
| ClassExpression
| MetaProperty
| Identifier
| AwaitExpression
| ImportExpression
| ChainExpression
| FunctionDeclaration
| VariableDeclaration
| ClassDeclaration
| PrivateIdentifier
),
number
],
boolean | void
>
>;
preStatement: SyncBailHook<
[
| FunctionDeclaration
| VariableDeclaration
| ClassDeclaration
| ExpressionStatement
| BlockStatement
| StaticBlock
| EmptyStatement
| DebuggerStatement
| WithStatement
| ReturnStatement
| LabeledStatement
| BreakStatement
| ContinueStatement
| IfStatement
| SwitchStatement
| ThrowStatement
| TryStatement
| WhileStatement
| DoWhileStatement
| ForStatement
| ForInStatement
| ForOfStatement
| ImportDeclaration
| ExportNamedDeclaration
| ExportDefaultDeclaration
| ExportAllDeclaration
],
boolean | void
>;
blockPreStatement: SyncBailHook<
[
| FunctionDeclaration
| VariableDeclaration
| ClassDeclaration
| ExpressionStatement
| BlockStatement
| StaticBlock
| EmptyStatement
| DebuggerStatement
| WithStatement
| ReturnStatement
| LabeledStatement
| BreakStatement
| ContinueStatement
| IfStatement
| SwitchStatement
| ThrowStatement
| TryStatement
| WhileStatement
| DoWhileStatement
| ForStatement
| ForInStatement
| ForOfStatement
| ImportDeclaration
| ExportNamedDeclaration
| ExportDefaultDeclaration
| ExportAllDeclaration
],
boolean | void
>;
statement: SyncBailHook<
[
| FunctionDeclaration
| VariableDeclaration
| ClassDeclaration
| ExpressionStatement
| BlockStatement
| StaticBlock
| EmptyStatement
| DebuggerStatement
| WithStatement
| ReturnStatement
| LabeledStatement
| BreakStatement
| ContinueStatement
| IfStatement
| SwitchStatement
| ThrowStatement
| TryStatement
| WhileStatement
| DoWhileStatement
| ForStatement
| ForInStatement
| ForOfStatement
| ImportDeclaration
| ExportNamedDeclaration
| ExportDefaultDeclaration
| ExportAllDeclaration
],
boolean | void
>;
statementIf: SyncBailHook<[IfStatement], boolean | void>;
classExtendsExpression: SyncBailHook<
[Expression, ClassExpression | ClassDeclaration],
boolean | void
>;
classBodyElement: SyncBailHook<
[
MethodDefinition | PropertyDefinition,
ClassExpression | ClassDeclaration
],
boolean | void
>;
classBodyValue: SyncBailHook<
[
Expression,
MethodDefinition | PropertyDefinition,
ClassExpression | ClassDeclaration
],
boolean | void
>;
label: HookMap<SyncBailHook<[LabeledStatement], boolean | void>>;
import: SyncBailHook<[ImportDeclaration, ImportSource], boolean | void>;
importSpecifier: SyncBailHook<
[ImportDeclaration, ImportSource, string, string],
boolean | void
>;
export: SyncBailHook<
[ExportNamedDeclaration | ExportAllDeclaration],
boolean | void
>;
exportImport: SyncBailHook<
[ExportNamedDeclaration | ExportAllDeclaration, ImportSource],
boolean | void
>;
exportDeclaration: SyncBailHook<
[ExportNamedDeclaration | ExportAllDeclaration, Declaration],
boolean | void
>;
exportExpression: SyncBailHook<
[ExportDefaultDeclaration, Declaration],
boolean | void
>;
exportSpecifier: SyncBailHook<
[
ExportNamedDeclaration | ExportAllDeclaration,
string,
string,
undefined | number
],
boolean | void
>;
exportImportSpecifier: SyncBailHook<
[
ExportNamedDeclaration | ExportAllDeclaration,
ImportSource,
string,
string,
undefined | number
],
boolean | void
>;
preDeclarator: SyncBailHook<
[VariableDeclarator, Statement],
boolean | void
>;
declarator: SyncBailHook<[VariableDeclarator, Statement], boolean | void>;
varDeclaration: HookMap<SyncBailHook<[Declaration], boolean | void>>;
varDeclarationLet: HookMap<SyncBailHook<[Declaration], boolean | void>>;
varDeclarationConst: HookMap<SyncBailHook<[Declaration], boolean | void>>;
varDeclarationVar: HookMap<SyncBailHook<[Declaration], boolean | void>>;
pattern: HookMap<SyncBailHook<[Identifier], boolean | void>>;
canRename: HookMap<SyncBailHook<[Expression], boolean | void>>;
rename: HookMap<SyncBailHook<[Expression], boolean | void>>;
assign: HookMap<SyncBailHook<[AssignmentExpression], boolean | void>>;
assignMemberChain: HookMap<
SyncBailHook<[AssignmentExpression, string[]], boolean | void>
>;
typeof: HookMap<SyncBailHook<[Expression], boolean | void>>;
importCall: SyncBailHook<[Expression], boolean | void>;
topLevelAwait: SyncBailHook<[Expression], boolean | void>;
call: HookMap<SyncBailHook<[Expression], boolean | void>>;
callMemberChain: HookMap<
SyncBailHook<[CallExpression, string[], boolean[]], boolean | void>
>;
memberChainOfCallMemberChain: HookMap<
SyncBailHook<
[Expression, string[], CallExpression, string[]],
boolean | void
>
>;
callMemberChainOfCallMemberChain: HookMap<
SyncBailHook<
[Expression, string[], CallExpression, string[]],
boolean | void
>
>;
optionalChaining: SyncBailHook<[ChainExpression], boolean | void>;
new: HookMap<SyncBailHook<[NewExpression], boolean | void>>;
binaryExpression: SyncBailHook<[BinaryExpression], boolean | void>;
expression: HookMap<SyncBailHook<[Expression], boolean | void>>;
expressionMemberChain: HookMap<
SyncBailHook<[Expression, string[], boolean[]], boolean | void>
>;
unhandledExpressionMemberChain: HookMap<
SyncBailHook<[Expression, string[]], boolean | void>
>;
expressionConditionalOperator: SyncBailHook<[Expression], boolean | void>;
expressionLogicalOperator: SyncBailHook<[Expression], boolean | void>;
program: SyncBailHook<[Program, Comment[]], boolean | void>;
finish: SyncBailHook<[Program, Comment[]], boolean | void>;
} |
3,397 | constructor(options: HttpUriOptions) | interface HttpUriOptions {
/**
* List of allowed URIs (resp. the beginning of them).
*/
allowedUris: (string | RegExp | ((uri: string) => boolean))[];
/**
* Location where resource content is stored for lockfile entries. It's also possible to disable storing by passing false.
*/
cacheLocation?: string | false;
/**
* When set, anything that would lead to a modification of the lockfile or any resource content, will result in an error.
*/
frozen?: boolean;
/**
* Location of the lockfile.
*/
lockfileLocation?: string;
/**
* Proxy configuration, which can be used to specify a proxy server to use for HTTP requests.
*/
proxy?: string;
/**
* When set, resources of existing lockfile entries will be fetched and entries will be upgraded when resource content has changed.
*/
upgrade?: boolean;
} |
3,398 | constructor(options: HttpUriOptions) | interface HttpUriOptions {
/**
* List of allowed URIs (resp. the beginning of them).
*/
allowedUris: HttpUriOptionsAllowedUris;
/**
* Location where resource content is stored for lockfile entries. It's also possible to disable storing by passing false.
*/
cacheLocation?: false | string;
/**
* When set, anything that would lead to a modification of the lockfile or any resource content, will result in an error.
*/
frozen?: boolean;
/**
* Location of the lockfile.
*/
lockfileLocation?: string;
/**
* Proxy configuration, which can be used to specify a proxy server to use for HTTP requests.
*/
proxy?: string;
/**
* When set, resources of existing lockfile entries will be fetched and entries will be upgraded when resource content has changed.
*/
upgrade?: boolean;
} |
3,399 | constructor(options: HttpUriOptions) | interface HttpUriOptions {
/**
* List of allowed URIs (resp. the beginning of them).
*/
allowedUris: HttpUriOptionsAllowedUris;
/**
* Location where resource content is stored for lockfile entries. It's also possible to disable storing by passing false.
*/
cacheLocation?: false | string;
/**
* When set, anything that would lead to a modification of the lockfile or any resource content, will result in an error.
*/
frozen?: boolean;
/**
* Location of the lockfile.
*/
lockfileLocation?: string;
/**
* Proxy configuration, which can be used to specify a proxy server to use for HTTP requests.
*/
proxy?: string;
/**
* When set, resources of existing lockfile entries will be fetched and entries will be upgraded when resource content has changed.
*/
upgrade?: boolean;
} |