terser-webpack-plugin

esbuildMinify: typeof esbuildMinify;

swcMinify: typeof swcMinify;

terserMinify: typeof terserMinify;

uglifyJsMinify: typeof uglifyJsMinify;

type Asset = import('webpack').Asset;

type BasePluginOptions = {
    test?: Rules | undefined;
    include?: Rules | undefined;
    exclude?: Rules | undefined;
    extractComments?: ExtractCommentsOptions | undefined;
    parallel?: Parallel;
};

type BasicMinimizerImplementation<T> = (
    input: Input,
    sourceMap: SourceMapInput | undefined,
    minifyOptions: MinimizerOptions<T>,
    extractComments: ExtractCommentsOptions | undefined
) => Promise<MinimizedResult>;

type Compilation = import('webpack').Compilation;

type Compiler = import('webpack').Compiler;

type CustomOptions = {
    [key: string]: any;
};

type DefinedDefaultMinimizerAndOptions<T> = T extends TerserOptions
    ? {
          minify?: MinimizerImplementation<T> | undefined;
          terserOptions?: MinimizerOptions<T> | undefined;
      }
    : {
          minify: MinimizerImplementation<T>;
          terserOptions?: MinimizerOptions<T> | undefined;
      };

type ExtractCommentsBanner = string | boolean | ((commentsFile: string) => string);

type ExtractCommentsCondition =
    | boolean
    | 'all'
    | 'some'
    | RegExp
    | ExtractCommentsFunction;

type ExtractCommentsFilename = string | ((fileData: any) => string);

type ExtractCommentsFunction = (
    astNode: any,
    comment: {
        value: string;
        type: 'comment1' | 'comment2' | 'comment3' | 'comment4';
        pos: number;
        line: number;
        col: number;
    }
) => boolean;

type ExtractCommentsObject = {
    condition?: ExtractCommentsCondition | undefined;
    filename?: ExtractCommentsFilename | undefined;
    banner?: ExtractCommentsBanner | undefined;
};

type ExtractCommentsOptions = ExtractCommentsCondition | ExtractCommentsObject;

type InferDefaultType<T> = T extends infer U ? U : CustomOptions;

type Input = {
    [file: string]: string;
};

type InternalOptions<T> = {
    name: string;
    input: string;
    inputSourceMap: SourceMapInput | undefined;
    extractComments: ExtractCommentsOptions | undefined;
    minimizer: {
        implementation: MinimizerImplementation<T>;
        options: MinimizerOptions<T>;
    };
};

type InternalPluginOptions<T> = BasePluginOptions & {
    minimizer: {
        implementation: MinimizerImplementation<T>;
        options: MinimizerOptions<T>;
    };
};

type JestWorker = import('jest-worker').Worker;

type MinimizedResult = {
    code: string;
    map?: import('@jridgewell/trace-mapping').SourceMapInput | undefined;
    errors?: (string | Error)[] | undefined;
    warnings?: (string | Error)[] | undefined;
    extractedComments?: string[] | undefined;
};

type MinimizeFunctionHelpers = {
    getMinimizerVersion?: (() => string | undefined) | undefined;
};

type MinimizerImplementation<T> = BasicMinimizerImplementation<T> &
    MinimizeFunctionHelpers;

type MinimizerOptions<T> = PredefinedOptions & InferDefaultType<T>;

type MinimizerWorker<T> = import('jest-worker').Worker & {
    transform: (options: string) => MinimizedResult;
    minify: (options: InternalOptions<T>) => MinimizedResult;
};

type Parallel = undefined | boolean | number;

type PredefinedOptions = {
    module?: boolean | undefined;
    ecma?: import('terser').ECMA | undefined;
};

type Rule = RegExp | string;

type Rules = Rule[] | Rule;

type Schema = import('schema-utils/declarations/validate').Schema;

type SourceMapInput = import('@jridgewell/trace-mapping').SourceMapInput;

type TerserECMA = import('./utils.js').TerserECMA;

type TerserOptions = import('./utils.js').TerserOptions;

type TraceMap = import('@jridgewell/trace-mapping').TraceMap;

type WebpackError = import('webpack').WebpackError;