terser-webpack-plugin

esbuildMinify: typeof esbuildMinify;

swcMinify: typeof swcMinify;

terserMinify: typeof terserMinify;

uglifyJsMinify: typeof uglifyJsMinify;

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

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

type BasePluginOptions = {
    /**
     * test rule
     */
    test?: Rules | undefined;
    /**
     * include rile
     */
    include?: Rules | undefined;
    /**
     * exclude rule
     */
    exclude?: Rules | undefined;
    /**
     * extract comments options
     */
    extractComments?: ExtractCommentsOptions | undefined;
    /**
     * parallel option
     */
    parallel?: Parallel | undefined;
};

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

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

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

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

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

type DefinedDefaultMinimizerAndOptions<T> = T extends import('terser').MinifyOptions
    ? {
          minify?: MinimizerImplementation<T> | undefined;
          terserOptions?: MinimizerOptions<T> | undefined;
      }
    : {
          minify: MinimizerImplementation<T>;
          terserOptions?: MinimizerOptions<T> | undefined;
      };

type ErrorObject = {
    /**
     * message
     */
    message: string;
    /**
     * line number
     */
    line?: number | undefined;
    /**
     * column number
     */
    column?: number | undefined;
    /**
     * error stack trace
     */
    stack?: string | undefined;
};

type ExtractCommentsBanner = boolean | string | ((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 which comments need to be expected
     */
    condition?: ExtractCommentsCondition | undefined;
    /**
     * filename for extracted comments
     */
    filename?: ExtractCommentsFilename | undefined;
    /**
     * banner in filename for extracted comments
     */
    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
     */
    name: string;
    /**
     * input
     */
    input: string;
    /**
     * input source map
     */
    inputSourceMap: RawSourceMap | undefined;
    /**
     * extract comments option
     */
    extractComments: ExtractCommentsOptions | undefined;
    /**
     * minimizer
     */
    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
     */
    code?: string | undefined;
    /**
     * source map
     */
    map?: RawSourceMap | undefined;
    /**
     * errors
     */
    errors?: Array<Error | string> | undefined;
    /**
     * warnings
     */
    warnings?: Array<Error | string> | undefined;
    /**
     * extracted comments
     */
    extractedComments?: Array<string> | undefined;
};

type MinimizeFunctionHelpers = {
    /**
     * function that returns version of minimizer
     */
    getMinimizerVersion?: (() => string | undefined) | undefined;
    /**
     * true when minimizer support worker threads, otherwise false
     */
    supportsWorkerThreads?: (() => boolean | undefined) | undefined;
};

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

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

type MinimizerWorker<T> = JestWorker & {
    transform: (options: string) => Promise<MinimizedResult>;
    minify: (options: InternalOptions<T>) => Promise<MinimizedResult>;
};

type Parallel = undefined | boolean | number;

type PredefinedOptions<T> = {
    /**
     * true when code is a EC module, otherwise false
     */
    module?:
        | (T extends {
              module?: infer P;
          }
              ? P
              : boolean | string)
        | undefined;
    /**
     * ecma version
     */
    ecma?:
        | (T extends {
              ecma?: infer P;
          }
              ? P
              : number | string)
        | undefined;
};

type RawSourceMap = import('@jridgewell/trace-mapping').EncodedSourceMap & {
    sources: string[];
    sourcesContent?: string[];
    file: string;
};

type Rule = RegExp | string;

type Rules = Rule[] | Rule;

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

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