cross-image 0.2.3 → 0.4.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 @cross
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 @cross
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,9 +1,8 @@
 # @cross/image
 
-A pure JavaScript, dependency-free, cross-runtime image processing library for
-Deno, Node.js, and Bun. Decode, encode, manipulate, and process images in
-multiple formats including PNG, JPEG, WebP, GIF, and more—all without native
-dependencies.
+A pure JavaScript, dependency-free, cross-runtime image processing library for Deno, Node.js, and
+Bun. Decode, encode, manipulate, and process images in multiple formats including PNG, JPEG, WebP,
+GIF, and more—all without native dependencies.
 
 📚 **[Full Documentation](https://cross-image.56k.guru/)**
 
@@ -12,12 +11,11 @@ dependencies.
 - 🚀 **Pure JavaScript** - No native dependencies
 - 🔌 **Pluggable formats** - Easy to extend with custom formats
 - 📦 **Cross-runtime** - Works on Deno, Node.js (18+), and Bun
-- 🎨 **Multiple formats** - PNG, APNG, JPEG, WebP, GIF, TIFF, BMP, ICO, DNG,
-  PAM, PPM, PCX and ASCII support
+- 🎨 **Multiple formats** - PNG, APNG, JPEG, WebP, GIF, TIFF, BMP, ICO, DNG, PAM, PPM, PCX, ASCII,
+  HEIC, and AVIF support
 - ✂️ **Image manipulation** - Resize, crop, composite, and more
-- 🎛️ **Image processing** - Chainable filters including `brightness`,
-  `contrast`, `saturation`, `hue`, `exposure`, `blur`, `sharpen`, `sepia`, and
-  more
+- 🎛️ **Image processing** - Chainable filters including `brightness`, `contrast`, `saturation`,
+  `hue`, `exposure`, `blur`, `sharpen`, `sepia`, and more
 - 🖌️ **Drawing operations** - Create, fill, and manipulate pixels
 - 🧩 **Multi-frame** - Decode/encode animated GIFs, APNGs and multi-page TIFFs
 - 🔧 **Simple API** - Easy to use, intuitive interface
@@ -55,7 +53,7 @@ import { Image } from "cross-image";
 ### Deno
 
 ```ts
-import { Image } from "@cross/image";
+import { Image } from "jsr:@cross/image";
 
 // Decode an image (auto-detects format)
 const data = await Deno.readFile("input.png");
@@ -102,33 +100,231 @@ const jpeg = await image.encode("jpeg");
 await writeFile("output.jpg", jpeg);
 ```
 
+### Bun
+
+```ts
+import { Image } from "cross-image";
+
+// Read an image (auto-detects format)
+const data = await Bun.file("input.png").arrayBuffer();
+const image = await Image.decode(new Uint8Array(data));
+
+console.log(`Image size: ${image.width}x${image.height}`);
+
+// Resize the image and save
+image.resize({ width: 800, height: 600 });
+const jpeg = await image.encode("jpeg");
+await Bun.write("output.jpg", jpeg);
+```
+
 ## Supported Formats
 
-| Format | Pure-JS     | Notes                                  |
-| ------ | ----------- | -------------------------------------- |
-| PNG    | ✅ Full     | Complete pure-JS implementation        |
-| APNG   | ✅ Full     | Animated PNG with multi-frame          |
-| BMP    | ✅ Full     | Complete pure-JS implementation        |
-| ICO    | ✅ Full     | Windows Icon format                    |
-| GIF    | ✅ Full     | Animated GIF with multi-frame          |
-| DNG    | ✅ Full     | Linear DNG (Uncompressed RGBA)         |
-| PAM    | ✅ Full     | Netpbm PAM format                      |
-| PPM    | ✅ Full     | Netpbm PPM format (P3/P6)              |
-| PCX    | ✅ Full     | ZSoft PCX (RLE compressed)             |
-| ASCII  | ✅ Full     | Text-based ASCII art                   |
-| JPEG   | ⚠️ Baseline | Pure-JS baseline DCT only              |
-| WebP   | ⚠️ Lossless | Pure-JS lossless VP8L                  |
-| TIFF   | ⚠️ Basic    | Pure-JS uncompressed, LZW, & grayscale |
-
-See the
-[full format support documentation](https://cross-image.56k.guru/formats/) for
-detailed compatibility information.
+| Format | Pure-JS                   | Notes                                                                                          |
+| ------ | ------------------------- | ---------------------------------------------------------------------------------------------- |
+| PNG    | ✅ Full                   | Complete pure-JS implementation                                                                |
+| APNG   | ✅ Full                   | Animated PNG with multi-frame                                                                  |
+| BMP    | ✅ Full                   | Complete pure-JS implementation                                                                |
+| ICO    | ✅ Full                   | Windows Icon format                                                                            |
+| GIF    | ✅ Full                   | Animated GIF with multi-frame                                                                  |
+| DNG    | ✅ Full                   | Linear DNG (Uncompressed RGBA)                                                                 |
+| PAM    | ✅ Full                   | Netpbm PAM format                                                                              |
+| PPM    | ✅ Full                   | Netpbm PPM format (P3/P6)                                                                      |
+| PCX    | ✅ Full                   | ZSoft PCX (RLE compressed)                                                                     |
+| ASCII  | ✅ Full                   | Text-based ASCII art                                                                           |
+| JPEG   | ⚠️ Baseline & Progressive | Pure-JS baseline & progressive DCT: decode with spectral selection; encode with 2-scan (DC+AC) |
+| WebP   | ⚠️ Lossless               | Pure-JS lossless VP8L                                                                          |
+| TIFF   | ⚠️ Basic                  | Pure-JS uncompressed, LZW, PackBits, & Deflate; grayscale & RGB/RGBA                           |
+| HEIC   | 🔌 Runtime                | Requires ImageDecoder/OffscreenCanvas API support                                              |
+| AVIF   | 🔌 Runtime                | Requires ImageDecoder/OffscreenCanvas API support                                              |
+
+See the [full format support documentation](https://cross-image.56k.guru/formats/) for detailed
+compatibility information.
+
+## Advanced Usage
+
+Most users should stick to the `Image` API (`Image.decode`, `image.encode`, etc.).
+
+If you need to work with format handlers directly (e.g. `new PNGFormat()`) or register your own
+`ImageFormat` implementation via `Image.registerFormat(...)`, see the API reference section
+“Exported Format Classes”:
+
+- https://cross-image.56k.guru/api/
+
+## JPEG Tolerant Decoding
+
+The JPEG decoder includes a tolerant decoding mode (enabled by default) that gracefully handles
+partially corrupted images or complex encoding patterns from mobile phone cameras. When enabled, the
+decoder will continue processing even if some blocks fail to decode, filling failed blocks with
+neutral values.
+
+**Features:**
+
+- **Enabled by default** - Handles real-world JPEGs from various devices
+- **Progressive JPEG support** - Decodes both baseline and progressive JPEGs
+- **Configurable** - Can be disabled for strict validation
+- **Fault-tolerant** - Recovers partial image data instead of failing completely
+- **Zero configuration** - Works automatically with the standard `Image.decode()` API
+
+**When to use:**
+
+- Mobile phone JPEGs with complex encoding patterns
+- Progressive JPEG images from web sources
+- Images from various camera manufacturers
+- Partially corrupted JPEG files
+- Production applications requiring maximum compatibility
+
+**Example:**
+
+```typescript
+import { Image } from "jsr:@cross/image";
+
+const data = await Deno.readFile("mobile-photo.jpg");
+// Default behavior - tolerant decoding enabled
+const image = await Image.decode(data);
+
+// Strict mode - fail fast on decode errors
+const strictImage = await Image.decode(data, { tolerantDecoding: false });
+
+// Optional: receive warnings during partial decode (pure-JS decoder paths)
+const imageWithWarnings = await Image.decode(data, {
+  tolerantDecoding: true,
+  runtimeDecoding: "never",
+  onWarning: (message, details) => {
+    console.log(`JPEG Warning: ${message}`, details);
+  },
+});
+```
+
+**Note:** When using `Image.decode()`, the library automatically tries runtime-optimized decoders
+(ImageDecoder API) first, falling back to the pure JS decoder with tolerant mode for maximum
+compatibility.
+
+## Fault-Tolerant Decoding for Other Formats
+
+In addition to JPEG, @cross/image provides fault-tolerant decoding for several other formats that
+commonly encounter corruption or complex encoding patterns:
+
+### GIF Fault-Tolerant Decoding
+
+The GIF decoder supports frame-level tolerance for animated GIFs. When enabled (default), corrupted
+frames are skipped instead of causing complete decode failure.
+
+**Features:**
+
+- **Enabled by default** - Handles multi-frame GIFs with some corrupted frames
+- **Frame-level recovery** - Skips bad frames, preserves good ones
+- **LZW decompression errors** - Continues past compression errors
+
+**Example:**
+
+```typescript
+import { Image } from "jsr:@cross/image";
+
+const data = await Deno.readFile("animated.gif");
+
+// Tolerant mode (default) - skips corrupted frames
+const tolerantFrames = await Image.decodeFrames(data);
+
+// Strict mode - throws on first corrupted frame
+const strictFrames = await Image.decodeFrames(data, {
+  tolerantDecoding: false,
+});
+
+// Optional: receive warnings when frames are skipped
+const framesWithWarnings = await Image.decodeFrames(data, {
+  tolerantDecoding: true,
+  runtimeDecoding: "never",
+  onWarning: (message, details) => {
+    console.log(`GIF Warning: ${message}`, details);
+  },
+});
+```
+
+### WebP Fault-Tolerant Decoding (VP8L Lossless)
+
+The WebP VP8L (lossless) decoder supports pixel-level tolerance. When enabled (default), decoding
+errors result in gray pixels for remaining data instead of complete failure.
+
+**Features:**
+
+- **Enabled by default** - Handles VP8L images with Huffman/LZ77 errors
+- **Pixel-level recovery** - Fills remaining pixels with neutral gray
+- **Huffman decode errors** - Continues past invalid codes
+
+**Example:**
+
+```typescript
+import { Image } from "jsr:@cross/image";
+
+const data = await Deno.readFile("image.webp");
+
+// Tolerant mode (default) - fills bad pixels with gray
+const tolerantImage = await Image.decode(data);
+
+// Strict mode - throws on first decode error
+const strictImage = await Image.decode(data, { tolerantDecoding: false });
+
+// Optional: receive warnings during partial decode
+const imageWithWarnings = await Image.decode(data, {
+  tolerantDecoding: true,
+  runtimeDecoding: "never",
+  onWarning: (message, details) => {
+    console.log(`WebP Warning: ${message}`, details);
+  },
+});
+void imageWithWarnings;
+```
+
+### When to Use Fault-Tolerant Modes
+
+**Use tolerant decoding (default) when:**
+
+- Processing user-uploaded images from various sources
+- Building production applications requiring maximum compatibility
+- Handling images from mobile devices or cameras
+- Recovering data from partially corrupted files
+- Batch processing where some failures are acceptable
+
+**Use strict decoding when:**
+
+- Validating image file integrity
+- Quality control in professional workflows
+- Detecting file corruption explicitly
+- Testing image encoder implementations
+
+### Warning Callbacks
+
+Decoding APIs accept an optional `onWarning` callback that gets invoked when non-fatal issues occur
+during decoding. This is useful for logging, monitoring, or debugging decoding issues without using
+`console` methods.
+
+**Example:**
+
+```typescript
+import { Image } from "jsr:@cross/image";
+
+const data = await Deno.readFile("input.webp");
+
+const image = await Image.decode(data, {
+  tolerantDecoding: true,
+  runtimeDecoding: "never",
+  onWarning: (message, details) => {
+    // Log to your preferred logging system
+    myLogger.warn(message, details);
+  },
+});
+void image;
+```
+
+The callback receives:
+
+- `message`: A human-readable description of the warning
+- `details`: Optional additional context (usually the error object)
 
 ## Metadata Support
 
-@cross/image provides comprehensive EXIF 3.0 compliant metadata support for
-image files, including camera information, GPS coordinates, and InteropIFD
-compatibility markers.
+@cross/image provides comprehensive EXIF 3.0 compliant metadata support for image files, including
+camera information, GPS coordinates, and InteropIFD compatibility markers.
 
 ### Supported Metadata Fields
 
@@ -165,15 +361,14 @@ The library implements the EXIF 3.0 specification with:
 
 - **50+ Exif Sub-IFD tags** for comprehensive camera metadata
 - **30+ IFD0 tags** for image information
-- **InteropIFD support** for format compatibility (R98/sRGB, R03/Adobe RGB,
-  THM/thumbnail)
+- **InteropIFD support** for format compatibility (R98/sRGB, R03/Adobe RGB, THM/thumbnail)
 - **GPS IFD** with proper coordinate conversion
 - All EXIF data types (BYTE, ASCII, SHORT, LONG, RATIONAL, etc.)
 
 ### Example Usage
 
 ```typescript
-import { Image } from "@cross/image";
+import { Image } from "jsr:@cross/image";
 
 // Load an image
 const data = await Deno.readFile("photo.jpg");
@@ -208,6 +403,41 @@ console.log(loaded.metadata?.cameraMake); // "Canon"
 console.log(loaded.getPosition()); // { latitude: 40.7128, longitude: -74.0060 }
 ```
 
+### Extracting Metadata Without Decoding
+
+For quickly reading metadata from images without the overhead of decoding pixel data, use
+`Image.extractMetadata()`. This is particularly useful for:
+
+- Reading EXIF data from large images or photos
+- Extracting metadata from images with unsupported compression
+- Building image catalogs or galleries
+- Processing metadata in batch operations
+
+```typescript
+import { Image } from "jsr:@cross/image";
+
+// Extract metadata without decoding pixels
+const data = await Deno.readFile("large-photo.jpg");
+const metadata = await Image.extractMetadata(data);
+
+console.log(metadata?.cameraMake); // "Canon"
+console.log(metadata?.iso); // 800
+console.log(metadata?.exposureTime); // 0.004
+
+// Works with auto-detection
+const metadata2 = await Image.extractMetadata(data); // Detects JPEG
+
+// Or specify format explicitly
+const metadata3 = await Image.extractMetadata(data, "jpeg");
+```
+
+This method is significantly faster than full decode when you only need metadata, as it:
+
+- Skips pixel data decompression
+- Only parses metadata chunks/markers
+- Returns `undefined` for unsupported formats
+- Works with JPEG, PNG, WebP, TIFF, HEIC, and AVIF formats
+
 ### Format-Specific Support
 
 Use `Image.getSupportedMetadata(format)` to check which fields are supported:
@@ -217,41 +447,41 @@ Image.getSupportedMetadata("jpeg"); // Full camera metadata + GPS (21 fields)
 Image.getSupportedMetadata("tiff"); // Comprehensive EXIF + GPS + InteropIFD (23+ fields)
 Image.getSupportedMetadata("png"); // DateTime, GPS, DPI, basic text (9 fields)
 Image.getSupportedMetadata("webp"); // Enhanced XMP + GPS (15 fields - includes camera metadata!)
+Image.getSupportedMetadata("heic"); // Full camera metadata + GPS (19 fields)
+Image.getSupportedMetadata("avif"); // Full camera metadata + GPS (19 fields)
 ```
 
 **Format Highlights:**
 
-- **JPEG**: Most comprehensive EXIF support, including all camera settings and
-  GPS
+- **JPEG**: Most comprehensive EXIF support, including all camera settings and GPS
 - **TIFF**: Full EXIF 3.0 support with IFD structure, InteropIFD compatibility
-- **WebP**: Enhanced XMP implementation with Dublin Core, EXIF, and TIFF
-  namespaces
+- **WebP**: Enhanced XMP implementation with Dublin Core, EXIF, and TIFF namespaces
 - **PNG**: Basic EXIF support via eXIf chunk plus GPS coordinates
+- **HEIC**: Full EXIF metadata extraction including camera settings, GPS, and image info
+  (runtime-dependent encoding)
+- **AVIF**: Full EXIF metadata extraction including camera settings, GPS, and image info
+  (runtime-dependent encoding)
 
 ## Documentation
 
-- **[API Reference](https://cross-image.56k.guru/api/)** - Complete API
-  documentation
-- **[Format Support](https://cross-image.56k.guru/formats/)** - Supported
-  formats and specifications
-- **[Image Processing](https://cross-image.56k.guru/processing/)** - Filters,
-  manipulation, and color adjustments
-  - [Filters](https://cross-image.56k.guru/processing/filters/) - Blur, sharpen,
-    and noise reduction
-  - [Manipulation](https://cross-image.56k.guru/processing/manipulation/) -
-    Resize, crop, composite, and draw
-  - [Color Adjustments](https://cross-image.56k.guru/processing/color-adjustments/) -
-    Brightness, contrast, saturation, and more
-- **[Examples](https://cross-image.56k.guru/examples/)** - Practical examples
-  for common tasks
+- **[API Reference](https://cross-image.56k.guru/api/)** - Complete API documentation
+- **[Format Support](https://cross-image.56k.guru/formats/)** - Supported formats and specifications
+- **[Image Processing](https://cross-image.56k.guru/processing/)** - Filters, manipulation, and
+  color adjustments
+  - [Filters](https://cross-image.56k.guru/processing/filters/) - Blur, sharpen, and noise reduction
+  - [Manipulation](https://cross-image.56k.guru/processing/manipulation/) - Resize, crop, composite,
+    and draw
+  - [Color Adjustments](https://cross-image.56k.guru/processing/color-adjustments/) - Brightness,
+    contrast, saturation, and more
+- **[Examples](https://cross-image.56k.guru/examples/)** - Practical examples for common tasks
   - [Decoding & Encoding](https://cross-image.56k.guru/examples/decoding-encoding/) -
     Format-specific examples
-  - [Using Filters](https://cross-image.56k.guru/examples/filters/) - Filter
-    workflows and techniques
-  - [Manipulation](https://cross-image.56k.guru/examples/manipulation/) -
-    Resizing, cropping, and compositing
-  - [Multi-Frame Images](https://cross-image.56k.guru/examples/multi-frame/) -
-    Animated GIFs, APNGs, and TIFFs
+  - [Using Filters](https://cross-image.56k.guru/examples/filters/) - Filter workflows and
+    techniques
+  - [Manipulation](https://cross-image.56k.guru/examples/manipulation/) - Resizing, cropping, and
+    compositing
+  - [Multi-Frame Images](https://cross-image.56k.guru/examples/multi-frame/) - Animated GIFs, APNGs,
+    and TIFFs
 - **[JPEG Implementation](https://cross-image.56k.guru/implementation/jpeg-implementation/)** -
   Technical details for JPEG
 - **[WebP Implementation](https://cross-image.56k.guru/implementation/webp-implementation/)** -
@@ -261,24 +491,12 @@ Image.getSupportedMetadata("webp"); // Enhanced XMP + GPS (15 fields - includes
 
 ## Development
 
-### Running Tests
-
 ```bash
-deno test -A
+deno task precommit
 ```
 
-### Linting and Formatting
-
-```bash
-deno fmt --check
-deno lint
-```
-
-### Type Checking
-
-```bash
-deno check mod.ts
-```
+CI validates cross-runtime compatibility (Deno, Bun, Node). See CONTRIBUTING.md for contributor
+workflow details.
 
 ## License
 

package/esm/mod.d.ts

@@ -7,7 +7,7 @@
  *
  * @example
  * ```ts
- * import { Image } from "@cross/image";
+ * import { Image } from "jsr:@cross/image";
  *
  * // Decode an image
  * const data = await Deno.readFile("input.png");
@@ -26,7 +26,7 @@
  *
  * @example
  * ```ts
- * import { Image } from "@cross/image";
+ * import { Image } from "jsr:@cross/image";
  *
  * // Create a blank canvas
  * const canvas = Image.create(400, 300, 255, 255, 255);
@@ -43,13 +43,13 @@
  * ```
  */
 export { Image } from "./src/image.js";
-export type { ASCIIOptions, FrameMetadata, ImageData, ImageFormat, ImageFrame, ImageMetadata, MultiFrameImageData, ResizeOptions, WebPEncodeOptions, } from "./src/types.js";
+export type { ASCIIEncoderOptions, FrameMetadata, ImageData, ImageDecoderOptions, ImageFormat, ImageFrame, ImageMetadata, JPEGEncoderOptions, MultiFrameImageData, ResizeOptions, TIFFEncoderOptions, WebPEncoderOptions, } from "./src/types.js";
 export { PNGFormat } from "./src/formats/png.js";
 export { APNGFormat } from "./src/formats/apng.js";
 export { JPEGFormat } from "./src/formats/jpeg.js";
 export { WebPFormat } from "./src/formats/webp.js";
 export { GIFFormat } from "./src/formats/gif.js";
-export { type TIFFEncodeOptions, TIFFFormat } from "./src/formats/tiff.js";
+export { TIFFFormat } from "./src/formats/tiff.js";
 export { BMPFormat } from "./src/formats/bmp.js";
 export { ICOFormat } from "./src/formats/ico.js";
 export { DNGFormat } from "./src/formats/dng.js";
@@ -57,4 +57,6 @@ export { PAMFormat } from "./src/formats/pam.js";
 export { PCXFormat } from "./src/formats/pcx.js";
 export { PPMFormat } from "./src/formats/ppm.js";
 export { ASCIIFormat } from "./src/formats/ascii.js";
+export { HEICFormat } from "./src/formats/heic.js";
+export { AVIFFormat } from "./src/formats/avif.js";
 //# sourceMappingURL=mod.d.ts.map

package/esm/mod.js

@@ -7,7 +7,7 @@
  *
  * @example
  * ```ts
- * import { Image } from "@cross/image";
+ * import { Image } from "jsr:@cross/image";
  *
  * // Decode an image
  * const data = await Deno.readFile("input.png");
@@ -26,7 +26,7 @@
  *
  * @example
  * ```ts
- * import { Image } from "@cross/image";
+ * import { Image } from "jsr:@cross/image";
  *
  * // Create a blank canvas
  * const canvas = Image.create(400, 300, 255, 255, 255);
@@ -56,3 +56,5 @@ export { PAMFormat } from "./src/formats/pam.js";
 export { PCXFormat } from "./src/formats/pcx.js";
 export { PPMFormat } from "./src/formats/ppm.js";
 export { ASCIIFormat } from "./src/formats/ascii.js";
+export { HEICFormat } from "./src/formats/heic.js";
+export { AVIFFormat } from "./src/formats/avif.js";

package/esm/src/formats/apng.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, MultiFrameImageData } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
 import { PNGBase } from "./png_base.js";
 /**
  * APNG (Animated PNG) format handler
@@ -26,25 +26,37 @@ export declare class APNGFormat extends PNGBase implements ImageFormat {
      * @param data Raw APNG image data
      * @returns Decoded image data with RGBA pixels of first frame
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Decode all frames from APNG image
      * @param data Raw APNG image data
      * @returns Decoded multi-frame image data
      */
-    decodeFrames(data: Uint8Array): Promise<MultiFrameImageData>;
+    decodeFrames(data: Uint8Array, _settings?: ImageDecoderOptions): Promise<MultiFrameImageData>;
     /**
      * Encode RGBA image data to APNG format (single frame)
      * @param imageData Image data to encode
      * @returns Encoded APNG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Encode multi-frame image data to APNG format
      * @param imageData Multi-frame image data to encode
      * @returns Encoded APNG image bytes
      */
-    encodeFrames(imageData: MultiFrameImageData): Promise<Uint8Array>;
+    encodeFrames(imageData: MultiFrameImageData, _options?: unknown): Promise<Uint8Array>;
     private decodeFrameData;
+    /**
+     * Get the list of metadata fields supported by APNG format
+     * Includes all PNG fields plus frame count
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from APNG data without fully decoding the pixel data
+     * This quickly parses PNG chunks to extract metadata including frame count
+     * @param data Raw APNG data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=apng.d.ts.map