WIP: Switch from custom VError to standard runtime_error

lovell · lovell · commit 9c5de8c6ac9d · 2026-01-23T20:48:15.000Z
diff --git a/docs/src/content/docs/api-output.md b/docs/src/content/docs/api-output.md
@@ -717,7 +717,7 @@ instead of providing `xres` and `yres` in pixels/mm.
 | [options.xres] | <code>number</code> | <code>1.0</code> | horizontal resolution in pixels/mm |
 | [options.yres] | <code>number</code> | <code>1.0</code> | vertical resolution in pixels/mm |
 | [options.resolutionUnit] | <code>string</code> | <code>&quot;&#x27;inch&#x27;&quot;</code> | resolution unit options: inch, cm |
-| [options.bitdepth] | <code>number</code> | <code>8</code> | reduce bitdepth to 1, 2 or 4 bit |
+| [options.bitdepth] | <code>number</code> | <code>0</code> | reduce bitdepth to 1, 2 or 4 bit |
 | [options.miniswhite] | <code>boolean</code> | <code>false</code> | write 1-bit images as miniswhite |
 
 **Example**  
diff --git a/docs/src/content/docs/changelog/v0.35.0.md b/docs/src/content/docs/changelog/v0.35.0.md
@@ -20,6 +20,8 @@ slug: changelog/v0.35.0
 
 * Upgrade to libvips v8.18.0 for upstream bug fixes.
 
+* Ensure TIFF output `bitdepth` option is limited to 1, 2 or 4.
+
 * Deprecate Windows 32-bit (win32-ia32) prebuilt binaries.
 
 * Add AVIF/HEIF `tune` option for control over quality metrics.
