payload 4.0.0-internal.cd69eef → 4.0.0-internal.d1cc1d3

package/dist/uploads/getImageSize.spec.js

@@ -0,0 +1,298 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import os from 'os';
+import path from 'path';
+import sharp from 'sharp';
+import { fileURLToPath } from 'url';
+import { afterAll, afterEach, describe, expect, it, vi } from 'vitest';
+import { getImageSize } from './getImageSize.js';
+// Tracks bytes actually read off disk so the streaming test below can assert
+// that a large file's tail is never pulled into memory
+const counters = vi.hoisted(()=>({
+        bytesReadFromDisk: 0
+    }));
+vi.mock('fs', async (importOriginal)=>{
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        createReadStream: (...args)=>{
+            const stream = actual.createReadStream(...args);
+            stream.on('data', (chunk)=>{
+                counters.bytesReadFromDisk += chunk.length;
+            });
+            return stream;
+        }
+    };
+});
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+const fixturesDir = path.resolve(dirname, '../../../../test/uploads');
+// Minimal JPEG XL bare-codestream encoder (bit-packed, little-endian, LSB
+// first). See probeImageSize.spec.ts for the full JXL parsing test suite;
+// this only needs to produce a valid header for the sharp-fallback tests below
+const encodeJXLCodestream = (width, height)=>{
+    const bits = [];
+    const pushBits = (value, length)=>{
+        for(let i = 0; i < length; i++){
+            bits.push(value >> i & 1);
+        }
+    };
+    const pushDimension = (value)=>{
+        const n = value - 1;
+        const sizeClasses = [
+            9,
+            13,
+            18,
+            30
+        ];
+        const classIndex = sizeClasses.findIndex((extraBits)=>n < 2 ** extraBits);
+        pushBits(classIndex, 2);
+        pushBits(n, sizeClasses[classIndex]);
+    };
+    pushBits(0, 1); // isSmallImage = false
+    pushDimension(height);
+    pushBits(0, 3); // widthMode = 0 (explicit dimension)
+    pushDimension(width);
+    const body = Buffer.alloc(Math.ceil(bits.length / 8));
+    bits.forEach((bit, i)=>{
+        if (bit) {
+            body[Math.floor(i / 8)] |= 1 << i % 8;
+        }
+    });
+    return Buffer.concat([
+        Buffer.from([
+            0xff,
+            0x0a
+        ]),
+        body
+    ]);
+};
+const fileFor = (name)=>{
+    const data = readFileSync(path.join(fixturesDir, name));
+    // In-memory uploads carry an empty `tempFilePath`, which must fall back to `data`
+    return {
+        data,
+        mimetype: 'image/test',
+        name,
+        size: data.length,
+        tempFilePath: ''
+    };
+};
+describe('getImageSize', ()=>{
+    const cases = [
+        {
+            file: 'test-image.png',
+            height: 800,
+            width: 800
+        },
+        {
+            file: 'test-image.jpg',
+            height: 800,
+            width: 800
+        },
+        {
+            file: 'non-animated.webp',
+            height: 420,
+            width: 900
+        },
+        {
+            file: 'test-image-avif.avif',
+            height: 800,
+            width: 800
+        },
+        {
+            file: 'image.svg',
+            height: 260,
+            width: 260
+        }
+    ];
+    it.each(cases)('should read $file dimensions via sharp', async ({ file, height, width })=>{
+        expect(await getImageSize({
+            file: fileFor(file),
+            sharp
+        })).toEqual({
+            height,
+            width
+        });
+    });
+    it.each(cases)('should read $file dimensions via the probe fallback', async ({ file, height, width })=>{
+        expect(await getImageSize({
+            file: fileFor(file)
+        })).toEqual({
+            height,
+            width
+        });
+    });
+    it('should fall back to the probe when sharp cannot decode a header-only image', async ()=>{
+        // A 1x1 PNG truncated after IHDR: the header is readable but there is no
+        // pixel data, so sharp throws while the probe still measures it.
+        const data = Buffer.from('89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c489', 'hex');
+        const file = {
+            data,
+            mimetype: 'image/png',
+            name: 'truncated.png',
+            size: data.length,
+            tempFilePath: ''
+        };
+        expect(await getImageSize({
+            file,
+            sharp
+        })).toEqual({
+            height: 1,
+            width: 1
+        });
+        expect(await getImageSize({
+            file
+        })).toEqual({
+            height: 1,
+            width: 1
+        });
+    });
+    it('should read TIFF dimensions from a tempFilePath without a temp-file workaround', async ()=>{
+        const tempFilePath = path.join(fixturesDir, 'test-image.tiff');
+        const file = {
+            mimetype: 'image/tiff',
+            name: 'test-image.tiff',
+            tempFilePath
+        };
+        expect(await getImageSize({
+            file,
+            sharp
+        })).toEqual({
+            height: 100,
+            width: 200
+        });
+        expect(await getImageSize({
+            file
+        })).toEqual({
+            height: 100,
+            width: 200
+        });
+    });
+    describe('sharp cannot decode JPEG XL', ()=>{
+        const tempDir = mkdtempSync(path.join(os.tmpdir(), 'payload-get-image-size-jxl-'));
+        afterAll(()=>{
+            rmSync(tempDir, {
+                recursive: true,
+                force: true
+            });
+        });
+        it('should fall back to the probe for an in-memory JPEG XL buffer', async ()=>{
+            // `isImage('image/jxl')` is true, so `generateFileData` always calls
+            // `getImageSize` with `sharp` for JXL uploads; sharp rejects the format
+            // (libvips has no JXL codec) and the probe must take over
+            const data = encodeJXLCodestream(1920, 1080);
+            const file = {
+                data,
+                mimetype: 'image/jxl',
+                name: 'test.jxl',
+                size: data.length,
+                tempFilePath: ''
+            };
+            expect(await getImageSize({
+                file,
+                sharp
+            })).toEqual({
+                height: 1080,
+                width: 1920
+            });
+        });
+        it('should fall back to the probe for a JPEG XL tempFilePath', async ()=>{
+            const tempFilePath = path.join(tempDir, 'test.jxl');
+            writeFileSync(tempFilePath, encodeJXLCodestream(640, 480));
+            const file = {
+                mimetype: 'image/jxl',
+                name: 'test.jxl',
+                tempFilePath
+            };
+            expect(await getImageSize({
+                file,
+                sharp
+            })).toEqual({
+                height: 480,
+                width: 640
+            });
+        });
+    });
+    describe('streaming from tempFilePath', ()=>{
+        const tempDir = mkdtempSync(path.join(os.tmpdir(), 'payload-get-image-size-'));
+        afterEach(()=>{
+            counters.bytesReadFromDisk = 0;
+        });
+        afterAll(()=>{
+            rmSync(tempDir, {
+                recursive: true,
+                force: true
+            });
+        });
+        it('should not read a whole large PNG into memory when probing via tempFilePath', async ()=>{
+            // image-dimensions only reads the PNG signature (bytes 0-7) and the
+            // width/height fields (bytes 16-23); everything else here is filler
+            const header = Buffer.alloc(24);
+            header.write('\x89PNG\r\n\x1a\n', 0, 'binary');
+            header.writeUInt32BE(1920, 16);
+            header.writeUInt32BE(1080, 20);
+            const largeFileSize = 3 * 1024 * 1024;
+            const largeFile = Buffer.concat([
+                header,
+                Buffer.alloc(largeFileSize)
+            ]);
+            const tempFilePath = path.join(tempDir, 'large.png');
+            writeFileSync(tempFilePath, largeFile);
+            const file = {
+                mimetype: 'image/png',
+                name: 'large.png',
+                tempFilePath
+            };
+            expect(await getImageSize({
+                file
+            })).toEqual({
+                height: 1080,
+                width: 1920
+            });
+            // Confirms the read actually went through `createReadStream` rather
+            // than skipping it entirely (which would trivially satisfy "< 500KB")
+            expect(counters.bytesReadFromDisk).toBeGreaterThan(0);
+            expect(counters.bytesReadFromDisk).toBeLessThan(500 * 1024);
+            expect(counters.bytesReadFromDisk).toBeLessThan(largeFile.length);
+        });
+        it.each(cases.filter(({ file })=>file !== 'image.svg'))('should read $file dimensions via imageDimensionsFromStream when streamed from a tempFilePath', async ({ file, height, width })=>{
+            const tempFilePath = path.join(tempDir, file);
+            writeFileSync(tempFilePath, readFileSync(path.join(fixturesDir, file)));
+            const streamedFile = {
+                mimetype: 'image/test',
+                name: file,
+                tempFilePath
+            };
+            expect(await getImageSize({
+                file: streamedFile
+            })).toEqual({
+                height,
+                width
+            });
+        });
+        it('should read GIF dimensions when streamed from a tempFilePath', async ()=>{
+            // No GIF fixture lives in this directory; `image-dimensions` only needs
+            // the 6-byte signature plus the 4-byte width/height fields that follow it
+            const header = Buffer.concat([
+                Buffer.from('GIF89a', 'ascii'),
+                Buffer.alloc(4)
+            ]);
+            header.writeUInt16LE(64, 6);
+            header.writeUInt16LE(48, 8);
+            const tempFilePath = path.join(tempDir, 'test.gif');
+            writeFileSync(tempFilePath, header);
+            const file = {
+                mimetype: 'image/gif',
+                name: 'test.gif',
+                tempFilePath
+            };
+            expect(await getImageSize({
+                file
+            })).toEqual({
+                height: 48,
+                width: 64
+            });
+        });
+    });
+});
+
+//# sourceMappingURL=getImageSize.spec.js.map

