Update exported types for image parsers.

README.md

@@ -136,8 +136,6 @@ import { JpegParser } from './bitjs/image/parsers/jpeg.js'
 import { ExifTagNumber } from './bitjs/image/parsers/exif.js';
 
 const parser = new JpegParser(someArrayBuffer);
-let exif;
-const parser = new JpegParser(ab);
 parser.onApp1Exif(evt => {
   console.log(evt.exifValueMap.get(ExifTagNumber.IMAGE_DESCRIPTION).stringValue);
 });

image/parsers/jpeg.js

@@ -34,7 +34,7 @@ export const JpegParseEventType = {
 }
 
 /** @enum {number} */
-const JpegSegmentType = {
+export const JpegSegmentType = {
   SOF0: 0xC0,
   SOF1: 0xC1,
   SOF2: 0xC2,
@@ -155,14 +155,14 @@ export class JpegDefineHuffmanTableEvent extends Event {
 }
 
 /** @enum {number} */
-const JpegDctType = {
+export const JpegDctType = {
   BASELINE: 0,
   EXTENDED_SEQUENTIAL: 1,
   PROGRESSIVE: 2,
 };
 
 /** @enum {number} */
-const JpegComponentType = {
+export const JpegComponentType = {
   Y: 1,
   CB: 2,
   CR: 3,

index.js

@@ -6,15 +6,26 @@
  * Copyright(c) 2020 Google Inc.
  */
 
-/**
- * @typedef {import('./codecs/codecs.js').ProbeStream} ProbeStream
- */
-/**
- * @typedef {import('./codecs/codecs.js').ProbeFormat} ProbeFormat
- */
-/**
- * @typedef {import('./codecs/codecs.js').ProbeInfo} ProbeInfo
- */
+/** @typedef {import('./codecs/codecs.js').ProbeStream} ProbeStream */
+/** @typedef {import('./codecs/codecs.js').ProbeFormat} ProbeFormat */
+/** @typedef {import('./codecs/codecs.js').ProbeInfo} ProbeInfo */
+
+/** @typedef {import('./image/parsers/gif.js').GifApplicationExtension} GifApplicationExtension */
+/** @typedef {import('./image/parsers/gif.js').GifColor} GifColor */
+/** @typedef {import('./image/parsers/gif.js').GifCommentExtension} GifCommentExtension */
+/** @typedef {import('./image/parsers/gif.js').GifGraphicControlExtension} GifGraphicControlExtension */
+/** @typedef {import('./image/parsers/gif.js').GifHeader} GifHeader */
+/** @typedef {import('./image/parsers/gif.js').GifLogicalScreen} GifLogicalScreen */
+/** @typedef {import('./image/parsers/gif.js').GifPlainTextExtension} GifPlainTextExtension */
+/** @typedef {import('./image/parsers/gif.js').GifTableBasedImage} GifTableBasedImage */
+
+/** @typedef {import('./image/parsers/jpeg.js').JpegApp0Extension} JpegApp0Extension */
+/** @typedef {import('./image/parsers/jpeg.js').JpegApp0Marker} JpegApp0Marker */
+/** @typedef {import('./image/parsers/jpeg.js').JpegComponentDetail} JpegComponentDetail */
+/** @typedef {import('./image/parsers/jpeg.js').JpegDefineHuffmanTable} JpegDefineHuffmanTable */
+/** @typedef {import('./image/parsers/jpeg.js').JpegDefineQuantizationTable} JpegDefineQuantizationTable */
+/** @typedef {import('./image/parsers/jpeg.js').JpegStartOfFrame} JpegStartOfFrame */
+/** @typedef {import('./image/parsers/jpeg.js').JpegStartOfScan} JpegStartOfScan */
 
 export {
   UnarchiveEvent, UnarchiveEventType, UnarchiveInfoEvent, UnarchiveErrorEvent,
@@ -26,6 +37,11 @@ export { findMimeType } from './file/sniffer.js';
 export { GifApplicationExtensionEvent, GifCommentExtensionEvent, GifGraphicControlExtensionEvent,
          GifHeaderEvent, GifLogicalScreenEvent, GifParseEventType, GifParser,
          GifPlainTextExtensionEvent, GifTableBasedImageEvent } from './image/parsers/gif.js';
+export { JpegApp0ExtensionEvent, JpegApp0MarkerEvent, JpegApp1ExifEvent, JpegComponentType,
+         JpegDctType, JpegDefineHuffmanTableEvent, JpegDefineQuantizationTableEvent,
+         JpegDensityUnits, JpegExtensionThumbnailFormat, JpegHuffmanTableType, JpegParseEventType,
+         JpegParser, JpegSegmentType, JpegStartOfFrameEvent,
+         JpegStartOfScanEvent } from './image/parsers/jpeg.js';
 export { convertWebPtoPNG, convertWebPtoJPG } from './image/webp-shim/webp-shim.js';
 export { BitBuffer } from './io/bitbuffer.js';
 export { BitStream } from './io/bitstream.js';

io/bytestream.js

@@ -73,7 +73,7 @@ export class ByteStream {
 
   /**
    * Big-Endian is sometimes called Motorola-style.
-   * @param {boolean=} The value to set. If not present, the stream is set to big-endian.
+   * @param {boolean=} val The value to set. If not present, the stream is set to big-endian.
    */
   setBigEndian(val = true) {
     this.littleEndian_ = !val;
@@ -81,7 +81,7 @@ export class ByteStream {
 
   /**
    * Little-Endian is sometimes called Intel-style.
-   * @param {boolean=} The value to set. If not present, the stream is set to little-endian.
+   * @param {boolean=} val The value to set. If not present, the stream is set to little-endian.
    */
   setLittleEndian(val = true) {
     this.littleEndian_ = val;

package.json

@@ -19,6 +19,7 @@
     "file",
     "codecs",
     "gif",
+    "jpeg",
     "mp4",
     "avc",
     "webm",

types/image/parsers/exif.d.ts

@@ -0,0 +1,127 @@
+/**
+ * @param {ByteStream} stream
+ * @param {ByteStream} lookAheadStream
+ * @param {boolean} debug
+ * @returns {ExifValue}
+ */
+export function getExifValue(stream: ByteStream, lookAheadStream: ByteStream, DEBUG?: boolean): ExifValue;
+export type ExifTagNumber = number;
+export namespace ExifTagNumber {
+    const IMAGE_DESCRIPTION: number;
+    const MAKE: number;
+    const MODEL: number;
+    const ORIENTATION: number;
+    const X_RESOLUTION: number;
+    const Y_RESOLUTION: number;
+    const RESOLUTION_UNIT: number;
+    const SOFTWARE: number;
+    const DATE_TIME: number;
+    const WHITE_POINT: number;
+    const PRIMARY_CHROMATICITIES: number;
+    const Y_CB_CR_COEFFICIENTS: number;
+    const Y_CB_CR_POSITIONING: number;
+    const REFERENCE_BLACK_WHITE: number;
+    const COPYRIGHT: number;
+    const EXIF_OFFSET: number;
+    const EXPOSURE_TIME: number;
+    const F_NUMBER: number;
+    const EXPOSURE_PROGRAM: number;
+    const ISO_SPEED_RATINGS: number;
+    const EXIF_VERSION: number;
+    const DATE_TIME_ORIGINAL: number;
+    const DATE_TIME_DIGITIZED: number;
+    const COMPONENT_CONFIGURATION: number;
+    const COMPRESSED_BITS_PER_PIXEL: number;
+    const SHUTTER_SPEED_VALUE: number;
+    const APERTURE_VALUE: number;
+    const BRIGHTNESS_VALUE: number;
+    const EXPOSURE_BIAS_VALUE: number;
+    const MAX_APERTURE_VALUE: number;
+    const SUBJECT_DISTANCE: number;
+    const METERING_MODE: number;
+    const LIGHT_SOURCE: number;
+    const FLASH: number;
+    const FOCAL_LENGTH: number;
+    const MAKER_NOTE: number;
+    const USER_COMMENT: number;
+    const FLASH_PIX_VERSION: number;
+    const COLOR_SPACE: number;
+    const EXIF_IMAGE_WIDTH: number;
+    const EXIF_IMAGE_HEIGHT: number;
+    const RELATED_SOUND_FILE: number;
+    const EXIF_INTEROPERABILITY_OFFSET: number;
+    const FOCAL_PLANE_X_RESOLUTION: number;
+    const FOCAL_PLANE_Y_RESOLUTION: number;
+    const FOCAL_PLANE_RESOLUTION_UNIT: number;
+    const SENSING_METHOD: number;
+    const FILE_SOURCE: number;
+    const SCENE_TYPE: number;
+    const IMAGE_WIDTH: number;
+    const IMAGE_LENGTH: number;
+    const BITS_PER_SAMPLE: number;
+    const COMPRESSION: number;
+    const PHOTOMETRIC_INTERPRETATION: number;
+    const STRIP_OFFSETS: number;
+    const SAMPLES_PER_PIXEL: number;
+    const ROWS_PER_STRIP: number;
+    const STRIP_BYTE_COUNTS: number;
+    const PLANAR_CONFIGURATION: number;
+    const JPEG_IF_OFFSET: number;
+    const JPEG_IF_BYTE_COUNT: number;
+    const Y_CB_CR_SUB_SAMPLING: number;
+}
+export type ExifDataFormat = number;
+export namespace ExifDataFormat {
+    const UNSIGNED_BYTE: number;
+    const ASCII_STRING: number;
+    const UNSIGNED_SHORT: number;
+    const UNSIGNED_LONG: number;
+    const UNSIGNED_RATIONAL: number;
+    const SIGNED_BYTE: number;
+    const UNDEFINED: number;
+    const SIGNED_SHORT: number;
+    const SIGNED_LONG: number;
+    const SIGNED_RATIONAL: number;
+    const SINGLE_FLOAT: number;
+    const DOUBLE_FLOAT: number;
+}
+export type ExifValue = {
+    /**
+     * The numerical value of the tag.
+     */
+    tagNumber: ExifTagNumber;
+    /**
+     * A string representing the tag number.
+     */
+    tagName?: string | undefined;
+    /**
+     * The data format.
+     */
+    dataFormat: ExifDataFormat;
+    /**
+     * Populated for SIGNED/UNSIGNED BYTE/SHORT/LONG/FLOAT.
+     */
+    numericalValue?: number | undefined;
+    /**
+     * Populated only for ASCII_STRING.
+     */
+    stringValue?: string | undefined;
+    /**
+     * Populated only for SIGNED/UNSIGNED RATIONAL.
+     */
+    numeratorValue?: number | undefined;
+    /**
+     * Populated only for SIGNED/UNSIGNED RATIONAL.
+     */
+    denominatorValue?: number | undefined;
+    /**
+     * Populated only for UNDEFINED data format.
+     */
+    numComponents?: number | undefined;
+    /**
+     * Populated only for UNDEFINED data format.
+     */
+    offsetValue?: number | undefined;
+};
+import { ByteStream } from "../../io/bytestream.js";
+//# sourceMappingURL=exif.d.ts.map

types/image/parsers/exif.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exif.d.ts","sourceRoot":"","sources":["../../../image/parsers/exif.js"],"names":[],"mappings":"AAqHA;;;;;GAKG;AACH,qCALW,UAAU,mBACV,UAAU,oBAER,SAAS,CAsGrB;4BA7NU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA2EN,MAAM;;;;;;;;;;;;;;;;;;;eAkBH,aAAa;;;;cACb,MAAM;;;;gBACN,cAAc;;;;qBACd,MAAM;;;;kBACN,MAAM;;;;qBACN,MAAM;;;;uBACN,MAAM;;;;oBACN,MAAM;;;;kBACN,MAAM"}

types/image/parsers/gif.d.ts

@@ -12,7 +12,7 @@ export namespace GifParseEventType {
  * @typedef GifHeader
  * @property {string} version
  */
-export class GifHeaderParseEvent extends Event {
+export class GifHeaderEvent extends Event {
     /** @param {GifHeader} header */
     constructor(header: GifHeader);
     /** @type {GifHeader} */
@@ -36,7 +36,7 @@ export class GifHeaderParseEvent extends Event {
  * @property {number} pixelAspectRatio
  * @property {GifColor[]=} globalColorTable Only if globalColorTableFlag is true.
  */
-export class GifLogicalScreenParseEvent extends Event {
+export class GifLogicalScreenEvent extends Event {
     /** @param {GifLogicalScreen} */
     constructor(logicalScreen: any);
     /** @type {GifLogicalScreen} */
@@ -134,9 +134,7 @@ export class GifTrailerEvent extends Event {
  *                                Comment Extension
  */
 export class GifParser extends EventTarget {
-    /**
-     * @param {ArrayBuffer} ab
-     */
+    /** @param {ArrayBuffer} ab */
     constructor(ab: ArrayBuffer);
     /**
      * @type {ByteStream}
@@ -149,12 +147,53 @@ export class GifParser extends EventTarget {
      */
     private version;
     /**
-     * Overridden so that the type hints for eventType are specific.
-     * @param {'application_extension'|'comment_extension'|'graphical_control_extension'|'header'|'logical_screen'|'plain_text_extension'|'table_based_image'|'trailer'} eventType
-     * @param {EventListenerOrEventListenerObject} listener
-     * @override
+     * Type-safe way to bind a listener for a GifApplicationExtensionEvent.
+     * @param {function(GifApplicationExtensionEvent): void} listener
+     * @returns {GifParser} for chaining
      */
-    override addEventListener(eventType: 'application_extension' | 'comment_extension' | 'graphical_control_extension' | 'header' | 'logical_screen' | 'plain_text_extension' | 'table_based_image' | 'trailer', listener: EventListenerOrEventListenerObject): void;
+    onApplicationExtension(listener: (arg0: GifApplicationExtensionEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifCommentExtensionEvent.
+     * @param {function(GifCommentExtensionEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onCommentExtension(listener: (arg0: GifCommentExtensionEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifGraphicControlExtensionEvent.
+     * @param {function(GifGraphicControlExtensionEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onGraphicControlExtension(listener: (arg0: GifGraphicControlExtensionEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifHeaderEvent.
+     * @param {function(GifHeaderEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onHeader(listener: (arg0: GifHeaderEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifLogicalScreenEvent.
+     * @param {function(GifLogicalScreenEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onLogicalScreen(listener: (arg0: GifLogicalScreenEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifPlainTextExtensionEvent.
+     * @param {function(GifPlainTextExtensionEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onPlainTextExtension(listener: (arg0: GifPlainTextExtensionEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifTableBasedImageEvent.
+     * @param {function(GifTableBasedImageEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onTableBasedImage(listener: (arg0: GifTableBasedImageEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifTrailerEvent.
+     * @param {function(GifTrailerEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onTrailer(listener: (arg0: GifTrailerEvent) => void): GifParser;
     /**
      * @returns {Promise<void>} A Promise that resolves when the parsing is complete.
      */

types/image/parsers/gif.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gif.d.ts","sourceRoot":"","sources":["../../../image/parsers/gif.js"],"names":[],"mappings":";;;;;;;;;;AA0BA;;;GAGG;AAEH;IACE,gCAAgC;IAChC,oBADY,SAAS,EAKpB;IAFC,wBAAwB;IACxB,QADW,SAAS,CACA;CAEvB;AAED;;;;;GAKG;AAEH;;;;;;;;;;;GAWG;AAEH;IACE,gCAAgC;IAChC,gCAIC;IAFC,+BAA+B;IAC/B,eADW,gBAAgB,CACO;CAErC;AAED;;;;;;;;;;;;;GAaG;AAEH;IACE,sCAAsC;IACtC,iBADY,kBAAkB,EAK7B;IAFC,iCAAiC;IACjC,iBADW,kBAAkB,CACH;CAE7B;AAED;;;;;;;GAOG;AAEH;IACE,8CAA8C;IAC9C,iBADY,0BAA0B,EAKrC;IAFC,yCAAyC;IACzC,yBADW,0BAA0B,CACH;CAErC;AAED;;;GAGG;AAEH;IACE,8BAA8B;IAC9B,qBADY,MAAM,EAKjB;IAFC,qBAAqB;IACrB,SADW,MAAM,CACK;CAEzB;AAED;;;;;;;;;;;GAWG;AAEH;IACE,yCAAyC;IACzC,iBADY,qBAAqB,EAKhC;IAFC,oCAAoC;IACpC,oBADW,qBAAqB,CACH;CAEhC;AAED;;;;;GAKG;AAEH;IACE,2CAA2C;IAC3C,iBADY,uBAAuB,EAKlC;IAFC,sCAAsC;IACtC,sBADW,uBAAuB,CACH;CAElC;AAED;IACE,cAEC;CACF;AAED;;;;;;;;;;;;;GAaG;AAEH;IAaE;;OAEG;IACH,gBAFW,WAAW,EAKrB;IAlBD;;;OAGG;IACH,gBAAQ;IAER;;;OAGG;IACH,gBAAQ;IAUR;;;;;OAKG;IACH,qCAJW,uBAAuB,GAAC,mBAAmB,GAAC,6BAA6B,GAAC,QAAQ,GAAC,gBAAgB,GAAC,sBAAsB,GAAC,mBAAmB,GAAC,SAAS,YACxJ,kCAAkC,QAK5C;IAED;;OAEG;IACH,SAFa,QAAQ,IAAI,CAAC,CAwDzB;IAED;;;OAGG;IACH,yBAoMC;IAED;;;OAGG;IACH,qBAIC;CACF;;aAzca,MAAM;;;SAcN,MAAM;WACN,MAAM;UACN,MAAM;;;wBAKN,MAAM;yBACN,MAAM;0BACN,OAAO;qBACP,MAAM;cACN,OAAO;0BACP,MAAM;0BACN,MAAM;sBACN,MAAM;;;;uBACN,QAAQ,EAAE;;;uBAcV,MAAM;sBACN,MAAM;gBACN,MAAM;iBACN,MAAM;yBACN,OAAO;mBACP,OAAO;cACP,OAAO;yBACP,MAAM;;;;sBACN,QAAQ,EAAE;wBACV,MAAM;eACN,UAAU;;;oBAcV,MAAM;mBACN,OAAO;0BACP,OAAO;eACP,MAAM;2BACN,MAAM;;;aAcN,MAAM;;;0BAcN,MAAM;yBACN,MAAM;mBACN,MAAM;oBACN,MAAM;wBACN,MAAM;yBACN,MAAM;8BACN,MAAM;8BACN,MAAM;eACN,MAAM;;;2BAcN,MAAM;mCACN,UAAU;qBACV,UAAU"}
+{"version":3,"file":"gif.d.ts","sourceRoot":"","sources":["../../../image/parsers/gif.js"],"names":[],"mappings":";;;;;;;;;;AA0BA;;;GAGG;AAEH;IACE,gCAAgC;IAChC,oBADY,SAAS,EAKpB;IAFC,wBAAwB;IACxB,QADW,SAAS,CACA;CAEvB;AAED;;;;;GAKG;AAEH;;;;;;;;;;;GAWG;AAEH;IACE,gCAAgC;IAChC,gCAIC;IAFC,+BAA+B;IAC/B,eADW,gBAAgB,CACO;CAErC;AAED;;;;;;;;;;;;;GAaG;AAEH;IACE,sCAAsC;IACtC,iBADY,kBAAkB,EAK7B;IAFC,iCAAiC;IACjC,iBADW,kBAAkB,CACH;CAE7B;AAED;;;;;;;GAOG;AAEH;IACE,8CAA8C;IAC9C,iBADY,0BAA0B,EAKrC;IAFC,yCAAyC;IACzC,yBADW,0BAA0B,CACH;CAErC;AAED;;;GAGG;AAEH;IACE,8BAA8B;IAC9B,qBADY,MAAM,EAKjB;IAFC,qBAAqB;IACrB,SADW,MAAM,CACK;CAEzB;AAED;;;;;;;;;;;GAWG;AAEH;IACE,yCAAyC;IACzC,iBADY,qBAAqB,EAKhC;IAFC,oCAAoC;IACpC,oBADW,qBAAqB,CACH;CAEhC;AAED;;;;;GAKG;AAEH;IACE,2CAA2C;IAC3C,iBADY,uBAAuB,EAKlC;IAFC,sCAAsC;IACtC,sBADW,uBAAuB,CACH;CAElC;AAED;IACE,cAEC;CACF;AAED;;;;;;;;;;;;;GAaG;AAEH;IAaE,8BAA8B;IAC9B,gBADY,WAAW,EAMtB;IAlBD;;;OAGG;IACH,gBAAQ;IAER;;;OAGG;IACH,gBAAQ;IAUR;;;;OAIG;IACH,wCAHoB,4BAA4B,KAAG,IAAI,GAC1C,SAAS,CAKrB;IAED;;;;OAIG;IACH,oCAHoB,wBAAwB,KAAG,IAAI,GACtC,SAAS,CAKrB;IAED;;;;OAIG;IACH,2CAHoB,+BAA+B,KAAG,IAAI,GAC7C,SAAS,CAKrB;IAED;;;;OAIG;IACH,0BAHoB,cAAc,KAAG,IAAI,GAC5B,SAAS,CAKrB;IAED;;;;OAIG;IACH,iCAHoB,qBAAqB,KAAG,IAAI,GACnC,SAAS,CAKrB;IAED;;;;OAIG;IACH,sCAHoB,0BAA0B,KAAG,IAAI,GACxC,SAAS,CAKrB;IAED;;;;OAIG;IACH,mCAHoB,uBAAuB,KAAG,IAAI,GACrC,SAAS,CAKrB;IAED;;;;OAIG;IACH,2BAHoB,eAAe,KAAG,IAAI,GAC7B,SAAS,CAKrB;IAED;;OAEG;IACH,SAFa,QAAQ,IAAI,CAAC,CAwDzB;IAED;;;OAGG;IACH,yBAmMC;IAED;;;OAGG;IACH,qBAIC;CACF;;aA9gBa,MAAM;;;SAcN,MAAM;WACN,MAAM;UACN,MAAM;;;wBAKN,MAAM;yBACN,MAAM;0BACN,OAAO;qBACP,MAAM;cACN,OAAO;0BACP,MAAM;0BACN,MAAM;sBACN,MAAM;;;;uBACN,QAAQ,EAAE;;;uBAcV,MAAM;sBACN,MAAM;gBACN,MAAM;iBACN,MAAM;yBACN,OAAO;mBACP,OAAO;cACP,OAAO;yBACP,MAAM;;;;sBACN,QAAQ,EAAE;wBACV,MAAM;eACN,UAAU;;;oBAcV,MAAM;mBACN,OAAO;0BACP,OAAO;eACP,MAAM;2BACN,MAAM;;;aAcN,MAAM;;;0BAcN,MAAM;yBACN,MAAM;mBACN,MAAM;oBACN,MAAM;wBACN,MAAM;yBACN,MAAM;8BACN,MAAM;8BACN,MAAM;eACN,MAAM;;;2BAcN,MAAM;mCACN,UAAU;qBACV,UAAU"}

types/image/parsers/jpeg.d.ts

@@ -0,0 +1,303 @@
+export type JpegParseEventType = string;
+export namespace JpegParseEventType {
+    const APP0_MARKER: string;
+    const APP0_EXTENSION: string;
+    const APP1_EXIF: string;
+    const DEFINE_QUANTIZATION_TABLE: string;
+    const DEFINE_HUFFMAN_TABLE: string;
+    const START_OF_FRAME: string;
+    const START_OF_SCAN: string;
+}
+export type JpegSegmentType = number;
+export namespace JpegSegmentType {
+    const SOF0: number;
+    const SOF1: number;
+    const SOF2: number;
+    const DHT: number;
+    const SOI: number;
+    const EOI: number;
+    const SOS: number;
+    const DQT: number;
+    const APP0: number;
+    const APP1: number;
+}
+export type JpegDensityUnits = number;
+export namespace JpegDensityUnits {
+    const NO_UNITS: number;
+    const PIXELS_PER_INCH: number;
+    const PIXELS_PER_CM: number;
+}
+/**
+ * @typedef JpegApp0Marker
+ * @property {string} jfifVersion Like '1.02'.
+ * @property {JpegDensityUnits} densityUnits
+ * @property {number} xDensity
+ * @property {number} yDensity
+ * @property {number} xThumbnail
+ * @property {number} yThumbnail
+ * @property {Uint8Array} thumbnailData RGB data. Size is 3 x thumbnailWidth x thumbnailHeight.
+ */
+export class JpegApp0MarkerEvent extends Event {
+    /** @param {JpegApp0Marker} */
+    constructor(segment: any);
+    /** @type {JpegApp0Marker} */
+    app0Marker: JpegApp0Marker;
+}
+export type JpegExtensionThumbnailFormat = number;
+export namespace JpegExtensionThumbnailFormat {
+    const JPEG: number;
+    const ONE_BYTE_PER_PIXEL_PALETTIZED: number;
+    const THREE_BYTES_PER_PIXEL_RGB: number;
+}
+/**
+ * @typedef JpegApp0Extension
+ * @property {JpegExtensionThumbnailFormat} thumbnailFormat
+ * @property {Uint8Array} thumbnailData Raw thumbnail data
+ */
+export class JpegApp0ExtensionEvent extends Event {
+    /** @param {JpegApp0Extension} */
+    constructor(segment: any);
+    /** @type {JpegApp0Extension} */
+    app0Extension: JpegApp0Extension;
+}
+export class JpegApp1ExifEvent extends Event {
+    /** @param {Map<number, ExifValue>} exifValueMap */
+    constructor(exifValueMap: Map<number, import("./exif.js").ExifValue>);
+    /** @type {Map<number, ExifValue>} */
+    exifValueMap: Map<number, import("./exif.js").ExifValue>;
+}
+/**
+ * @typedef JpegDefineQuantizationTable
+ * @property {number} tableNumber Table/component number.
+ * @property {number} precision (0=byte, 1=word).
+ * @property {number[]} tableValues 64 numbers representing the quantization table.
+ */
+export class JpegDefineQuantizationTableEvent extends Event {
+    /** @param {JpegDefineQuantizationTable} table */
+    constructor(table: JpegDefineQuantizationTable);
+    /** @type {JpegDefineQuantizationTable} */
+    quantizationTable: JpegDefineQuantizationTable;
+}
+export type JpegHuffmanTableType = number;
+export namespace JpegHuffmanTableType {
+    const DC: number;
+    const AC: number;
+}
+/**
+ * @typedef JpegDefineHuffmanTable
+ * @property {number} tableNumber Table/component number (0-3).
+ * @property {JpegHuffmanTableType} tableType Either DC or AC.
+ * @property {number[]} numberOfSymbols A 16-byte array specifying the # of symbols of each length.
+ * @property {number[]} symbols
+ */
+export class JpegDefineHuffmanTableEvent extends Event {
+    /** @param {JpegDefineHuffmanTable} table */
+    constructor(table: JpegDefineHuffmanTable);
+    /** @type {JpegDefineHuffmanTable} */
+    huffmanTable: JpegDefineHuffmanTable;
+}
+export type JpegDctType = number;
+export namespace JpegDctType {
+    const BASELINE: number;
+    const EXTENDED_SEQUENTIAL: number;
+    const PROGRESSIVE: number;
+}
+export type JpegComponentType = number;
+export namespace JpegComponentType {
+    const Y: number;
+    const CB: number;
+    const CR: number;
+    const I: number;
+    const Q: number;
+}
+/**
+ * @typedef JpegComponentDetail
+ * @property {JpegComponentType} componentId
+ * @property {number} verticalSamplingFactor
+ * @property {number} horizontalSamplingFactor
+ * @property {number} quantizationTableNumber
+ */
+/**
+ * @typedef JpegStartOfFrame
+ * @property {JpegDctType} dctType
+ * @property {number} dataPrecision
+ * @property {number} imageHeight
+ * @property {number} imageWidth
+ * @property {number} numberOfComponents Usually 1, 3, or 4.
+ * @property {JpegComponentDetail[]} componentDetails
+ */
+export class JpegStartOfFrameEvent extends Event {
+    /** @param {JpegStartOfFrame} sof */
+    constructor(sof: JpegStartOfFrame);
+    /** @type {JpegStartOfFrame} */
+    startOfFrame: JpegStartOfFrame;
+}
+/**
+ * @typedef JpegStartOfScan
+ * @property {number} componentsInScan
+ * @property {number} componentSelectorY
+ * @property {number} huffmanTableSelectorY
+ * @property {number} componentSelectorCb
+ * @property {number} huffmanTableSelectorCb
+ * @property {number} componentSelectorCr
+ * @property {number} huffmanTableSelectorCr
+ * @property {number} scanStartPositionInBlock
+ * @property {number} scanEndPositionInBlock
+ * @property {number} successiveApproximationBitPosition
+ * @property {Uint8Array} rawImageData
+ */
+export class JpegStartOfScanEvent extends Event {
+    constructor(sos: any);
+    /** @type {JpegStartOfScan} */
+    sos: JpegStartOfScan;
+}
+export class JpegParser extends EventTarget {
+    /** @param {ArrayBuffer} ab */
+    constructor(ab: ArrayBuffer);
+    /**
+     * @type {ByteStream}
+     * @private
+     */
+    private bstream;
+    /**
+     * @type {boolean}
+     * @private
+     */
+    private hasApp0MarkerSegment;
+    /**
+     * Type-safe way to bind a listener for a JpegApp0MarkerEvent.
+     * @param {function(JpegApp0MarkerEvent): void} listener
+     * @returns {JpegParser} for chaining
+     */
+    onApp0Marker(listener: (arg0: JpegApp0MarkerEvent) => void): JpegParser;
+    /**
+     * Type-safe way to bind a listener for a JpegApp0ExtensionEvent.
+     * @param {function(JpegApp0MarkerEvent): void} listener
+     * @returns {JpegParser} for chaining
+     */
+    onApp0Extension(listener: (arg0: JpegApp0MarkerEvent) => void): JpegParser;
+    /**
+     * Type-safe way to bind a listener for a JpegApp1ExifEvent.
+     * @param {function(JpegApp1ExifEvent): void} listener
+     * @returns {JpegParser} for chaining
+     */
+    onApp1Exif(listener: (arg0: JpegApp1ExifEvent) => void): JpegParser;
+    /**
+     * Type-safe way to bind a listener for a JpegDefineQuantizationTableEvent.
+     * @param {function(JpegDefineQuantizationTableEvent): void} listener
+     * @returns {JpegParser} for chaining
+     */
+    onDefineQuantizationTable(listener: (arg0: JpegDefineQuantizationTableEvent) => void): JpegParser;
+    /**
+     * Type-safe way to bind a listener for a JpegDefineHuffmanTableEvent.
+     * @param {function(JpegDefineHuffmanTableEvent): void} listener
+     * @returns {JpegParser} for chaining
+     */
+    onDefineHuffmanTable(listener: (arg0: JpegDefineHuffmanTableEvent) => void): JpegParser;
+    /**
+     * Type-safe way to bind a listener for a JpegStartOfFrameEvent.
+     * @param {function(JpegStartOfFrameEvent): void} listener
+     * @returns {JpegParser} for chaining
+     */
+    onStartOfFrame(listener: (arg0: JpegStartOfFrameEvent) => void): JpegParser;
+    /**
+     * Type-safe way to bind a listener for a JpegStartOfScanEvent.
+     * @param {function(JpegStartOfScanEvent): void} listener
+     * @returns {JpegParser} for chaining
+     */
+    onStartOfScan(listener: (arg0: JpegStartOfScanEvent) => void): JpegParser;
+    /** @returns {Promise<void>} A Promise that resolves when the parsing is complete. */
+    start(): Promise<void>;
+    /**
+     * Reads an Image File Directory from stream.
+     * @param {ByteStream} stream The stream to extract the Exif value descriptor.
+     * @param {ByteStream} lookAheadStream The lookahead stream if the offset is used.
+     * @param {Map<number, ExifValue} exifValueMap This map to add the Exif values.
+     * @returns {number} The next IFD offset.
+     */
+    readExifIfd(stream: ByteStream, lookAheadStream: ByteStream, exifValueMap: Map<number, import("./exif.js").ExifValue>): number;
+}
+export type ExifValue = import('./exif.js').ExifValue;
+export type JpegApp0Marker = {
+    /**
+     * Like '1.02'.
+     */
+    jfifVersion: string;
+    densityUnits: JpegDensityUnits;
+    xDensity: number;
+    yDensity: number;
+    xThumbnail: number;
+    yThumbnail: number;
+    /**
+     * RGB data. Size is 3 x thumbnailWidth x thumbnailHeight.
+     */
+    thumbnailData: Uint8Array;
+};
+export type JpegApp0Extension = {
+    thumbnailFormat: JpegExtensionThumbnailFormat;
+    /**
+     * Raw thumbnail data
+     */
+    thumbnailData: Uint8Array;
+};
+export type JpegDefineQuantizationTable = {
+    /**
+     * Table/component number.
+     */
+    tableNumber: number;
+    /**
+     * (0=byte, 1=word).
+     */
+    precision: number;
+    /**
+     * 64 numbers representing the quantization table.
+     */
+    tableValues: number[];
+};
+export type JpegDefineHuffmanTable = {
+    /**
+     * Table/component number (0-3).
+     */
+    tableNumber: number;
+    /**
+     * Either DC or AC.
+     */
+    tableType: JpegHuffmanTableType;
+    /**
+     * A 16-byte array specifying the # of symbols of each length.
+     */
+    numberOfSymbols: number[];
+    symbols: number[];
+};
+export type JpegComponentDetail = {
+    componentId: JpegComponentType;
+    verticalSamplingFactor: number;
+    horizontalSamplingFactor: number;
+    quantizationTableNumber: number;
+};
+export type JpegStartOfFrame = {
+    dctType: JpegDctType;
+    dataPrecision: number;
+    imageHeight: number;
+    imageWidth: number;
+    /**
+     * Usually 1, 3, or 4.
+     */
+    numberOfComponents: number;
+    componentDetails: JpegComponentDetail[];
+};
+export type JpegStartOfScan = {
+    componentsInScan: number;
+    componentSelectorY: number;
+    huffmanTableSelectorY: number;
+    componentSelectorCb: number;
+    huffmanTableSelectorCb: number;
+    componentSelectorCr: number;
+    huffmanTableSelectorCr: number;
+    scanStartPositionInBlock: number;
+    scanEndPositionInBlock: number;
+    successiveApproximationBitPosition: number;
+    rawImageData: Uint8Array;
+};
+import { ByteStream } from "../../io/bytestream.js";
+//# sourceMappingURL=jpeg.d.ts.map

types/image/parsers/jpeg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jpeg.d.ts","sourceRoot":"","sources":["../../../image/parsers/jpeg.js"],"names":[],"mappings":"iCAwBW,MAAM;;;;;;;;;;8BAWN,MAAM;;;;;;;;;;;;;+BAwBN,MAAM;;;;;;AAOjB;;;;;;;;;GASG;AAEH;IACE,8BAA8B;IAC9B,0BAIC;IAFC,6BAA6B;IAC7B,YADW,cAAc,CACA;CAE5B;2CAEU,MAAM;;;;;;AAOjB;;;;GAIG;AAEH;IACE,iCAAiC;IACjC,0BAIC;IAFC,gCAAgC;IAChC,eADW,iBAAiB,CACA;CAE/B;AAED;IACE,mDAAmD;IACnD,sEAIC;IAFC,qCAAqC;IACrC,yDAAgC;CAEnC;AAED;;;;;GAKG;AAEH;IACE,iDAAiD;IACjD,mBADY,2BAA2B,EAKtC;IAFC,0CAA0C;IAC1C,mBADW,2BAA2B,CACR;CAEjC;mCAEU,MAAM;;;;;AAMjB;;;;;;GAMG;AAEH;IACE,4CAA4C;IAC5C,mBADY,sBAAsB,EAKjC;IAFC,qCAAqC;IACrC,cADW,sBAAsB,CACR;CAE5B;0BAEU,MAAM;;;;;;gCAON,MAAM;;;;;;;;AASjB;;;;;;GAMG;AAEH;;;;;;;;GAQG;AAEH;IACE,oCAAoC;IACpC,iBADY,gBAAgB,EAK3B;IAFC,+BAA+B;IAC/B,cADW,gBAAgB,CACJ;CAE1B;AAED;;;;;;;;;;;;;GAaG;AAEH;IACE,sBAIC;IAFC,8BAA8B;IAC9B,KADW,eAAe,CACZ;CAEjB;AAED;IAaE,8BAA8B;IAC9B,gBADY,WAAW,EAItB;IAhBD;;;OAGG;IACH,gBAAQ;IAER;;;OAGG;IACH,6BAA6B;IAQ7B;;;;OAIG;IACH,8BAHoB,mBAAmB,KAAG,IAAI,GACjC,UAAU,CAKtB;IAED;;;;OAIG;IACH,iCAHoB,mBAAmB,KAAG,IAAI,GACjC,UAAU,CAKtB;IAED;;;;OAIG;IACH,4BAHoB,iBAAiB,KAAG,IAAI,GAC/B,UAAU,CAKtB;IAED;;;;OAIG;IACH,2CAHoB,gCAAgC,KAAG,IAAI,GAC9C,UAAU,CAKtB;IAED;;;;OAIG;IACH,sCAHoB,2BAA2B,KAAG,IAAI,GACzC,UAAU,CAKtB;IAED;;;;OAIG;IACH,gCAHoB,qBAAqB,KAAG,IAAI,GACnC,UAAU,CAKtB;IAED;;;;OAIG;IACH,+BAHoB,oBAAoB,KAAG,IAAI,GAClC,UAAU,CAKtB;IAED,qFAAqF;IACrF,SADc,QAAQ,IAAI,CAAC,CAgR1B;IAED;;;;;;OAMG;IACH,oBALW,UAAU,mBACV,UAAU,6DAER,MAAM,CAoBlB;CACF;wBArlBY,OAAO,WAAW,EAAE,SAAS;;;;;iBAsD5B,MAAM;kBACN,gBAAgB;cAChB,MAAM;cACN,MAAM;gBACN,MAAM;gBACN,MAAM;;;;mBACN,UAAU;;;qBAqBV,4BAA4B;;;;mBAC5B,UAAU;;;;;;iBAuBV,MAAM;;;;eACN,MAAM;;;;iBACN,MAAM,EAAE;;;;;;iBAoBR,MAAM;;;;eACN,oBAAoB;;;;qBACpB,MAAM,EAAE;aACR,MAAM,EAAE;;;iBA8BR,iBAAiB;4BACjB,MAAM;8BACN,MAAM;6BACN,MAAM;;;aAKN,WAAW;mBACX,MAAM;iBACN,MAAM;gBACN,MAAM;;;;wBACN,MAAM;sBACN,mBAAmB,EAAE;;;sBAcrB,MAAM;wBACN,MAAM;2BACN,MAAM;yBACN,MAAM;4BACN,MAAM;yBACN,MAAM;4BACN,MAAM;8BACN,MAAM;4BACN,MAAM;wCACN,MAAM;kBACN,UAAU"}

types/index.d.ts

@@ -6,8 +6,24 @@ export { ByteStream } from "./io/bytestream.js";
 export type ProbeStream = import('./codecs/codecs.js').ProbeStream;
 export type ProbeFormat = import('./codecs/codecs.js').ProbeFormat;
 export type ProbeInfo = import('./codecs/codecs.js').ProbeInfo;
+export type GifApplicationExtension = import('./image/parsers/gif.js').GifApplicationExtension;
+export type GifColor = import('./image/parsers/gif.js').GifColor;
+export type GifCommentExtension = import('./image/parsers/gif.js').GifCommentExtension;
+export type GifGraphicControlExtension = import('./image/parsers/gif.js').GifGraphicControlExtension;
+export type GifHeader = import('./image/parsers/gif.js').GifHeader;
+export type GifLogicalScreen = import('./image/parsers/gif.js').GifLogicalScreen;
+export type GifPlainTextExtension = import('./image/parsers/gif.js').GifPlainTextExtension;
+export type GifTableBasedImage = import('./image/parsers/gif.js').GifTableBasedImage;
+export type JpegApp0Extension = import('./image/parsers/jpeg.js').JpegApp0Extension;
+export type JpegApp0Marker = import('./image/parsers/jpeg.js').JpegApp0Marker;
+export type JpegComponentDetail = import('./image/parsers/jpeg.js').JpegComponentDetail;
+export type JpegDefineHuffmanTable = import('./image/parsers/jpeg.js').JpegDefineHuffmanTable;
+export type JpegDefineQuantizationTable = import('./image/parsers/jpeg.js').JpegDefineQuantizationTable;
+export type JpegStartOfFrame = import('./image/parsers/jpeg.js').JpegStartOfFrame;
+export type JpegStartOfScan = import('./image/parsers/jpeg.js').JpegStartOfScan;
 export { UnarchiveEvent, UnarchiveEventType, UnarchiveInfoEvent, UnarchiveErrorEvent, UnarchiveStartEvent, UnarchiveFinishEvent, UnarchiveProgressEvent, UnarchiveExtractEvent, Unarchiver, Unzipper, Unrarrer, Untarrer, getUnarchiver } from "./archive/decompress.js";
 export { getFullMIMEString, getShortMIMEString } from "./codecs/codecs.js";
-export { GifApplicationExtensionEvent, GifCommentExtensionEvent, GifGraphicControlExtensionEvent, GifHeaderParseEvent, GifLogicalScreenParseEvent, GifParseEventType, GifParser, GifPlainTextExtensionEvent, GifTableBasedImageEvent } from "./image/parsers/gif.js";
+export { GifApplicationExtensionEvent, GifCommentExtensionEvent, GifGraphicControlExtensionEvent, GifHeaderEvent, GifLogicalScreenEvent, GifParseEventType, GifParser, GifPlainTextExtensionEvent, GifTableBasedImageEvent } from "./image/parsers/gif.js";
+export { JpegApp0ExtensionEvent, JpegApp0MarkerEvent, JpegApp1ExifEvent, JpegComponentType, JpegDctType, JpegDefineHuffmanTableEvent, JpegDefineQuantizationTableEvent, JpegDensityUnits, JpegExtensionThumbnailFormat, JpegHuffmanTableType, JpegParseEventType, JpegParser, JpegSegmentType, JpegStartOfFrameEvent, JpegStartOfScanEvent } from "./image/parsers/jpeg.js";
 export { convertWebPtoPNG, convertWebPtoJPG } from "./image/webp-shim/webp-shim.js";
 //# sourceMappingURL=index.d.ts.map

types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":";;;;;0BASa,OAAO,oBAAoB,EAAE,WAAW;0BAGxC,OAAO,oBAAoB,EAAE,WAAW;wBAGxC,OAAO,oBAAoB,EAAE,SAAS"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":";;;;;0BAQc,OAAO,oBAAoB,EAAE,WAAW;0BACxC,OAAO,oBAAoB,EAAE,WAAW;wBACxC,OAAO,oBAAoB,EAAE,SAAS;sCAEtC,OAAO,wBAAwB,EAAE,uBAAuB;uBACxD,OAAO,wBAAwB,EAAE,QAAQ;kCACzC,OAAO,wBAAwB,EAAE,mBAAmB;yCACpD,OAAO,wBAAwB,EAAE,0BAA0B;wBAC3D,OAAO,wBAAwB,EAAE,SAAS;+BAC1C,OAAO,wBAAwB,EAAE,gBAAgB;oCACjD,OAAO,wBAAwB,EAAE,qBAAqB;iCACtD,OAAO,wBAAwB,EAAE,kBAAkB;gCAEnD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,yBAAyB,EAAE,cAAc;kCAChD,OAAO,yBAAyB,EAAE,mBAAmB;qCACrD,OAAO,yBAAyB,EAAE,sBAAsB;0CACxD,OAAO,yBAAyB,EAAE,2BAA2B;+BAC7D,OAAO,yBAAyB,EAAE,gBAAgB;8BAClD,OAAO,yBAAyB,EAAE,eAAe"}

types/io/bitstream.d.ts

@@ -28,7 +28,7 @@
  */
 export class BitStream {
     /**
-     * @param {ArrayBuffer} ab An ArrayBuffer object or a Uint8Array.
+     * @param {ArrayBuffer} ab An ArrayBuffer object.
      * @param {boolean} mtl Whether the stream reads bits from the byte starting with the
      *     most-significant-bit (bit 7) to least-significant (bit 0). False means the direction is
      *     from least-significant-bit (bit 0) to most-significant (bit 7).
@@ -62,7 +62,7 @@ export class BitStream {
     private bitsRead_;
     peekBits: (n: number, opt_movePointers: any) => number;
     /**
-     * Returns how many bites have been read in the stream since the beginning of time.
+     * Returns how many bits have been read in the stream since the beginning of time.
      * @returns {number}
      */
     getNumBitsRead(): number;

types/io/bytestream.d.ts

@@ -2,6 +2,8 @@
  * This object allows you to peek and consume bytes as numbers and strings out
  * of a stream.  More bytes can be pushed into the back of the stream via the
  * push() method.
+ * By default, the stream is Little Endian (that is the least significant byte
+ * is first). To change to Big Endian, use setBigEndian().
  */
 export class ByteStream {
     /**
@@ -34,12 +36,32 @@ export class ByteStream {
      * @private
      */
     private bytesRead_;
+    /**
+     * Whether the stream is little-endian (true) or big-endian (false).
+     * @type {boolean}
+     * @private
+     */
+    private littleEndian_;
+    /** @returns {boolean} Whether the stream is little-endian. */
+    isLittleEndian(): boolean;
+    /**
+     * Big-Endian is sometimes called Motorola-style.
+     * @param {boolean=} val The value to set. If not present, the stream is set to big-endian.
+     */
+    setBigEndian(val?: boolean | undefined): void;
+    /**
+     * Little-Endian is sometimes called Intel-style.
+     * @param {boolean=} val The value to set. If not present, the stream is set to little-endian.
+     */
+    setLittleEndian(val?: boolean | undefined): void;
     /**
      * Returns how many bytes have been read in the stream since the beginning of time.
+     * @returns {number}
      */
     getNumBytesRead(): number;
     /**
      * Returns how many bytes are currently in the stream left to be read.
+     * @returns {number}
      */
     getNumBytesLeft(): number;
     /**
@@ -104,6 +126,12 @@ export class ByteStream {
      * @returns {string} The next n bytes as a string.
      */
     readString(n: number): string;
+    /**
+     * Skips n bytes in the stream.
+     * @param {number} n The number of bytes to skip. Must be a positive integer.
+     * @returns {ByteStream} Returns this ByteStream for chaining.
+     */
+    skip(n: number): ByteStream;
     /**
      * Feeds more bytes into the back of the stream.
      * @param {ArrayBuffer} ab
@@ -111,6 +139,10 @@ export class ByteStream {
     push(ab: ArrayBuffer): void;
     /**
      * Creates a new ByteStream from this ByteStream that can be read / peeked.
+     * Note that the teed stream is a disconnected copy. If you push more bytes to the original
+     * stream, the copy does not get them.
+     * TODO: Assess whether the above causes more bugs than it avoids. (It would feel weird to me if
+     *       the teed stream shared some state with the original stream.)
      * @returns {ByteStream} A clone of this ByteStream.
      */
     tee(): ByteStream;

types/io/bytestream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bytestream.d.ts","sourceRoot":"","sources":["../../io/bytestream.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IACE;;;;OAIG;IACH,gBAJW,WAAW,eACX,MAAM,2BACN,MAAM,cAqChB;IA3BC;;;;OAIG;IACH,cAA+C;IAE/C;;;;OAIG;IACH,eAAgB;IAEhB;;;;OAIG;IACH,YAAY;IAEZ;;;;OAIG;IACH,mBAAmB;IAGrB;;OAEG;IACH,0BAEC;IAED;;OAEG;IACH,0BAGC;IAED;;;;;;OAMG;IACH,qBAOC;IAED;;;;;OAKG;IACH,cAHW,MAAM,GACJ,MAAM,CAkClB;IAGD;;;;;OAKG;IACH,cAHW,MAAM,GACJ,MAAM,CAMlB;IAGD;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,MAAM,CAUlB;IAGD;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAMlB;IAGD;;;;;;OAMG;IACH,aAJW,MAAM,gBACN,OAAO,GACL,UAAU,CAyCtB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,UAAU,CAItB;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,MAAM,CA6BlB;IAED;;;;;OAKG;IACH,cAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;OAGG;IACH,SAFW,WAAW,QAWrB;IAED;;;OAGG;IACH,OAFa,UAAU,CAStB;CACF"}
+{"version":3,"file":"bytestream.d.ts","sourceRoot":"","sources":["../../io/bytestream.js"],"names":[],"mappings":"AAWA;;;;;;GAMG;AACH;IACE;;;;OAIG;IACH,gBAJW,WAAW,eACX,MAAM,2BACN,MAAM,cA4ChB;IAlCC;;;;OAIG;IACH,cAA+C;IAE/C;;;;OAIG;IACH,eAAgB;IAEhB;;;;OAIG;IACH,YAAY;IAEZ;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,sBAAyB;IAG3B,8DAA8D;IAC9D,kBADc,OAAO,CAGpB;IAED;;;OAGG;IACH,mBAFW,OAAO,oBAIjB;IAED;;;OAGG;IACH,sBAFW,OAAO,oBAIjB;IAED;;;OAGG;IACH,mBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAFa,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,qBAOC;IAED;;;;;OAKG;IACH,cAHW,MAAM,GACJ,MAAM,CAmClB;IAGD;;;;;OAKG;IACH,cAHW,MAAM,GACJ,MAAM,CAMlB;IAGD;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,MAAM,CAUlB;IAGD;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAMlB;IAGD;;;;;;OAMG;IACH,aAJW,MAAM,gBACN,OAAO,GACL,UAAU,CAyCtB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,UAAU,CAItB;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,MAAM,CA6BlB;IAED;;;;;OAKG;IACH,cAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;;OAIG;IACH,QAHW,MAAM,GACJ,UAAU,CAkBtB;IAED;;;OAGG;IACH,SAFW,WAAW,QAWrB;IAED;;;;;;;OAOG;IACH,OAFa,UAAU,CAUtB;CACF"}