whalibmob 5.10.8 → 5.10.9

package/README.md

@@ -1791,9 +1791,11 @@ Photos and videos are sent with an inline preview so they show up in the chat
 directly, rather than as a placeholder the recipient has to tap. The dimensions
 are read out of the file header with no dependency at all. The preview itself
 uses `jimp` (installed automatically as an optional dependency) or `sharp` if
-you have it; failing both, a photo that carries an EXIF thumbnail still gets
-one. Video previews need `ffmpeg` on PATH — on Termux, `pkg install ffmpeg`.
-Without any of these the media still sends, just without the preview.
+you have it; failing both, a photo that carries an EXIF thumbnail gets one for
+free, and anything else is scaled in process — JPEG, PNG, GIF and BMP all work
+with nothing installed. Video previews need `ffmpeg` on PATH — on Termux,
+`pkg install ffmpeg`. Without any of these the media still sends, just without
+the preview.
 
 ### Image Message
 
@@ -2180,8 +2182,25 @@ rather than refused — so an unprepared file fails as a timeout that looks like
 network fault. The image is cropped square, scaled and written out as a fresh
 JPEG, which also strips EXIF and any progressive encoding the file was carrying.
 
-This needs `jimp` (an optional dependency) or `sharp`. Without either, the file
-is sent as it is and an already-correct picture still works.
+**No image library is required.** JPEG, PNG, GIF and BMP are decoded, cropped
+and re-encoded in process, so a bare `npm install` on a phone or a container
+built without a compiler converts a picture just as well as a full desktop.
+Whatever is installed is preferred, and the fallbacks run in this order:
+
+| | Handles | Needs |
+|---|---|---|
+| `sharp` or `jimp` | everything, best quality | either installed |
+| built in | JPEG, PNG, GIF, BMP | nothing |
+| `ffmpeg` | WebP, HEIC, progressive JPEG | `ffmpeg` on PATH |
+| metadata strip | an already-square JPEG | nothing |
+
+The built-in converter also reads the EXIF orientation tag, so a photo taken in
+portrait is turned upright instead of arriving on its side, and flattens
+transparency onto white, since a JPEG has no alpha channel.
+
+Only an exotic format with nothing installed — a WebP or a HEIC on a machine
+with no `ffmpeg` — still fails, and the error says so rather than reporting a
+bare `406`.
 
 ```js
 // skip the re-encode if you have prepared the image yourself
@@ -3133,11 +3152,16 @@ about updated
 
 #### CLI Change Profile Picture
 
-Reads the image from disk and uploads it as your profile picture. Supported formats: JPEG, PNG.
+Reads the image from disk, crops it square, scales it to 640×640 and uploads it
+as your profile picture. JPEG, PNG, GIF and BMP need nothing installed; WebP and
+HEIC need `ffmpeg` or `jimp`.
 
 ```sh
 wa> /photo ./avatar.jpg
-profile picture updated
+profile picture updated  id=1753912045
+
+wa> /photo remove
+profile picture removed
 ```
 
 #### CLI Change Privacy Settings

package/cli.js

@@ -447,7 +447,7 @@ const HELP = `
   Profile
     /name    <text>                          change display name
     /about   <text>                          change own bio / about text
-    /photo   <file>|remove                   change or remove own profile picture (JPEG)
+    /photo   <file>|remove                   change or remove own profile picture (any image)
     /privacy [<type> <value>]                show or change privacy settings
                                                types:  last_seen profile_picture status
                                                        online read_receipts groups_add

package/lib/Client.js

@@ -10,7 +10,7 @@ const { NoiseSocket }     = require('./noise');
 const { MessageSender, generateMessageId, makeJid, buildOrGetAdvIdentity } = require('./messages/MessageSender');
 const { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, assertRegistrationKeys, fetchIosVersion, fetchWaVersion } = require('./Registration');
 const { getDeviceConfig } = require('./DeviceConfig');
-const { prepareProfilePicture } = require('./MediaThumbnail');
+const { prepareProfilePicture, probeImageSize, canDecodeImage } = require('./MediaThumbnail');
 const { createNewStore, saveStore, loadStore, toSixParts, fromSixParts } = require('./Store');
 const { BinaryNode }      = require('./BinaryNode');
 const { AppStateStore, COLLECTIONS } = require('./appstate/AppStateStore');