package/dist/uploads/getImageSize.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/getImageSize.spec.ts"],"sourcesContent":["import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport sharp from 'sharp'\nimport { fileURLToPath } from 'url'\nimport { afterAll, afterEach, describe, expect, it, vi } from 'vitest'\n\nimport type { PayloadRequest } from '../types/index.js'\n\nimport { getImageSize } from './getImageSize.js'\n\n// Tracks bytes actually read off disk so the streaming test below can assert\n// that a large file's tail is never pulled into memory\nconst counters = vi.hoisted(() => ({ bytesReadFromDisk: 0 }))\n\nvi.mock('fs', async (importOriginal) => {\n  const actual = await importOriginal<typeof import('fs')>()\n  return {\n    ...actual,\n    createReadStream: (...args: Parameters<typeof actual.createReadStream>) => {\n      const stream = actual.createReadStream(...args)\n      stream.on('data', (chunk: Buffer) => {\n        counters.bytesReadFromDisk += chunk.length\n      })\n      return stream\n    },\n  }\n})\n\nconst dirname = path.dirname(fileURLToPath(import.meta.url))\nconst fixturesDir = path.resolve(dirname, '../../../../test/uploads')\n\n// Minimal JPEG XL bare-codestream encoder (bit-packed, little-endian, LSB\n// first). See probeImageSize.spec.ts for the full JXL parsing test suite;\n// this only needs to produce a valid header for the sharp-fallback tests below\nconst encodeJXLCodestream = (width: number, height: number): Buffer => {\n  const bits: number[] = []\n  const pushBits = (value: number, length: number) => {\n    for (let i = 0; i < length; i++) {\n      bits.push((value >> i) & 1)\n    }\n  }\n  const pushDimension = (value: number) => {\n    const n = value - 1\n    const sizeClasses = [9, 13, 18, 30]\n    const classIndex = sizeClasses.findIndex((extraBits) => n < 2 ** extraBits)\n    pushBits(classIndex, 2)\n    pushBits(n, sizeClasses[classIndex]!)\n  }\n\n  pushBits(0, 1) // isSmallImage = false\n  pushDimension(height)\n  pushBits(0, 3) // widthMode = 0 (explicit dimension)\n  pushDimension(width)\n\n  const body = Buffer.alloc(Math.ceil(bits.length / 8))\n  bits.forEach((bit, i) => {\n    if (bit) {\n      body[Math.floor(i / 8)]! |= 1 << i % 8\n    }\n  })\n\n  return Buffer.concat([Buffer.from([0xff, 0x0a]), body])\n}\n\nconst fileFor = (name: string): PayloadRequest['file'] => {\n  const data = readFileSync(path.join(fixturesDir, name))\n  // In-memory uploads carry an empty `tempFilePath`, which must fall back to `data`\n  return {\n    data,\n    mimetype: 'image/test',\n    name,\n    size: data.length,\n    tempFilePath: '',\n  } as PayloadRequest['file']\n}\n\ndescribe('getImageSize', () => {\n  const cases: Array<{ file: string; height: number; width: number }> = [\n    { file: 'test-image.png', height: 800, width: 800 },\n    { file: 'test-image.jpg', height: 800, width: 800 },\n    { file: 'non-animated.webp', height: 420, width: 900 },\n    { file: 'test-image-avif.avif', height: 800, width: 800 },\n    { file: 'image.svg', height: 260, width: 260 },\n  ]\n\n  it.each(cases)('should read $file dimensions via sharp', async ({ file, height, width }) => {\n    expect(await getImageSize({ file: fileFor(file), sharp })).toEqual({ height, width })\n  })\n\n  it.each(cases)(\n    'should read $file dimensions via the probe fallback',\n    async ({ file, height, width }) => {\n      expect(await getImageSize({ file: fileFor(file) })).toEqual({ height, width })\n    },\n  )\n\n  it('should fall back to the probe when sharp cannot decode a header-only image', async () => {\n    // A 1x1 PNG truncated after IHDR: the header is readable but there is no\n    // pixel data, so sharp throws while the probe still measures it.\n    const data = Buffer.from(\n      '89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c489',\n      'hex',\n    )\n    const file = {\n      data,\n      mimetype: 'image/png',\n      name: 'truncated.png',\n      size: data.length,\n      tempFilePath: '',\n    } as PayloadRequest['file']\n\n    expect(await getImageSize({ file, sharp })).toEqual({ height: 1, width: 1 })\n    expect(await getImageSize({ file })).toEqual({ height: 1, width: 1 })\n  })\n\n  it('should read TIFF dimensions from a tempFilePath without a temp-file workaround', async () => {\n    const tempFilePath = path.join(fixturesDir, 'test-image.tiff')\n    const file = {\n      mimetype: 'image/tiff',\n      name: 'test-image.tiff',\n      tempFilePath,\n    } as PayloadRequest['file']\n\n    expect(await getImageSize({ file, sharp })).toEqual({ height: 100, width: 200 })\n    expect(await getImageSize({ file })).toEqual({ height: 100, width: 200 })\n  })\n\n  describe('sharp cannot decode JPEG XL', () => {\n    const tempDir = mkdtempSync(path.join(os.tmpdir(), 'payload-get-image-size-jxl-'))\n\n    afterAll(() => {\n      rmSync(tempDir, { recursive: true, force: true })\n    })\n\n    it('should fall back to the probe for an in-memory JPEG XL buffer', async () => {\n      // `isImage('image/jxl')` is true, so `generateFileData` always calls\n      // `getImageSize` with `sharp` for JXL uploads; sharp rejects the format\n      // (libvips has no JXL codec) and the probe must take over\n      const data = encodeJXLCodestream(1920, 1080)\n      const file = {\n        data,\n        mimetype: 'image/jxl',\n        name: 'test.jxl',\n        size: data.length,\n        tempFilePath: '',\n      } as PayloadRequest['file']\n\n      expect(await getImageSize({ file, sharp })).toEqual({ height: 1080, width: 1920 })\n    })\n\n    it('should fall back to the probe for a JPEG XL tempFilePath', async () => {\n      const tempFilePath = path.join(tempDir, 'test.jxl')\n      writeFileSync(tempFilePath, encodeJXLCodestream(640, 480))\n\n      const file = {\n        mimetype: 'image/jxl',\n        name: 'test.jxl',\n        tempFilePath,\n      } as PayloadRequest['file']\n\n      expect(await getImageSize({ file, sharp })).toEqual({ height: 480, width: 640 })\n    })\n  })\n\n  describe('streaming from tempFilePath', () => {\n    const tempDir = mkdtempSync(path.join(os.tmpdir(), 'payload-get-image-size-'))\n\n    afterEach(() => {\n      counters.bytesReadFromDisk = 0\n    })\n\n    afterAll(() => {\n      rmSync(tempDir, { recursive: true, force: true })\n    })\n\n    it('should not read a whole large PNG into memory when probing via tempFilePath', async () => {\n      // image-dimensions only reads the PNG signature (bytes 0-7) and the\n      // width/height fields (bytes 16-23); everything else here is filler\n      const header = Buffer.alloc(24)\n      header.write('\\x89PNG\\r\\n\\x1a\\n', 0, 'binary')\n      header.writeUInt32BE(1920, 16)\n      header.writeUInt32BE(1080, 20)\n      const largeFileSize = 3 * 1024 * 1024\n      const largeFile = Buffer.concat([header, Buffer.alloc(largeFileSize)])\n\n      const tempFilePath = path.join(tempDir, 'large.png')\n      writeFileSync(tempFilePath, largeFile)\n\n      const file = {\n        mimetype: 'image/png',\n        name: 'large.png',\n        tempFilePath,\n      } as PayloadRequest['file']\n\n      expect(await getImageSize({ file })).toEqual({ height: 1080, width: 1920 })\n      // Confirms the read actually went through `createReadStream` rather\n      // than skipping it entirely (which would trivially satisfy \"< 500KB\")\n      expect(counters.bytesReadFromDisk).toBeGreaterThan(0)\n      expect(counters.bytesReadFromDisk).toBeLessThan(500 * 1024)\n      expect(counters.bytesReadFromDisk).toBeLessThan(largeFile.length)\n    })\n\n    it.each(cases.filter(({ file }) => file !== 'image.svg'))(\n      'should read $file dimensions via imageDimensionsFromStream when streamed from a tempFilePath',\n      async ({ file, height, width }) => {\n        const tempFilePath = path.join(tempDir, file)\n        writeFileSync(tempFilePath, readFileSync(path.join(fixturesDir, file)))\n\n        const streamedFile = {\n          mimetype: 'image/test',\n          name: file,\n          tempFilePath,\n        } as PayloadRequest['file']\n\n        expect(await getImageSize({ file: streamedFile })).toEqual({ height, width })\n      },\n    )\n\n    it('should read GIF dimensions when streamed from a tempFilePath', async () => {\n      // No GIF fixture lives in this directory; `image-dimensions` only needs\n      // the 6-byte signature plus the 4-byte width/height fields that follow it\n      const header = Buffer.concat([Buffer.from('GIF89a', 'ascii'), Buffer.alloc(4)])\n      header.writeUInt16LE(64, 6)\n      header.writeUInt16LE(48, 8)\n\n      const tempFilePath = path.join(tempDir, 'test.gif')\n      writeFileSync(tempFilePath, header)\n\n      const file = {\n        mimetype: 'image/gif',\n        name: 'test.gif',\n        tempFilePath,\n      } as PayloadRequest['file']\n\n      expect(await getImageSize({ file })).toEqual({ height: 48, width: 64 })\n    })\n  })\n})\n"],"names":["mkdtempSync","readFileSync","rmSync","writeFileSync","os","path","sharp","fileURLToPath","afterAll","afterEach","describe","expect","it","vi","getImageSize","counters","hoisted","bytesReadFromDisk","mock","importOriginal","actual","createReadStream","args","stream","on","chunk","length","dirname","url","fixturesDir","resolve","encodeJXLCodestream","width","height","bits","pushBits","value","i","push","pushDimension","n","sizeClasses","classIndex","findIndex","extraBits","body","Buffer","alloc","Math","ceil","forEach","bit","floor","concat","from","fileFor","name","data","join","mimetype","size","tempFilePath","cases","file","each","toEqual","tempDir","tmpdir","recursive","force","header","write","writeUInt32BE","largeFileSize","largeFile","toBeGreaterThan","toBeLessThan","filter","streamedFile","writeUInt16LE"],"mappings":"AAAA,SAASA,WAAW,EAAEC,YAAY,EAAEC,MAAM,EAAEC,aAAa,QAAQ,KAAI;AACrE,OAAOC,QAAQ,KAAI;AACnB,OAAOC,UAAU,OAAM;AACvB,OAAOC,WAAW,QAAO;AACzB,SAASC,aAAa,QAAQ,MAAK;AACnC,SAASC,QAAQ,EAAEC,SAAS,EAAEC,QAAQ,EAAEC,MAAM,EAAEC,EAAE,EAAEC,EAAE,QAAQ,SAAQ;AAItE,SAASC,YAAY,QAAQ,oBAAmB;AAEhD,6EAA6E;AAC7E,uDAAuD;AACvD,MAAMC,WAAWF,GAAGG,OAAO,CAAC,IAAO,CAAA;QAAEC,mBAAmB;IAAE,CAAA;AAE1DJ,GAAGK,IAAI,CAAC,MAAM,OAAOC;IACnB,MAAMC,SAAS,MAAMD;IACrB,OAAO;QACL,GAAGC,MAAM;QACTC,kBAAkB,CAAC,GAAGC;YACpB,MAAMC,SAASH,OAAOC,gBAAgB,IAAIC;YAC1CC,OAAOC,EAAE,CAAC,QAAQ,CAACC;gBACjBV,SAASE,iBAAiB,IAAIQ,MAAMC,MAAM;YAC5C;YACA,OAAOH;QACT;IACF;AACF;AAEA,MAAMI,UAAUtB,KAAKsB,OAAO,CAACpB,cAAc,YAAYqB,GAAG;AAC1D,MAAMC,cAAcxB,KAAKyB,OAAO,CAACH,SAAS;AAE1C,0EAA0E;AAC1E,0EAA0E;AAC1E,+EAA+E;AAC/E,MAAMI,sBAAsB,CAACC,OAAeC;IAC1C,MAAMC,OAAiB,EAAE;IACzB,MAAMC,WAAW,CAACC,OAAeV;QAC/B,IAAK,IAAIW,IAAI,GAAGA,IAAIX,QAAQW,IAAK;YAC/BH,KAAKI,IAAI,CAAC,AAACF,SAASC,IAAK;QAC3B;IACF;IACA,MAAME,gBAAgB,CAACH;QACrB,MAAMI,IAAIJ,QAAQ;QAClB,MAAMK,cAAc;YAAC;YAAG;YAAI;YAAI;SAAG;QACnC,MAAMC,aAAaD,YAAYE,SAAS,CAAC,CAACC,YAAcJ,IAAI,KAAKI;QACjET,SAASO,YAAY;QACrBP,SAASK,GAAGC,WAAW,CAACC,WAAW;IACrC;IAEAP,SAAS,GAAG,IAAG,uBAAuB;IACtCI,cAAcN;IACdE,SAAS,GAAG,IAAG,qCAAqC;IACpDI,cAAcP;IAEd,MAAMa,OAAOC,OAAOC,KAAK,CAACC,KAAKC,IAAI,CAACf,KAAKR,MAAM,GAAG;IAClDQ,KAAKgB,OAAO,CAAC,CAACC,KAAKd;QACjB,IAAIc,KAAK;YACPN,IAAI,CAACG,KAAKI,KAAK,CAACf,IAAI,GAAG,IAAK,KAAKA,IAAI;QACvC;IACF;IAEA,OAAOS,OAAOO,MAAM,CAAC;QAACP,OAAOQ,IAAI,CAAC;YAAC;YAAM;SAAK;QAAGT;KAAK;AACxD;AAEA,MAAMU,UAAU,CAACC;IACf,MAAMC,OAAOxD,aAAaI,KAAKqD,IAAI,CAAC7B,aAAa2B;IACjD,kFAAkF;IAClF,OAAO;QACLC;QACAE,UAAU;QACVH;QACAI,MAAMH,KAAK/B,MAAM;QACjBmC,cAAc;IAChB;AACF;AAEAnD,SAAS,gBAAgB;IACvB,MAAMoD,QAAgE;QACpE;YAAEC,MAAM;YAAkB9B,QAAQ;YAAKD,OAAO;QAAI;QAClD;YAAE+B,MAAM;YAAkB9B,QAAQ;YAAKD,OAAO;QAAI;QAClD;YAAE+B,MAAM;YAAqB9B,QAAQ;YAAKD,OAAO;QAAI;QACrD;YAAE+B,MAAM;YAAwB9B,QAAQ;YAAKD,OAAO;QAAI;QACxD;YAAE+B,MAAM;YAAa9B,QAAQ;YAAKD,OAAO;QAAI;KAC9C;IAEDpB,GAAGoD,IAAI,CAACF,OAAO,0CAA0C,OAAO,EAAEC,IAAI,EAAE9B,MAAM,EAAED,KAAK,EAAE;QACrFrB,OAAO,MAAMG,aAAa;YAAEiD,MAAMR,QAAQQ;YAAOzD;QAAM,IAAI2D,OAAO,CAAC;YAAEhC;YAAQD;QAAM;IACrF;IAEApB,GAAGoD,IAAI,CAACF,OACN,uDACA,OAAO,EAAEC,IAAI,EAAE9B,MAAM,EAAED,KAAK,EAAE;QAC5BrB,OAAO,MAAMG,aAAa;YAAEiD,MAAMR,QAAQQ;QAAM,IAAIE,OAAO,CAAC;YAAEhC;YAAQD;QAAM;IAC9E;IAGFpB,GAAG,8EAA8E;QAC/E,yEAAyE;QACzE,iEAAiE;QACjE,MAAM6C,OAAOX,OAAOQ,IAAI,CACtB,sEACA;QAEF,MAAMS,OAAO;YACXN;YACAE,UAAU;YACVH,MAAM;YACNI,MAAMH,KAAK/B,MAAM;YACjBmC,cAAc;QAChB;QAEAlD,OAAO,MAAMG,aAAa;YAAEiD;YAAMzD;QAAM,IAAI2D,OAAO,CAAC;YAAEhC,QAAQ;YAAGD,OAAO;QAAE;QAC1ErB,OAAO,MAAMG,aAAa;YAAEiD;QAAK,IAAIE,OAAO,CAAC;YAAEhC,QAAQ;YAAGD,OAAO;QAAE;IACrE;IAEApB,GAAG,kFAAkF;QACnF,MAAMiD,eAAexD,KAAKqD,IAAI,CAAC7B,aAAa;QAC5C,MAAMkC,OAAO;YACXJ,UAAU;YACVH,MAAM;YACNK;QACF;QAEAlD,OAAO,MAAMG,aAAa;YAAEiD;YAAMzD;QAAM,IAAI2D,OAAO,CAAC;YAAEhC,QAAQ;YAAKD,OAAO;QAAI;QAC9ErB,OAAO,MAAMG,aAAa;YAAEiD;QAAK,IAAIE,OAAO,CAAC;YAAEhC,QAAQ;YAAKD,OAAO;QAAI;IACzE;IAEAtB,SAAS,+BAA+B;QACtC,MAAMwD,UAAUlE,YAAYK,KAAKqD,IAAI,CAACtD,GAAG+D,MAAM,IAAI;QAEnD3D,SAAS;YACPN,OAAOgE,SAAS;gBAAEE,WAAW;gBAAMC,OAAO;YAAK;QACjD;QAEAzD,GAAG,iEAAiE;YAClE,qEAAqE;YACrE,wEAAwE;YACxE,0DAA0D;YAC1D,MAAM6C,OAAO1B,oBAAoB,MAAM;YACvC,MAAMgC,OAAO;gBACXN;gBACAE,UAAU;gBACVH,MAAM;gBACNI,MAAMH,KAAK/B,MAAM;gBACjBmC,cAAc;YAChB;YAEAlD,OAAO,MAAMG,aAAa;gBAAEiD;gBAAMzD;YAAM,IAAI2D,OAAO,CAAC;gBAAEhC,QAAQ;gBAAMD,OAAO;YAAK;QAClF;QAEApB,GAAG,4DAA4D;YAC7D,MAAMiD,eAAexD,KAAKqD,IAAI,CAACQ,SAAS;YACxC/D,cAAc0D,cAAc9B,oBAAoB,KAAK;YAErD,MAAMgC,OAAO;gBACXJ,UAAU;gBACVH,MAAM;gBACNK;YACF;YAEAlD,OAAO,MAAMG,aAAa;gBAAEiD;gBAAMzD;YAAM,IAAI2D,OAAO,CAAC;gBAAEhC,QAAQ;gBAAKD,OAAO;YAAI;QAChF;IACF;IAEAtB,SAAS,+BAA+B;QACtC,MAAMwD,UAAUlE,YAAYK,KAAKqD,IAAI,CAACtD,GAAG+D,MAAM,IAAI;QAEnD1D,UAAU;YACRM,SAASE,iBAAiB,GAAG;QAC/B;QAEAT,SAAS;YACPN,OAAOgE,SAAS;gBAAEE,WAAW;gBAAMC,OAAO;YAAK;QACjD;QAEAzD,GAAG,+EAA+E;YAChF,oEAAoE;YACpE,oEAAoE;YACpE,MAAM0D,SAASxB,OAAOC,KAAK,CAAC;YAC5BuB,OAAOC,KAAK,CAAC,qBAAqB,GAAG;YACrCD,OAAOE,aAAa,CAAC,MAAM;YAC3BF,OAAOE,aAAa,CAAC,MAAM;YAC3B,MAAMC,gBAAgB,IAAI,OAAO;YACjC,MAAMC,YAAY5B,OAAOO,MAAM,CAAC;gBAACiB;gBAAQxB,OAAOC,KAAK,CAAC0B;aAAe;YAErE,MAAMZ,eAAexD,KAAKqD,IAAI,CAACQ,SAAS;YACxC/D,cAAc0D,cAAca;YAE5B,MAAMX,OAAO;gBACXJ,UAAU;gBACVH,MAAM;gBACNK;YACF;YAEAlD,OAAO,MAAMG,aAAa;gBAAEiD;YAAK,IAAIE,OAAO,CAAC;gBAAEhC,QAAQ;gBAAMD,OAAO;YAAK;YACzE,oEAAoE;YACpE,sEAAsE;YACtErB,OAAOI,SAASE,iBAAiB,EAAE0D,eAAe,CAAC;YACnDhE,OAAOI,SAASE,iBAAiB,EAAE2D,YAAY,CAAC,MAAM;YACtDjE,OAAOI,SAASE,iBAAiB,EAAE2D,YAAY,CAACF,UAAUhD,MAAM;QAClE;QAEAd,GAAGoD,IAAI,CAACF,MAAMe,MAAM,CAAC,CAAC,EAAEd,IAAI,EAAE,GAAKA,SAAS,cAC1C,gGACA,OAAO,EAAEA,IAAI,EAAE9B,MAAM,EAAED,KAAK,EAAE;YAC5B,MAAM6B,eAAexD,KAAKqD,IAAI,CAACQ,SAASH;YACxC5D,cAAc0D,cAAc5D,aAAaI,KAAKqD,IAAI,CAAC7B,aAAakC;YAEhE,MAAMe,eAAe;gBACnBnB,UAAU;gBACVH,MAAMO;gBACNF;YACF;YAEAlD,OAAO,MAAMG,aAAa;gBAAEiD,MAAMe;YAAa,IAAIb,OAAO,CAAC;gBAAEhC;gBAAQD;YAAM;QAC7E;QAGFpB,GAAG,gEAAgE;YACjE,wEAAwE;YACxE,0EAA0E;YAC1E,MAAM0D,SAASxB,OAAOO,MAAM,CAAC;gBAACP,OAAOQ,IAAI,CAAC,UAAU;gBAAUR,OAAOC,KAAK,CAAC;aAAG;YAC9EuB,OAAOS,aAAa,CAAC,IAAI;YACzBT,OAAOS,aAAa,CAAC,IAAI;YAEzB,MAAMlB,eAAexD,KAAKqD,IAAI,CAACQ,SAAS;YACxC/D,cAAc0D,cAAcS;YAE5B,MAAMP,OAAO;gBACXJ,UAAU;gBACVH,MAAM;gBACNK;YACF;YAEAlD,OAAO,MAAMG,aAAa;gBAAEiD;YAAK,IAAIE,OAAO,CAAC;gBAAEhC,QAAQ;gBAAID,OAAO;YAAG;QACvE;IACF;AACF"}

