compression-webpack-plugin

type AlgorithmFunction<T> = (
    input: Buffer,
    options: CompressionOptions<T>,
    callback: (
        error: Error | null | undefined,
        result:
            | WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>
            | Uint8Array
            | ReadonlyArray<number>
            | WithImplicitCoercion<Uint8Array | ReadonlyArray<number> | string>
            | WithImplicitCoercion<string>
            | {
                  [Symbol.toPrimitive](hint: 'string'): string;
              }
    ) => void
) => any;

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

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

type BasePluginOptions<T> = {
    /**
     * include all assets that pass test assertion
     */
    test?: Rules | undefined;
    /**
     * include all assets matching any of these conditions
     */
    include?: Rules | undefined;
    /**
     * exclude all assets matching any of these conditions
     */
    exclude?: Rules | undefined;
    /**
     * only assets bigger than this size are processed, in bytes
     */
    threshold?: number | undefined;
    /**
     * only assets that compress better than this ratio are processed (`minRatio = Compressed Size / Original Size`)
     */
    minRatio?: number | undefined;
    /**
     * whether to delete the original assets or not
     */
    deleteOriginalAssets?: DeleteOriginalAssets | undefined;
    /**
     * the target asset filename
     */
    filename?: Filename | undefined;
};

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

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

type CompressionOptions<T> = InferDefaultType<T>;

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

type DefinedDefaultAlgorithmAndOptions<T> = T extends ZlibOptions
    ? {
          algorithm?: string | AlgorithmFunction<T> | undefined;
          compressionOptions?: CompressionOptions<T> | undefined;
      }
    : {
          algorithm: string | AlgorithmFunction<T>;
          compressionOptions?: CompressionOptions<T> | undefined;
      };

type DeleteOriginalAssets =
    | boolean
    | 'keep-source-map'
    | ((name: string) => boolean);

type EXPECTED_ANY = any;

type Filename = string | ((fileData: PathData) => string);

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

type InternalPluginOptions<T> = BasePluginOptions<T> & {
    algorithm: string | AlgorithmFunction<T>;
    compressionOptions: CompressionOptions<T>;
    threshold: number;
    minRatio: number;
    deleteOriginalAssets: DeleteOriginalAssets;
    filename: Filename;
};

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

type Rule = RegExp | string;

type Rules = Rule[] | Rule;

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

type Source = import('webpack').sources.Source;

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

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

type WithImplicitCoercion<T> =
    | T
    | {
          valueOf(): T;
      };

type ZlibOptions = import('zlib').ZlibOptions;