@@ -252,6 +252,38 @@ function describeNodeBriefly(node, depth) {
   return out + '/>';
 }
 
+// Say why a picture was turned down, from what can be read off the file.
+//
+// "not acceptable" is all the server offers, so the useful part is what we can
+// work out ourselves: what the image is, whether it is square, and whether
+// anything was available to fix it before it went out.
+function _pictureRejected(what, picture, original, opts) {
+  const size = picture ? probeImageSize(picture) : null;
+  const bits = ['the server would not take this image (406 not-acceptable)'];
+
+  if (size && size.width && size.height) {
+    bits.push('it went out as ' + size.width + 'x' + size.height +
+      (size.width === size.height ? '' : ', which is not square'));
+  }
+  const isJpeg = picture && picture[0] === 0xff && picture[1] === 0xd8;
+  if (picture && !isJpeg) bits.push('and it is not a JPEG');
+
+  if (opts && opts.raw) {
+    bits.push('this call passed { raw: true }, so the file was sent exactly as given');
+  } else if (!isJpeg && original && !canDecodeImage(original)) {
+    // WebP, HEIC and the like need an outside converter; everything ordinary
+    // is handled without one.
+    bits.push('this format could not be converted here — install ffmpeg, or ' +
+      'save the picture as a JPEG or PNG first');
+  } else {
+    bits.push('the picture was cropped square and re-encoded before sending, ' +
+      'so the file itself is unlikely to be the problem — the account may not ' +
+      'be allowed to set one');
+  }
+
+  return what + ': ' + bits.join('. ') + '.';
+}
+
 function getNodeContent(node) {
   if (!node) return null;
   if (Buffer.isBuffer(node.content)) return node.content;
@@ -4365,15 +4397,16 @@ class WhalibmobClient extends EventEmitter {
         'The server drops a picture it will not take rather than refusing it, so ' +
         'this usually means the image was not in the form it wants' +
         (opts.raw ? ' — this call passed { raw: true }, so nothing was re-encoded'
-                  : '. Install jimp if it is not present, so the image can be ' +
-                    're-encoded before sending') + '.');
+                  : '') + '.');
     }
     if (resp.attrs && resp.attrs.type === 'error') {
       const errNode = findChild(resp, 'error');
       const code    = errNode && errNode.attrs && errNode.attrs.code;
+      if (String(code) === '406') {
+        throw new Error(_pictureRejected('changeProfilePicture', picture, buf, opts));
+      }
       throw new Error('changeProfilePicture: ' +
-        (String(code) === '406' ? 'the image was rejected (must be a JPEG)'
-       : String(code) === '401' ? 'not authorised to change this picture'
+        (String(code) === '401' ? 'not authorised to change this picture'
        : 'server rejected the request' + (code ? ' (' + code + ')' : '')));
     }
 
@@ -5960,9 +5993,11 @@ class WhalibmobClient extends EventEmitter {
     if (resp.attrs && resp.attrs.type === 'error') {
       const errNode = findChild(resp, 'error');
       const code    = errNode && errNode.attrs && errNode.attrs.code;
+      if (String(code) === '406') {
+        throw new Error(_pictureRejected('changeGroupPicture', picture, buf, opts));
+      }
       throw new Error('changeGroupPicture: ' +
-        (String(code) === '406' ? 'the image was rejected (must be a JPEG)'
-       : String(code) === '403' ? 'you are not allowed to change this group picture'
+        (String(code) === '403' ? 'you are not allowed to change this group picture'
        : 'server rejected the request' + (code ? ' (' + code + ')' : '')));
     }
     if (!buf) return 'remove';

package/lib/MediaThumbnail.js

@@ -15,7 +15,8 @@
 //     GIF and BMP — with no library at all.
 //   • The thumbnail is made with sharp or jimp when either is installed. When
 //     neither is, a JPEG that carries an EXIF thumbnail (which is to say, most
-//     photos taken on a phone) still yields one, again with no library.
+//     photos taken on a phone) yields one for free, and anything else goes
+//     through the decoder in lib/image — still with nothing installed.
 //   • Video frames need ffmpeg. Without it the video still sends, just without
 //     an inline preview.
 //
@@ -30,6 +31,8 @@ const path = require('path');
 const crypto = require('crypto');
 const { execFile } = require('child_process');
 
+const { toSquareJpeg, toScaledJpeg, canDecode: canDecodeImage } = require('./image');
+
 // The preview is deliberately tiny; it is only ever shown blurred behind the
 // real image while that downloads.
 const THUMB_WIDTH   = 32;
@@ -220,8 +223,8 @@ async function loadImageLib() {
     }
   } catch (_) {}
 
-  _whaDbg('[DBG] THUMB no image library — install jimp for inline previews ' +
-    'on images an EXIF thumbnail cannot cover');
+  _whaDbg('[DBG] THUMB no image library — falling back to the built-in ' +
+    'decoder, which reads JPEG, PNG, GIF and BMP');
   return _imageLib;
 }
 
@@ -277,16 +280,32 @@ async function imageThumbnail(buf, opts) {
     _whaDbg('[DBG] THUMB image library failed: ' + (err && err.message));
   }
 
-  // No library, or it could not read this file — fall back to whatever the
-  // camera already embedded.
+  // No library, or it could not read this file. The camera's own embedded
+  // preview is the cheapest thing left, and on a phone photo it is usually
+  // there — a few kilobytes already sized about right.
   const exif = extractExifThumbnail(buf);
   if (exif) {
     out.thumbnail = exif;
     _whaDbg('[DBG] THUMB using embedded EXIF thumbnail (' + exif.length + ' bytes)');
-  } else {
-    _whaDbg('[DBG] THUMB none available — the image will show as a download ' +
-      'placeholder; install jimp to fix');
+    return out;
+  }
+
+  // Otherwise scale it here. Slower than a library, but a preview is 32 pixels
+  // wide and this is the difference between the picture showing in the chat and
+  // a grey download placeholder.
+  try {
+    const built = toScaledJpeg(buf, width, quality);
+    if (built && built.length) {
+      out.thumbnail = built;
+      _whaDbg('[DBG] THUMB made in-process (' + built.length + ' bytes)');
+      return out;
+    }
+  } catch (err) {
+    _whaDbg('[DBG] THUMB built-in scaler failed: ' + (err && err.message));
   }
+
+  _whaDbg('[DBG] THUMB none available — the image will show as a download ' +
+    'placeholder; install jimp to fix');
   return out;
 }
 
