qpdf-compress 0.5.0 → 0.6.1

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/), and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.6.1] - 2026-04-06
+
+### Fixed
+
+- Statically link libstdc++ on Linux to fix `GLIBCXX_3.4.31 not found` errors on systems with older GCC
+
+## [0.6.0] - 2026-04-04
+
+### Changed
+
+- **mozjpeg**: replaced libjpeg-turbo with vendored mozjpeg 4.1.1 for 5–15% smaller JPEGs via trellis quantization, overshoot deringing, and optimized progressive scan ordering — applies to both lossy recompression and lossless Huffman optimization
+
 ## [0.5.0] - 2026-04-04
 
 ### Added

package/README.md

@@ -58,7 +58,7 @@ const smaller = await compress(pdfBuffer, { lossy: true });
 | Integration               | Native Node.js addon  | Shell exec        | Shell exec        |
 | Async I/O                 | ✅ Non-blocking       | ❌ Blocks on exec | ❌ Blocks on exec |
 | Image deduplication       | ✅                    | ❌                | ❌                |
-| JPEG Huffman optimization | ✅ Lossless (libjpeg) | ❌                | ❌                |
+| JPEG Huffman optimization | ✅ Lossless (mozjpeg) | ❌                | ❌                |
 | Lossy image compression   | ✅ Auto quality       | ❌                | ✅                |
 | CMYK → RGB conversion     | ✅ Automatic          | ❌                | ✅                |
 | DPI downscaling           | ✅ Lossy mode         | ❌                | ✅                |
