## API Report File for "@rushstack/module-minifier-plugin"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { AsyncSeriesWaterfallHook } from 'tapable';
import { Compiler } from 'webpack';
import { MinifyOptions } from 'terser';
import { Plugin } from 'webpack';
import { RawSourceMap } from 'source-map';
import { ReplaceSource } from 'webpack-sources';
import { Source } from 'webpack-sources';
import { SyncWaterfallHook } from 'tapable';
import * as webpack from 'webpack';

// @public
export const CHUNK_MODULES_TOKEN: '__WEBPACK_CHUNK_MODULES__';

// @public
export function generateLicenseFileForAsset(compilation: webpack.compilation.Compilation, asset: IAssetInfo, minifiedModules: IModuleMap): string;

// @public
export interface IAssetInfo {
    chunk: webpack.compilation.Chunk;
    externalNames: Map<string, string>;
    extractedComments: string[];
    fileName: string;
    modules: (string | number)[];
    source: Source;
}

// @public
export type IAssetMap = Map<string, IAssetInfo>;

// @public
export interface IDehydratedAssets {
    assets: IAssetMap;
    modules: IModuleMap;
}

// @public
export const IDENTIFIER_LEADING_DIGITS: string;

// @public
export const IDENTIFIER_TRAILING_DIGITS: string;

// @public
export interface IExtendedModule extends webpack.compilation.Module {
    external?: boolean;
    id: string | number | null;
    identifier(): string;
    readableIdentifier(requestShortener: unknown): string;
    resource?: string;
    skipMinification?: boolean;
}

// @public
export interface IModuleInfo {
    extractedComments: string[];
    module: IExtendedModule;
    source: Source;
}

// @public
export type IModuleMap = Map<string | number, IModuleInfo>;

// @public
export interface IModuleMinificationCallback {
    // (undocumented)
    (result: IModuleMinificationResult): void;
}

// @public
export interface IModuleMinificationErrorResult {
    code?: undefined;
    error: Error;
    extractedComments?: undefined;
    hash: string;
    map?: undefined;
}

// @public
export interface IModuleMinificationRequest {
    code: string;
    externals: string[] | undefined;
    hash: string;
    nameForMap: string | undefined;
}

// @public
export type IModuleMinificationResult = IModuleMinificationErrorResult | IModuleMinificationSuccessResult;

// @public
export interface IModuleMinificationSuccessResult {
    code: string;
    error: undefined;
    extractedComments: string[];
    hash: string;
    map?: RawSourceMap;
}

// @public
export interface IModuleMinifier {
    // (undocumented)
    minify: IModuleMinifierFunction;
    ref?(): () => Promise<void>;
}

// @public
export interface IModuleMinifierFunction {
    // (undocumented)
    (request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void;
}

// @public
export interface IModuleMinifierPluginHooks {
    finalModuleId: SyncWaterfallHook<string | number | undefined>;
    postProcessCodeFragment: SyncWaterfallHook<ReplaceSource, string>;
    rehydrateAssets: AsyncSeriesWaterfallHook<IDehydratedAssets, webpack.compilation.Compilation>;
}

// @public
export interface IModuleMinifierPluginOptions {
    minifier: IModuleMinifier;
    sourceMap?: boolean;
    usePortableModules?: boolean;
}

// @internal
export interface _INormalModuleFactoryModuleData {
    // (undocumented)
    resourceResolveData?: {
        descriptionFileData?: {
            name: string;
        };
        descriptionFilePath?: string;
        descriptionFileRoot?: string;
        relativePath?: string;
    };
}

// @public
export interface ISynchronousMinifierOptions {
    // (undocumented)
    terserOptions?: MinifyOptions;
}

// @public
export interface IWorkerPoolMinifierOptions {
    maxThreads?: number;
    terserOptions?: MinifyOptions;
}

// @public
export const MODULE_WRAPPER_PREFIX: '__MINIFY_MODULE__(';

// @public
export const MODULE_WRAPPER_SUFFIX: ');';

// @public
export class ModuleMinifierPlugin implements webpack.Plugin {
    constructor(options: IModuleMinifierPluginOptions);
    // (undocumented)
    apply(compiler: webpack.Compiler): void;
    // (undocumented)
    readonly hooks: IModuleMinifierPluginHooks;
    // (undocumented)
    minifier: IModuleMinifier;
    }

// @public
export class NoopMinifier implements IModuleMinifier {
    minify(request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void;
}

// @public
export class PortableMinifierModuleIdsPlugin implements Plugin {
    constructor(minifierHooks: IModuleMinifierPluginHooks);
    // (undocumented)
    apply(compiler: Compiler): void;
    }

// @public
export function rehydrateAsset(asset: IAssetInfo, moduleMap: IModuleMap, banner: string): Source;

// @public
export const STAGE_AFTER: 100;

// @public
export const STAGE_BEFORE: -100;

// @public
export class SynchronousMinifier implements IModuleMinifier {
    constructor(options: ISynchronousMinifierOptions);
    minify(request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void;
    // (undocumented)
    readonly terserOptions: MinifyOptions;
}

// @public
export class WorkerPoolMinifier implements IModuleMinifier {
    constructor(options: IWorkerPoolMinifierOptions);
    // (undocumented)
    maxThreads: number;
    minify(request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void;
    // (undocumented)
    ref(): () => Promise<void>;
    }


// (No @packageDocumentation comment for this package)

```