@@ -301,13 +320,22 @@ const AVATAR_QUALITY = 50;
 /**
  * Re-encode an image into the form a profile picture has to be in.
  *
- * Cropped square from the top-left of the shorter side, scaled to 640x640, and
- * written out as a fresh JPEG. Re-encoding is the point rather than a side
- * effect: it strips EXIF, progressive scans and unusual chroma subsampling —
- * anything the file happened to carry — and produces a plain baseline JPEG.
+ * Cropped square, scaled to 640x640, and written out as a fresh JPEG.
+ * Re-encoding is the point rather than a side effect: it strips EXIF,
+ * progressive scans and unusual chroma subsampling — anything the file happened
+ * to carry — and produces a plain baseline JPEG.
  *
- * Returns the original buffer untouched when no image library is installed,
- * which at least gives an already-correct picture a chance to go through.
+ * Four converters are tried in turn, so a picture goes through whatever the
+ * machine happens to have:
+ *
+ *   1. sharp or jimp, when one is installed — the best quality and the widest
+ *      range of formats.
+ *   2. the built-in converter, which reads JPEG, PNG, GIF and BMP with no
+ *      dependency at all. This is the one that runs on a bare install.
+ *   3. ffmpeg, which covers what the built-in one does not: WebP, HEIC,
+ *      progressive JPEG.
+ *   4. failing all of that, the file with its metadata segments stripped, which
+ *      at least gives an already-square JPEG a chance.
  */
 async function prepareProfilePicture(buf, opts) {
   opts = opts || {};
@@ -345,15 +373,130 @@ async function prepareProfilePicture(buf, opts) {
       return await img.getBufferAsync(Jimp.MIME_JPEG);
     }
   } catch (err) {
-    _whaDbg('[DBG] AVATAR could not re-encode: ' + (err && err.message));
-    return buf;
+    _whaDbg('[DBG] AVATAR image library failed: ' + (err && err.message));
+  }
+
+  // No image library, or it could not read this file. The built-in converter
+  // needs nothing installed and handles the formats a picture is usually in.
+  try {
+    const built = toSquareJpeg(buf, size, quality);
+    if (built && built.length) {
+      _whaDbg('[DBG] AVATAR converted in-process to ' + size + 'x' + size +
+        ' (' + buf.length + ' → ' + built.length + ' bytes)');
+      return built;
+    }
+  } catch (err) {
+    _whaDbg('[DBG] AVATAR built-in converter failed: ' + (err && err.message));
+  }
+
+  // A format the built-in decoder does not read — WebP, HEIC, a progressive
+  // JPEG. ffmpeg can do the same job and is already used by the video path, so
+  // try it before giving up.
+  const viaFfmpeg = await avatarViaFfmpeg(buf, size, quality);
+  if (viaFfmpeg) return viaFfmpeg;
+
+  // Nothing that can re-encode. Strip the metadata segments at least: EXIF and
+  // the other APPn blocks are the part of an ordinary camera JPEG the server
+  // most often will not take, and removing them needs no decoder — the image
+  // data is left exactly as it was.
+  const stripped = stripJpegMetadata(buf);
+  if (stripped !== buf) {
+    _whaDbg('[DBG] AVATAR no converter — sent with metadata stripped (' +
+      buf.length + ' → ' + stripped.length + ' bytes). Install jimp or ffmpeg ' +
+      'to have the image resized properly.');
+    return stripped;
   }
 