@@ -91,20 +91,20 @@ Prebuilt binaries are available for all [supported platforms](#-supported-platfo
 - CMake ≥ 3.16
 - C++20 compiler (GCC 10+, Clang 13+, MSVC 2019+)
 - zlib development headers
-- libjpeg-turbo (or libjpeg) development headers
+- nasm (optional, for mozjpeg SIMD acceleration)
 
 ```bash
 # macOS
-brew install cmake jpeg-turbo
+brew install cmake nasm
 
 # Ubuntu / Debian
-sudo apt install cmake g++ zlib1g-dev libjpeg-turbo8-dev
+sudo apt install cmake g++ zlib1g-dev nasm
 
 # Amazon Linux / RHEL
-sudo yum install cmake3 gcc-c++ zlib-devel libjpeg-turbo-devel
+sudo yum install cmake3 gcc-c++ zlib-devel nasm
 
 # Windows (using vcpkg)
-vcpkg install zlib libjpeg-turbo --triplet x64-windows-static
+vcpkg install zlib --triplet x64-windows-static
 ```
 
 ## 🌍 Supported Platforms
@@ -209,7 +209,7 @@ concurrency(0); // reset to default
 
 ## ⚙️ How it works
 
-This package embeds [QPDF](https://github.com/qpdf/qpdf) (v12.3.2) as a statically linked C++ library, exposed to Node.js via N-API. Lossless JPEG optimization uses [libjpeg-turbo](https://libjpeg-turbo.org/) at the DCT coefficient level. Image recompression in lossy mode also uses libjpeg-turbo for JPEG encoding. TrueType font subsetting is handled by a custom binary parser that reads cmap tables, resolves composite glyph dependencies, and rebuilds glyf/loca/hmtx tables with only the used glyphs.
+This package embeds [QPDF](https://github.com/qpdf/qpdf) (v12.3.2) and [mozjpeg](https://github.com/mozilla/mozjpeg) (v4.1.1) as statically linked C++ libraries, exposed to Node.js via N-API. Lossless JPEG optimization uses mozjpeg at the DCT coefficient level with progressive scan optimization. Image recompression in lossy mode uses mozjpeg's trellis quantization for 5–15% smaller JPEGs at the same perceptual quality. TrueType font subsetting is handled by a custom binary parser that reads cmap tables, resolves composite glyph dependencies, and rebuilds glyf/loca/hmtx tables with only the used glyphs.
 
 All operations run in a background thread via `Napi::AsyncWorker`, so the event loop is never blocked.
 

package/binding.gyp

@@ -12,6 +12,7 @@
       "include_dirs": [
         "<!@(node -p \"require('node-addon-api').include\")",
         "deps/qpdf/include",
+        "deps/mozjpeg/include",
         "src"
       ],
       "defines": [
@@ -39,7 +40,8 @@
           {
             "include_dirs": [
               "/opt/homebrew/include",
-              "/usr/local/include"
+              "/usr/local/include",
+              "<(module_root_dir)/deps/mozjpeg/include"
             ],
             "xcode_settings": {
               "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
@@ -58,7 +60,7 @@
                 "-L/opt/homebrew/lib",
                 "-L/usr/local/lib",
                 "-lz",
-                "-ljpeg",
+                "<(module_root_dir)/deps/mozjpeg/lib/libjpeg.a",
                 "-flto",
                 "-Wl,-dead_strip",
                 "-Wl,-S"
@@ -72,7 +74,8 @@
             "libraries": [
               "<(module_root_dir)/deps/qpdf/lib/libqpdf.a",
               "-lz",
-              "-ljpeg",
+              "<(module_root_dir)/deps/mozjpeg/lib/libjpeg.a",
+              "-static-libstdc++",
               "-flto",
               "-Wl,--gc-sections",
               "-Wl,-S",
@@ -104,7 +107,7 @@
             "libraries": [
               "<(module_root_dir)/deps/qpdf/lib/qpdf.lib",
               "<(module_root_dir)/deps/qpdf/lib/zlib.lib",
-              "<(module_root_dir)/deps/qpdf/lib/jpeg.lib"
+              "<(module_root_dir)/deps/mozjpeg/lib/jpeg-static.lib"
             ]
           }
         ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qpdf-compress",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Native PDF compression for Node.js, powered by QPDF",
   "license": "Apache-2.0",
   "type": "module",
@@ -69,7 +69,9 @@
     "build": "node-gyp rebuild && node scripts/bundle-lib.mjs",
     "build:ts": "tsc",
     "prepublishOnly": "tsc",
-    "download": "node scripts/download-qpdf.mjs",
+    "download": "node scripts/download-mozjpeg.mjs && node scripts/download-qpdf.mjs",
+    "download:mozjpeg": "node scripts/download-mozjpeg.mjs",
+    "download:qpdf": "node scripts/download-qpdf.mjs",
     "test": "vitest run",
     "lint": "eslint --fix .",
     "lint:check": "eslint .",

package/scripts/download-mozjpeg.mjs

@@ -0,0 +1,162 @@
+import { execFileSync } from 'node:child_process';
+import { createWriteStream, mkdirSync, existsSync, rmSync, readdirSync } from 'node:fs';
+import { pipeline } from 'node:stream/promises';
+import { Readable } from 'node:stream';
+import { join } from 'node:path';
+
+const MOZJPEG_VERSION = '4.1.1';
+const BASE_URL = 'https://github.com/mozilla/mozjpeg/archive/refs/tags';
+
+const root = join(import.meta.dirname, '..');
+const depsDir = join(root, 'deps', 'mozjpeg');
+
+if (existsSync(join(depsDir, 'include', 'jpeglib.h'))) {
+  console.log('mozjpeg already built, skipping.');
+  process.exit(0);
+}
+
+// validate version to prevent SSRF
+if (!/^\d+\.\d+\.\d+$/.test(MOZJPEG_VERSION)) {
+  console.error(`Invalid mozjpeg version: ${MOZJPEG_VERSION}`);
+  process.exit(1);
+}
+
+const url = `${BASE_URL}/v${MOZJPEG_VERSION}.tar.gz`;
+const tarball = join(root, `mozjpeg-${MOZJPEG_VERSION}.tar.gz`);
+const srcDir = join(root, `mozjpeg-${MOZJPEG_VERSION}`);
+const buildDir = join(root, 'build-mozjpeg');
+
+// step 1: download
+console.log(`Downloading mozjpeg ${MOZJPEG_VERSION}...`);
+console.log(`URL: ${url}`);
+
+const response = await fetch(url, { redirect: 'follow' });
+if (!response.ok) {
+  console.error(`Download failed: ${response.status} ${response.statusText}`);
+  process.exit(1);
+}
+
+mkdirSync(join(root, 'deps'), { recursive: true });
+await pipeline(Readable.fromWeb(response.body), createWriteStream(tarball));
+
+console.log('Extracting...');
+execFileSync('tar', ['-xzf', tarball, '-C', root], { stdio: 'inherit' });
+rmSync(tarball);
+
+// GitHub archive tarballs extract to `mozjpeg-{tag}` — find the directory
+if (!existsSync(srcDir)) {
+  const candidates = readdirSync(root).filter(
+    (d) => d.startsWith('mozjpeg-') && !d.endsWith('.tar.gz'),
+  );
+  const match = candidates.find((d) => d.includes(MOZJPEG_VERSION));
+  if (match) {
+    const { renameSync } = await import('node:fs');
+    renameSync(join(root, match), srcDir);
+    console.log(`Renamed ${match} → mozjpeg-${MOZJPEG_VERSION}`);
+  } else {
+    console.error(
+      `Could not find extracted mozjpeg source directory. Found: ${candidates.join(', ')}`,
+    );
+    process.exit(1);
+  }
+}
+
+// step 2: build with CMake
+console.log('Building mozjpeg...');
+mkdirSync(buildDir, { recursive: true });
+
+const cmakeArgs = [
+  '-S',
+  srcDir,
+  '-B',
+  buildDir,
+  '-DCMAKE_BUILD_TYPE=Release',
+  '-DCMAKE_POSITION_INDEPENDENT_CODE=ON',
+  '-DCMAKE_POLICY_VERSION_MINIMUM=3.5',
+  '-DENABLE_STATIC=ON',
+  '-DENABLE_SHARED=OFF',
+  '-DPNG_SUPPORTED=OFF',
+  '-DWITH_TURBOJPEG=OFF',
+  `-DCMAKE_INSTALL_LIBDIR=${join(depsDir, 'lib')}`,
+  `-DCMAKE_INSTALL_PREFIX=${depsDir}`,
+];
+
+// force -fPIC on Linux
+if (process.platform === 'linux') {
+  cmakeArgs.push('-DCMAKE_C_FLAGS=-fPIC', '-DCMAKE_CXX_FLAGS=-fPIC');
+}
+
+// match node-gyp's deployment target on macOS to avoid linker warnings
+if (process.platform === 'darwin') {
+  cmakeArgs.push('-DCMAKE_OSX_DEPLOYMENT_TARGET=11.0');
+}
+
+// Windows multi-config generator
+if (process.platform === 'win32') {
+  cmakeArgs.push('-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded');
+  cmakeArgs.splice(cmakeArgs.indexOf('-DCMAKE_BUILD_TYPE=Release'), 1);
+
+  // cross-compile for ARM64 when VCPKG_TARGET_TRIPLET indicates it
+  const triplet = process.env.VCPKG_TARGET_TRIPLET || '';
+  if (triplet.startsWith('arm64')) {
+    // use lowercase 'arm64' — mozjpeg's CMakeLists.txt checks
+    // CMAKE_GENERATOR_PLATFORM with a case-sensitive regex ("arm64")
+    cmakeArgs.push('-A', 'arm64');
+    cmakeArgs.push('-DNEON_INTRINSICS=ON');
+  }
+}
+
+execFileSync('cmake', cmakeArgs, { stdio: 'inherit' });
+
+const buildArgs = ['--build', buildDir, '--parallel'];
+if (process.platform === 'win32') {
+  buildArgs.push('--config', 'Release');
+}
+execFileSync('cmake', buildArgs, { stdio: 'inherit' });
+
+// step 3: install
+console.log('Installing to deps/mozjpeg...');
+const installArgs = ['--install', buildDir];
+if (process.platform === 'win32') {
+  installArgs.push('--config', 'Release');
+}
+execFileSync('cmake', installArgs, { stdio: 'inherit' });
+
+// verify installation
+if (!existsSync(join(depsDir, 'include', 'jpeglib.h'))) {
+  console.error('mozjpeg install failed: jpeglib.h not found');
+  process.exit(1);
+}
+
+// find the static library (varies by platform and install layout)
+const libDirs = ['lib', 'lib64'].map((d) => join(depsDir, d));
+const libNames = ['libjpeg.a', 'jpeg-static.lib', 'jpeg.lib'];
+let foundLib = false;
+for (const dir of libDirs) {
+  if (!existsSync(dir)) continue;
+  for (const name of libNames) {
+    if (existsSync(join(dir, name))) {
+      foundLib = true;
+      console.log(`Found static library: ${join(dir, name)}`);
+      break;
+    }
+  }
+  if (foundLib) break;
+}
+
+if (!foundLib) {
+  // list what we have for debugging
+  for (const dir of libDirs) {
+    if (existsSync(dir)) {
+      console.log(`Contents of ${dir}:`, readdirSync(dir));
+    }
+  }
+  console.error('mozjpeg install failed: static library not found');
+  process.exit(1);
+}
+
+// step 4: clean up source and build dirs
+rmSync(srcDir, { recursive: true, force: true });
+rmSync(buildDir, { recursive: true, force: true });
+
+console.log(`mozjpeg ${MOZJPEG_VERSION} installed to ${depsDir}`);

package/scripts/download-qpdf.mjs

@@ -88,24 +88,35 @@ if (process.platform === 'linux') {
   cmakeArgs.push('-DCMAKE_C_FLAGS=-fPIC', '-DCMAKE_CXX_FLAGS=-fPIC');
 }
 
-// on macOS, help CMake find Homebrew libjpeg-turbo
-if (process.platform === 'darwin') {
-  const brewPrefixes = ['/opt/homebrew', '/usr/local'];
-  for (const prefix of brewPrefixes) {
-    const jpegDir = join(prefix, 'opt', 'jpeg-turbo');
-    if (existsSync(jpegDir)) {
-      cmakeArgs.push(`-DCMAKE_PREFIX_PATH=${jpegDir}`);
-      break;
-    }
-    const jpegDir2 = join(prefix, 'opt', 'jpeg');
-    if (existsSync(jpegDir2)) {
-      cmakeArgs.push(`-DCMAKE_PREFIX_PATH=${jpegDir2}`);
-      break;
-    }
-  }
+// point QPDF at vendored mozjpeg
+const mozjpegDir = join(root, 'deps', 'mozjpeg');
+if (existsSync(join(mozjpegDir, 'include', 'jpeglib.h'))) {
+  // try lib/ then lib64/ (some CMake installs use lib64 on Linux)
+  const libDir = existsSync(join(mozjpegDir, 'lib')) ? 'lib' : 'lib64';
+  const libExt = process.platform === 'win32' ? 'jpeg-static.lib' : 'libjpeg.a';
+
+  // QPDF uses pkg_check_modules first, then falls back to find_path/find_library
+  // with custom variable names LIBJPEG_H_PATH and LIBJPEG_LIB_PATH.
+
+  // 1) set PKG_CONFIG_PATH so pkg-config finds mozjpeg's libjpeg.pc (Linux/macOS)
+  const pkgConfigDir = join(mozjpegDir, libDir, 'pkgconfig');
+  const existing = process.env.PKG_CONFIG_PATH || '';
+  process.env.PKG_CONFIG_PATH = existing ? `${pkgConfigDir}:${existing}` : pkgConfigDir;
+
+  // 2) set QPDF's cmake cache vars for the find_path/find_library fallback (Windows)
+  cmakeArgs.push(
+    `-DLIBJPEG_H_PATH:PATH=${join(mozjpegDir, 'include')}`,
+    `-DLIBJPEG_LIB_PATH:FILEPATH=${join(mozjpegDir, libDir, libExt)}`,
+  );
+
+  // 3) add mozjpeg to CMAKE_PREFIX_PATH as a belt-and-suspenders fallback
+  cmakeArgs.push(`-DCMAKE_PREFIX_PATH=${mozjpegDir}`);
+} else {
+  console.error('mozjpeg not found — run "node scripts/download-mozjpeg.mjs" first');
+  process.exit(1);
 }
 
-// on Windows, use vcpkg for zlib and libjpeg-turbo
+// on Windows, use vcpkg for zlib (mozjpeg is vendored separately)
 if (process.platform === 'win32') {
   const vcpkgRoot = process.env.VCPKG_ROOT || join(process.env.GITHUB_WORKSPACE || '', 'vcpkg');
   if (existsSync(join(vcpkgRoot, 'scripts', 'buildsystems', 'vcpkg.cmake'))) {
@@ -117,7 +128,7 @@ if (process.platform === 'win32') {
 
     // cross-compile for ARM64 when triplet indicates it
     if (triplet.startsWith('arm64')) {
-      cmakeArgs.push('-A', 'ARM64');
+      cmakeArgs.push('-A', 'arm64');
     }
   }
   // force static CRT (/MT) to match node-gyp
@@ -170,7 +181,7 @@ if (staticLibs.length === 0) {
   }
 }
 
-// step 4: on Windows, copy vcpkg zlib/jpeg static libs and headers for binding.gyp
+// step 4: on Windows, copy vcpkg zlib static lib and headers for binding.gyp
 if (process.platform === 'win32') {
   const triplet = process.env.VCPKG_TARGET_TRIPLET || `${process.arch}-windows-static`;
   const vcpkgRoot = process.env.VCPKG_ROOT || '';
@@ -180,27 +191,15 @@ if (process.platform === 'win32') {
     join(buildDir, 'vcpkg_installed', triplet, 'lib'),
     join(vcpkgRoot, 'installed', triplet, 'lib'),
   ];
-  const candidateIncludeDirs = [
-    join(buildDir, 'vcpkg_installed', triplet, 'include'),
-    join(vcpkgRoot, 'installed', triplet, 'include'),
-  ];
 
   const vcpkgLibDir = candidateLibDirs.find((d) => existsSync(d));
   if (vcpkgLibDir) {
-    for (const lib of ['zlib.lib', 'jpeg.lib', 'turbojpeg.lib']) {
-      const src = join(vcpkgLibDir, lib);
-      if (existsSync(src)) {
-        cpSync(src, join(depsDir, 'lib', lib));
-        console.log(`Copied vcpkg ${lib}`);
-      }
+    const src = join(vcpkgLibDir, 'zlib.lib');
+    if (existsSync(src)) {
+      cpSync(src, join(depsDir, 'lib', 'zlib.lib'));
+      console.log('Copied vcpkg zlib.lib');
     }
   }
-
-  const vcpkgIncludeDir = candidateIncludeDirs.find((d) => existsSync(d));
-  if (vcpkgIncludeDir) {
-    cpSync(vcpkgIncludeDir, join(depsDir, 'include'), { recursive: true, force: true });
-    console.log(`Copied vcpkg headers from ${vcpkgIncludeDir}`);
-  }
 }
 
 // step 5: clean up source and build dirs

package/scripts/install.mjs

@@ -96,6 +96,7 @@ async function tryDownload() {
 
 async function buildFromSource() {
   console.log('Building from source...');
+  execSync('node scripts/download-mozjpeg.mjs', { stdio: 'inherit', cwd: root });
   execSync('node scripts/download-qpdf.mjs', { stdio: 'inherit', cwd: root });
   execSync('npx node-gyp rebuild', { stdio: 'inherit', cwd: root });
   execSync('node scripts/bundle-lib.mjs', { stdio: 'inherit', cwd: root });

package/src/images.cc

@@ -391,7 +391,7 @@ void optimizeImages(QPDF &qpdf, const CompressOptions &opts) {
         return;
     }
 
-    // encode as JPEG via libjpeg-turbo
+    // encode as JPEG via mozjpeg
     std::vector<uint8_t> jpegData;
     if (!encodeJpeg(pixels, width, height, encodeComponents, opts.targetQuality,
                     jpegData))

package/src/jpeg.cc

@@ -55,6 +55,10 @@ static bool losslessJpegOptimizeImpl(const unsigned char *data, size_t size,
   jpeg_copy_critical_parameters(&srcinfo, &dstinfo);
   dstinfo.optimize_coding = TRUE;
 
+  // mozjpeg progressive scan optimization — lossless, reorders existing DCT
+  // coefficients into optimized progressive scans for better entropy coding
+  jpeg_simple_progression(&dstinfo);
+
   jpeg_write_coefficients(&dstinfo, coef_arrays);
   jpeg_finish_compress(&dstinfo);
   jpeg_finish_decompress(&srcinfo);
@@ -79,7 +83,7 @@ bool losslessJpegOptimize(const unsigned char *data, size_t size,
 }
 
 // ---------------------------------------------------------------------------
-// Lossy JPEG encoding via libjpeg-turbo
+// Lossy JPEG encoding via mozjpeg
 // ---------------------------------------------------------------------------
 
 // isolated setjmp scope
@@ -115,6 +119,16 @@ static bool encodeJpegImpl(const unsigned char *pixels, int width, int height,
   jpeg_set_quality(&cinfo, quality, TRUE);
   cinfo.optimize_coding = TRUE;
 
+  // mozjpeg trellis quantization — 5–15% smaller at same perceptual quality
+  jpeg_c_set_bool_param(&cinfo, JBOOLEAN_TRELLIS_QUANT, TRUE);
+  jpeg_c_set_bool_param(&cinfo, JBOOLEAN_TRELLIS_QUANT_DC, TRUE);
+  jpeg_c_set_bool_param(&cinfo, JBOOLEAN_OVERSHOOT_DERINGING, TRUE);
+  jpeg_c_set_bool_param(&cinfo, JBOOLEAN_USE_SCANS_IN_TRELLIS, TRUE);
+  jpeg_c_set_bool_param(&cinfo, JBOOLEAN_USE_LAMBDA_WEIGHT_TBL, TRUE);
+
+  // mozjpeg progressive scan optimization
+  jpeg_simple_progression(&cinfo);
+
   jpeg_start_compress(&cinfo, TRUE);
 
   int row_stride = width * components;

package/src/jpeg.h

@@ -21,7 +21,7 @@ void jpegErrorExit(j_common_ptr cinfo);
 bool losslessJpegOptimize(const unsigned char *data, size_t size,
                           std::vector<uint8_t> &out);
 
-// encodes raw pixels as JPEG at the given quality (1–100) via libjpeg-turbo
+// encodes raw pixels as JPEG at the given quality (1–100) via mozjpeg
 bool encodeJpeg(const unsigned char *pixels, int width, int height,
                 int components, int quality, std::vector<uint8_t> &out);