payload 4.0.0-internal.cd69eef → 4.0.0-internal.ce66a41

package/dist/uploads/isAnimatedImage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/isAnimatedImage.ts"],"sourcesContent":["// Matches the formats sharp's own `animated` input option documents as supported (reading every\n// frame/page instead of just the first): https://sharp.pixelplumbing.com/api-constructor - \"Set to\n// true to read all frames/pages of an animated image (GIF, WebP, TIFF)\". AVIF is deliberately\n// excluded even though the format itself supports animation: this sharp version's AVIF encoder\n// silently flattens `join({ animated: true })` frames into a single tall static image instead of\n// a multi-page sequence (verified directly - the output always comes back as `pages: 1`), so\n// there's no working animated-AVIF path to account for here.\nconst ANIMATED_IMAGE_MIME_TYPES = ['image/gif', 'image/tiff', 'image/webp']\n\n/**\n * Whether sharp needs to read every frame/page of this mime type (rather than just the first) to\n * process it correctly - used to decide whether a file needs its full bytes fetched/processed\n * even without any resize/format/trim adjustments configured, and whether sharp should be asked\n * to read all frames when it does run.\n */\nexport function isAnimatedImage(mimeType: string): boolean {\n  return ANIMATED_IMAGE_MIME_TYPES.includes(mimeType)\n}\n"],"names":["ANIMATED_IMAGE_MIME_TYPES","isAnimatedImage","mimeType","includes"],"mappings":"AAAA,gGAAgG;AAChG,mGAAmG;AACnG,8FAA8F;AAC9F,+FAA+F;AAC/F,iGAAiG;AACjG,6FAA6F;AAC7F,6DAA6D;AAC7D,MAAMA,4BAA4B;IAAC;IAAa;IAAc;CAAa;AAE3E;;;;;CAKC,GACD,OAAO,SAASC,gBAAgBC,QAAgB;IAC9C,OAAOF,0BAA0BG,QAAQ,CAACD;AAC5C"}

package/dist/uploads/isProcessableImage.d.ts

@@ -0,0 +1,2 @@
+export declare function isProcessableImage(mimeType: string): boolean;
+//# sourceMappingURL=isProcessableImage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isProcessableImage.d.ts","sourceRoot":"","sources":["../../src/uploads/isProcessableImage.ts"],"names":[],"mappings":"AAGA,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE5D"}

package/dist/uploads/isProcessableImage.js

@@ -0,0 +1,7 @@
+import { canResizeImage } from './canResizeImage.js';
+import { isImage } from './isImage.js';
+export function isProcessableImage(mimeType) {
+    return isImage(mimeType) || canResizeImage(mimeType);
+}
+
+//# sourceMappingURL=isProcessableImage.js.map

package/dist/uploads/isProcessableImage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/isProcessableImage.ts"],"sourcesContent":["import { canResizeImage } from './canResizeImage.js'\nimport { isImage } from './isImage.js'\n\nexport function isProcessableImage(mimeType: string): boolean {\n  return isImage(mimeType) || canResizeImage(mimeType)\n}\n"],"names":["canResizeImage","isImage","isProcessableImage","mimeType"],"mappings":"AAAA,SAASA,cAAc,QAAQ,sBAAqB;AACpD,SAASC,OAAO,QAAQ,eAAc;AAEtC,OAAO,SAASC,mBAAmBC,QAAgB;IACjD,OAAOF,QAAQE,aAAaH,eAAeG;AAC7C"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"parseFilename.d.ts","sourceRoot":"","sources":["../../src/uploads/parseFilename.ts"],"names":[],"mappings":"AAEA,KAAK,kBAAkB,GAAG;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa,gBAAiB,MAAM,KAAG,kBAInD,CAAA"}

package/dist/uploads/parseFilename.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/parseFilename.ts"],"sourcesContent":["import sanitize from 'sanitize-filename'\n\ntype SanitizedImageData = {\n  ext: string\n  name: string\n}\n\n/**\n * Sanitize the image name and extract the extension from the source image\n *\n * @param sourceImage - the source image\n * @returns the sanitized name and extension\n */\nexport const parseFilename = (sourceImage: string): SanitizedImageData => {\n  const extension = sourceImage.split('.').pop()\n  const name = sanitize(sourceImage.substring(0, sourceImage.lastIndexOf('.')) || sourceImage)\n  return { name, ext: extension! }\n}\n"],"names":["sanitize","parseFilename","sourceImage","extension","split","pop","name","substring","lastIndexOf","ext"],"mappings":"AAAA,OAAOA,cAAc,oBAAmB;AAOxC;;;;;CAKC,GACD,OAAO,MAAMC,gBAAgB,CAACC;IAC5B,MAAMC,YAAYD,YAAYE,KAAK,CAAC,KAAKC,GAAG;IAC5C,MAAMC,OAAON,SAASE,YAAYK,SAAS,CAAC,GAAGL,YAAYM,WAAW,CAAC,SAASN;IAChF,OAAO;QAAEI;QAAMG,KAAKN;IAAW;AACjC,EAAC"}

package/dist/uploads/probeImageSize.d.ts