package/dist/uploads/probeImageSize.d.ts

@@ -0,0 +1,39 @@
+import type { ProbedImageSize } from './types.js';
+/**
+ * Image dimension probe used as a fallback when `sharp` is not configured.
+ * Reads only the header bytes needed to determine width and height.
+ *
+ * PNG, JPEG, GIF, WebP, AVIF and HEIF/HEIC are delegated to `image-dimensions`
+ * (actively maintained, zero dependencies). BMP, ICO/CUR, SVG, TIFF and JPEG
+ * XL have no such maintained equivalent, so they're read here directly; each
+ * of those parsers advances by a fixed amount or is bounded by an explicit
+ * guard, so malformed input can never block the event loop.
+ *
+ * Replaces the archived `image-size` package, whose ICNS/HEIF parsers shipped
+ * unpatched denial-of-service vulnerabilities (CVE-2025-71330, CVE-2025-71319).
+ *
+ * Two edge cases changed behavior compared to the previous hand-rolled parser:
+ * - JPEG files using arithmetic coding or hierarchical encoding (SOF markers
+ *   5-7, 9-11, 13-15) are no longer read; `image-dimensions` only recognizes
+ *   baseline and progressive JPEG (SOF0-3). These encodings are not produced
+ *   by browsers or cameras, so this is not expected to affect real uploads.
+ * - AVIF/HEIF detection now checks the container's brand list instead of
+ *   accepting any ISO base media file with a `ftyp` box, so non-image formats
+ *   that share the same container (for example MP4/MOV) are correctly no
+ *   longer misidentified as images.
+ *
+ * @throws if the buffer is not a recognized/parseable image format
+ */
+export declare function probeImageSize(data: Buffer): ProbedImageSize;
+/**
+ * Probe used when the file lives on disk via `tempFilePath`. PNG, JPEG, GIF,
+ * WebP, AVIF and HEIF/HEIC are read through `imageDimensionsFromStream`,
+ * which reads only as many bytes as are needed to find the header, so a
+ * large file's data is never pulled into memory. BMP, ICO/CUR, SVG, TIFF and
+ * JPEG XL are detected from a small header sniff and, only then, read in
+ * full for `probeImageSize` to parse.
+ *
+ * @throws if the file is not a recognized/parseable image format
+ */
+export declare function probeImageSizeFromPath(tempFilePath: string): Promise<ProbedImageSize>;
+//# sourceMappingURL=probeImageSize.d.ts.map

package/dist/uploads/probeImageSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probeImageSize.d.ts","sourceRoot":"","sources":["../../src/uploads/probeImageSize.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAW5D;AAQD;;;;;;;;;GASG;AACH,wBAAsB,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAgB3F"}