diff --git a/lib/constructor.js b/lib/constructor.js
@@ -366,7 +366,7 @@ const Sharp = function (input, options) {
     tiffPredictor: 'horizontal',
     tiffPyramid: false,
     tiffMiniswhite: false,
-    tiffBitdepth: 8,
+    tiffBitdepth: 0,
     tiffTile: false,
     tiffTileHeight: 256,
     tiffTileWidth: 256,
diff --git a/lib/index.d.ts b/lib/index.d.ts
@@ -1479,8 +1479,8 @@ declare namespace sharp {
         xres?: number | undefined;
         /** Vertical resolution in pixels/mm (optional, default 1.0) */
         yres?: number | undefined;
-        /** Reduce bitdepth to 1, 2 or 4 bit (optional, default 8) */
-        bitdepth?: 1 | 2 | 4 | 8 | undefined;
+        /** Reduce bitdepth to 1, 2 or 4 bit (optional, default 0) */
+        bitdepth?: 1 | 2 | 4 | undefined;
         /** Write 1-bit images as miniswhite (optional, default false) */
         miniswhite?: boolean | undefined;
         /** Resolution unit options: inch, cm (optional, default 'inch') */
diff --git a/lib/output.js b/lib/output.js
@@ -1055,7 +1055,7 @@ function trySetAnimationOptions (source, target) {
  * @param {number} [options.xres=1.0] - horizontal resolution in pixels/mm
  * @param {number} [options.yres=1.0] - vertical resolution in pixels/mm
  * @param {string} [options.resolutionUnit='inch'] - resolution unit options: inch, cm
- * @param {number} [options.bitdepth=8] - reduce bitdepth to 1, 2 or 4 bit
+ * @param {number} [options.bitdepth=0] - reduce bitdepth to 1, 2 or 4 bit
  * @param {boolean} [options.miniswhite=false] - write 1-bit images as miniswhite
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -1070,10 +1070,10 @@ function tiff (options) {
       }
     }
     if (is.defined(options.bitdepth)) {
-      if (is.integer(options.bitdepth) && is.inArray(options.bitdepth, [1, 2, 4, 8])) {
+      if (is.integer(options.bitdepth) && is.inArray(options.bitdepth, [1, 2, 4])) {
         this.options.tiffBitdepth = options.bitdepth;
       } else {
-        throw is.invalidParameterError('bitdepth', '1, 2, 4 or 8', options.bitdepth);
+        throw is.invalidParameterError('bitdepth', '1, 2 or 4', options.bitdepth);
       }
     }
     // tiling
diff --git a/src/common.cc b/src/common.cc
@@ -510,11 +510,11 @@ namespace sharp {
               option = GetOptionsForImageType(imageType, descriptor);
               image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);
             }
-          } catch (vips::VError const &err) {
-            throw vips::VError(std::string("Input buffer has corrupt header: ") + err.what());
+          } catch (std::runtime_error const &err) {
+            throw std::runtime_error(std::string("Input buffer has corrupt header: ") + err.what());
           }
         } else {
-          throw vips::VError("Input buffer contains unsupported image format");
+          throw std::runtime_error("Input buffer contains unsupported image format");
         }
       }
     } else {
@@ -585,10 +585,10 @@ namespace sharp {
         imageType = DetermineImageType(descriptor->file.data());
         if (imageType == ImageType::MISSING) {
           if (descriptor->file.find("<svg") != std::string::npos) {
-            throw vips::VError("Input file is missing, did you mean "
+            throw std::runtime_error("Input file is missing, did you mean "
               "sharp(Buffer.from('" + descriptor->file.substr(0, 8) + "...')?");
           }
-          throw vips::VError("Input file is missing: " + descriptor->file);
+          throw std::runtime_error("Input file is missing: " + descriptor->file);
         }
         if (imageType != ImageType::UNKNOWN) {
           try {
@@ -600,19 +600,19 @@ namespace sharp {
               option = GetOptionsForImageType(imageType, descriptor);
               image = VImage::new_from_file(descriptor->file.data(), option);
             }
-          } catch (vips::VError const &err) {
-            throw vips::VError(std::string("Input file has corrupt header: ") + err.what());
+          } catch (std::runtime_error const &err) {
+            throw std::runtime_error(std::string("Input file has corrupt header: ") + err.what());
           }
         } else {
-          throw vips::VError("Input file contains unsupported image format");
+          throw std::runtime_error("Input file contains unsupported image format");
         }
       }
     }
 
     // Limit input images to a given number of pixels, where pixels = width * height
     if (descriptor->limitInputPixels > 0 &&
       static_cast<uint64_t>(image.width()) * image.height() > descriptor->limitInputPixels) {
-      throw vips::VError("Input image exceeds pixel limit");
+      throw std::runtime_error("Input image exceeds pixel limit");
     }
     return std::make_tuple(image, imageType);
   }
@@ -788,19 +788,19 @@ namespace sharp {
       : image.height();
     if (imageType == ImageType::JPEG) {
       if (image.width() > 65535 || height > 65535) {
-        throw vips::VError("Processed image is too large for the JPEG format");
+        throw std::runtime_error("Processed image is too large for the JPEG format");
       }
     } else if (imageType == ImageType::WEBP) {
       if (image.width() > 16383 || height > 16383) {
-        throw vips::VError("Processed image is too large for the WebP format");
+        throw std::runtime_error("Processed image is too large for the WebP format");
       }
     } else if (imageType == ImageType::GIF) {
       if (image.width() > 65535 || height > 65535) {
-        throw vips::VError("Processed image is too large for the GIF format");
+        throw std::runtime_error("Processed image is too large for the GIF format");
       }
     } else if (imageType == ImageType::HEIF) {
       if (image.width() > 16384 || height > 16384) {
-        throw vips::VError("Processed image is too large for the HEIF format");
+        throw std::runtime_error("Processed image is too large for the HEIF format");
       }
     }
   }
