@rsbuild/plugin-image-compress 0.0.17 → 0.0.19

package/dist/index.d.ts

@@ -1,10 +1,37 @@
-import type { RsbuildPlugin } from '@rsbuild/webpack';
-import { Codecs, Options } from './types';
-export type PluginImageCompressOptions = Options[];
-export declare const DEFAULT_OPTIONS: Codecs[];
-export interface IPluginImageCompress {
-  (...options: Options[]): RsbuildPlugin;
-  (options: Options[]): RsbuildPlugin;
+import { RsbuildPlugin } from '@rsbuild/webpack';
+import { JpegCompressOptions, PngQuantOptions, PNGLosslessOptions } from '@napi-rs/image';
+import { Config } from 'svgo';
+
+type ArrayOrNot<T> = T | T[];
+interface CodecBaseOptions {
+    jpeg: JpegCompressOptions;
+    png: PngQuantOptions;
+    pngLossless: PNGLosslessOptions;
+    ico: {};
+    svg: Config;
+}
+interface BaseCompressOptions<T extends Codecs> {
+    use: T;
+    test?: ArrayOrNot<RegExp>;
+    include?: ArrayOrNot<RegExp>;
+    exclude?: ArrayOrNot<RegExp>;
+}
+type FinalOptionCollection = {
+    [K in Codecs]: BaseCompressOptions<K> & CodecBaseOptions[K];
+};
+type Codecs = keyof CodecBaseOptions;
+type OptionCollection = {
+    [K in Codecs]: K | FinalOptionCollection[K];
+};
+type Options = OptionCollection[Codecs];
+
+type PluginImageCompressOptions = Options[];
+declare const DEFAULT_OPTIONS: Codecs[];
+interface IPluginImageCompress {
+    (...options: Options[]): RsbuildPlugin;
+    (options: Options[]): RsbuildPlugin;
 }
 /** Options enable by default: {@link DEFAULT_OPTIONS} */
-export declare const pluginImageCompress: IPluginImageCompress;
+declare const pluginImageCompress: IPluginImageCompress;
+
+export { DEFAULT_OPTIONS, IPluginImageCompress, PluginImageCompressOptions, pluginImageCompress };

package/dist/index.js

@@ -26,34 +26,175 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
 var src_exports = {};
 __export(src_exports, {
   DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
   pluginImageCompress: () => pluginImageCompress
 });
 module.exports = __toCommonJS(src_exports);
+var import_assert2 = __toESM(require("assert"));
+
+// src/minimizer.ts
+var import_buffer2 = require("buffer");
+
+// src/shared/codecs.ts
+var import_buffer = require("buffer");
+var import_image = require("@napi-rs/image");
+var import_svgo = __toESM(require("svgo"));
+var jpegCodec = {
+  handler(buf, options) {
+    return (0, import_image.compressJpeg)(buf, options);
+  },
+  defaultOptions: {
+    test: /\.(jpg|jpeg)$/
+  }
+};
+var pngCodec = {
+  handler(buf, options) {
+    return (0, import_image.pngQuantize)(buf, options);
+  },
+  defaultOptions: {
+    test: /\.png$/
+  }
+};
+var pngLosslessCodec = {
+  handler(buf, options) {
+    return (0, import_image.losslessCompressPng)(buf, options);
+  },
+  defaultOptions: {
+    test: /\.png$/
+  }
+};
+var icoCodec = {
+  handler(buf) {
+    return new import_image.Transformer(buf).ico();
+  },
+  defaultOptions: {
+    test: /\.(ico|icon)$/
+  }
+};
+var svgCodec = {
+  async handler(buf, options) {
+    const result = import_svgo.default.optimize(buf.toString(), options);
+    return import_buffer.Buffer.from(result.data);
+  },
+  defaultOptions: {
+    test: /\.svg$/
+  }
+};
+var codecs = {
+  jpeg: jpegCodec,
+  png: pngCodec,
+  pngLossless: pngLosslessCodec,
+  ico: icoCodec,
+  svg: svgCodec
+};
+var codecs_default = codecs;
+
+// src/minimizer.ts
+var MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME = "@rsbuild/plugin-image-compress/minimizer";
+var ModernJsImageMinimizerPlugin = class {
+  constructor(options) {
+    this.name = MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME;
+    this.options = options;
+  }
+  async optimize(compiler, compilation, assets) {
+    const cache = compilation.getCache(MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME);
+    const { RawSource } = compiler.webpack.sources;
+    const { matchObject } = compiler.webpack.ModuleFilenameHelpers;
+    const buildError = (error, file, context) => {
+      const cause = error instanceof Error ? error : new Error();
+      const message = file && context ? `"${file}" in "${context}" from Modern.js Image Minimizer:
+${cause.message}` : cause.message;
+      const ret = new compiler.webpack.WebpackError(message);
+      error instanceof Error && (ret.error = error);
+      return ret;
+    };
+    const codec = codecs_default[this.options.use];
+    if (!codec) {
+      compilation.errors.push(
+        buildError(new Error(`Codec ${this.options.use} is not supported`))
+      );
+    }
+    const opts = { ...codec.defaultOptions, ...this.options };
+    const handleAsset = async (name) => {
+      var _a;
+      const info = (_a = compilation.getAsset(name)) == null ? void 0 : _a.info;
+      if ((info == null ? void 0 : info.minimized) || !matchObject(opts, name)) {
+        return;
+      }
+      const { source: inputSource } = compilation.getAsset(name);
+      const eTag = cache.getLazyHashedEtag(inputSource);
+      const cacheItem = cache.getItemCache(name, eTag);
+      let result = await cacheItem.getPromise();
+      try {
+        if (!result) {
+          const input = inputSource.source();
+          const buf = await codec.handler(import_buffer2.Buffer.from(input), opts);
+          result = { source: new RawSource(buf) };
+          await cacheItem.storePromise(result);
+        }
+        compilation.updateAsset(name, result.source, { minimized: true });
+      } catch (error) {
+        compilation.errors.push(buildError(error, name, compiler.context));
+      }
+    };
+    const promises = Object.keys(assets).map((name) => handleAsset(name));
+    await Promise.all(promises);
+  }
+  apply(compiler) {
+    const handleCompilation = (compilation) => {
+      compilation.hooks.processAssets.tapPromise(
+        {
+          name: this.name,
+          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+          additionalAssets: true
+        },
+        (assets) => this.optimize(compiler, compilation, assets)
+      );
+      compilation.hooks.statsPrinter.tap(this.name, (stats) => {
+        stats.hooks.print.for("asset.info.minimized").tap(
+          "@rsbuild/plugin-image-compress",
+          (minimized, { green, formatFlag }) => minimized && green && formatFlag ? green(formatFlag("minimized")) : ""
+        );
+      });
+    };
+    compiler.hooks.compilation.tap(this.name, handleCompilation);
+  }
+};
+
+// src/shared/utils.ts
 var import_assert = __toESM(require("assert"));
-var import_minimizer = require("./minimizer");
-var import_utils = require("./shared/utils");
-const DEFAULT_OPTIONS = ["jpeg", "png", "ico"];
-const castOptions = (args) => {
+var withDefaultOptions = (opt) => {
+  const options = typeof opt === "string" ? { use: opt } : opt;
+  const { defaultOptions } = codecs_default[options.use];
+  const ret = { ...defaultOptions, ...options };
+  (0, import_assert.default)("test" in ret);
+  return ret;
+};
+
+// src/index.ts
+var DEFAULT_OPTIONS = ["jpeg", "png", "ico"];
+var castOptions = (args) => {
   const head = args[0];
   if (Array.isArray(head)) {
     return head;
   }
   const ret = [];
   for (const arg of args) {
-    (0, import_assert.default)(!Array.isArray(arg));
+    (0, import_assert2.default)(!Array.isArray(arg));
     ret.push(arg);
   }
   return ret;
 };
-const normalizeOptions = (options) => {
+var normalizeOptions = (options) => {
   const opts = options.length ? options : DEFAULT_OPTIONS;
-  const normalized = opts.map((opt) => (0, import_utils.withDefaultOptions)(opt));
+  const normalized = opts.map((opt) => withDefaultOptions(opt));
   return normalized;
 };
-const pluginImageCompress = (...args) => ({
+var pluginImageCompress = (...args) => ({
   name: "plugin-image-compress",
   setup(api) {
     const opts = normalizeOptions(castOptions(args));
@@ -63,7 +204,7 @@ const pluginImageCompress = (...args) => ({
       }
       chain.optimization.minimize(true);
       for (const opt of opts) {
-        chain.optimization.minimizer(`image-compress-${opt.use}`).use(import_minimizer.ModernJsImageMinimizerPlugin, [opt]);
+        chain.optimization.minimizer(`image-compress-${opt.use}`).use(ModernJsImageMinimizerPlugin, [opt]);
       }
     });
   }

package/dist/index.mjs

@@ -0,0 +1,192 @@
+// ../../node_modules/.pnpm/@modern-js+module-tools@2.40.0_typescript@5.2.2/node_modules/@modern-js/module-tools/shims/esm.js
+import { fileURLToPath } from "url";
+import path from "path";
+
+// ../../scripts/require_shims.js
+import { createRequire } from "module";
+global.require = createRequire(import.meta.url);
+
+// src/index.ts
+import assert2 from "assert";
+
+// src/minimizer.ts
+import { Buffer as Buffer2 } from "buffer";
+
+// src/shared/codecs.ts
+import { Buffer } from "buffer";
+import {
+  compressJpeg,
+  losslessCompressPng,
+  pngQuantize,
+  Transformer
+} from "@napi-rs/image";
+import svgo from "svgo";
+var jpegCodec = {
+  handler(buf, options) {
+    return compressJpeg(buf, options);
+  },
+  defaultOptions: {
+    test: /\.(jpg|jpeg)$/
+  }
+};
+var pngCodec = {
+  handler(buf, options) {
+    return pngQuantize(buf, options);
+  },
+  defaultOptions: {
+    test: /\.png$/
+  }
+};
+var pngLosslessCodec = {
+  handler(buf, options) {
+    return losslessCompressPng(buf, options);
+  },
+  defaultOptions: {
+    test: /\.png$/
+  }
+};
+var icoCodec = {
+  handler(buf) {
+    return new Transformer(buf).ico();
+  },
+  defaultOptions: {
+    test: /\.(ico|icon)$/
+  }
+};
+var svgCodec = {
+  async handler(buf, options) {
+    const result = svgo.optimize(buf.toString(), options);
+    return Buffer.from(result.data);
+  },
+  defaultOptions: {
+    test: /\.svg$/
+  }
+};
+var codecs = {
+  jpeg: jpegCodec,
+  png: pngCodec,
+  pngLossless: pngLosslessCodec,
+  ico: icoCodec,
+  svg: svgCodec
+};
+var codecs_default = codecs;
+
+// src/minimizer.ts
+var MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME = "@rsbuild/plugin-image-compress/minimizer";
+var ModernJsImageMinimizerPlugin = class {
+  constructor(options) {
+    this.name = MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME;
+    this.options = options;
+  }
+  async optimize(compiler, compilation, assets) {
+    const cache = compilation.getCache(MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME);
+    const { RawSource } = compiler.webpack.sources;
+    const { matchObject } = compiler.webpack.ModuleFilenameHelpers;
+    const buildError = (error, file, context) => {
+      const cause = error instanceof Error ? error : new Error();
+      const message = file && context ? `"${file}" in "${context}" from Modern.js Image Minimizer:
+${cause.message}` : cause.message;
+      const ret = new compiler.webpack.WebpackError(message);
+      error instanceof Error && (ret.error = error);
+      return ret;
+    };
+    const codec = codecs_default[this.options.use];
+    if (!codec) {
+      compilation.errors.push(
+        buildError(new Error(`Codec ${this.options.use} is not supported`))
+      );
+    }
+    const opts = { ...codec.defaultOptions, ...this.options };
+    const handleAsset = async (name) => {
+      const info = compilation.getAsset(name)?.info;
+      if (info?.minimized || !matchObject(opts, name)) {
+        return;
+      }
+      const { source: inputSource } = compilation.getAsset(name);
+      const eTag = cache.getLazyHashedEtag(inputSource);
+      const cacheItem = cache.getItemCache(name, eTag);
+      let result = await cacheItem.getPromise();
+      try {
+        if (!result) {
+          const input = inputSource.source();
+          const buf = await codec.handler(Buffer2.from(input), opts);
+          result = { source: new RawSource(buf) };
+          await cacheItem.storePromise(result);
+        }
+        compilation.updateAsset(name, result.source, { minimized: true });
+      } catch (error) {
+        compilation.errors.push(buildError(error, name, compiler.context));
+      }
+    };
+    const promises = Object.keys(assets).map((name) => handleAsset(name));
+    await Promise.all(promises);
+  }
+  apply(compiler) {
+    const handleCompilation = (compilation) => {
+      compilation.hooks.processAssets.tapPromise(
+        {
+          name: this.name,
+          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+          additionalAssets: true
+        },
+        (assets) => this.optimize(compiler, compilation, assets)
+      );
+      compilation.hooks.statsPrinter.tap(this.name, (stats) => {
+        stats.hooks.print.for("asset.info.minimized").tap(
+          "@rsbuild/plugin-image-compress",
+          (minimized, { green, formatFlag }) => minimized && green && formatFlag ? green(formatFlag("minimized")) : ""
+        );
+      });
+    };
+    compiler.hooks.compilation.tap(this.name, handleCompilation);
+  }
+};
+
+// src/shared/utils.ts
+import assert from "assert";
+var withDefaultOptions = (opt) => {
+  const options = typeof opt === "string" ? { use: opt } : opt;
+  const { defaultOptions } = codecs_default[options.use];
+  const ret = { ...defaultOptions, ...options };
+  assert("test" in ret);
+  return ret;
+};
+
+// src/index.ts
+var DEFAULT_OPTIONS = ["jpeg", "png", "ico"];
+var castOptions = (args) => {
+  const head = args[0];
+  if (Array.isArray(head)) {
+    return head;
+  }
+  const ret = [];
+  for (const arg of args) {
+    assert2(!Array.isArray(arg));
+    ret.push(arg);
+  }
+  return ret;
+};
+var normalizeOptions = (options) => {
+  const opts = options.length ? options : DEFAULT_OPTIONS;
+  const normalized = opts.map((opt) => withDefaultOptions(opt));
+  return normalized;
+};
+var pluginImageCompress = (...args) => ({
+  name: "plugin-image-compress",
+  setup(api) {
+    const opts = normalizeOptions(castOptions(args));
+    api.modifyBundlerChain((chain, { env }) => {
+      if (env !== "production") {
+        return;
+      }
+      chain.optimization.minimize(true);
+      for (const opt of opts) {
+        chain.optimization.minimizer(`image-compress-${opt.use}`).use(ModernJsImageMinimizerPlugin, [opt]);
+      }
+    });
+  }
+});
+export {
+  DEFAULT_OPTIONS,
+  pluginImageCompress
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/plugin-image-compress",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Image compress plugin for Rsbuild",
   "homepage": "https://rsbuild.dev",
   "repository": {
@@ -12,6 +12,7 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
       "default": "./dist/index.js"
     }
   },
@@ -23,15 +24,15 @@
   "dependencies": {
     "@napi-rs/image": "^1.7.0",
     "svgo": "^3.0.2",
-    "@rsbuild/shared": "0.0.17"
+    "@rsbuild/shared": "0.0.19"
   },
   "devDependencies": {
     "@types/node": "^16",
     "typescript": "^5.2.2",
     "webpack": "^5.89.0",
-    "@rsbuild/core": "0.0.17",
-    "@rsbuild/test-helper": "0.0.17",
-    "@rsbuild/webpack": "0.0.17"
+    "@rsbuild/core": "0.0.19",
+    "@rsbuild/test-helper": "0.0.19",
+    "@rsbuild/webpack": "0.0.19"
   },
   "publishConfig": {
     "access": "public",

package/dist/minimizer.d.ts

@@ -1,13 +0,0 @@
-import type { webpack } from '@rsbuild/webpack';
-import type { FinalOptions } from './types';
-export declare const MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME: "@rsbuild/plugin-image-compress/minimizer";
-export interface MinimizedResult {
-  source: webpack.sources.RawSource;
-}
-export declare class ModernJsImageMinimizerPlugin {
-  name: "@rsbuild/plugin-image-compress/minimizer";
-  options: FinalOptions;
-  constructor(options: FinalOptions);
-  optimize(compiler: webpack.Compiler, compilation: webpack.Compilation, assets: Record<string, webpack.sources.Source>): Promise<void>;
-  apply(compiler: webpack.Compiler): void;
-}

package/dist/minimizer.js

@@ -1,111 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var minimizer_exports = {};
-__export(minimizer_exports, {
-  MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME: () => MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME,
-  ModernJsImageMinimizerPlugin: () => ModernJsImageMinimizerPlugin
-});
-module.exports = __toCommonJS(minimizer_exports);
-var import_buffer = require("buffer");
-var import_codecs = __toESM(require("./shared/codecs"));
-const MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME = "@rsbuild/plugin-image-compress/minimizer";
-class ModernJsImageMinimizerPlugin {
-  constructor(options) {
-    this.name = MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME;
-    this.options = options;
-  }
-  async optimize(compiler, compilation, assets) {
-    const cache = compilation.getCache(MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME);
-    const { RawSource } = compiler.webpack.sources;
-    const { matchObject } = compiler.webpack.ModuleFilenameHelpers;
-    const buildError = (error, file, context) => {
-      const cause = error instanceof Error ? error : new Error();
-      const message = file && context ? `"${file}" in "${context}" from Modern.js Image Minimizer:
-${cause.message}` : cause.message;
-      const ret = new compiler.webpack.WebpackError(message);
-      error instanceof Error && (ret.error = error);
-      return ret;
-    };
-    const codec = import_codecs.default[this.options.use];
-    if (!codec) {
-      compilation.errors.push(
-        buildError(new Error(`Codec ${this.options.use} is not supported`))
-      );
-    }
-    const opts = { ...codec.defaultOptions, ...this.options };
-    const handleAsset = async (name) => {
-      var _a;
-      const info = (_a = compilation.getAsset(name)) == null ? void 0 : _a.info;
-      if ((info == null ? void 0 : info.minimized) || !matchObject(opts, name)) {
-        return;
-      }
-      const { source: inputSource } = compilation.getAsset(name);
-      const eTag = cache.getLazyHashedEtag(inputSource);
-      const cacheItem = cache.getItemCache(name, eTag);
-      let result = await cacheItem.getPromise();
-      try {
-        if (!result) {
-          const input = inputSource.source();
-          const buf = await codec.handler(import_buffer.Buffer.from(input), opts);
-          result = { source: new RawSource(buf) };
-          await cacheItem.storePromise(result);
-        }
-        compilation.updateAsset(name, result.source, { minimized: true });
-      } catch (error) {
-        compilation.errors.push(buildError(error, name, compiler.context));
-      }
-    };
-    const promises = Object.keys(assets).map((name) => handleAsset(name));
-    await Promise.all(promises);
-  }
-  apply(compiler) {
-    const handleCompilation = (compilation) => {
-      compilation.hooks.processAssets.tapPromise(
-        {
-          name: this.name,
-          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
-          additionalAssets: true
-        },
-        (assets) => this.optimize(compiler, compilation, assets)
-      );
-      compilation.hooks.statsPrinter.tap(this.name, (stats) => {
-        stats.hooks.print.for("asset.info.minimized").tap(
-          "@rsbuild/plugin-image-compress",
-          (minimized, { green, formatFlag }) => minimized && green && formatFlag ? green(formatFlag("minimized")) : ""
-        );
-      });
-    };
-    compiler.hooks.compilation.tap(this.name, handleCompilation);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME,
-  ModernJsImageMinimizerPlugin
-});

package/dist/shared/codecs.d.ts

@@ -1,8 +0,0 @@
-import { Codec, Codecs } from '../types';
-export declare const jpegCodec: Codec<'jpeg'>;
-export declare const pngCodec: Codec<'png'>;
-export declare const pngLosslessCodec: Codec<'pngLossless'>;
-export declare const icoCodec: Codec<'ico'>;
-export declare const svgCodec: Codec<'svg'>;
-declare const codecs: Record<Codecs, Codec<any>>;
-export default codecs;

package/dist/shared/codecs.js

@@ -1,98 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var codecs_exports = {};
-__export(codecs_exports, {
-  default: () => codecs_default,
-  icoCodec: () => icoCodec,
-  jpegCodec: () => jpegCodec,
-  pngCodec: () => pngCodec,
-  pngLosslessCodec: () => pngLosslessCodec,
-  svgCodec: () => svgCodec
-});
-module.exports = __toCommonJS(codecs_exports);
-var import_buffer = require("buffer");
-var import_image = require("@napi-rs/image");
-var import_svgo = __toESM(require("svgo"));
-const jpegCodec = {
-  handler(buf, options) {
-    return (0, import_image.compressJpeg)(buf, options);
-  },
-  defaultOptions: {
-    test: /\.(jpg|jpeg)$/
-  }
-};
-const pngCodec = {
-  handler(buf, options) {
-    return (0, import_image.pngQuantize)(buf, options);
-  },
-  defaultOptions: {
-    test: /\.png$/
-  }
-};
-const pngLosslessCodec = {
-  handler(buf, options) {
-    return (0, import_image.losslessCompressPng)(buf, options);
-  },
-  defaultOptions: {
-    test: /\.png$/
-  }
-};
-const icoCodec = {
-  handler(buf) {
-    return new import_image.Transformer(buf).ico();
-  },
-  defaultOptions: {
-    test: /\.(ico|icon)$/
-  }
-};
-const svgCodec = {
-  async handler(buf, options) {
-    const result = import_svgo.default.optimize(buf.toString(), options);
-    return import_buffer.Buffer.from(result.data);
-  },
-  defaultOptions: {
-    test: /\.svg$/
-  }
-};
-const codecs = {
-  jpeg: jpegCodec,
-  png: pngCodec,
-  pngLossless: pngLosslessCodec,
-  ico: icoCodec,
-  svg: svgCodec
-};
-var codecs_default = codecs;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  icoCodec,
-  jpegCodec,
-  pngCodec,
-  pngLosslessCodec,
-  svgCodec
-});

package/dist/shared/utils.d.ts

@@ -1,2 +0,0 @@
-import { FinalOptions, Options } from '../types';
-export declare const withDefaultOptions: (opt: Options) => FinalOptions;

package/dist/shared/utils.js

@@ -1,46 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  withDefaultOptions: () => withDefaultOptions
-});
-module.exports = __toCommonJS(utils_exports);
-var import_assert = __toESM(require("assert"));
-var import_codecs = __toESM(require("./codecs"));
-const withDefaultOptions = (opt) => {
-  const options = typeof opt === "string" ? { use: opt } : opt;
-  const { defaultOptions } = import_codecs.default[options.use];
-  const ret = { ...defaultOptions, ...options };
-  (0, import_assert.default)("test" in ret);
-  return ret;
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  withDefaultOptions
-});

package/dist/types/index.d.ts

@@ -1,30 +0,0 @@
-/// <reference types="node" />
-import type { Buffer } from 'buffer';
-import { JpegCompressOptions, PNGLosslessOptions, PngQuantOptions } from '@napi-rs/image';
-import type { Config as SvgoConfig } from 'svgo';
-export type ArrayOrNot<T> = T | T[];
-export interface WebpTransformOptions {
-  quality?: number;
-}
-export interface CodecBaseOptions {
-  jpeg: JpegCompressOptions;
-  png: PngQuantOptions;
-  pngLossless: PNGLosslessOptions;
-  ico: {};
-  svg: SvgoConfig;
-}
-export interface BaseCompressOptions<T extends Codecs> {
-  use: T;
-  test?: ArrayOrNot<RegExp>;
-  include?: ArrayOrNot<RegExp>;
-  exclude?: ArrayOrNot<RegExp>;
-}
-export type FinalOptionCollection = { [K in Codecs]: BaseCompressOptions<K> & CodecBaseOptions[K] };
-export type FinalOptions = FinalOptionCollection[Codecs];
-export interface Codec<T extends Codecs> {
-  handler: (buf: Buffer, options: CodecBaseOptions[T]) => Promise<Buffer>;
-  defaultOptions: Omit<FinalOptionCollection[T], 'use'>;
-}
-export type Codecs = keyof CodecBaseOptions;
-export type OptionCollection = { [K in Codecs]: K | FinalOptionCollection[K] };
-export type Options = OptionCollection[Codecs];

package/dist/types/index.js

@@ -1,16 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);