image-in-browser/lib/index.js

Package for encoding / decoding images, transforming images, applying filters, drawing primitives on images on the client side (no need for server Node.js)

import { BmpDecoder } from './formats/bmp-decoder.js';
import { BmpEncoder } from './formats/bmp-encoder.js';
import { GifDecoder } from './formats/gif-decoder.js';
import { GifEncoder } from './formats/gif-encoder.js';
import { IcoDecoder } from './formats/ico-decoder.js';
import { IcoEncoder } from './formats/ico-encoder.js';
import { JpegDecoder } from './formats/jpeg-decoder.js';
import { JpegChroma, JpegEncoder } from './formats/jpeg-encoder.js';
import { PngDecoder } from './formats/png-decoder.js';
import { PngEncoder } from './formats/png-encoder.js';
import { TgaDecoder } from './formats/tga-decoder.js';
import { TgaEncoder } from './formats/tga-encoder.js';
import { TiffDecoder } from './formats/tiff-decoder.js';
import { TiffEncoder } from './formats/tiff-encoder.js';
import { PngFilterType } from './formats/png/png-filter-type.js';
import { DitherKernel } from './filter/dither-kernel.js';
import { JpegUtils } from './formats/jpeg/jpeg-utils.js';
import { WebPDecoder } from './formats/webp-decoder.js';
import { PnmDecoder } from './formats/pnm-decoder.js';
import { ImageFormat } from './formats/image-format.js';
import { PsdDecoder } from './formats/psd-decoder.js';
import { PvrEncoder } from './formats/pvr-encoder.js';
import { PvrDecoder } from './formats/pvr-decoder.js';
export { ChannelOrder, ChannelOrderLength } from './color/channel-order.js';
export { Channel } from './color/channel.js';
export { ColorFloat16 } from './color/color-float16.js';
export { ColorFloat32 } from './color/color-float32.js';
export { ColorFloat64 } from './color/color-float64.js';
export { ColorInt8 } from './color/color-int8.js';
export { ColorInt16 } from './color/color-int16.js';
export { ColorInt32 } from './color/color-int32.js';
export { ColorRgb8 } from './color/color-rgb8.js';
export { ColorRgba8 } from './color/color-rgba8.js';
export { ColorUint1 } from './color/color-uint1.js';
export { ColorUint2 } from './color/color-uint2.js';
export { ColorUint4 } from './color/color-uint4.js';
export { ColorUint8 } from './color/color-uint8.js';
export { ColorUint16 } from './color/color-uint16.js';
export { ColorUint32 } from './color/color-uint32.js';
export { Format, FormatType, FormatMaxValue, FormatSize, FormatToFormatType, getRowStride, convertFormatValue, } from './color/format.js';
export { ColorUtils } from './color/color-utils.js';
export { ArrayUtils } from './common/array-utils.js';
export { BitUtils } from './common/bit-utils.js';
export { Crc32 } from './common/crc32.js';
export { Float16 } from './common/float16.js';
export { InputBuffer } from './common/input-buffer.js';
export { Interpolation } from './common/interpolation.js';
export { Line } from './common/line.js';
export { MathUtils } from './common/math-utils.js';
export { OutputBuffer, } from './common/output-buffer.js';
export { Point } from './common/point.js';
export { RandomUtils } from './common/random-utils.js';
export { Rational } from './common/rational.js';
export { Rectangle } from './common/rectangle.js';
export { StringUtils } from './common/string-utils.js';
export { BlendMode } from './draw/blend-mode.js';
export { CircleQuadrant } from './draw/circle-quadrant.js';
export { Draw, } from './draw/draw.js';
export { LibError } from './error/lib-error.js';
export { IfdAsciiValue } from './exif/ifd-value/ifd-ascii-value.js';
export { IfdByteValue } from './exif/ifd-value/ifd-byte-value.js';
export { IfdDoubleValue } from './exif/ifd-value/ifd-double-value.js';
export { IfdLongValue } from './exif/ifd-value/ifd-long-value.js';
export { IfdRationalValue } from './exif/ifd-value/ifd-rational-value.js';
export { IfdSByteValue } from './exif/ifd-value/ifd-sbyte-value.js';
export { IfdShortValue } from './exif/ifd-value/ifd-short-value.js';
export { IfdSingleValue } from './exif/ifd-value/ifd-single-value.js';
export { IfdSLongValue } from './exif/ifd-value/ifd-slong-value.js';
export { IfdSRationalValue } from './exif/ifd-value/ifd-srational-value.js';
export { IfdSShortValue } from './exif/ifd-value/ifd-sshort-value.js';
export { IfdUndefinedValue } from './exif/ifd-value/ifd-undefined-value.js';
export { IfdValue } from './exif/ifd-value/ifd-value.js';
export { ExifData } from './exif/exif-data.js';
export { ExifEntry } from './exif/exif-entry.js';
export { ExifTag, ExifGpsTags, ExifImageTags, ExifInteropTags, ExifTagNameToID, } from './exif/exif-tag.js';
export { IfdContainer } from './exif/ifd-container.js';
export { IfdDirectory } from './exif/ifd-directory.js';
export { IfdValueType, IfdValueTypeSize, getIfdValueTypeSize, getIfdValueTypeString, } from './exif/ifd-value-type.js';
export { ContrastMode } from './filter/contrast-mode.js';
export { DitherKernel, DitherKernels } from './filter/dither-kernel.js';
export { Filter, } from './filter/filter.js';
export { NoiseType } from './filter/noise-type.js';
export { PixelateMode } from './filter/pixelate-mode.js';
export { QuantizeMethod } from './filter/quantize-method.js';
export { SeparableKernel, } from './filter/separable-kernel.js';
export { SolarizeMode } from './filter/solarize-mode.js';
export { BmpCompressionMode } from './formats/bmp/bmp-compression-mode.js';
export { BmpFileHeader } from './formats/bmp/bmp-file-header.js';
export { BmpInfo } from './formats/bmp/bmp-info.js';
export { GifColorMap } from './formats/gif/gif-color-map.js';
export { GifImageDesc } from './formats/gif/gif-image-desc.js';
export { GifInfo } from './formats/gif/gif-info.js';
export { IcoBmpInfo } from './formats/ico/ico-bmp-info.js';
export { IcoInfoImage, } from './formats/ico/ico-info-image.js';
export { IcoInfo } from './formats/ico/ico-info.js';
export { IcoType, IcoTypeLength } from './formats/ico/ico-type.js';
export { HuffmanNode } from './formats/jpeg/huffman-node.js';
export { HuffmanParent } from './formats/jpeg/huffman-parent.js';
export { HuffmanValue } from './formats/jpeg/huffman-value.js';
export { JpegAdobe } from './formats/jpeg/jpeg-adobe.js';
export { JpegComponentData } from './formats/jpeg/jpeg-component-data.js';
export { JpegComponent } from './formats/jpeg/jpeg-component.js';
export { JpegData } from './formats/jpeg/jpeg-data.js';
export { JpegFrame } from './formats/jpeg/jpeg-frame.js';
export { JpegHuffman } from './formats/jpeg/jpeg-huffman.js';
export { JpegInfo } from './formats/jpeg/jpeg-info.js';
export { JpegJfif } from './formats/jpeg/jpeg-jfif.js';
export { JpegMarker } from './formats/jpeg/jpeg-marker.js';
export { JpegQuantize } from './formats/jpeg/jpeg-quantize.js';
export { JpegScan } from './formats/jpeg/jpeg-scan.js';
export { JpegUtils } from './formats/jpeg/jpeg-utils.js';
export { PngBlendMode } from './formats/png/png-blend-mode.js';
export { PngColorType } from './formats/png/png-color-type.js';
export { PngDisposeMode } from './formats/png/png-dispose-mode.js';
export { PngFilterType } from './formats/png/png-filter-type.js';
export { PngFrame } from './formats/png/png-frame.js';
export { PngInfo } from './formats/png/png-info.js';
export { PngPhysicalPixelDimensions } from './formats/png/png-physical-pixel-dimensions.js';
export { PnmFormat } from './formats/pnm/pnm-format.js';
export { PnmInfo } from './formats/pnm/pnm-info.js';
export { PsdBevelEffect, } from './formats/psd/effect/psd-bevel-effect.js';
export { PsdDropShadowEffect, } from './formats/psd/effect/psd-drop-shadow-effect.js';
export { PsdEffect, } from './formats/psd/effect/psd-effect.js';
export { PsdInnerGlowEffect, } from './formats/psd/effect/psd-inner-glow-effect.js';
export { PsdInnerShadowEffect, } from './formats/psd/effect/psd-inner-shadow-effect.js';
export { PsdOuterGlowEffect, } from './formats/psd/effect/psd-outer-glow-effect.js';
export { PsdSolidFillEffect, } from './formats/psd/effect/psd-solid-fill-effect.js';
export { PsdLayerDataFactory } from './formats/psd/layer-data/psd-layer-data-factory.js';
export { PsdLayerData } from './formats/psd/layer-data/psd-layer-data.js';
export { PsdLayerAdditionalData } from './formats/psd/layer-data/psd-layer-additional-data.js';
export { PsdLayerSectionDivider } from './formats/psd/layer-data/psd-layer-section-divider.js';
export { PsdBlendMode } from './formats/psd/psd-blend-mode.js';
export { PsdBlendingRanges } from './formats/psd/psd-blending-ranges.js';
export { PsdChannel, } from './formats/psd/psd-channel.js';
export { PsdColorMode } from './formats/psd/psd-color-mode.js';
export { PsdFlag } from './formats/psd/psd-flag.js';
export { PsdImage } from './formats/psd/psd-image.js';
export { PsdImageResource } from './formats/psd/psd-image-resource.js';
export { PsdLayer } from './formats/psd/psd-layer.js';
export { PsdMask } from './formats/psd/psd-mask.js';
export { PvrAppleInfo, } from './formats/pvr/pvr-apple-info.js';
export { PvrBitUtility } from './formats/pvr/pvr-bit-utility.js';
export { PvrColorBoundingBox } from './formats/pvr/pvr-color-bounding-box.js';
export { PvrColorRgb } from './formats/pvr/pvr-color-rgb.js';
export { PvrColorRgba } from './formats/pvr/pvr-color-rgba.js';
export { PvrFormat } from './formats/pvr/pvr-format.js';
export { PvrPacket } from './formats/pvr/pvr-packet.js';
export { Pvr2Info } from './formats/pvr/pvr2-info.js';
export { Pvr3Info } from './formats/pvr/pvr3-info.js';
export { TgaImageType, TgaImageTypeLength, } from './formats/tga/tga-image-type.js';
export { TgaInfo } from './formats/tga/tga-info.js';
export { TiffBitReader } from './formats/tiff/tiff-bit-reader.js';
export { TiffCompression } from './formats/tiff/tiff-compression.js';
export { TiffEntry } from './formats/tiff/tiff-entry.js';
export { TiffFaxDecoder, } from './formats/tiff/tiff-fax-decoder.js';
export { TiffFormat } from './formats/tiff/tiff-format.js';
export { TiffImageType } from './formats/tiff/tiff-image-type.js';
export { TiffImage } from './formats/tiff/tiff-image.js';
export { TiffInfo } from './formats/tiff/tiff-info.js';
export { LzwDecoder } from './formats/tiff/tiff-lzw-decoder.js';
export { TiffPhotometricType, TiffPhotometricTypeLength, } from './formats/tiff/tiff-photometric-type.js';
export { VP8BandProbas } from './formats/webp/vp8-band-probas.js';
export { VP8BitReader } from './formats/webp/vp8-bit-reader.js';
export { VP8FInfo } from './formats/webp/vp8-f-info.js';
export { VP8FilterHeader } from './formats/webp/vp8-filter-header.js';
export { VP8Filter } from './formats/webp/vp8-filter.js';
export { VP8FrameHeader } from './formats/webp/vp8-frame-header.js';
export { VP8MBData } from './formats/webp/vp8-mb-data.js';
export { VP8MB } from './formats/webp/vp8-mb.js';
export { VP8PictureHeader } from './formats/webp/vp8-picture-header.js';
export { VP8Proba } from './formats/webp/vp8-proba.js';
export { VP8QuantMatrix } from './formats/webp/vp8-quant-matrix.js';
export { VP8Random } from './formats/webp/vp8-random.js';
export { VP8SegmentHeader } from './formats/webp/vp8-segment-header.js';
export { VP8TopSamples } from './formats/webp/vp8-top-samples.js';
export { VP8 } from './formats/webp/vp8.js';
export { VP8LBitReader } from './formats/webp/vp8l-bit-reader.js';
export { VP8LColorCache } from './formats/webp/vp8l-color-cache.js';
export { VP8LImageTransformType } from './formats/webp/vp8l-image-transform-type.js';
export { VP8LInternal } from './formats/webp/vp8l-internal.js';
export { VP8LMultipliers } from './formats/webp/vp8l-multipliers.js';
export { VP8LTransform } from './formats/webp/vp8l-transform.js';
export { VP8L } from './formats/webp/vp8l.js';
export { WebPAlpha } from './formats/webp/webp-alpha.js';
export { WebPFilters } from './formats/webp/webp-filters.js';
export { WebPFormat } from './formats/webp/webp-format.js';
export { WebPFrame } from './formats/webp/webp-frame.js';
export { HuffmanTreeGroup } from './formats/webp/webp-huffman-tree-group.js';
export { HuffmanTree } from './formats/webp/webp-huffman-tree.js';
export { WebPInfoInternal } from './formats/webp/webp-info-internal.js';
export { WebPInfo } from './formats/webp/webp-info.js';
export { BmpDecoder } from './formats/bmp-decoder.js';
export { BmpEncoder } from './formats/bmp-encoder.js';
export { DibDecoder } from './formats/dib-decoder.js';
export { GifDecoder } from './formats/gif-decoder.js';
export { GifEncoder } from './formats/gif-encoder.js';
export { IcoDecoder } from './formats/ico-decoder.js';
export { IcoEncoder } from './formats/ico-encoder.js';
export { ImageFormat } from './formats/image-format.js';
export { JpegDecoder } from './formats/jpeg-decoder.js';
export { JpegChroma, JpegEncoder, } from './formats/jpeg-encoder.js';
export { PngDecoder } from './formats/png-decoder.js';
export { PngEncoder } from './formats/png-encoder.js';
export { PnmDecoder } from './formats/pnm-decoder.js';
export { PsdDecoder } from './formats/psd-decoder.js';
export { PvrDecoder } from './formats/pvr-decoder.js';
export { PvrEncoder } from './formats/pvr-encoder.js';
export { TgaDecoder } from './formats/tga-decoder.js';
export { TgaEncoder } from './formats/tga-encoder.js';
export { TiffDecoder } from './formats/tiff-decoder.js';
export { TiffEncoder } from './formats/tiff-encoder.js';
export { WebPDecoder } from './formats/webp-decoder.js';
export { WinEncoder } from './formats/win-encoder.js';
export { BinaryQuantizer } from './image/binary-quantizer.js';
export { FrameType } from './image/frame-type.js';
export { HeapNode } from './image/heap-node.js';
export { IccProfile } from './image/icc-profile.js';
export { IccProfileCompression } from './image/icc-profile-compression.js';
export { MemoryImageDataFloat16 } from './image/image-data-float16.js';
export { MemoryImageDataFloat32 } from './image/image-data-float32.js';
export { MemoryImageDataFloat64 } from './image/image-data-float64.js';
export { MemoryImageDataInt8 } from './image/image-data-int8.js';
export { MemoryImageDataInt16 } from './image/image-data-int16.js';
export { MemoryImageDataInt32 } from './image/image-data-int32.js';
export { MemoryImageDataUint1 } from './image/image-data-uint1.js';
export { MemoryImageDataUint2 } from './image/image-data-uint2.js';
export { MemoryImageDataUint4 } from './image/image-data-uint4.js';
export { MemoryImageDataUint8 } from './image/image-data-uint8.js';
export { MemoryImageDataUint16 } from './image/image-data-uint16.js';
export { MemoryImageDataUint32 } from './image/image-data-uint32.js';
export { ImageUtils } from './image/image-utils.js';
export { MemoryImage, } from './image/image.js';
export { NeuralQuantizer } from './image/neural-quantizer.js';
export { OctreeNode } from './image/octree-node.js';
export { OctreeQuantizer } from './image/octree-quantizer.js';
export { PaletteFloat16 } from './image/palette-float16.js';
export { PaletteFloat32 } from './image/palette-float32.js';
export { PaletteFloat64 } from './image/palette-float64.js';
export { PaletteInt8 } from './image/palette-int8.js';
export { PaletteInt16 } from './image/palette-int16.js';
export { PaletteInt32 } from './image/palette-int32.js';
export { PaletteUint8 } from './image/palette-uint8.js';
export { PaletteUint16 } from './image/palette-uint16.js';
export { PaletteUint32 } from './image/palette-uint32.js';
export { PixelFloat16 } from './image/pixel-float16.js';
export { PixelFloat32 } from './image/pixel-float32.js';
export { PixelFloat64 } from './image/pixel-float64.js';
export { PixelInt8 } from './image/pixel-int8.js';
export { PixelInt16 } from './image/pixel-int16.js';
export { PixelInt32 } from './image/pixel-int32.js';
export { PixelUint1 } from './image/pixel-uint1.js';
export { PixelUint2 } from './image/pixel-uint2.js';
export { PixelUint4 } from './image/pixel-uint4.js';
export { PixelUint8 } from './image/pixel-uint8.js';
export { PixelUint16 } from './image/pixel-uint16.js';
export { PixelUint32 } from './image/pixel-uint32.js';
export { PixelUndefined } from './image/pixel-undefined.js';
export { PixelRangeIterator } from './image/pixel-range-iterator.js';
export { UndefinedPixel } from './image/pixel.js';
export { QuantizerType } from './image/quantizer-type.js';
export { ExpandCanvasPosition } from './transform/expand-canvas-position.js';
export { FlipDirection } from './transform/flip-direction.js';
export { Transform, } from './transform/transform.js';
export { TrimMode } from './transform/trim-mode.js';
export { TrimSide } from './transform/trim-side.js';
export function findDecoderForMimeType(mimeType) {
    const type = mimeType.toLowerCase();
    switch (type) {
        case 'image/jpeg':
            return new JpegDecoder();
        case 'image/png':
            return new PngDecoder();
        case 'image/x-targa':
        case 'image/x-tga':
            return new TgaDecoder();
        case 'image/webp':
            return new WebPDecoder();
        case 'image/gif':
            return new GifDecoder();
        case 'image/tiff':
        case 'image/tiff-fx':
            return new TiffDecoder();
        case 'application/photoshop':
        case 'application/psd':
        case 'application/x-photoshop':
        case 'image/psd':
        case 'image/vnd.adobe.photoshop':
            return new PsdDecoder();
        case 'image/bmp':
        case 'image/x-bmp':
            return new BmpDecoder();
        case 'image/x-icon':
        case 'image/vnd.microsoft.icon':
            return new IcoDecoder();
        case 'image/x-portable-bitmap':
        case 'image/x-portable-pixmap':
        case 'image/x-portable-anymap':
            return new PnmDecoder();
        case 'image/x-pvr':
            return new PvrDecoder();
        default:
            return undefined;
    }
}
export function findDecoderForNamedImage(name) {
    const n = name.toLowerCase();
    if (n.endsWith('.jpg') || n.endsWith('.jpeg')) {
        return new JpegDecoder();
    }
    if (n.endsWith('.png')) {
        return new PngDecoder();
    }
    if (n.endsWith('.tga')) {
        return new TgaDecoder();
    }
    if (n.endsWith('.webp')) {
        return new WebPDecoder();
    }
    if (n.endsWith('.gif')) {
        return new GifDecoder();
    }
    if (n.endsWith('.tif') || n.endsWith('.tiff')) {
        return new TiffDecoder();
    }
    if (n.endsWith('.psd')) {
        return new PsdDecoder();
    }
    if (n.endsWith('.bmp')) {
        return new BmpDecoder();
    }
    if (n.endsWith('.ico')) {
        return new IcoDecoder();
    }
    if (n.endsWith('.pnm') ||
        n.endsWith('.pbm') ||
        n.endsWith('.pgm') ||
        n.endsWith('.ppm')) {
        return new PnmDecoder();
    }
    if (n.endsWith('.pvr')) {
        return new PvrDecoder();
    }
    return undefined;
}
export function findEncoderForMimeType(mimeType) {
    const type = mimeType.toLowerCase();
    switch (type) {
        case 'image/jpeg':
            return new JpegEncoder();
        case 'image/png':
            return new PngEncoder();
        case 'image/x-targa':
        case 'image/x-tga':
            return new TgaEncoder();
        case 'image/gif':
            return new GifEncoder();
        case 'image/tiff':
        case 'image/tiff-fx':
            return new TiffEncoder();
        case 'image/bmp':
        case 'image/x-bmp':
            return new BmpEncoder();
        case 'image/x-icon':
        case 'image/vnd.microsoft.icon':
            return new IcoEncoder();
        case 'image/x-pvr':
            return new PvrEncoder();
        default:
            return undefined;
    }
}
export function findEncoderForNamedImage(name) {
    const n = name.toLowerCase();
    if (n.endsWith('.jpg') || n.endsWith('.jpeg')) {
        return new JpegEncoder();
    }
    if (n.endsWith('.png')) {
        return new PngEncoder();
    }
    if (n.endsWith('.tga')) {
        return new TgaEncoder();
    }
    if (n.endsWith('.gif')) {
        return new GifEncoder();
    }
    if (n.endsWith('.tif') || n.endsWith('.tiff')) {
        return new TiffEncoder();
    }
    if (n.endsWith('.bmp')) {
        return new BmpEncoder();
    }
    if (n.endsWith('.ico')) {
        return new IcoEncoder();
    }
    if (n.endsWith('.cur')) {
        return new IcoEncoder();
    }
    if (n.endsWith('.pvr')) {
        return new PvrEncoder();
    }
    return undefined;
}
export function findFormatForData(data) {
    const decoder = findDecoderForData(data);
    if (decoder === undefined) {
        return ImageFormat.invalid;
    }
    return decoder.format;
}
export function findDecoderForFormat(format) {
    switch (format) {
        case ImageFormat.bmp:
            return new BmpDecoder();
        case ImageFormat.gif:
            return new GifDecoder();
        case ImageFormat.ico:
            return new IcoDecoder();
        case ImageFormat.jpg:
            return new JpegDecoder();
        case ImageFormat.png:
            return new PngDecoder();
        case ImageFormat.pnm:
            return new PnmDecoder();
        case ImageFormat.psd:
            return new PsdDecoder();
        case ImageFormat.pvr:
            return new PvrDecoder();
        case ImageFormat.tga:
            return new TgaDecoder();
        case ImageFormat.tiff:
            return new TiffDecoder();
        case ImageFormat.webp:
            return new WebPDecoder();
        default:
            return undefined;
    }
}
export function findDecoderForData(data) {
    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
    const jpg = new JpegDecoder();
    if (jpg.isValidFile(bytes)) {
        return jpg;
    }
    const png = new PngDecoder();
    if (png.isValidFile(bytes)) {
        return png;
    }
    const gif = new GifDecoder();
    if (gif.isValidFile(bytes)) {
        return gif;
    }
    const webp = new WebPDecoder();
    if (webp.isValidFile(bytes)) {
        return webp;
    }
    const tiff = new TiffDecoder();
    if (tiff.isValidFile(bytes)) {
        return tiff;
    }
    const psd = new PsdDecoder();
    if (psd.isValidFile(bytes)) {
        return psd;
    }
    const bmp = new BmpDecoder();
    if (bmp.isValidFile(bytes)) {
        return bmp;
    }
    const tga = new TgaDecoder();
    if (tga.isValidFile(bytes)) {
        return tga;
    }
    const ico = new IcoDecoder();
    if (ico.isValidFile(bytes)) {
        return ico;
    }
    const pvr = new PvrDecoder();
    if (pvr.isValidFile(bytes)) {
        return pvr;
    }
    const pnm = new PnmDecoder();
    if (pnm.isValidFile(bytes)) {
        return pnm;
    }
    return undefined;
}
export function decodeImage(opt) {
    const decoder = findDecoderForData(opt.data);
    if (decoder === undefined) {
        return undefined;
    }
    const dataUint8 = new Uint8Array(opt.data);
    if (opt.largest === true && decoder instanceof IcoDecoder) {
        return decoder.decodeImageLargest(dataUint8);
    }
    return decoder.decode({
        bytes: dataUint8,
        frameIndex: opt.frameIndex,
    });
}
export function decodeImageByMimeType(opt) {
    const decoder = findDecoderForMimeType(opt.mimeType);
    if (decoder !== undefined) {
        const dataUint8 = new Uint8Array(opt.data);
        if (opt.largest === true && decoder instanceof IcoDecoder) {
            return decoder.decodeImageLargest(dataUint8);
        }
        return decoder.decode({
            bytes: dataUint8,
            frameIndex: opt.frameIndex,
        });
    }
    return decodeImage(opt);
}
export function decodeNamedImage(opt) {
    const decoder = findDecoderForNamedImage(opt.name);
    if (decoder !== undefined) {
        const dataUint8 = new Uint8Array(opt.data);
        if (opt.largest === true && decoder instanceof IcoDecoder) {
            return decoder.decodeImageLargest(dataUint8);
        }
        return decoder.decode({
            bytes: dataUint8,
            frameIndex: opt.frameIndex,
        });
    }
    return decodeImage(opt);
}
export function encodeImageByMimeType(opt) {
    var _a;
    const skipExif = (_a = opt.skipExif) !== null && _a !== void 0 ? _a : false;
    const encoder = findEncoderForMimeType(opt.mimeType);
    if (encoder === undefined) {
        return undefined;
    }
    return encoder.encode({
        image: opt.image,
        skipExif: skipExif,
    });
}
export function encodeNamedImage(opt) {
    var _a;
    const skipExif = (_a = opt.skipExif) !== null && _a !== void 0 ? _a : false;
    const encoder = findEncoderForNamedImage(opt.name);
    if (encoder === undefined) {
        return undefined;
    }
    return encoder.encode({
        image: opt.image,
        skipExif: skipExif,
    });
}
export function decodeJpg(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    return new JpegDecoder().decode({
        bytes: dataUint8,
    });
}
export function encodeJpg(opt) {
    var _a, _b, _c;
    const skipExif = (_a = opt.skipExif) !== null && _a !== void 0 ? _a : false;
    const quality = (_b = opt.quality) !== null && _b !== void 0 ? _b : 100;
    const chroma = (_c = opt.chroma) !== null && _c !== void 0 ? _c : JpegChroma.yuv444;
    return new JpegEncoder(quality).encode({
        image: opt.image,
        chroma: chroma,
        skipExif: skipExif,
    });
}
export function decodeJpgExif(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    return new JpegUtils().decodeExif(dataUint8);
}
export function injectJpgExif(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    return new JpegUtils().injectExif(opt.exifData, dataUint8);
}
export function decodePng(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    return new PngDecoder().decode({
        bytes: dataUint8,
        frameIndex: opt.frameIndex,
    });
}
export function encodePng(opt) {
    var _a, _b, _c;
    const singleFrame = (_a = opt.singleFrame) !== null && _a !== void 0 ? _a : false;
    const level = (_b = opt.level) !== null && _b !== void 0 ? _b : 6;
    const filter = (_c = opt.filter) !== null && _c !== void 0 ? _c : PngFilterType.paeth;
    return new PngEncoder({
        filter: filter,
        level: level,
    }).encode({
        image: opt.image,
        singleFrame: singleFrame,
    });
}
export function decodePnm(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    return new PnmDecoder().decode({
        bytes: dataUint8,
    });
}
export function decodeTga(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    return new TgaDecoder().decode({
        bytes: dataUint8,
        frameIndex: opt.frameIndex,
    });
}
export function encodeTga(opt) {
    return new TgaEncoder().encode({
        image: opt.image,
    });
}
export function decodeWebP(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    return new WebPDecoder().decode({
        bytes: dataUint8,
        frameIndex: opt.frameIndex,
    });
}
export function decodeGif(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    return new GifDecoder().decode({
        bytes: dataUint8,
        frameIndex: opt.frameIndex,
    });
}
export function encodeGif(opt) {
    var _a, _b, _c, _d, _e;
    const singleFrame = (_a = opt.singleFrame) !== null && _a !== void 0 ? _a : false;
    const repeat = (_b = opt.repeat) !== null && _b !== void 0 ? _b : 0;
    const samplingFactor = (_c = opt.samplingFactor) !== null && _c !== void 0 ? _c : 10;
    const dither = (_d = opt.dither) !== null && _d !== void 0 ? _d : DitherKernel.floydSteinberg;
    const ditherSerpentine = (_e = opt.ditherSerpentine) !== null && _e !== void 0 ? _e : false;
    return new GifEncoder({
        repeat: repeat,
        samplingFactor: samplingFactor,
        dither: dither,
        ditherSerpentine: ditherSerpentine,
    }).encode({
        image: opt.image,
        singleFrame: singleFrame,
    });
}
export function decodeTiff(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    return new TiffDecoder().decode({
        bytes: dataUint8,
        frameIndex: opt.frameIndex,
    });
}
export function encodeTiff(opt) {
    var _a, _b;
    const singleFrame = (_a = opt.singleFrame) !== null && _a !== void 0 ? _a : false;
    const skipExif = (_b = opt.skipExif) !== null && _b !== void 0 ? _b : false;
    return new TiffEncoder().encode({
        image: opt.image,
        singleFrame: singleFrame,
        skipExif: skipExif,
    });
}
export function decodePsd(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    return new PsdDecoder().decode({
        bytes: dataUint8,
    });
}
export function decodeBmp(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    return new BmpDecoder().decode({
        bytes: dataUint8,
    });
}
export function encodeBmp(opt) {
    return new BmpEncoder().encode({
        image: opt.image,
    });
}
export function decodeIco(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    const decoder = new IcoDecoder();
    if (opt.largest === true) {
        return decoder.decodeImageLargest(dataUint8);
    }
    return decoder.decode({
        bytes: dataUint8,
        frameIndex: opt.frameIndex,
    });
}
export function encodeIco(opt) {
    var _a;
    const singleFrame = (_a = opt.singleFrame) !== null && _a !== void 0 ? _a : false;
    return new IcoEncoder().encode({
        image: opt.image,
        singleFrame: singleFrame,
    });
}
export function encodeIcoImages(opt) {
    return new IcoEncoder().encodeImages(opt.images);
}
export function decodePvr(opt) {
    const dataUint8 = new Uint8Array(opt.data);
    return new PvrDecoder().decode({
        bytes: dataUint8,
    });
}
export function encodePvr(opt) {
    return new PvrEncoder().encode({
        image: opt.image,
    });
}
//# sourceMappingURL=index.js.map