-  _whaDbg('[DBG] AVATAR no image library — sending the file as it is. ' +
-    'WhatsApp wants a square JPEG; install jimp to have that done for you.');
+  _whaDbg('[DBG] AVATAR nothing could read this file — sending it as it is. ' +
+    'WhatsApp wants a square JPEG; JPEG, PNG, GIF and BMP are converted here ' +
+    'on their own, and ffmpeg or jimp covers the rest.');
   return buf;
 }
 
+/**
+ * Crop square and resize with ffmpeg, which needs no native npm module.
+ *
+ * Returns null when ffmpeg is not installed or cannot read the file, so the
+ * caller can carry on to the next fallback.
+ */
+async function avatarViaFfmpeg(buf, size, quality) {
+  if (!(await hasFfmpeg())) return null;
+
+  const src = tmpFile('.img');
+  const dst = tmpFile('.jpg');
+  try {
+    fs.writeFileSync(src, buf);
+    // Crop to the shorter side, scale, and write baseline JPEG. -q:v runs 2..31
+    // worst-to-best in ffmpeg, the opposite way round to a percentage quality.
+    const q = Math.max(2, Math.min(31, Math.round(31 - (quality / 100) * 29)));
+    const ok = await run('ffmpeg', [
+      '-y', '-i', src,
+      '-vf', "crop='min(iw,ih)':'min(iw,ih)',scale=" + size + ':' + size,
+      '-q:v', String(q),
+      '-f', 'mjpeg',
+      dst
+    ]);
+    if (ok === null) return null;
+    const out = fs.readFileSync(dst);
+    if (!out.length || out[0] !== 0xff || out[1] !== 0xd8) return null;
+    _whaDbg('[DBG] AVATAR re-encoded with ffmpeg (' + out.length + ' bytes)');
+    return out;
+  } catch (err) {
+    _whaDbg('[DBG] AVATAR ffmpeg failed: ' + (err && err.message));
+    return null;
+  } finally {
+    try { fs.unlinkSync(src); } catch (_) {}
+    try { fs.unlinkSync(dst); } catch (_) {}
+  }
+}
+
+/**
+ * Drop every APPn segment from a JPEG, keeping the image itself byte for byte.
+ *
+ * EXIF, ICC profiles, thumbnails and camera maker notes all live in these, and
+ * a picture that carries them is the ordinary case a phone produces. Removing
+ * them takes no decoder — it is a walk over the segment headers — so it works
+ * where nothing else is installed.
+ *
+ * Returns the input unchanged when it is not a JPEG or has nothing to drop.
+ */
+function stripJpegMetadata(buf) {
+  if (!Buffer.isBuffer(buf) || buf.length < 4) return buf;
+  if (buf[0] !== 0xff || buf[1] !== 0xd8) return buf;   // not a JPEG
+
+  const keep = [buf.slice(0, 2)];
+  let i = 2, dropped = 0;
+
+  while (i + 4 <= buf.length) {
+    if (buf[i] !== 0xff) break;                 // out of step; leave the rest be
+    const marker = buf[i + 1];
+
+    // Start of scan — everything from here is entropy-coded image data.
+    if (marker === 0xda) { keep.push(buf.slice(i)); i = buf.length; break; }
+    // Standalone markers carry no length.
+    if (marker === 0xd8 || (marker >= 0xd0 && marker <= 0xd9)) {
+      keep.push(buf.slice(i, i + 2)); i += 2; continue;
+    }
+
+    const len = buf.readUInt16BE(i + 2);
+    if (len < 2 || i + 2 + len > buf.length) break;     // malformed; stop here
+    const seg = buf.slice(i, i + 2 + len);
+
+    // APP0 is the JFIF header, which is the one to keep; APP1..APPF and the
+    // comment segment are metadata.
+    const isAppN    = marker >= 0xe1 && marker <= 0xef;
+    const isComment = marker === 0xfe;
+    if (isAppN || isComment) dropped += seg.length;
+    else keep.push(seg);
+
+    i += 2 + len;
+  }
+
+  if (!dropped) return buf;
+  if (i < buf.length) keep.push(buf.slice(i));
+  return Buffer.concat(keep);
+}
+
 // ─── ffmpeg ──────────────────────────────────────────────────────────────────
 
 function run(cmd, args) {
@@ -450,6 +593,8 @@ module.exports = {
   extractExifThumbnail,
   imageThumbnail,
   prepareProfilePicture,
+  stripJpegMetadata,
+  canDecodeImage,
   videoThumbnail,
   hasFfmpeg,
   THUMB_WIDTH,

package/lib/image/Bmp.js

@@ -0,0 +1,94 @@
+'use strict';
+
+// BMP → RGBA.
+//
+// Uncompressed only, which is all but every BMP in the wild: 1/4/8-bit through
+// the palette, and 16/24/32-bit direct. Rows are padded to four bytes and are
+// stored bottom-up unless the height is negative.
+
+function isBmp(buf) {
+  return Buffer.isBuffer(buf) && buf.length > 26 && buf[0] === 0x42 && buf[1] === 0x4d;
+}
+
+function decodeBmp(buf) {
+  if (!isBmp(buf)) return null;
+
+  const dataOffset = buf.readUInt32LE(10);
+  const headerSize = buf.readUInt32LE(14);
+  if (headerSize < 12) return null;
+
+  let width, height, bpp, compression = 0, paletteCount = 0;
+  if (headerSize === 12) {                       // BITMAPCOREHEADER
+    width  = buf.readInt16LE(18);
+    height = buf.readInt16LE(20);
+    bpp    = buf.readUInt16LE(24);
+  } else {
+    width  = buf.readInt32LE(18);
+    height = buf.readInt32LE(22);
+    bpp    = buf.readUInt16LE(28);
+    compression  = buf.readUInt32LE(30);
+    paletteCount = buf.readUInt32LE(46);
+  }
+
+  const bottomUp = height > 0;
+  height = Math.abs(height);
+  if (!width || !height || width < 0) return null;
+  if (compression !== 0 && compression !== 3) return null;   // RLE, JPEG, PNG
+  if (![1, 4, 8, 16, 24, 32].includes(bpp)) return null;
+
+  // The palette sits between the header and the pixel data.
+  const paletteStart = 14 + headerSize;
+  const entrySize    = headerSize === 12 ? 3 : 4;
+  if (!paletteCount && bpp <= 8) paletteCount = 1 << bpp;
+
+  const rowBytes = Math.floor((width * bpp + 31) / 32) * 4;
+  if (dataOffset + rowBytes * height > buf.length) return null;
+
+  const out = Buffer.alloc(width * height * 4, 0xff);
+
+  for (let y = 0; y < height; y++) {
+    const srcRow = dataOffset + (bottomUp ? (height - 1 - y) : y) * rowBytes;
+    for (let x = 0; x < width; x++) {
+      let r, g, b, a = 255;
+
+      if (bpp <= 8) {
+        const perByte = 8 / bpp;
+        const byte    = buf[srcRow + Math.floor(x / perByte)];
+        const shift   = 8 - bpp * ((x % perByte) + 1);
+        const idx     = (byte >> shift) & ((1 << bpp) - 1);
+        const p       = paletteStart + idx * entrySize;
+        if (idx >= paletteCount || p + 2 >= buf.length) { r = g = b = 0; }
+        else { b = buf[p]; g = buf[p + 1]; r = buf[p + 2]; }
+      } else if (bpp === 16) {
+        // 5-5-5 with the top bit unused, widened back out to eight bits each.
+        const v = buf.readUInt16LE(srcRow + x * 2);
+        r = ((v >> 10) & 31) * 255 / 31;
+        g = ((v >> 5)  & 31) * 255 / 31;
+        b = (v & 31)         * 255 / 31;
+        r = Math.round(r); g = Math.round(g); b = Math.round(b);
+      } else {
+        const p = srcRow + x * (bpp / 8);
+        b = buf[p]; g = buf[p + 1]; r = buf[p + 2];
+        if (bpp === 32) {
+          const alpha = buf[p + 3];
+          // A 32-bit BMP often leaves the fourth byte at zero rather than
+          // meaning fully transparent; treat an all-zero channel as opaque.
+          a = alpha;
+        }
+      }
+
+      const o = (y * width + x) * 4;
+      out[o] = r; out[o + 1] = g; out[o + 2] = b; out[o + 3] = a;
+    }
+  }
+
+  if (bpp === 32) {
+    let anyAlpha = false;
+    for (let i = 3; i < out.length; i += 4) if (out[i] !== 0) { anyAlpha = true; break; }
+    if (!anyAlpha) for (let i = 3; i < out.length; i += 4) out[i] = 255;
+  }
+
+  return { width, height, data: out };
+}
+
+module.exports = { isBmp, decodeBmp };

package/lib/image/Gif.js

@@ -0,0 +1,186 @@
+'use strict';
+
+// GIF → RGBA, first frame only.
+//
+// A profile picture is a still, so an animation is read down to the image it
+// opens on. The pixels are LZW-coded with a code width that grows as the
+// dictionary fills — about forty lines of it, and the rest is walking the block
+// structure to find where the frame starts.
+
+function isGif(buf) {
+  return Buffer.isBuffer(buf) && buf.length > 13 &&
+         buf.slice(0, 3).toString('latin1') === 'GIF';
+}
+
+function decodeGif(buf) {
+  if (!isGif(buf)) return null;
+
+  const screenWidth  = buf.readUInt16LE(6);
+  const screenHeight = buf.readUInt16LE(8);
+  const packed       = buf[10];
+  const hasGlobal    = !!(packed & 0x80);
+  const globalSize   = 2 << (packed & 7);
+
+  let pos = 13;
+  let globalPalette = null;
+  if (hasGlobal) {
+    globalPalette = buf.slice(pos, pos + globalSize * 3);
+    pos += globalSize * 3;
+  }
+
+  let transparentIndex = -1;
+
+  while (pos < buf.length) {
+    const block = buf[pos];
+
+    if (block === 0x21) {                       // extension
+      const label = buf[pos + 1];
+      pos += 2;
+      if (label === 0xf9 && buf[pos] >= 4) {    // graphic control
+        if (buf[pos + 1] & 1) transparentIndex = buf[pos + 4];
+      }
+      pos = skipBlocks(buf, pos);
+      continue;
+    }
+
+    if (block === 0x2c) {                       // image descriptor
+      const left   = buf.readUInt16LE(pos + 1);
+      const top    = buf.readUInt16LE(pos + 3);
+      const width  = buf.readUInt16LE(pos + 5);
+      const height = buf.readUInt16LE(pos + 7);
+      const flags  = buf[pos + 9];
+      pos += 10;
+
+      let palette = globalPalette;
+      if (flags & 0x80) {
+        const localSize = 2 << (flags & 7);
+        palette = buf.slice(pos, pos + localSize * 3);
+        pos += localSize * 3;
+      }
+      if (!palette) return null;
+      const interlaced = !!(flags & 0x40);
+
+      const minCodeSize = buf[pos];
+      pos++;
+      const data = gatherBlocks(buf, pos);
+      if (!data) return null;
+
+      const indices = lzw(data, minCodeSize, width * height);
+      if (!indices) return null;
+
+      return paint(indices, width, height, left, top,
+        screenWidth || width, screenHeight || height,
+        palette, transparentIndex, interlaced);
+    }
+
+    if (block === 0x3b) break;                  // trailer
+    pos++;                                      // anything unexpected: step on
+  }
+
+  return null;
+}
+
+// Sub-blocks are length-prefixed and end with a zero length.
+function skipBlocks(buf, pos) {
+  while (pos < buf.length && buf[pos] !== 0) pos += buf[pos] + 1;
+  return pos + 1;
+}
+
+function gatherBlocks(buf, pos) {
+  const parts = [];
+  while (pos < buf.length && buf[pos] !== 0) {
+    const len = buf[pos];
+    if (pos + 1 + len > buf.length) return null;
+    parts.push(buf.slice(pos + 1, pos + 1 + len));
+    pos += len + 1;
+  }
+  return Buffer.concat(parts);
+}
+
+// Variable-width LZW. The dictionary starts with one entry per colour plus a
+// clear code and an end code, and every new entry is a previous one with one
+// more pixel on the end.
+function lzw(data, minCodeSize, expected) {
+  if (minCodeSize < 2 || minCodeSize > 8) return null;
+
+  const clearCode = 1 << minCodeSize;
+  const endCode   = clearCode + 1;
+  const out       = new Uint8Array(expected);
+
+  let dict = [], codeSize = 0, next = 0;
+  const reset = () => {
+    dict = new Array(clearCode + 2);
+    for (let i = 0; i < clearCode; i++) dict[i] = [i];
+    codeSize = minCodeSize + 1;
+    next     = clearCode + 2;
+  };
+  reset();
+
+  let bitPos = 0, written = 0, prev = null;
+  const totalBits = data.length * 8;
+
+  while (written < expected && bitPos + codeSize <= totalBits) {
+    let code = 0;
+    for (let i = 0; i < codeSize; i++) {
+      const b = bitPos + i;
+      code |= ((data[b >> 3] >> (b & 7)) & 1) << i;   // codes are little-endian
+    }
+    bitPos += codeSize;
+
+    if (code === clearCode) { reset(); prev = null; continue; }
+    if (code === endCode) break;
+
+    let entry;
+    if (code < next && dict[code]) entry = dict[code];
+    else if (prev) entry = prev.concat(prev[0]);       // the KwKwK case
+    else break;
+
+    for (let i = 0; i < entry.length && written < expected; i++) out[written++] = entry[i];
+
+    if (prev) {
+      dict[next++] = prev.concat(entry[0]);
+      if (next === (1 << codeSize) && codeSize < 12) codeSize++;
+    }
+    prev = entry;
+  }
+
+  return out;
+}
+
+function paint(indices, width, height, left, top, canvasW, canvasH,
+               palette, transparentIndex, interlaced) {
+  const out = Buffer.alloc(canvasW * canvasH * 4, 0);
+
+  // An interlaced frame arrives in four passes over every eighth, fourth and
+  // second row in turn.
+  const rowOf = interlaced ? interlacedRows(height) : null;
+
+  for (let y = 0; y < height; y++) {
+    const dy = (rowOf ? rowOf[y] : y) + top;
+    if (dy < 0 || dy >= canvasH) continue;
+    for (let x = 0; x < width; x++) {
+      const dx = x + left;
+      if (dx < 0 || dx >= canvasW) continue;
+      const idx = indices[y * width + x];
+      const o   = (dy * canvasW + dx) * 4;
+      if (idx === transparentIndex) { out[o + 3] = 0; continue; }
+      const p = idx * 3;
+      out[o]     = palette[p]     || 0;
+      out[o + 1] = palette[p + 1] || 0;
+      out[o + 2] = palette[p + 2] || 0;
+      out[o + 3] = 255;
+    }
+  }
+
+  return { width: canvasW, height: canvasH, data: out };
+}
+
+function interlacedRows(height) {
+  const rows = [];
+  for (const [start, step] of [[0, 8], [4, 8], [2, 4], [1, 2]]) {
+    for (let y = start; y < height; y += step) rows.push(y);
+  }
+  return rows;
+}
+
+module.exports = { isGif, decodeGif };