@@ -0,0 +1,39 @@
+import type { ProbedImageSize } from './types.js';
+/**
+ * Dependency-free image dimension probe. 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"}

package/dist/uploads/probeImageSize.js

@@ -0,0 +1,374 @@
+import { createReadStream } from 'fs';
+import fs from 'fs/promises';
+import { imageDimensionsFromData, imageDimensionsFromStream } from 'image-dimensions';
+/**
+ * Dependency-free image dimension probe. 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 function probeImageSize(data) {
+    const modernDimensions = imageDimensionsFromData(data);
+    const dimensions = modernDimensions ? {
+        height: modernDimensions.height,
+        width: modernDimensions.width
+    } : probeLegacyFormat(data);
+    if (!dimensions || !dimensions.width || !dimensions.height) {
+        throw new Error('Unsupported image type: unable to determine dimensions');
+    }
+    return dimensions;
+}
+/**
+ * Bytes read from the start of the file to detect a legacy/JXL format from
+ * its header; comfortably covers every signature `detectLegacyType` checks.
+ */ const HEADER_SNIFF_LENGTH = 4096;
+/**
+ * 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 async function probeImageSizeFromPath(tempFilePath) {
+    const headerSniff = await readHeaderSniff(tempFilePath);
+    if (detectLegacyType(headerSniff)) {
+        return probeImageSize(await fs.readFile(tempFilePath));
+    }
+    const modernDimensions = await imageDimensionsFromStream(ReadableStream.from(createReadStream(tempFilePath)));
+    if (modernDimensions) {
+        return {
+            height: modernDimensions.height,
+            width: modernDimensions.width
+        };
+    }
+    return probeImageSize(await fs.readFile(tempFilePath));
+}
+async function readHeaderSniff(tempFilePath) {
+    const handle = await fs.open(tempFilePath, 'r');
+    try {
+        const buffer = Buffer.alloc(HEADER_SNIFF_LENGTH);
+        const { bytesRead } = await handle.read(buffer, 0, HEADER_SNIFF_LENGTH, 0);
+        return buffer.subarray(0, bytesRead);
+    } finally{
+        await handle.close();
+    }
+}
+function probeLegacyFormat(data) {
+    const type = detectLegacyType(data);
+    return type ? legacyParsers[type](data) : null;
+}
+function detectLegacyType(data) {
+    if (data.length < 2) {
+        return null;
+    }
+    if (data[0] === 0x42 && data[1] === 0x4d) {
+        return 'bmp';
+    }
+    if (data.length >= 8 && (data[0] === 0x49 && data[1] === 0x49 && data[2] === 0x2a || data[0] === 0x4d && data[1] === 0x4d && data[3] === 0x2a)) {
+        return 'tiff';
+    }
+    if (data.length >= 6 && data[0] === 0 && data[1] === 0 && (data[2] === 1 || data[2] === 2) && data[3] === 0) {
+        return 'ico';
+    }
+    if (data[0] === 0xff && data[1] === 0x0a || isJXLContainerSignature(data)) {
+        return 'jxl';
+    }
+    const head = data.toString('utf8', 0, Math.min(data.length, 1000));
+    if (/<svg[\s>]/i.test(head) || head.trimStart().startsWith('<?xml') && /<svg/i.test(head)) {
+        return 'svg';
+    }
+    return null;
+}
+const legacyParsers = {
+    bmp: (data)=>({
+            height: Math.abs(data.readInt32LE(22)),
+            width: data.readInt32LE(18)
+        }),
+    ico: (data)=>{
+        const count = data.readUInt16LE(4);
+        let best = {
+            height: 0,
+            width: 0
+        };
+        for(let i = 0; i < count && i < 1000; i++){
+            const entry = 6 + i * 16;
+            if (entry + 2 > data.length) {
+                break;
+            }
+            // A zero byte means 256 px in the ICO format
+            const width = data[entry] === 0 ? 256 : data[entry];
+            const height = data[entry + 1] === 0 ? 256 : data[entry + 1];
+            if (width * height > best.width * best.height) {
+                best = {
+                    height,
+                    width
+                };
+            }
+        }
+        return best.width ? best : null;
+    },
+    jxl: (data)=>parseJXL(data),
+    svg: (data)=>parseSVG(data),
+    tiff: (data)=>{
+        const isLittleEndian = data[0] === 0x49;
+        const readU16 = (offset)=>isLittleEndian ? data.readUInt16LE(offset) : data.readUInt16BE(offset);
+        const readU32 = (offset)=>isLittleEndian ? data.readUInt32LE(offset) : data.readUInt32BE(offset);
+        const ifdOffset = readU32(4);
+        if (ifdOffset + 2 > data.length) {
+            return null;
+        }
+        const entryCount = readU16(ifdOffset);
+        let width;
+        let height;
+        for(let i = 0; i < entryCount && i < 1000; i++){
+            const entry = ifdOffset + 2 + i * 12;
+            if (entry + 12 > data.length) {
+                break;
+            }
+            const tag = readU16(entry);
+            const fieldType = readU16(entry + 2);
+            // SHORT (type 3) values are 16-bit, otherwise read as 32-bit LONG
+            const value = fieldType === 3 ? readU16(entry + 8) : readU32(entry + 8);
+            if (tag === 256) {
+                width = value;
+            } else if (tag === 257) {
+                height = value;
+            }
+        }
+        return width && height ? {
+            height,
+            width
+        } : null;
+    }
+};
+function parseSVG(data) {
+    const text = data.toString('utf8', 0, Math.min(data.length, 65536));
+    const tagMatch = text.match(/<svg[^>]*>/i);
+    if (!tagMatch) {
+        return null;
+    }
+    const tag = tagMatch[0];
+    const readLength = (name)=>{
+        const match = tag.match(new RegExp(`${name}\\s*=\\s*["']?\\s*([^"'\\s>]+)`, 'i'));
+        if (!match) {
+            return null;
+        }
+        // Percentage units are relative and yield no concrete pixel size
+        if (/%\s*$/.test(match[1])) {
+            return null;
+        }
+        const value = parseFloat(match[1]);
+        return Number.isFinite(value) ? value : null;
+    };
+    const width = readLength('width');
+    const height = readLength('height');
+    if (width != null && height != null) {
+        return {
+            height: Math.round(height),
+            width: Math.round(width)
+        };
+    }
+    const viewBoxMatch = tag.match(/viewbox\s*=\s*["']?\s*([\d.\s,+-]+)/i);
+    if (viewBoxMatch) {
+        const parts = viewBoxMatch[1].trim().split(/[\s,]+/).map(Number);
+        if (parts.length === 4 && parts.every((n)=>Number.isFinite(n))) {
+            const [, , viewWidth, viewHeight] = parts;
+            if (width != null) {
+                return {
+                    height: Math.round(width / viewWidth * viewHeight),
+                    width: Math.round(width)
+                };
+            }
+            if (height != null) {
+                return {
+                    height: Math.round(height),
+                    width: Math.round(height / viewHeight * viewWidth)
+                };
+            }
+            return {
+                height: Math.round(viewHeight),
+                width: Math.round(viewWidth)
+            };
+        }
+    }
+    return null;
+}
+/**
+ * JPEG XL isn't supported by `image-dimensions`, so its size header is read
+ * directly. A JXL file is either a bare codestream starting `FF 0A`, or an
+ * ISOBMFF container carrying the codestream in a single `jxlc` box or split
+ * across several `jxlp` boxes; either way the dimensions live in the first
+ * bits of the codestream (the `SizeHeader`). See https://www.w3.org/TR/jpeg-xl/
+ * for the bitstream layout.
+ */ function parseJXL(data) {
+    if (data[0] === 0xff && data[1] === 0x0a) {
+        return parseJXLSizeHeader(data, 2);
+    }
+    // A boxed codestream still starts with the `FF 0A` signature, so it's
+    // skipped here too, same as the bare-codestream case above
+    const jxlcBox = findBox(data, 'jxlc', 0);
+    if (jxlcBox) {
+        return parseJXLSizeHeader(data, jxlcBox.bodyOffset + 2);
+    }
+    const jxlpBoxes = findAllBoxes(data, 'jxlp');
+    if (!jxlpBoxes.length) {
+        return null;
+    }
+    // Each `jxlp` payload is prefixed with a 4-byte partial-codestream index
+    const codestream = Buffer.concat(jxlpBoxes.map((box)=>data.subarray(box.bodyOffset + 4, box.offset + box.size)));
+    return parseJXLSizeHeader(codestream, 2);
+}
+function isJXLContainerSignature(data) {
+    return data.length >= 12 && data.readUInt32BE(0) === 0x0000000c && data.toString('ascii', 4, 8) === 'JXL ' && data[8] === 0x0d && data[9] === 0x0a && data[10] === 0x87 && data[11] === 0x0a;
+}
+function readBoxHeader(data, offset) {
+    if (offset + 8 > data.length) {
+        return null;
+    }
+    const name = data.toString('ascii', offset + 4, offset + 8);
+    let size = data.readUInt32BE(offset);
+    let bodyOffset = offset + 8;
+    if (size === 1) {
+        // A size of 1 means a 64-bit size follows the 8-byte header
+        if (offset + 16 > data.length) {
+            return null;
+        }
+        const largeSize = data.readBigUInt64BE(offset + 8);
+        if (largeSize > BigInt(Number.MAX_SAFE_INTEGER)) {
+            return null;
+        }
+        size = Number(largeSize);
+        bodyOffset = offset + 16;
+    } else if (size === 0) {
+        // A size of 0 means the box extends to the end of the buffer
+        size = data.length - offset;
+    }
+    if (size < bodyOffset - offset || offset + size > data.length) {
+        return null;
+    }
+    return {
+        name,
+        bodyOffset,
+        offset,
+        size
+    };
+}
+// Bounded to the same 1000-entry cap used elsewhere in this file so a
+// malformed chain of boxes can never block the event loop
+function findBox(data, name, startOffset) {
+    let offset = startOffset;
+    for(let i = 0; i < 1000 && offset < data.length; i++){
+        const box = readBoxHeader(data, offset);
+        if (!box) {
+            return null;
+        }
+        if (box.name === name) {
+            return box;
+        }
+        offset += box.size;
+    }
+    return null;
+}
+function findAllBoxes(data, name) {
+    const boxes = [];
+    let offset = 0;
+    for(let i = 0; i < 1000 && offset < data.length; i++){
+        const box = readBoxHeader(data, offset);
+        if (!box) {
+            break;
+        }
+        if (box.name === name) {
+            boxes.push(box);
+        }
+        offset += box.size;
+    }
+    return boxes;
+}
+/**
+ * Reads the JXL `SizeHeader` bit-packed structure (little-endian, LSB
+ * first) starting at `startOffset` in the codestream.
+ */ function parseJXLSizeHeader(data, startOffset) {
+    let byteOffset = startOffset;
+    let bitOffset = 0;
+    const readBits = (length)=>{
+        let result = 0;
+        let bitsRead = 0;
+        while(bitsRead < length){
+            if (byteOffset >= data.length) {
+                throw new RangeError('Unexpected end of JXL codestream');
+            }
+            const currentByte = data[byteOffset];
+            const bitsLeft = 8 - bitOffset;
+            const bitsToRead = Math.min(length - bitsRead, bitsLeft);
+            const mask = (1 << bitsToRead) - 1;
+            result |= (currentByte >> bitOffset & mask) << bitsRead;
+            bitsRead += bitsToRead;
+            bitOffset += bitsToRead;
+            if (bitOffset === 8) {
+                byteOffset++;
+                bitOffset = 0;
+            }
+        }
+        return result;
+    };
+    const readExplicitDimension = ()=>{
+        const sizeClass = readBits(2);
+        const extraBits = [
+            9,
+            13,
+            18,
+            30
+        ][sizeClass];
+        return 1 + readBits(extraBits);
+    };
+    try {
+        const isSmallImage = readBits(1) === 1;
+        const height = isSmallImage ? 8 * (1 + readBits(5)) : readExplicitDimension();
+        const widthMode = readBits(3);
+        let width;
+        if (isSmallImage && widthMode === 0) {
+            width = 8 * (1 + readBits(5));
+        } else if (widthMode === 0) {
+            width = readExplicitDimension();
+        } else {
+            const aspectRatios = [
+                1,
+                1.2,
+                4 / 3,
+                1.5,
+                16 / 9,
+                5 / 4,
+                2
+            ];
+            width = Math.floor(height * aspectRatios[widthMode - 1]);
+        }
+        return {
+            height,
+            width
+        };
+    } catch  {
+        return null;
+    }
+}
+
+//# sourceMappingURL=probeImageSize.js.map