diff --git a/src/metadata.cc b/src/metadata.cc
@@ -31,7 +31,7 @@ class MetadataWorker : public Napi::AsyncWorker {
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
     try {
       std::tie(image, imageType) = OpenInput(baton->input);
-    } catch (vips::VError const &err) {
+    } catch (std::runtime_error const &err) {
       (baton->err).append(err.what());
     }
     if (imageType != sharp::ImageType::UNKNOWN) {
diff --git a/src/operations.cc b/src/operations.cc
@@ -14,7 +14,6 @@
 #include "./operations.h"
 
 using vips::VImage;
-using vips::VError;
 
 namespace sharp {
   /*
@@ -287,7 +286,7 @@ namespace sharp {
   */
   VImage Trim(VImage image, std::vector<double> background, double threshold, bool const lineArt, int const margin) {
     if (image.width() < 3 && image.height() < 3) {
-      throw VError("Image to trim must be at least 3x3 pixels");
+      throw std::runtime_error("Image to trim must be at least 3x3 pixels");
     }
     if (background.size() == 0) {
       // Top-left pixel provides the default background colour if none is given
@@ -361,7 +360,7 @@ namespace sharp {
   VImage Linear(VImage image, std::vector<double> const a, std::vector<double> const b) {
     size_t const bands = static_cast<size_t>(image.bands());
     if (a.size() > bands) {
-      throw VError("Band expansion using linear is unsupported");
+      throw std::runtime_error("Band expansion using linear is unsupported");
     }
     bool const uchar = !Is16Bit(image.interpretation());
     if (image.has_alpha() && a.size() != bands && (a.size() == 1 || a.size() == bands - 1 || bands - 1 == 1)) {
diff --git a/src/pipeline.cc b/src/pipeline.cc
@@ -274,7 +274,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           }
           sharp::SetDensity(image, baton->input->density);
           if (image.width() > 32767 || image.height() > 32767) {
-            throw vips::VError("Input SVG image will exceed 32767x32767 pixel limit when scaled");
+            throw std::runtime_error("Input SVG image will exceed 32767x32767 pixel limit when scaled");
           }
         } else if (inputImageType == sharp::ImageType::PDF) {
           if (baton->input->buffer != nullptr) {
@@ -290,7 +290,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         }
       } else {
         if (inputImageType == sharp::ImageType::SVG && (image.width() > 32767 || image.height() > 32767)) {
-          throw vips::VError("Input SVG image exceeds 32767x32767 pixel limit");
+          throw std::runtime_error("Input SVG image exceeds 32767x32767 pixel limit");
         }
       }
       if (baton->input->autoOrient) {
@@ -675,7 +675,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
           // Verify within current dimensions
           if (compositeImage.width() > image.width() || compositeImage.height() > image.height()) {
-            throw vips::VError("Image to composite must have same dimensions or smaller");
+            throw std::runtime_error("Image to composite must have same dimensions or smaller");
           }
           // Check if overlay is tiled
           if (composite->tile) {
@@ -1086,20 +1086,19 @@ class PipelineWorker : public Napi::AsyncWorker {
           // Get raw image data
           baton->bufferOut = static_cast<char*>(image.write_to_memory(&baton->bufferOutLength));
           if (baton->bufferOut == nullptr) {
-            (baton->err).append("Could not allocate enough memory for raw output");
-            return Error();
+            throw std::runtime_error("Could not allocate enough memory for raw output");
           }
           baton->formatOut = "raw";
         } else {
           // Unsupported output format
-          (baton->err).append("Unsupported output format ");
+          auto unsupported = std::string("Unsupported output format ");
           if (baton->formatOut == "input") {
-            (baton->err).append("when trying to match input format of ");
-            (baton->err).append(ImageTypeId(inputImageType));
+            unsupported.append("when trying to match input format of ");
+            unsupported.append(ImageTypeId(inputImageType));
           } else {
-            (baton->err).append(baton->formatOut);
+            unsupported.append(baton->formatOut);
           }
-          return Error();
+          throw std::runtime_error(unsupported);
         }
       } else {
         // File output
@@ -1274,7 +1273,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           return Error();
         }
       }
-    } catch (vips::VError const &err) {
+    } catch (std::runtime_error const &err) {
       char const *what = err.what();
       if (what && what[0]) {
         (baton->err).append(what);
@@ -1306,7 +1305,6 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
       warning = sharp::VipsWarningPop();
     }
-
     if (baton->err.empty()) {
       int width = baton->width;
       int height = baton->height;
@@ -1407,7 +1405,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
   void MultiPageUnsupported(int const pages, std::string op) {
     if (pages > 1) {
-      throw vips::VError(op + " is not supported for multi-page images");
+      throw std::runtime_error(op + " is not supported for multi-page images");
     }
   }
 
diff --git a/src/pipeline.h b/src/pipeline.h
@@ -365,7 +365,7 @@ struct PipelineBaton {
     tiffBigtiff(false),
     tiffPredictor(VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL),
     tiffPyramid(false),
-    tiffBitdepth(8),
+    tiffBitdepth(0),
     tiffMiniswhite(false),
     tiffTile(false),
     tiffTileHeight(256),
diff --git a/src/stats.cc b/src/stats.cc
@@ -39,7 +39,7 @@ class StatsWorker : public Napi::AsyncWorker {
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
     try {
       std::tie(image, imageType) = OpenInput(baton->input);
-    } catch (vips::VError const &err) {
+    } catch (std::runtime_error const &err) {
       (baton->err).append(err.what());
     }
     if (imageType != sharp::ImageType::UNKNOWN) {
@@ -92,7 +92,7 @@ class StatsWorker : public Napi::AsyncWorker {
         baton->dominantRed = dx * 16 + 8;
         baton->dominantGreen = dy * 16 + 8;
         baton->dominantBlue = dz * 16 + 8;
-      } catch (vips::VError const &err) {
+      } catch (std::runtime_error const &err) {
         (baton->err).append(err.what());
       }
     }
@@ -112,7 +112,6 @@ class StatsWorker : public Napi::AsyncWorker {
       debuglog.Call(Receiver().Value(), { Napi::String::New(env, warning) });
       warning = sharp::VipsWarningPop();
     }
-
     if (baton->err.empty()) {
       // Stats Object
       Napi::Object info = Napi::Object::New(env);
diff --git a/src/utilities.cc b/src/utilities.cc
@@ -244,7 +244,7 @@ Napi::Value _maxColourDistance(const Napi::CallbackInfo& info) {
     }
     // Calculate colour distance
     maxColourDistance = image1.dE00(image2).max();
-  } catch (vips::VError const &err) {
+  } catch (std::runtime_error const &err) {
     throw Napi::Error::New(env, err.what());
   }
 
diff --git a/test/unit/tiff.js b/test/unit/tiff.js
@@ -122,7 +122,6 @@ describe('TIFF', () => {
     sharp(fixtures.inputTiff8BitDepth)
       .toColourspace('b-w') // can only squash 1 band uchar images
       .tiff({
-        bitdepth: 8,
         compression: 'none',
         predictor: 'none'
       })
@@ -154,7 +153,7 @@ describe('TIFF', () => {
   it('Invalid TIFF bitdepth value throws error', () => {
     assert.throws(() => {
       sharp().tiff({ bitdepth: 3 });
-    }, /Error: Expected 1, 2, 4 or 8 for bitdepth but received 3 of type number/);
+    }, /Error: Expected 1, 2 or 4 for bitdepth but received 3 of type number/);
   });
 
   it('TIFF setting xres and yres on file', () =>

Original file line number	Diff line number	Diff line change
`@@ -1055,7 +1055,7 @@ function trySetAnimationOptions (source, target) {`
`1055`	`1055`	`* @param {number} [options.xres=1.0] - horizontal resolution in pixels/mm`
`1056`	`1056`	`* @param {number} [options.yres=1.0] - vertical resolution in pixels/mm`
`1057`	`1057`	`* @param {string} [options.resolutionUnit='inch'] - resolution unit options: inch, cm`
`1058`		`- * @param {number} [options.bitdepth=8] - reduce bitdepth to 1, 2 or 4 bit`
	`1058`	`+ * @param {number} [options.bitdepth=0] - reduce bitdepth to 1, 2 or 4 bit`
`1059`	`1059`	`* @param {boolean} [options.miniswhite=false] - write 1-bit images as miniswhite`
`1060`	`1060`	`* @returns {Sharp}`
`1061`	`1061`	`* @throws {Error} Invalid options`
`@@ -1070,10 +1070,10 @@ function tiff (options) {`
`1070`	`1070`	`}`
`1071`	`1071`	`}`
`1072`	`1072`	`if (is.defined(options.bitdepth)) {`
`1073`		`- if (is.integer(options.bitdepth) && is.inArray(options.bitdepth, [1, 2, 4, 8])) {`
	`1073`	`+ if (is.integer(options.bitdepth) && is.inArray(options.bitdepth, [1, 2, 4])) {`
`1074`	`1074`	`this.options.tiffBitdepth = options.bitdepth;`
`1075`	`1075`	`} else {`
`1076`		`- throw is.invalidParameterError('bitdepth', '1, 2, 4 or 8', options.bitdepth);`
	`1076`	`+ throw is.invalidParameterError('bitdepth', '1, 2 or 4', options.bitdepth);`
`1077`	`1077`	`}`
`1078`	`1078`	`}`
`1079`	`1079`	`// tiling`
Original file line number	Diff line number	Diff line change
`@@ -510,11 +510,11 @@ namespace sharp {`
`510`	`510`	`option = GetOptionsForImageType(imageType, descriptor);`
`511`	`511`	`image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);`
`512`	`512`	`}`
`513`		`- } catch (vips::VError const &err) {`
`514`		`- throw vips::VError(std::string("Input buffer has corrupt header: ") + err.what());`
	`513`	`+ } catch (std::runtime_error const &err) {`
	`514`	`+ throw std::runtime_error(std::string("Input buffer has corrupt header: ") + err.what());`
`515`	`515`	`}`
`516`	`516`	`} else {`
`517`		`- throw vips::VError("Input buffer contains unsupported image format");`
	`517`	`+ throw std::runtime_error("Input buffer contains unsupported image format");`
`518`	`518`	`}`
`519`	`519`	`}`
`520`	`520`	`} else {`
`@@ -585,10 +585,10 @@ namespace sharp {`
`585`	`585`	`imageType = DetermineImageType(descriptor->file.data());`
`586`	`586`	`if (imageType == ImageType::MISSING) {`
`587`	`587`	`if (descriptor->file.find("<svg") != std::string::npos) {`
`588`		`- throw vips::VError("Input file is missing, did you mean "`
	`588`	`+ throw std::runtime_error("Input file is missing, did you mean "`
`589`	`589`	`"sharp(Buffer.from('" + descriptor->file.substr(0, 8) + "...')?");`
`590`	`590`	`}`
`591`		`- throw vips::VError("Input file is missing: " + descriptor->file);`
	`591`	`+ throw std::runtime_error("Input file is missing: " + descriptor->file);`
`592`	`592`	`}`
`593`	`593`	`if (imageType != ImageType::UNKNOWN) {`
`594`	`594`	`try {`
`@@ -600,19 +600,19 @@ namespace sharp {`
`600`	`600`	`option = GetOptionsForImageType(imageType, descriptor);`
`601`	`601`	`image = VImage::new_from_file(descriptor->file.data(), option);`
`602`	`602`	`}`
`603`		`- } catch (vips::VError const &err) {`
`604`		`- throw vips::VError(std::string("Input file has corrupt header: ") + err.what());`
	`603`	`+ } catch (std::runtime_error const &err) {`
	`604`	`+ throw std::runtime_error(std::string("Input file has corrupt header: ") + err.what());`
`605`	`605`	`}`
`606`	`606`	`} else {`
`607`		`- throw vips::VError("Input file contains unsupported image format");`
	`607`	`+ throw std::runtime_error("Input file contains unsupported image format");`
`608`	`608`	`}`
`609`	`609`	`}`
`610`	`610`	`}`
`611`	`611`
`612`	`612`	`// Limit input images to a given number of pixels, where pixels = width * height`
`613`	`613`	`if (descriptor->limitInputPixels > 0 &&`
`614`	`614`	`static_cast<uint64_t>(image.width()) * image.height() > descriptor->limitInputPixels) {`
`615`		`- throw vips::VError("Input image exceeds pixel limit");`
	`615`	`+ throw std::runtime_error("Input image exceeds pixel limit");`
`616`	`616`	`}`
`617`	`617`	`return std::make_tuple(image, imageType);`
`618`	`618`	`}`
`@@ -788,19 +788,19 @@ namespace sharp {`
`788`	`788`	`: image.height();`
`789`	`789`	`if (imageType == ImageType::JPEG) {`
`790`	`790`	`if (image.width() > 65535 \|\| height > 65535) {`
`791`		`- throw vips::VError("Processed image is too large for the JPEG format");`
	`791`	`+ throw std::runtime_error("Processed image is too large for the JPEG format");`
`792`	`792`	`}`
`793`	`793`	`} else if (imageType == ImageType::WEBP) {`
`794`	`794`	`if (image.width() > 16383 \|\| height > 16383) {`
`795`		`- throw vips::VError("Processed image is too large for the WebP format");`
	`795`	`+ throw std::runtime_error("Processed image is too large for the WebP format");`
`796`	`796`	`}`
`797`	`797`	`} else if (imageType == ImageType::GIF) {`
`798`	`798`	`if (image.width() > 65535 \|\| height > 65535) {`
`799`		`- throw vips::VError("Processed image is too large for the GIF format");`
	`799`	`+ throw std::runtime_error("Processed image is too large for the GIF format");`
`800`	`800`	`}`
`801`	`801`	`} else if (imageType == ImageType::HEIF) {`
`802`	`802`	`if (image.width() > 16384 \|\| height > 16384) {`
`803`		`- throw vips::VError("Processed image is too large for the HEIF format");`
	`803`	`+ throw std::runtime_error("Processed image is too large for the HEIF format");`
`804`	`804`	`}`
`805`	`805`	`}`
`806`	`806`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ class MetadataWorker : public Napi::AsyncWorker {`
`31`	`31`	`sharp::ImageType imageType = sharp::ImageType::UNKNOWN;`
`32`	`32`	`try {`
`33`	`33`	`std::tie(image, imageType) = OpenInput(baton->input);`
`34`		`- } catch (vips::VError const &err) {`
	`34`	`+ } catch (std::runtime_error const &err) {`
`35`	`35`	`(baton->err).append(err.what());`
`36`	`36`	`}`
`37`	`37`	`if (imageType != sharp::ImageType::UNKNOWN) {`
Original file line number	Diff line number	Diff line change
`@@ -274,7 +274,7 @@ class PipelineWorker : public Napi::AsyncWorker {`
`274`	`274`	`}`
`275`	`275`	`sharp::SetDensity(image, baton->input->density);`
`276`	`276`	`if (image.width() > 32767 \|\| image.height() > 32767) {`
`277`		`- throw vips::VError("Input SVG image will exceed 32767x32767 pixel limit when scaled");`
	`277`	`+ throw std::runtime_error("Input SVG image will exceed 32767x32767 pixel limit when scaled");`
`278`	`278`	`}`
`279`	`279`	`} else if (inputImageType == sharp::ImageType::PDF) {`
`280`	`280`	`if (baton->input->buffer != nullptr) {`
`@@ -290,7 +290,7 @@ class PipelineWorker : public Napi::AsyncWorker {`
`290`	`290`	`}`
`291`	`291`	`} else {`
`292`	`292`	`if (inputImageType == sharp::ImageType::SVG && (image.width() > 32767 \|\| image.height() > 32767)) {`
`293`		`- throw vips::VError("Input SVG image exceeds 32767x32767 pixel limit");`
	`293`	`+ throw std::runtime_error("Input SVG image exceeds 32767x32767 pixel limit");`
`294`	`294`	`}`
`295`	`295`	`}`
`296`	`296`	`if (baton->input->autoOrient) {`
`@@ -675,7 +675,7 @@ class PipelineWorker : public Napi::AsyncWorker {`
`675`	`675`
`676`	`676`	`// Verify within current dimensions`
`677`	`677`	`if (compositeImage.width() > image.width() \|\| compositeImage.height() > image.height()) {`
`678`		`- throw vips::VError("Image to composite must have same dimensions or smaller");`
	`678`	`+ throw std::runtime_error("Image to composite must have same dimensions or smaller");`
`679`	`679`	`}`
`680`	`680`	`// Check if overlay is tiled`
`681`	`681`	`if (composite->tile) {`
`@@ -1086,20 +1086,19 @@ class PipelineWorker : public Napi::AsyncWorker {`
`1086`	`1086`	`// Get raw image data`
`1087`	`1087`	`baton->bufferOut = static_cast<char*>(image.write_to_memory(&baton->bufferOutLength));`
`1088`	`1088`	`if (baton->bufferOut == nullptr) {`
`1089`		`- (baton->err).append("Could not allocate enough memory for raw output");`
`1090`		`- return Error();`
	`1089`	`+ throw std::runtime_error("Could not allocate enough memory for raw output");`
`1091`	`1090`	`}`
`1092`	`1091`	`baton->formatOut = "raw";`
`1093`	`1092`	`} else {`
`1094`	`1093`	`// Unsupported output format`
`1095`		`- (baton->err).append("Unsupported output format ");`
	`1094`	`+ auto unsupported = std::string("Unsupported output format ");`
`1096`	`1095`	`if (baton->formatOut == "input") {`
`1097`		`- (baton->err).append("when trying to match input format of ");`
`1098`		`- (baton->err).append(ImageTypeId(inputImageType));`
	`1096`	`+ unsupported.append("when trying to match input format of ");`
	`1097`	`+ unsupported.append(ImageTypeId(inputImageType));`
`1099`	`1098`	`} else {`
`1100`		`- (baton->err).append(baton->formatOut);`
	`1099`	`+ unsupported.append(baton->formatOut);`
`1101`	`1100`	`}`
`1102`		`- return Error();`
	`1101`	`+ throw std::runtime_error(unsupported);`
`1103`	`1102`	`}`
`1104`	`1103`	`} else {`
`1105`	`1104`	`// File output`
`@@ -1274,7 +1273,7 @@ class PipelineWorker : public Napi::AsyncWorker {`
`1274`	`1273`	`return Error();`
`1275`	`1274`	`}`
`1276`	`1275`	`}`
`1277`		`- } catch (vips::VError const &err) {`
	`1276`	`+ } catch (std::runtime_error const &err) {`
`1278`	`1277`	`char const *what = err.what();`
`1279`	`1278`	`if (what && what[0]) {`
`1280`	`1279`	`(baton->err).append(what);`
`@@ -1306,7 +1305,6 @@ class PipelineWorker : public Napi::AsyncWorker {`
`1306`	`1305`	`}`
`1307`	`1306`	`warning = sharp::VipsWarningPop();`
`1308`	`1307`	`}`
`1309`		`-`
`1310`	`1308`	`if (baton->err.empty()) {`
`1311`	`1309`	`int width = baton->width;`
`1312`	`1310`	`int height = baton->height;`
`@@ -1407,7 +1405,7 @@ class PipelineWorker : public Napi::AsyncWorker {`
`1407`	`1405`
`1408`	`1406`	`void MultiPageUnsupported(int const pages, std::string op) {`
`1409`	`1407`	`if (pages > 1) {`
`1410`		`- throw vips::VError(op + " is not supported for multi-page images");`
	`1408`	`+ throw std::runtime_error(op + " is not supported for multi-page images");`
`1411`	`1409`	`}`
`1412`	`1410`	`}`
`1413`	`1411`