vue-svg-loader

// Type definitions for webpack 4.41 // Project: https://github.com/webpack/webpack // Definitions by: Qubo <https://github.com/tkqubo> // Benjamin Lim <https://github.com/bumbleblym> // Boris Cherny <https://github.com/bcherny> // Tommy Troy Lin <https://github.com/tommytroylin> // Mohsen Azimi <https://github.com/mohsen1> // Jonathan Creamer <https://github.com/jcreamer898> // Alan Agius <https://github.com/alan-agius4> // Dennis George <https://github.com/dennispg> // Christophe Hurpeau <https://github.com/christophehurpeau> // ZSkycat <https://github.com/ZSkycat> // John Reilly <https://github.com/johnnyreilly> // Ryan Waskiewicz <https://github.com/rwaskiewicz> // Kyle Uehlein <https://github.com/kuehlein> // Grgur Grisogono <https://github.com/grgur> // Rubens Pinheiro Gonçalves Cavalcante <https://github.com/rubenspgcavalcante> // Anders Kaseorg <https://github.com/andersk> // Felix Haus <https://github.com/ofhouse> // Daniel Chin <https://github.com/danielthank> // Daiki Ihara <https://github.com/sasurau4> // Dion Shi <https://github.com/dionshihk> // Piotr Błażejewicz <https://github.com/peterblazejewicz> // Michał Grzegorzewski <https://github.com/spamshaker> // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.3 /// <reference types="node" /> import { Hash as CryptoHash } from 'crypto'; import { Tapable, HookMap, SyncBailHook, SyncHook, SyncLoopHook, SyncWaterfallHook, AsyncParallelBailHook, AsyncParallelHook, AsyncSeriesBailHook, AsyncSeriesHook, AsyncSeriesWaterfallHook, } from 'tapable'; import * as UglifyJS from 'uglify-js'; import * as anymatch from 'anymatch'; import { RawSourceMap } from 'source-map'; import { ConcatSource } from 'webpack-sources'; export = webpack; declare function webpack( options: | webpack.Configuration | webpack.ConfigurationFactory, handler: webpack.Compiler.Handler, ): webpack.Compiler.Watching | webpack.Compiler; declare function webpack(options?: webpack.Configuration): webpack.Compiler; declare function webpack( options: | webpack.Configuration[] | webpack.MultiConfigurationFactory, handler: webpack.MultiCompiler.Handler ): webpack.MultiWatching | webpack.MultiCompiler; declare function webpack(options: webpack.Configuration[]): webpack.MultiCompiler; declare namespace webpack { /** Webpack package version. */ const version: string | undefined; interface Configuration { /** Enable production optimizations or development hints. */ mode?: "development" | "production" | "none"; /** Name of the configuration. Used when loading multiple configurations. */ name?: string; /** * The base directory (absolute path!) for resolving the `entry` option. * If `output.pathinfo` is set, the included pathinfo is shortened to this directory. */ context?: string; entry?: string | string[] | Entry | EntryFunc; /** Choose a style of source mapping to enhance the debugging process. These values can affect build and rebuild speed dramatically. */ devtool?: Options.Devtool; /** Options affecting the output. */ output?: Output; /** Options affecting the normal modules (NormalModuleFactory) */ module?: Module; /** Options affecting the resolving of modules. */ resolve?: Resolve; /** Like resolve but for loaders. */ resolveLoader?: ResolveLoader; /** * Specify dependencies that shouldn’t be resolved by webpack, but should become dependencies of the resulting bundle. * The kind of the dependency depends on output.libraryTarget. */ externals?: ExternalsElement | ExternalsElement[]; /** * - "web" Compile for usage in a browser-like environment (default). * - "webworker" Compile as WebWorker. * - "node" Compile for usage in a node.js-like environment (use require to load chunks). * - "async-node" Compile for usage in a node.js-like environment (use fs and vm to load chunks async). * - "node-webkit" Compile for usage in webkit, uses jsonp chunk loading but also supports builtin node.js modules plus require(“nw.gui”) (experimental) * - "atom" Compile for usage in electron (formerly known as atom-shell), supports require for modules necessary to run Electron. * - "electron-renderer" Compile for Electron for renderer process, providing a target using JsonpTemplatePlugin, FunctionModulePlugin for browser * environments and NodeTargetPlugin and ExternalsPlugin for CommonJS and Electron built-in modules. * - "electron-preload" Compile for Electron for renderer process, providing a target using NodeTemplatePlugin with asyncChunkLoading set to true, * FunctionModulePlugin for browser environments and NodeTargetPlugin and ExternalsPlugin for CommonJS and Electron built-in modules. * - "electron-main" Compile for Electron for main process. * - "atom" Alias for electron-main. * - "electron" Alias for electron-main. */ target?: 'web' | 'webworker' | 'node' | 'async-node' | 'node-webkit' | 'atom' | 'electron' | 'electron-renderer' | 'electron-preload' | 'electron-main' | ((compiler?: any) => void); /** Report the first error as a hard error instead of tolerating it. */ bail?: boolean; /** Capture timing information for each module. */ profile?: boolean; /** Cache generated modules and chunks to improve performance for multiple incremental builds. */ cache?: boolean | object; /** Enter watch mode, which rebuilds on file change. */ watch?: boolean; watchOptions?: Options.WatchOptions; /** Include polyfills or mocks for various node stuff */ node?: Node | false; /** Set the value of require.amd and define.amd. */ amd?: { [moduleName: string]: boolean }; /** Used for recordsInputPath and recordsOutputPath */ recordsPath?: string; /** Load compiler state from a json file. */ recordsInputPath?: string; /** Store compiler state to a json file. */ recordsOutputPath?: string; /** Add additional plugins to the compiler. */ plugins?: Plugin[]; /** Stats options for logging */ stats?: Options.Stats; /** Performance options */ performance?: Options.Performance | false; /** Limit the number of parallel processed modules. Can be used to fine tune performance or to get more reliable profiling results */ parallelism?: number; /** Optimization options */ optimization?: Options.Optimization; } interface CliConfigOptions { config?: string; mode?: Configuration["mode"]; env?: string; 'config-register'?: string; configRegister?: string; 'config-name'?: string; configName?: string; } type ConfigurationFactory = (( env: string | Record<string, boolean | number | string> | undefined, args: CliConfigOptions, ) => Configuration | Promise<Configuration>); type MultiConfigurationFactory = (( env: string | Record<string, boolean | number | string> | undefined, args: CliConfigOptions, ) => Configuration[] | Promise<Configuration[]>); interface Entry { [name: string]: string | string[]; } type EntryFunc = () => (string | string[] | Entry | Promise<string | string[] | Entry>); interface DevtoolModuleFilenameTemplateInfo { identifier: string; shortIdentifier: string; resource: any; resourcePath: string; absoluteResourcePath: string; allLoaders: any[]; query: string; moduleId: string; hash: string; } interface Output { /** When used in tandem with output.library and output.libraryTarget, this option allows users to insert comments within the export wrapper. */ auxiliaryComment?: string | AuxiliaryCommentObject; /** The filename of the entry chunk as relative path inside the output.path directory. */ filename?: string | ((chunkData: ChunkData) => string); /** The filename of non-entry chunks as relative path inside the output.path directory. */ chunkFilename?: string; /** Number of milliseconds before chunk request expires, defaults to 120,000. */ chunkLoadTimeout?: number; /** This option enables cross-origin loading of chunks. */ crossOriginLoading?: string | boolean; /** The JSONP function used by webpack for asnyc loading of chunks. */ jsonpFunction?: string; /** Allows customization of the script type webpack injects script tags into the DOM to download async chunks. */ jsonpScriptType?: 'text/javascript' | 'module'; /** Filename template string of function for the sources array in a generated SourceMap. */ devtoolModuleFilenameTemplate?: string | ((info: DevtoolModuleFilenameTemplateInfo) => string); /** Similar to output.devtoolModuleFilenameTemplate, but used in the case of duplicate module identifiers. */ devtoolFallbackModuleFilenameTemplate?: string | ((info: DevtoolModuleFilenameTemplateInfo) => string); /** * Enable line to line mapped mode for all/specified modules. * Line to line mapped mode uses a simple SourceMap where each line of the generated source is mapped to the same line of the original source. * It’s a performance optimization. Only use it if your performance need to be better and you are sure that input lines match which generated lines. * true enables it for all modules (not recommended) */ devtoolLineToLine?: boolean; /** This option determines the modules namespace used with the output.devtoolModuleFilenameTemplate. */ devtoolNamespace?: string; /** The filename of the Hot Update Chunks. They are inside the output.path directory. */ hotUpdateChunkFilename?: string; /** The JSONP function used by webpack for async loading of hot update chunks. */ hotUpdateFunction?: string; /** The filename of the Hot Update Main File. It is inside the output.path directory. */ hotUpdateMainFilename?: string; /** If set, export the bundle as library. output.library is the name. */ library?: string | string[] | {[key: string]: string}; /** * Which format to export the library: * - "var" - Export by setting a variable: var Library = xxx (default) * - "this" - Export by setting a property of this: this["Library"] = xxx * - "commonjs" - Export by setting a property of exports: exports["Library"] = xxx * - "commonjs2" - Export by setting module.exports: module.exports = xxx * - "amd" - Export to AMD (optionally named) * - "umd" - Export to AMD, CommonJS2 or as property in root * - "window" - Assign to window * - "assign" - Assign to a global variable * - "jsonp" - Generate Webpack JSONP module * - "system" - Generate a SystemJS module */ libraryTarget?: LibraryTarget; /** Configure which module or modules will be exposed via the `libraryTarget` */ libraryExport?: string | string[]; /** If output.libraryTarget is set to umd and output.library is set, setting this to true will name the AMD module. */ umdNamedDefine?: boolean; /** The output directory as absolute path. */ path?: string; /** Include comments with information about the modules. */ pathinfo?: boolean; /** The output.path from the view of the Javascript / HTML page. */ publicPath?: string; /** The filename of the SourceMaps for the JavaScript files. They are inside the output.path directory. */ sourceMapFilename?: string; /** Prefixes every line of the source in the bundle with this string. */ sourcePrefix?: string; /** The encoding to use when generating the hash, defaults to 'hex' */ hashDigest?: 'hex' | 'latin1' | 'base64'; /** The prefix length of the hash digest to use, defaults to 20. */ hashDigestLength?: number; /** Algorithm used for generation the hash (see node.js crypto package) */ hashFunction?: string | ((algorithm: string, options?: any) => any); /** An optional salt to update the hash via Node.JS' hash.update. */ hashSalt?: string; /** An expression which is used to address the global object/scope in runtime code. */ globalObject?: string; /** * Use the future version of asset emitting logic, which allows freeing memory of assets after emitting. * It could break plugins which assume that assets are still readable after they were emitted. * @deprecated - will be removed in webpack v5.0.0 and this behaviour will become the new default. */ futureEmitAssets?: boolean; } type LibraryTarget = 'var' | 'assign' | 'this' | 'window' | 'global' | 'commonjs' | 'commonjs2' | 'amd' | 'umd' | 'jsonp' | 'system'; type AuxiliaryCommentObject = { [P in LibraryTarget]: string }; interface ChunkData { chunk: compilation.Chunk; } interface Module { /** A RegExp or an array of RegExps. Don’t parse files matching. */ noParse?: RegExp | RegExp[] | ((content: string) => boolean); unknownContextRequest?: string; unknownContextRecursive?: boolean; unknownContextRegExp?: RegExp; unknownContextCritical?: boolean; exprContextRequest?: string; exprContextRegExp?: RegExp; exprContextRecursive?: boolean; exprContextCritical?: boolean; wrappedContextRegExp?: RegExp; wrappedContextRecursive?: boolean; wrappedContextCritical?: boolean; strictExportPresence?: boolean; /** An array of rules applied for modules. */ rules: RuleSetRule[]; } interface Resolve { /** * A list of directories to resolve modules from. * * Absolute paths will be searched once. * * If an entry is relative, will be resolved using node's resolution algorithm * relative to the requested file. * * Defaults to `["node_modules"]` */ modules?: string[]; /** * A list of package description files to search for. * * Defaults to `["package.json"]` */ descriptionFiles?: string[]; /** * A list of fields in a package description object to use for finding * the entry point. * * Defaults to `["browser", "module", "main"]` or `["module", "main"]`, * depending on the value of the `target` `Configuration` value. */ mainFields?: string[] | string[][]; /** * A list of fields in a package description object to try to parse * in the same format as the `alias` resolve option. * * Defaults to `["browser"]` or `[]`, depending on the value of the * `target` `Configuration` value. * * @see alias */ aliasFields?: string[] | string[][]; /** * A list of file names to search for when requiring directories that * don't contain a package description file. * * Defaults to `["index"]`. */ mainFiles?: string[]; /** * A list of file extensions to try when requesting files. * * An empty string is considered invalid. */ extensions?: string[]; /** * If true, requires that all requested paths must use an extension * from `extensions`. */ enforceExtension?: boolean; /** * Replace the given module requests with other modules or paths. * * @see aliasFields */ alias?: { [key: string]: string; }; /** * Whether to use a cache for resolving, or the specific object * to use for caching. Sharing objects may be useful when running * multiple webpack compilers. * * Defaults to `true`. */ unsafeCache?: {} | boolean; /** * A function used to decide whether to cache the given resolve request. * * Defaults to `() => true`. */ cachePredicate?(data: { path: string, request: string }): boolean; /** * A list of additional resolve plugins which should be applied. */ plugins?: ResolvePlugin[]; /** * Whether to resolve symlinks to their symlinked location. * * Defaults to `true` */ symlinks?: boolean; /** * If unsafe cache is enabled, includes request.context in the cache key. * This option is taken into account by the enhanced-resolve module. * Since webpack 3.1.0 context in resolve caching is ignored when resolve or resolveLoader plugins are provided. * This addresses a performance regression. */ cacheWithContext?: boolean; } interface ResolveLoader extends Resolve { /** * List of strings to append to a loader's name when trying to resolve it. */ moduleExtensions?: string[]; enforceModuleExtension?: boolean; } type ExternalsElement = string | RegExp | ExternalsObjectElement | ExternalsFunctionElement; interface ExternalsObjectElement { [key: string]: boolean | string | string[] | Record<string, string | string[]>; } interface ExternalsFunctionCallback { /** * Invoke with no arguments to not externalize */ (): void; /** * Callback with an Error */ (error: {}): void; /* tslint:disable-line */ /** * Externalize the dependency */ (error: null, result: string | string[] | ExternalsObjectElement, type?: string): void; } type ExternalsFunctionElement = (context: any, request: any, callback: ExternalsFunctionCallback) => any; interface Node { console?: boolean | 'mock'; process?: boolean | 'mock'; global?: boolean; __filename?: boolean | 'mock'; __dirname?: boolean | 'mock'; Buffer?: boolean | 'mock'; setImmediate?: boolean | 'mock' | 'empty'; [nodeBuiltin: string]: boolean | 'mock' | 'empty' | undefined; } interface NewLoader { loader: string; options?: { [name: string]: any }; } type Loader = string | NewLoader; interface ParserOptions { [optName: string]: any; system?: boolean; } type RuleSetCondition = | RegExp | string | ((path: string) => boolean) | RuleSetConditions | { /** * Logical AND */ and?: RuleSetCondition[]; /** * Exclude all modules matching any of these conditions */ exclude?: RuleSetCondition; /** * Exclude all modules matching not any of these conditions */ include?: RuleSetCondition; /** * Logical NOT */ not?: RuleSetCondition[]; /** * Logical OR */ or?: RuleSetCondition[]; /** * Exclude all modules matching any of these conditions */ test?: RuleSetCondition; }; // A hack around circular type referencing interface RuleSetConditions extends Array<RuleSetCondition> {} interface RuleSetRule { /** * Enforce this rule as pre or post step */ enforce?: "pre" | "post"; /** * Shortcut for resource.exclude */ exclude?: RuleSetCondition; /** * Shortcut for resource.include */ include?: RuleSetCondition; /** * Match the issuer of the module (The module pointing to this module) */ issuer?: RuleSetCondition; /** * Shortcut for use.loader */ loader?: RuleSetUse; /** * Shortcut for use.loader */ loaders?: RuleSetUse; /** * Only execute the first matching rule in this array */ oneOf?: RuleSetRule[]; /** * Shortcut for use.options */ options?: RuleSetQuery; /** * Options for parsing */ parser?: { [k: string]: any }; /** * Options for the resolver */ resolve?: Resolve; /** * Flags a module as with or without side effects */ sideEffects?: boolean; /** * Shortcut for use.query */ query?: RuleSetQuery; /** * Module type to use for the module */ type?: "javascript/auto" | "javascript/dynamic" | "javascript/esm" | "json" | "webassembly/experimental"; /** * Match the resource path of the module */ resource?: RuleSetCondition; /** * Match the resource query of the module */ resourceQuery?: RuleSetCondition; /** * Match the child compiler name */ compiler?: RuleSetCondition; /** * Match and execute these rules when this rule is matched */ rules?: RuleSetRule[]; /** * Shortcut for resource.test */ test?: RuleSetCondition; /** * Modifiers applied to the module when rule is matched */ use?: RuleSetUse; } type RuleSetUse = | RuleSetUseItem | RuleSetUseItem[] | ((data: any) => RuleSetUseItem | RuleSetUseItem[]); interface RuleSetLoader { /** * Loader name */ loader?: string; /** * Loader options */ options?: RuleSetQuery; /** * Unique loader identifier */ ident?: string; /** * Loader query */ query?: RuleSetQuery; } type RuleSetUseItem = | string | RuleSetLoader | ((data: any) => string | RuleSetLoader); type RuleSetQuery = | string | { [k: string]: any }; /** * @deprecated Use RuleSetCondition instead */ type Condition = RuleSetCondition; /** * @deprecated Use RuleSetRule instead */ type Rule = RuleSetRule; namespace Options { // tslint:disable-next-line:max-line-length type Devtool = 'eval' | 'inline-source-map' | 'cheap-eval-source-map' | 'cheap-source-map' | 'cheap-module-eval-source-map' | 'cheap-module-source-map' | 'eval-source-map' | 'source-map' | 'nosources-source-map' | 'hidden-source-map' | 'nosources-source-map' | 'inline-cheap-source-map' | 'inline-cheap-module-source-map' | '@eval' | '@inline-source-map' | '@cheap-eval-source-map' | '@cheap-source-map' | '@cheap-module-eval-source-map' | '@cheap-module-source-map' | '@eval-source-map' | '@source-map' | '@nosources-source-map' | '@hidden-source-map' | '@nosources-source-map' | '#eval' | '#inline-source-map' | '#cheap-eval-source-map' | '#cheap-source-map' | '#cheap-module-eval-source-map' | '#cheap-module-source-map' | '#eval-source-map' | '#source-map' | '#nosources-source-map' | '#hidden-source-map' | '#nosources-source-map' | '#@eval' | '#@inline-source-map' | '#@cheap-eval-source-map' | '#@cheap-source-map' | '#@cheap-module-eval-source-map' | '#@cheap-module-source-map' | '#@eval-source-map' | '#@source-map' | '#@nosources-source-map' | '#@hidden-source-map' | '#@nosources-source-map' | boolean; interface Performance { /** This property allows webpack to control what files are used to calculate performance hints. */ assetFilter?(assetFilename: string): boolean; /** * Turns hints on/off. In addition, tells webpack to throw either an error or a warning when hints are * found. This property is set to "warning" by default. */ hints?: 'warning' | 'error' | false; /** * An asset is any emitted file from webpack. This option controls when webpack emits a performance hint * based on individual asset size. The default value is 250000 (bytes). */ maxAssetSize?: number; /** * An entrypoint represents all assets that would be utilized during initial load time for a specific entry. * This option controls when webpack should emit performance hints based on the maximum entrypoint size. * The default value is 250000 (bytes). */ maxEntrypointSize?: number; } type Stats = Stats.ToStringOptions; type WatchOptions = ICompiler.WatchOptions; interface CacheGroupsOptions { /** Assign modules to a cache group */ test?: ((...args: any[]) => boolean) | string | RegExp; /** Select chunks for determining cache group content (defaults to \"initial\", \"initial\" and \"all\" requires adding these chunks to the HTML) */ chunks?: "initial" | "async" | "all" | ((chunk: compilation.Chunk) => boolean); /** Ignore minimum size, minimum chunks and maximum requests and always create chunks for this cache group */ enforce?: boolean; /** Priority of this cache group */ priority?: number; /** Minimal size for the created chunk */ minSize?: number; /** Maximum size for the created chunk */ maxSize?: number; /** Minimum number of times a module has to be duplicated until it's considered for splitting */ minChunks?: number; /** Maximum number of requests which are accepted for on-demand loading */ maxAsyncRequests?: number; /** Maximum number of initial chunks which are accepted for an entry point */ maxInitialRequests?: number; /** Try to reuse existing chunk (with name) when it has matching modules */ reuseExistingChunk?: boolean; /** Give chunks created a name (chunks with equal name are merged) */ name?: boolean | string | ((...args: any[]) => any); } interface SplitChunksOptions { /** Select chunks for determining shared modules (defaults to \"async\", \"initial\" and \"all\" requires adding these chunks to the HTML) */ chunks?: "initial" | "async" | "all" | ((chunk: compilation.Chunk) => boolean); /** Minimal size for the created chunk */ minSize?: number; /** Maximum size for the created chunk */ maxSize?: number; /** Minimum number of times a module has to be duplicated until it's considered for splitting */ minChunks?: number; /** Maximum number of requests which are accepted for on-demand loading */ maxAsyncRequests?: number; /** Maximum number of initial chunks which are accepted for an entry point */ maxInitialRequests?: number; /** Give chunks created a name (chunks with equal name are merged) */ name?: boolean | string | ((...args: any[]) => any); /** Assign modules to a cache group (modules from different cache groups are tried to keep in separate chunks) */ cacheGroups?: false | string | ((...args: any[]) => any) | RegExp | { [key: string]: CacheGroupsOptions | false }; /** Override the default name separator (~) when generating names automatically (name: true) */ automaticNameDelimiter?: string; } interface RuntimeChunkOptions { /** The name or name factory for the runtime chunks. */ name?: string | ((...args: any[]) => any); } interface Optimization { /** * Modules are removed from chunks when they are already available in all parent chunk groups. * This reduces asset size. Smaller assets also result in faster builds since less code generation has to be performed. */ removeAvailableModules?: boolean; /** Empty chunks are removed. This reduces load in filesystem and results in faster builds. */ removeEmptyChunks?: boolean; /** Equal chunks are merged. This results in less code generation and faster builds. */ mergeDuplicateChunks?: boolean; /** Chunks which are subsets of other chunks are determined and flagged in a way that subsets don’t have to be loaded when the bigger chunk has been loaded. */ flagIncludedChunks?: boolean; /** Give more often used ids smaller (shorter) values. */ occurrenceOrder?: boolean; /** Determine exports for each module when possible. This information is used by other optimizations or code generation. I. e. to generate more efficient code for export * from. */ providedExports?: boolean; /** * Determine used exports for each module. This depends on optimization.providedExports. This information is used by other optimizations or code generation. * I. e. exports are not generated for unused exports, export names are mangled to single char identifiers when all usages are compatible. * DCE in minimizers will benefit from this and can remove unused exports. */ usedExports?: boolean; /** * Recognise the sideEffects flag in package.json or rules to eliminate modules. This depends on optimization.providedExports and optimization.usedExports. * These dependencies have a cost, but eliminating modules has positive impact on performance because of less code generation. It depends on your codebase. * Try it for possible performance wins. */ sideEffects?: boolean; /** Tries to find segments of the module graph which can be safely concatenated into a single module. Depends on optimization.providedExports and optimization.usedExports. */ concatenateModules?: boolean; /** Finds modules which are shared between chunk and splits them into separate chunks to reduce duplication or separate vendor modules from application modules. */ splitChunks?: SplitChunksOptions | false; /** Create a separate chunk for the webpack runtime code and chunk hash maps. This chunk should be inlined into the HTML */ runtimeChunk?: boolean | "single" | "multiple" | RuntimeChunkOptions; /** Avoid emitting assets when errors occur. */ noEmitOnErrors?: boolean; /** Instead of numeric ids, give modules readable names for better debugging. */ namedModules?: boolean; /** Instead of numeric ids, give chunks readable names for better debugging. */ namedChunks?: boolean; /** Tells webpack which algorithm to use when choosing module ids. Default false. */ moduleIds?: boolean | "natural" | "named" | "hashed" | "size" | "total-size"; /** Tells webpack which algorithm to use when choosing chunk ids. Default false. */ chunkIds?: boolean | "natural" | "named" | "size" | "total-size"; /** Defines the process.env.NODE_ENV constant to a compile-time-constant value. This allows to remove development only code from code. */ nodeEnv?: string | false; /** Use the minimizer (optimization.minimizer, by default uglify-js) to minimize output assets. */ minimize?: boolean; /** Minimizer(s) to use for minimizing the output */ minimizer?: Array<Plugin | Tapable.Plugin>; /** Generate records with relative paths to be able to move the context folder". */ portableRecords?: boolean; } } /** * @see https://webpack.js.org/api/logging/ * @since 4.39.0 */ interface Logger { error(message?: any, ...optionalParams: any[]): void; warn(message?: any, ...optionalParams: any[]): void; info(message?: any, ...optionalParams: any[]): void; log(message?: any, ...optionalParams: any[]): void; debug(message?: any, ...optionalParams: any[]): void; trace(message?: any, ...optionalParams: any[]): void; group(...label: any[]): void; groupEnd(): void; groupCollapsed(...label: any[]): void; status(message?: any, ...optionalParams: any[]): void; clear(): void; profile(label?: string): void; profileEnd(label?: string): void; } namespace debug { interface ProfilingPluginOptions { /** A relative path to a custom output file (json) */ outputPath?: string; } /** * Generate Chrome profile file which includes timings of plugins execution. Outputs `events.json` file by * default. It is possible to provide custom file path using `outputPath` option. * * In order to view the profile file: * * Run webpack with ProfilingPlugin. * * Go to Chrome, open the Profile Tab. * * Drag and drop generated file (events.json by default) into the profiler. * * It will then display timeline stats and calls per plugin! */ class ProfilingPlugin extends Plugin { constructor(options?: ProfilingPluginOptions); } } namespace compilation { class Asset { } class DependenciesBlock { } class Module extends DependenciesBlock { constructor(type: string, context?: string); type: string; context: string | null; debugId: number; hash: string | undefined; renderedHash: string | undefined; resolveOptions: any; factoryMeta: any; warnings: any[]; errors: any[]; buildMeta: any; buildInfo: any; reasons: any[]; _chunks: SortableSet<Chunk>; id: number | string | null; index: number | null; index2: number | null; depth: number | null; issuer: Module | null; profile: any; prefetched: boolean; built: boolean; used: null | boolean; usedExports: false | true | string[] | null; optimizationBailout: string | any[]; _rewriteChunkInReasons: { oldChunk: Chunk, newChunks: Chunk[] } | undefined; useSourceMap: boolean; _source: any; exportsArgument: string | 'exports'; moduleArgument: string | 'module'; disconnect(): void; unseal(): void; setChunks(chunks: Chunk[]): void; addChunk(chunk: Chunk): boolean; removeChunk(chunk: Chunk): boolean; isInChunk(chunk: Chunk): boolean; isEntryModule(): boolean; optional: boolean; getChunks(): Chunk[]; getNumberOfChunks: number; chunksIterable: SortableSet<Chunk>; hasEqualsChunks(module: Module): boolean; addReason(module: Module, dependency: any, explanation: any): void; removeReason(module: Module, dependency: any): boolean; hasReasonForChunk(chunk: Chunk): boolean; hasReasons(): boolean; rewriteChunkInReasons(oldChunk: Chunk, newChunks: Chunk[]): void; _doRewriteChunkInReasons(oldChunk: Chunk, newChunks: Chunk[]): void; isUsed(exportName?: string): boolean | string; isProvided(exportName: string): boolean | null; toString(): string; needRebuild(fileTimestamps: any, contextTimestamps: any): boolean; updateHash(hash: any): void; sortItems(sortChunks?: boolean): void; unbuild(): void; } class Record { } class Chunk { constructor(name?: string); id: number | null; ids: number[] | null; debugId: number; name: string; preventIntegration: boolean; entryModule: Module | undefined; _modules: SortableSet<Module>; filenameTemplate: string | undefined; _groups: SortableSet<ChunkGroup>; files: string[]; rendered: boolean; hash: string | undefined; contentHash: object; renderedHash: string | undefined; chunkReason: string | undefined; extraAsync: boolean; removedModules: any; hasRuntime(): boolean; canBeInitial(): boolean; isOnlyInitial(): boolean; hasEntryModule(): boolean; addModule(module: Module): boolean; removeModule(module: Module): boolean; setModules(modules: Module[]): void; getNumberOfModules(): number; // Internally returns this._modules // So it should have the same type as this._modules modulesIterable: SortableSet<Module>; addGroup(chunkGroup: ChunkGroup): boolean; removeGroup(chunkGroup: ChunkGroup): boolean; isInGroup(chunkGroup: ChunkGroup): boolean; getNumberOfGroups(): number; // Internally returns this._groups // So it should have the same type as this._groups groupsIterable: SortableSet<ChunkGroup>; compareTo(otherChunk: Chunk): -1 | 0 | 1; containsModule(module: Module): boolean; getModules(): Module[]; getModulesIdent(): any[]; remove(reason?: string): void; moveModule(module: Module, otherChunk: Chunk): void; integrate(otherChunk: Chunk, reason: string): boolean; split(newChunk: Chunk): void; isEmpty(): boolean; updateHash(hash: any): void; canBeIntegrated(otherChunk: Chunk): boolean; addMultiplierAndOverhead( size: number, options: { chunkOverhead?: number; entryChunkMultiplicator?: number }, ): number; modulesSize(): number; size(options?: { chunkOverhead?: number; entryChunkMultiplicator?: number }): number; integratedSize(otherChunk: Chunk, options: any): number | false; sortModules( sortByFn: (module1: Module, module2: Module) => -1 | 0 | 1 ): void; sortItems(): void; getAllAsyncChunks(): Set<Chunk>; getChunkMaps(realHash: boolean): { hash: any; contentHash: any; name: any; }; getChildIdsByOrders(): any; getChildIdsByOrdersMap(includeDirectChildren?: boolean): any; // tslint:disable-next-line:ban-types getChunkModuleMaps(filterFn: Function): { id: any; hash: any }; hasModuleInGraph( filterFn: (module: Module) => boolean, filterChunkFn: (chunk: Chunk) => boolean ): boolean; toString(): string; } type GroupOptions = string | { name?: string; }; class ChunkGroup { chunks: Chunk[]; childrenIterable: SortableSet<ChunkGroup>; parentsIterable: SortableSet<ChunkGroup>; insertChunk(chunk: Chunk, before: Chunk): boolean; getNumberOfChildren(): number; setModuleIndex(module: Module, index: number): void; getModuleIndex(module: Module): number | undefined; setModuleIndex2(module: Module, index: number): void; getModuleIndex2(module: Module): number | undefined; addChild(chunk: ChunkGroup): boolean; removeChild(chunk: ChunkGroup): boolean; setParents(newParents: Iterable<ChunkGroup>): void; } class ChunkHash { } interface SourcePosition { line: number; column?: number; } interface RealDependencyLocation { start: SourcePosition; end?: SourcePosition; index?: number; } interface SynteticDependencyLocation { name: string; index?: number; } type DependencyLocation = SynteticDependencyLocation | RealDependencyLocation; class Dependency { constructor(); getResourceIdentifier(): any; getReference(): any; getExports(): any; getWarnings(): any; getErrors(): any; updateHash(hash: any): void; disconnect(): void; static compare(a: any, b: any): any; } interface NormalModuleFactoryHooks { resolver: SyncWaterfallHook; factory: SyncWaterfallHook; beforeResolve: AsyncSeriesWaterfallHook; afterResolve: AsyncSeriesWaterfallHook; createModule: SyncBailHook; module: SyncWaterfallHook; createParser: HookMap; parser: HookMap<normalModuleFactory.Parser>; createGenerator: HookMap; generator: HookMap; } class NormalModuleFactory extends Tapable { hooks: NormalModuleFactoryHooks; } namespace normalModuleFactory { interface ParserHooks { evaluateTypeof: HookMap; evaluate: HookMap; evaluateIdentifier: HookMap; evaluateDefinedIdentifier: HookMap; evaluateCallExpressionMember: HookMap; statement: SyncBailHook; statementIf: SyncBailHook; label: HookMap; import: SyncBailHook; importSpecifier: SyncBailHook; export: SyncBailHook; exportImport: SyncBailHook; exportDeclaration: SyncBailHook; exportExpression: SyncBailHook; exportSpecifier: SyncBailHook; exportImportSpecifier: SyncBailHook; varDeclaration: SyncBailHook; varDeclarationLet: HookMap; varDeclarationConst: HookMap; varDeclarationVar: HookMap; canRename: HookMap; rename: HookMap; assigned: HookMap; typeof: HookMap; importCall: SyncBailHook; call: HookMap; callAnyMember: HookMap; new: HookMap; expression: HookMap; expressionAnyMember: HookMap; expressionConditionalOperator: SyncBailHook; expressionLogicalOperator: SyncBailHook; program: SyncBailHook; } class Parser extends Tapable { hooks: ParserHooks; } } interface ContextModuleFactoryHooks { beforeResolve: AsyncSeriesWaterfallHook; afterResolve: AsyncSeriesWaterfallHook; contextModuleFiles: SyncWaterfallHook; alternatives: AsyncSeriesWaterfallHook; } class ContextModuleFactory extends Tapable { hooks: ContextModuleFactoryHooks; } class DllModuleFactory extends Tapable { hooks: {}; } interface CompilationHooks { buildModule: SyncHook<Module>; rebuildModule: SyncHook<Module>; failedModule: SyncHook<Module, Error>; succeedModule: SyncHook<Module>; finishModules: SyncHook<Module[]>; finishRebuildingModule: SyncHook<Module>; unseal: SyncHook; seal: SyncHook; optimizeDependenciesBasic: SyncBailHook<Module[]>; optimizeDependencies: SyncBailHook<Module[]>; optimizeDependenciesAdvanced: SyncBailHook<Module[]>; afterOptimizeDependencies: SyncHook<Module[]>; optimize: SyncHook; optimizeModulesBasic: SyncBailHook<Module[]>; optimizeModules: SyncBailHook<Module[]>; optimizeModulesAdvanced: SyncBailHook<Module[]>; afterOptimizeModules: SyncHook<Module[]>; optimizeChunksBasic: SyncBailHook<Chunk[], ChunkGroup[]>; optimizeChunks: SyncBailHook<Chunk[], ChunkGroup[]>; optimizeChunksAdvanced: SyncBailHook<Chunk[], ChunkGroup[]>; afterOptimizeChunks: SyncHook<Chunk[], ChunkGroup[]>; optimizeTree: AsyncSeriesHook<Chunk[], Module[]>; afterOptimizeTree: SyncHook<Chunk[], Module[]>; optimizeChunkModulesBasic: SyncBailHook<Chunk[], Module[]>; optimizeChunkModules: SyncBailHook<Chunk[], Module[]>; optimizeChunkModulesAdvanced: SyncBailHook<Chunk[], Module[]>; afterOptimizeChunkModules: SyncHook<Chunk[], Module[]>; shouldRecord: SyncBailHook; reviveModules: SyncHook<Module[], Record[]>; optimizeModuleOrder: SyncHook<Module[]>; advancedOptimizeModuleOrder: SyncHook<Module[]>; beforeModuleIds: SyncHook<Module[]>; moduleIds: SyncHook<Module[]>; optimizeModuleIds: SyncHook<Module[]>; afterOptimizeModuleIds: SyncHook<Module[]>; reviveChunks: SyncHook<Chunk[], Record[]>; optimizeChunkOrder: SyncHook<Chunk[]>; beforeChunkIds: SyncHook<Chunk[]>; optimizeChunkIds: SyncHook<Chunk[]>; afterOptimizeChunkIds: SyncHook<Chunk[]>; recordModules: SyncHook<Module[], Record[]>; recordChunks: SyncHook<Chunk[], Record[]>; beforeHash: SyncHook; afterHash: SyncHook; recordHash: SyncHook<Record[]>; record: SyncHook<Compilation, Record[]>; beforeModuleAssets: SyncHook; shouldGenerateChunkAssets: SyncBailHook; beforeChunkAssets: SyncHook; additionalChunkAssets: SyncHook<Chunk[]>; records: SyncHook<Compilation, Record[]>; additionalAssets: AsyncSeriesHook; optimizeChunkAssets: AsyncSeriesHook<Chunk[]>; afterOptimizeChunkAssets: SyncHook<Chunk[]>; optimizeAssets: AsyncSeriesHook<Asset[]>; afterOptimizeAssets: SyncHook<Asset[]>; needAdditionalSeal: SyncBailHook; afterSeal: AsyncSeriesHook; chunkHash: SyncHook<Chunk, ChunkHash>; moduleAsset: SyncHook<Module, string>; chunkAsset: SyncHook<Chunk, string>; assetPath: SyncWaterfallHook<string>; needAdditionalPass: SyncBailHook; childCompiler: SyncHook; normalModuleLoader: SyncHook<any, Module>; optimizeExtractedChunksBasic: SyncBailHook<Chunk[]>; optimizeExtractedChunks: SyncBailHook<Chunk[]>; optimizeExtractedChunksAdvanced: SyncBailHook<Chunk[]>; afterOptimizeExtractedChunks: SyncHook<Chunk[]>; } interface CompilationModule { module: any; issuer: boolean; build: boolean; dependencies: boolean; } class MainTemplate extends Tapable { hooks: { jsonpScript?: SyncWaterfallHook<string, Chunk, string>; require: SyncWaterfallHook<string, Chunk, string>; requireExtensions: SyncWaterfallHook<string, Chunk, string>; requireEnsure: SyncWaterfallHook<string, Chunk, string>; localVars: SyncWaterfallHook<string, Chunk, string>; afterStartup: SyncWaterfallHook<string, Chunk, string>; hash: SyncHook<CryptoHash>; hashForChunk: SyncHook<CryptoHash, Chunk>; }; outputOptions: Output; requireFn: string; renderRequireFunctionForModule(hash: string, chunk: Chunk, varModuleId?: number | string): string; renderAddModule(hash: string, chunk: Chunk, varModuleId: number | string | undefined, varModule: string): string; } class ChunkTemplate extends Tapable {} class HotUpdateChunkTemplate extends Tapable {} class RuntimeTemplate {} interface ModuleTemplateHooks { content: SyncWaterfallHook; module: SyncWaterfallHook; render: SyncWaterfallHook; packa