package/dist/uploads/probeImageSize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/probeImageSize.ts"],"sourcesContent":["import { createReadStream } from 'fs'\nimport fs from 'fs/promises'\nimport { imageDimensionsFromData, imageDimensionsFromStream } from 'image-dimensions'\n\nimport type { ProbedImageSize } from './types.js'\n\n/**\n * Dependency-free image dimension probe. Reads only the header bytes needed\n * to determine width and height.\n *\n * PNG, JPEG, GIF, WebP, AVIF and HEIF/HEIC are delegated to `image-dimensions`\n * (actively maintained, zero dependencies). BMP, ICO/CUR, SVG, TIFF and JPEG\n * XL have no such maintained equivalent, so they're read here directly; each\n * of those parsers advances by a fixed amount or is bounded by an explicit\n * guard, so malformed input can never block the event loop.\n *\n * Replaces the archived `image-size` package, whose ICNS/HEIF parsers shipped\n * unpatched denial-of-service vulnerabilities (CVE-2025-71330, CVE-2025-71319).\n *\n * Two edge cases changed behavior compared to the previous hand-rolled parser:\n * - JPEG files using arithmetic coding or hierarchical encoding (SOF markers\n *   5-7, 9-11, 13-15) are no longer read; `image-dimensions` only recognizes\n *   baseline and progressive JPEG (SOF0-3). These encodings are not produced\n *   by browsers or cameras, so this is not expected to affect real uploads.\n * - AVIF/HEIF detection now checks the container's brand list instead of\n *   accepting any ISO base media file with a `ftyp` box, so non-image formats\n *   that share the same container (for example MP4/MOV) are correctly no\n *   longer misidentified as images.\n *\n * @throws if the buffer is not a recognized/parseable image format\n */\nexport function probeImageSize(data: Buffer): ProbedImageSize {\n  const modernDimensions = imageDimensionsFromData(data)\n  const dimensions = modernDimensions\n    ? { height: modernDimensions.height, width: modernDimensions.width }\n    : probeLegacyFormat(data)\n\n  if (!dimensions || !dimensions.width || !dimensions.height) {\n    throw new Error('Unsupported image type: unable to determine dimensions')\n  }\n\n  return dimensions\n}\n\n/**\n * Bytes read from the start of the file to detect a legacy/JXL format from\n * its header; comfortably covers every signature `detectLegacyType` checks.\n */\nconst HEADER_SNIFF_LENGTH = 4096\n\n/**\n * Probe used when the file lives on disk via `tempFilePath`. PNG, JPEG, GIF,\n * WebP, AVIF and HEIF/HEIC are read through `imageDimensionsFromStream`,\n * which reads only as many bytes as are needed to find the header, so a\n * large file's data is never pulled into memory. BMP, ICO/CUR, SVG, TIFF and\n * JPEG XL are detected from a small header sniff and, only then, read in\n * full for `probeImageSize` to parse.\n *\n * @throws if the file is not a recognized/parseable image format\n */\nexport async function probeImageSizeFromPath(tempFilePath: string): Promise<ProbedImageSize> {\n  const headerSniff = await readHeaderSniff(tempFilePath)\n\n  if (detectLegacyType(headerSniff)) {\n    return probeImageSize(await fs.readFile(tempFilePath))\n  }\n\n  const modernDimensions = await imageDimensionsFromStream(\n    ReadableStream.from(createReadStream(tempFilePath)),\n  )\n\n  if (modernDimensions) {\n    return { height: modernDimensions.height, width: modernDimensions.width }\n  }\n\n  return probeImageSize(await fs.readFile(tempFilePath))\n}\n\nasync function readHeaderSniff(tempFilePath: string): Promise<Buffer> {\n  const handle = await fs.open(tempFilePath, 'r')\n\n  try {\n    const buffer = Buffer.alloc(HEADER_SNIFF_LENGTH)\n    const { bytesRead } = await handle.read(buffer, 0, HEADER_SNIFF_LENGTH, 0)\n    return buffer.subarray(0, bytesRead)\n  } finally {\n    await handle.close()\n  }\n}\n\ntype Dimensions = null | ProbedImageSize\n\ntype LegacyImageType = 'bmp' | 'ico' | 'jxl' | 'svg' | 'tiff'\n\nfunction probeLegacyFormat(data: Buffer): Dimensions {\n  const type = detectLegacyType(data)\n  return type ? legacyParsers[type](data) : null\n}\n\nfunction detectLegacyType(data: Buffer): LegacyImageType | null {\n  if (data.length < 2) {\n    return null\n  }\n\n  if (data[0] === 0x42 && data[1] === 0x4d) {\n    return 'bmp'\n  }\n  if (\n    data.length >= 8 &&\n    ((data[0] === 0x49 && data[1] === 0x49 && data[2] === 0x2a) ||\n      (data[0] === 0x4d && data[1] === 0x4d && data[3] === 0x2a))\n  ) {\n    return 'tiff'\n  }\n  if (\n    data.length >= 6 &&\n    data[0] === 0 &&\n    data[1] === 0 &&\n    (data[2] === 1 || data[2] === 2) &&\n    data[3] === 0\n  ) {\n    return 'ico'\n  }\n  if ((data[0] === 0xff && data[1] === 0x0a) || isJXLContainerSignature(data)) {\n    return 'jxl'\n  }\n\n  const head = data.toString('utf8', 0, Math.min(data.length, 1000))\n  if (/<svg[\\s>]/i.test(head) || (head.trimStart().startsWith('<?xml') && /<svg/i.test(head))) {\n    return 'svg'\n  }\n\n  return null\n}\n\nconst legacyParsers: Record<LegacyImageType, (data: Buffer) => Dimensions> = {\n  bmp: (data) => ({ height: Math.abs(data.readInt32LE(22)), width: data.readInt32LE(18) }),\n  ico: (data) => {\n    const count = data.readUInt16LE(4)\n    let best: ProbedImageSize = { height: 0, width: 0 }\n\n    for (let i = 0; i < count && i < 1000; i++) {\n      const entry = 6 + i * 16\n      if (entry + 2 > data.length) {\n        break\n      }\n      // A zero byte means 256 px in the ICO format\n      const width = data[entry] === 0 ? 256 : data[entry]!\n      const height = data[entry + 1] === 0 ? 256 : data[entry + 1]!\n      if (width * height > best.width * best.height) {\n        best = { height, width }\n      }\n    }\n\n    return best.width ? best : null\n  },\n  jxl: (data) => parseJXL(data),\n  svg: (data) => parseSVG(data),\n  tiff: (data) => {\n    const isLittleEndian = data[0] === 0x49\n    const readU16 = (offset: number) =>\n      isLittleEndian ? data.readUInt16LE(offset) : data.readUInt16BE(offset)\n    const readU32 = (offset: number) =>\n      isLittleEndian ? data.readUInt32LE(offset) : data.readUInt32BE(offset)\n\n    const ifdOffset = readU32(4)\n    if (ifdOffset + 2 > data.length) {\n      return null\n    }\n\n    const entryCount = readU16(ifdOffset)\n    let width: number | undefined\n    let height: number | undefined\n\n    for (let i = 0; i < entryCount && i < 1000; i++) {\n      const entry = ifdOffset + 2 + i * 12\n      if (entry + 12 > data.length) {\n        break\n      }\n      const tag = readU16(entry)\n      const fieldType = readU16(entry + 2)\n      // SHORT (type 3) values are 16-bit, otherwise read as 32-bit LONG\n      const value = fieldType === 3 ? readU16(entry + 8) : readU32(entry + 8)\n      if (tag === 256) {\n        width = value\n      } else if (tag === 257) {\n        height = value\n      }\n    }\n\n    return width && height ? { height, width } : null\n  },\n}\n\nfunction parseSVG(data: Buffer): Dimensions {\n  const text = data.toString('utf8', 0, Math.min(data.length, 65536))\n  const tagMatch = text.match(/<svg[^>]*>/i)\n  if (!tagMatch) {\n    return null\n  }\n\n  const tag = tagMatch[0]\n  const readLength = (name: string): null | number => {\n    const match = tag.match(new RegExp(`${name}\\\\s*=\\\\s*[\"']?\\\\s*([^\"'\\\\s>]+)`, 'i'))\n    if (!match) {\n      return null\n    }\n    // Percentage units are relative and yield no concrete pixel size\n    if (/%\\s*$/.test(match[1]!)) {\n      return null\n    }\n    const value = parseFloat(match[1]!)\n    return Number.isFinite(value) ? value : null\n  }\n\n  const width = readLength('width')\n  const height = readLength('height')\n  if (width != null && height != null) {\n    return { height: Math.round(height), width: Math.round(width) }\n  }\n\n  const viewBoxMatch = tag.match(/viewbox\\s*=\\s*[\"']?\\s*([\\d.\\s,+-]+)/i)\n  if (viewBoxMatch) {\n    const parts = viewBoxMatch[1]!\n      .trim()\n      .split(/[\\s,]+/)\n      .map(Number)\n    if (parts.length === 4 && parts.every((n) => Number.isFinite(n))) {\n      const [, , viewWidth, viewHeight] = parts as [number, number, number, number]\n      if (width != null) {\n        return { height: Math.round((width / viewWidth) * viewHeight), width: Math.round(width) }\n      }\n      if (height != null) {\n        return { height: Math.round(height), width: Math.round((height / viewHeight) * viewWidth) }\n      }\n      return { height: Math.round(viewHeight), width: Math.round(viewWidth) }\n    }\n  }\n\n  return null\n}\n\n/**\n * JPEG XL isn't supported by `image-dimensions`, so its size header is read\n * directly. A JXL file is either a bare codestream starting `FF 0A`, or an\n * ISOBMFF container carrying the codestream in a single `jxlc` box or split\n * across several `jxlp` boxes; either way the dimensions live in the first\n * bits of the codestream (the `SizeHeader`). See https://www.w3.org/TR/jpeg-xl/\n * for the bitstream layout.\n */\nfunction parseJXL(data: Buffer): Dimensions {\n  if (data[0] === 0xff && data[1] === 0x0a) {\n    return parseJXLSizeHeader(data, 2)\n  }\n\n  // A boxed codestream still starts with the `FF 0A` signature, so it's\n  // skipped here too, same as the bare-codestream case above\n  const jxlcBox = findBox(data, 'jxlc', 0)\n  if (jxlcBox) {\n    return parseJXLSizeHeader(data, jxlcBox.bodyOffset + 2)\n  }\n\n  const jxlpBoxes = findAllBoxes(data, 'jxlp')\n  if (!jxlpBoxes.length) {\n    return null\n  }\n\n  // Each `jxlp` payload is prefixed with a 4-byte partial-codestream index\n  const codestream = Buffer.concat(\n    jxlpBoxes.map((box) => data.subarray(box.bodyOffset + 4, box.offset + box.size)),\n  )\n  return parseJXLSizeHeader(codestream, 2)\n}\n\nfunction isJXLContainerSignature(data: Buffer): boolean {\n  return (\n    data.length >= 12 &&\n    data.readUInt32BE(0) === 0x0000000c &&\n    data.toString('ascii', 4, 8) === 'JXL ' &&\n    data[8] === 0x0d &&\n    data[9] === 0x0a &&\n    data[10] === 0x87 &&\n    data[11] === 0x0a\n  )\n}\n\ntype Box = { bodyOffset: number; name: string; offset: number; size: number }\n\nfunction readBoxHeader(data: Buffer, offset: number): Box | null {\n  if (offset + 8 > data.length) {\n    return null\n  }\n\n  const name = data.toString('ascii', offset + 4, offset + 8)\n  let size = data.readUInt32BE(offset)\n  let bodyOffset = offset + 8\n\n  if (size === 1) {\n    // A size of 1 means a 64-bit size follows the 8-byte header\n    if (offset + 16 > data.length) {\n      return null\n    }\n    const largeSize = data.readBigUInt64BE(offset + 8)\n    if (largeSize > BigInt(Number.MAX_SAFE_INTEGER)) {\n      return null\n    }\n    size = Number(largeSize)\n    bodyOffset = offset + 16\n  } else if (size === 0) {\n    // A size of 0 means the box extends to the end of the buffer\n    size = data.length - offset\n  }\n\n  if (size < bodyOffset - offset || offset + size > data.length) {\n    return null\n  }\n\n  return { name, bodyOffset, offset, size }\n}\n\n// Bounded to the same 1000-entry cap used elsewhere in this file so a\n// malformed chain of boxes can never block the event loop\nfunction findBox(data: Buffer, name: string, startOffset: number): Box | null {\n  let offset = startOffset\n\n  for (let i = 0; i < 1000 && offset < data.length; i++) {\n    const box = readBoxHeader(data, offset)\n    if (!box) {\n      return null\n    }\n    if (box.name === name) {\n      return box\n    }\n    offset += box.size\n  }\n\n  return null\n}\n\nfunction findAllBoxes(data: Buffer, name: string): Box[] {\n  const boxes: Box[] = []\n  let offset = 0\n\n  for (let i = 0; i < 1000 && offset < data.length; i++) {\n    const box = readBoxHeader(data, offset)\n    if (!box) {\n      break\n    }\n    if (box.name === name) {\n      boxes.push(box)\n    }\n    offset += box.size\n  }\n\n  return boxes\n}\n\n/**\n * Reads the JXL `SizeHeader` bit-packed structure (little-endian, LSB\n * first) starting at `startOffset` in the codestream.\n */\nfunction parseJXLSizeHeader(data: Buffer, startOffset: number): Dimensions {\n  let byteOffset = startOffset\n  let bitOffset = 0\n\n  const readBits = (length: number): number => {\n    let result = 0\n    let bitsRead = 0\n\n    while (bitsRead < length) {\n      if (byteOffset >= data.length) {\n        throw new RangeError('Unexpected end of JXL codestream')\n      }\n      const currentByte = data[byteOffset]!\n      const bitsLeft = 8 - bitOffset\n      const bitsToRead = Math.min(length - bitsRead, bitsLeft)\n      const mask = (1 << bitsToRead) - 1\n      result |= ((currentByte >> bitOffset) & mask) << bitsRead\n\n      bitsRead += bitsToRead\n      bitOffset += bitsToRead\n      if (bitOffset === 8) {\n        byteOffset++\n        bitOffset = 0\n      }\n    }\n\n    return result\n  }\n\n  const readExplicitDimension = (): number => {\n    const sizeClass = readBits(2)\n    const extraBits = [9, 13, 18, 30][sizeClass]!\n    return 1 + readBits(extraBits)\n  }\n\n  try {\n    const isSmallImage = readBits(1) === 1\n    const height = isSmallImage ? 8 * (1 + readBits(5)) : readExplicitDimension()\n    const widthMode = readBits(3)\n\n    let width: number\n    if (isSmallImage && widthMode === 0) {\n      width = 8 * (1 + readBits(5))\n    } else if (widthMode === 0) {\n      width = readExplicitDimension()\n    } else {\n      const aspectRatios = [1, 1.2, 4 / 3, 1.5, 16 / 9, 5 / 4, 2]\n      width = Math.floor(height * aspectRatios[widthMode - 1]!)\n    }\n\n    return { height, width }\n  } catch {\n    return null\n  }\n}\n"],"names":["createReadStream","fs","imageDimensionsFromData","imageDimensionsFromStream","probeImageSize","data","modernDimensions","dimensions","height","width","probeLegacyFormat","Error","HEADER_SNIFF_LENGTH","probeImageSizeFromPath","tempFilePath","headerSniff","readHeaderSniff","detectLegacyType","readFile","ReadableStream","from","handle","open","buffer","Buffer","alloc","bytesRead","read","subarray","close","type","legacyParsers","length","isJXLContainerSignature","head","toString","Math","min","test","trimStart","startsWith","bmp","abs","readInt32LE","ico","count","readUInt16LE","best","i","entry","jxl","parseJXL","svg","parseSVG","tiff","isLittleEndian","readU16","offset","readUInt16BE","readU32","readUInt32LE","readUInt32BE","ifdOffset","entryCount","tag","fieldType","value","text","tagMatch","match","readLength","name","RegExp","parseFloat","Number","isFinite","round","viewBoxMatch","parts","trim","split","map","every","n","viewWidth","viewHeight","parseJXLSizeHeader","jxlcBox","findBox","bodyOffset","jxlpBoxes","findAllBoxes","codestream","concat","box","size","readBoxHeader","largeSize","readBigUInt64BE","BigInt","MAX_SAFE_INTEGER","startOffset","boxes","push","byteOffset","bitOffset","readBits","result","bitsRead","RangeError","currentByte","bitsLeft","bitsToRead","mask","readExplicitDimension","sizeClass","extraBits","isSmallImage","widthMode","aspectRatios","floor"],"mappings":"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"}

package/dist/uploads/resolveURLUploadInput.d.ts

@@ -0,0 +1,25 @@
+import * as z from 'zod/mini';
+import type { CollectionSlug } from '../index.js';
+import type { PayloadRequest } from '../types/index.js';
+import type { File } from './types.js';
+export declare const externalURLInputSchema: z.ZodMiniObject<{
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    source: z.ZodMiniLiteral<"externalURL">;
+    url: z.ZodMiniURL;
+}, z.core.$strict>;
+export type ExternalURLInput = z.infer<typeof externalURLInputSchema>;
+/**
+ * Resolves caller-supplied URL upload input, not existing files being resized or copied.
+ *
+ * For example, `{ source: 'externalURL', url: 'https://example.com/image.png' }`
+ * becomes a Payload `File` after applying `pasteURL`, allow-list, and size restrictions.
+ * Remote callers require an explicit allow-list; the trusted local CLI can opt out.
+ * Operation-specific access checks belong to the caller and the subsequent Payload operation.
+ */
+export declare const resolveURLUploadInput: ({ slug, input, req, requireAllowList, }: {
+    input: ExternalURLInput;
+    req: PayloadRequest;
+    requireAllowList?: boolean;
+    slug: CollectionSlug;
+}) => Promise<File>;
+//# sourceMappingURL=resolveURLUploadInput.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveURLUploadInput.d.ts","sourceRoot":"","sources":["../../src/uploads/resolveURLUploadInput.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAOtC,eAAO,MAAM,sBAAsB;;;;kBAIjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,4CAK/B;IACD,KAAK,EAAE,gBAAgB,CAAA;IACvB,GAAG,EAAE,cAAc,CAAA;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,IAAI,EAAE,cAAc,CAAA;CACrB,KAAG,OAAO,CAAC,IAAI,CA0Bf,CAAA"}

package/dist/uploads/resolveURLUploadInput.js

@@ -0,0 +1,53 @@
+import * as z from 'zod/mini';
+import { APIError } from '../errors/index.js';
+import { sanitizeFilename } from '../utilities/sanitizeFilename.js';
+import { downloadFileToBuffer } from './downloadFileToBuffer.js';
+import { validateUploadURL } from './validateUploadURL.js';
+export const externalURLInputSchema = z.strictObject({
+    name: z.optional(z.string().check(z.minLength(1))).check(z.describe('File name override.')),
+    source: z.literal('externalURL'),
+    url: z.url().check(z.describe('The http or https URL to download.'))
+});
+/**
+ * Resolves caller-supplied URL upload input, not existing files being resized or copied.
+ *
+ * For example, `{ source: 'externalURL', url: 'https://example.com/image.png' }`
+ * becomes a Payload `File` after applying `pasteURL`, allow-list, and size restrictions.
+ * Remote callers require an explicit allow-list; the trusted local CLI can opt out.
+ * Operation-specific access checks belong to the caller and the subsequent Payload operation.
+ */ export const resolveURLUploadInput = async ({ slug, input, req, requireAllowList = true })=>{
+    const uploadConfig = req.payload.collections[slug]?.config.upload;
+    const url = validateUploadURL({
+        requireAllowList,
+        uploadConfig,
+        url: input.url
+    });
+    const file = await downloadFileToBuffer({
+        data: {
+            filename: sanitizeFilename(input.name || getURLFilename(url)),
+            url: url.href
+        },
+        req,
+        uploadConfig: {
+            ...uploadConfig,
+            externalFileHeaderFilter: uploadConfig?.externalFileHeaderFilter ?? (()=>({}))
+        }
+    });
+    file.mimetype = file.mimetype?.split(';')[0] || 'application/octet-stream';
+    file.size = file.data.length;
+    const maxFileSize = req.payload.config.upload.limits?.fileSize;
+    if (maxFileSize !== undefined && Number.isFinite(maxFileSize) && file.size > maxFileSize) {
+        throw new APIError(`File exceeds the ${maxFileSize} byte upload limit.`, 400);
+    }
+    return file;
+};
+const getURLFilename = (url)=>{
+    const pathSegment = url.pathname.split('/').pop() || 'upload';
+    try {
+        return decodeURIComponent(pathSegment);
+    } catch  {
+        return pathSegment;
+    }
+};
+
+//# sourceMappingURL=resolveURLUploadInput.js.map

package/dist/uploads/resolveURLUploadInput.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/resolveURLUploadInput.ts"],"sourcesContent":["import * as z from 'zod/mini'\n\nimport type { CollectionSlug } from '../index.js'\nimport type { PayloadRequest } from '../types/index.js'\nimport type { File } from './types.js'\n\nimport { APIError } from '../errors/index.js'\nimport { sanitizeFilename } from '../utilities/sanitizeFilename.js'\nimport { downloadFileToBuffer } from './downloadFileToBuffer.js'\nimport { validateUploadURL } from './validateUploadURL.js'\n\nexport const externalURLInputSchema = z.strictObject({\n  name: z.optional(z.string().check(z.minLength(1))).check(z.describe('File name override.')),\n  source: z.literal('externalURL'),\n  url: z.url().check(z.describe('The http or https URL to download.')),\n})\n\nexport type ExternalURLInput = z.infer<typeof externalURLInputSchema>\n\n/**\n * Resolves caller-supplied URL upload input, not existing files being resized or copied.\n *\n * For example, `{ source: 'externalURL', url: 'https://example.com/image.png' }`\n * becomes a Payload `File` after applying `pasteURL`, allow-list, and size restrictions.\n * Remote callers require an explicit allow-list; the trusted local CLI can opt out.\n * Operation-specific access checks belong to the caller and the subsequent Payload operation.\n */\nexport const resolveURLUploadInput = async ({\n  slug,\n  input,\n  req,\n  requireAllowList = true,\n}: {\n  input: ExternalURLInput\n  req: PayloadRequest\n  requireAllowList?: boolean\n  slug: CollectionSlug\n}): Promise<File> => {\n  const uploadConfig = req.payload.collections[slug]?.config.upload\n  const url = validateUploadURL({ requireAllowList, uploadConfig, url: input.url })\n\n  const file = await downloadFileToBuffer({\n    data: {\n      filename: sanitizeFilename(input.name || getURLFilename(url)),\n      url: url.href,\n    },\n    req,\n    uploadConfig: {\n      ...uploadConfig,\n      externalFileHeaderFilter: uploadConfig?.externalFileHeaderFilter ?? (() => ({})),\n    },\n  })\n\n  file.mimetype = file.mimetype?.split(';')[0] || 'application/octet-stream'\n  file.size = file.data.length\n\n  const maxFileSize = req.payload.config.upload.limits?.fileSize\n\n  if (maxFileSize !== undefined && Number.isFinite(maxFileSize) && file.size > maxFileSize) {\n    throw new APIError(`File exceeds the ${maxFileSize} byte upload limit.`, 400)\n  }\n\n  return file\n}\n\nconst getURLFilename = (url: URL): string => {\n  const pathSegment = url.pathname.split('/').pop() || 'upload'\n\n  try {\n    return decodeURIComponent(pathSegment)\n  } catch {\n    return pathSegment\n  }\n}\n"],"names":["z","APIError","sanitizeFilename","downloadFileToBuffer","validateUploadURL","externalURLInputSchema","strictObject","name","optional","string","check","minLength","describe","source","literal","url","resolveURLUploadInput","slug","input","req","requireAllowList","uploadConfig","payload","collections","config","upload","file","data","filename","getURLFilename","href","externalFileHeaderFilter","mimetype","split","size","length","maxFileSize","limits","fileSize","undefined","Number","isFinite","pathSegment","pathname","pop","decodeURIComponent"],"mappings":"AAAA,YAAYA,OAAO,WAAU;AAM7B,SAASC,QAAQ,QAAQ,qBAAoB;AAC7C,SAASC,gBAAgB,QAAQ,mCAAkC;AACnE,SAASC,oBAAoB,QAAQ,4BAA2B;AAChE,SAASC,iBAAiB,QAAQ,yBAAwB;AAE1D,OAAO,MAAMC,yBAAyBL,EAAEM,YAAY,CAAC;IACnDC,MAAMP,EAAEQ,QAAQ,CAACR,EAAES,MAAM,GAAGC,KAAK,CAACV,EAAEW,SAAS,CAAC,KAAKD,KAAK,CAACV,EAAEY,QAAQ,CAAC;IACpEC,QAAQb,EAAEc,OAAO,CAAC;IAClBC,KAAKf,EAAEe,GAAG,GAAGL,KAAK,CAACV,EAAEY,QAAQ,CAAC;AAChC,GAAE;AAIF;;;;;;;CAOC,GACD,OAAO,MAAMI,wBAAwB,OAAO,EAC1CC,IAAI,EACJC,KAAK,EACLC,GAAG,EACHC,mBAAmB,IAAI,EAMxB;IACC,MAAMC,eAAeF,IAAIG,OAAO,CAACC,WAAW,CAACN,KAAK,EAAEO,OAAOC;IAC3D,MAAMV,MAAMX,kBAAkB;QAAEgB;QAAkBC;QAAcN,KAAKG,MAAMH,GAAG;IAAC;IAE/E,MAAMW,OAAO,MAAMvB,qBAAqB;QACtCwB,MAAM;YACJC,UAAU1B,iBAAiBgB,MAAMX,IAAI,IAAIsB,eAAed;YACxDA,KAAKA,IAAIe,IAAI;QACf;QACAX;QACAE,cAAc;YACZ,GAAGA,YAAY;YACfU,0BAA0BV,cAAcU,4BAA6B,CAAA,IAAO,CAAA,CAAC,CAAA,CAAC;QAChF;IACF;IAEAL,KAAKM,QAAQ,GAAGN,KAAKM,QAAQ,EAAEC,MAAM,IAAI,CAAC,EAAE,IAAI;IAChDP,KAAKQ,IAAI,GAAGR,KAAKC,IAAI,CAACQ,MAAM;IAE5B,MAAMC,cAAcjB,IAAIG,OAAO,CAACE,MAAM,CAACC,MAAM,CAACY,MAAM,EAAEC;IAEtD,IAAIF,gBAAgBG,aAAaC,OAAOC,QAAQ,CAACL,gBAAgBV,KAAKQ,IAAI,GAAGE,aAAa;QACxF,MAAM,IAAInC,SAAS,CAAC,iBAAiB,EAAEmC,YAAY,mBAAmB,CAAC,EAAE;IAC3E;IAEA,OAAOV;AACT,EAAC;AAED,MAAMG,iBAAiB,CAACd;IACtB,MAAM2B,cAAc3B,IAAI4B,QAAQ,CAACV,KAAK,CAAC,KAAKW,GAAG,MAAM;IAErD,IAAI;QACF,OAAOC,mBAAmBH;IAC5B,EAAE,OAAM;QACN,OAAOA;IACT;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"safeFetch.d.ts","sourceRoot":"","sources":["../../src/uploads/safeFetch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,EAAS,KAAK,IAAI,WAAW,EAAE,MAAM,QAAQ,CAAA;AAEpD;;GAEG;AACH,eAAO,MAAM,yBAAyB;;CAErC,CAAA;AAsDD;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,YAAmB,UAAU,CAAC,OAAO,WAAW,CAAC,KAAG,OAAO,CAAC,QAAQ,CA4CzF,CAAA"}
+{"version":3,"file":"safeFetch.d.ts","sourceRoot":"","sources":["../../src/uploads/safeFetch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,EAAS,KAAK,IAAI,WAAW,EAAE,MAAM,QAAQ,CAAA;AAEpD;;GAEG;AACH,eAAO,MAAM,yBAAyB;;CAErC,CAAA;AA6DD;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,YAAmB,UAAU,CAAC,OAAO,WAAW,CAAC,KAAG,OAAO,CAAC,QAAQ,CA4CzF,CAAA"}

package/dist/uploads/safeFetch.js

@@ -6,6 +6,7 @@ import { Agent, fetch as undiciFetch } from 'undici';
  */ export const _internal_safeFetchGlobal = {
     lookup
 };
+const buildBlockedFetchError = (hostname)=>new Error(`Blocked unsafe attempt to ${hostname}. This host resolves to a private or internal address. ` + `If this is a trusted destination, allowlist it via the upload collection's "skipSafeFetch" option ` + `(https://payloadcms.com/docs/upload/overview#skip-safe-fetch).`);
 const isSafeIp = (ip)=>{
     try {
         if (!ip) {
@@ -39,7 +40,7 @@ const ssrfFilterInterceptor = (hostname, options, callback)=>{
                 ];
             }
             if (ips.some((ip)=>!isSafeIp(ip))) {
-                callback(new Error(`Blocked unsafe attempt to ${hostname}`), address, family);
+                callback(buildBlockedFetchError(hostname), address, family);
                 return;
             }
             callback(null, address, family);
@@ -74,7 +75,7 @@ const getSafeDispatcher = ()=>{
         }
         if (ipaddr.isValid(hostname)) {
             if (!isSafeIp(hostname)) {
-                throw new Error(`Blocked unsafe attempt to ${hostname}`);
+                throw buildBlockedFetchError(hostname);
             }
         }
         return await undiciFetch(url, {