@woosh/meep-engine 3.63.1 → 3.63.3

package/src/format/image/jpeg/jpeg_decode.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param {ArrayBuffer} jpegData
+ * @param [userOpts]
+ * @return {{width: number, height: number, exifBuffer: Uint8Array, data: Uint8Array}}
+ */
+export function jpeg_decode(jpegData: ArrayBuffer, userOpts?: {}): {
+    width: number;
+    height: number;
+    exifBuffer: Uint8Array;
+    data: Uint8Array;
+};
+//# sourceMappingURL=jpeg_decode.d.ts.map

package/src/format/image/jpeg/jpeg_decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jpeg_decode.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/jpeg/jpeg_decode.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,sCAJW,WAAW,kBAEV;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAC,CAkCpF"}

package/src/format/image/png/PNG.d.ts

@@ -0,0 +1,91 @@
+export class PNG {
+    /**
+     *
+     * @type {number}
+     */
+    width: number;
+    /**
+     *
+     * @type {number}
+     */
+    height: number;
+    /**
+     * Number of bits per channel?
+     * @type {number}
+     */
+    bitDepth: number;
+    colorType: number;
+    compressionMethod: number;
+    filterMethod: number;
+    interlaceMethod: number;
+    /**
+     * Number of channels in the image
+     * @example RGB = 3, RGBA = 4, etc.
+     * @type {number}
+     */
+    colors: number;
+    alpha: boolean;
+    /**
+     *
+     * @type {Uint8Array|null}
+     */
+    palette: Uint8Array | null;
+    /**
+     *
+     * @type {Uint8Array|null}
+     */
+    pixels: Uint8Array | null;
+    /**
+     * Transparency palette
+     * @type {Uint8Array|null}
+     */
+    transparency_lookup: Uint8Array | null;
+    /**
+     * Text metadata coming from tEXt chunks
+     * @type {Object<string>}
+     */
+    text: any;
+    getWidth(): number;
+    setWidth(width: any): void;
+    getHeight(): number;
+    setHeight(height: any): void;
+    getBitDepth(): number;
+    setBitDepth(bitDepth: any): void;
+    getColorType(): number;
+    setColorType(colorType: any): void;
+    /**
+     *
+     * @param {number} compressionMethod
+     */
+    setCompressionMethod(compressionMethod: number): void;
+    /**
+     *
+     * @param {number} filterMethod
+     */
+    setFilterMethod(filterMethod: number): void;
+    getInterlaceMethod(): number;
+    setInterlaceMethod(interlaceMethod: any): void;
+    /**
+     *
+     * @param {Uint8Array} palette
+     */
+    setPalette(palette: Uint8Array): void;
+    /**
+     * Expand a palette (colour type 3) image to interleaved RGB, or RGBA when a `tRNS` chunk gave
+     * the palette entries an alpha.
+     * @returns {{data: Uint8Array, itemSize: number}}
+     */
+    getUint8Data_case3(): {
+        data: Uint8Array;
+        itemSize: number;
+    };
+    /**
+     * @returns {{itemSize:number, data:Uint8Array, bitDepth: number}}
+     */
+    getUint8Data(): {
+        itemSize: number;
+        data: Uint8Array;
+        bitDepth: number;
+    };
+}
+//# sourceMappingURL=PNG.d.ts.map

package/src/format/image/png/PNG.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PNG.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/png/PNG.js"],"names":[],"mappings":"AAAA;IAEI;;;OAGG;IACH,OAFU,MAAM,CAEN;IACV;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb,kBAAc;IACd,0BAAsB;IACtB,qBAAiB;IACjB,wBAAoB;IAEpB;;;;OAIG;IACH,QAFU,MAAM,CAEL;IACX,eAAc;IAEd;;;OAGG;IACH,SAFU,UAAU,GAAC,IAAI,CAEV;IAEf;;;OAGG;IACH,QAFU,UAAU,GAAC,IAAI,CAEX;IAEd;;;OAGG;IACH,qBAFU,UAAU,GAAC,IAAI,CAEE;IAG3B;;;OAGG;IACH,UAAU;IAGV,mBAEC;IAED,2BAEC;IAED,oBAEC;IAED,6BAEC;IAED,sBAEC;IAED,iCAKC;IAED,uBAEC;IAED,mCA6CC;IAED;;;OAGG;IACH,wCAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,8BAFW,MAAM,QAOhB;IAED,6BAEC;IAED,+CAKC;IAED;;;OAGG;IACH,oBAFW,UAAU,QAUpB;IAED;;;;OAIG;IACH,sBAFa;QAAC,IAAI,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CA8DhD;IAED;;OAEG;IACH,gBAFa;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,UAAU,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CA0ChE;CACJ"}

package/src/format/image/png/PNGReader.d.ts

@@ -0,0 +1,159 @@
+/**
+ *
+ * @param {ArrayBuffer} bytes
+ * @constructor
+ */
+export function PNGReader(bytes: ArrayBuffer): void;
+export class PNGReader {
+    /**
+     *
+     * @param {ArrayBuffer} bytes
+     * @constructor
+     */
+    constructor(bytes: ArrayBuffer);
+    /**
+     * Output object
+     * @type {PNG}
+     */
+    png: PNG;
+    /**
+     *
+     * @type {Uint8Array[]}
+     */
+    dataChunks: Uint8Array[];
+    /**
+     *
+     * @type {BinaryBuffer}
+     */
+    buffer: BinaryBuffer;
+    /**
+     * Whether CRC should be performed or not
+     * @type {boolean}
+     */
+    crc_enabled: boolean;
+    /**
+     *
+     * @param {number} length
+     * @return {Uint8Array}
+     */
+    readBytes(length: number): Uint8Array;
+    /**
+     * http://www.w3.org/TR/2003/REC-PNG-20031110/#5PNG-file-signature
+     */
+    decodeHeader(): void;
+    /**
+     * http://www.w3.org/TR/2003/REC-PNG-20031110/#5Chunk-layout
+     *
+     * length =  4      bytes
+     * type   =  4      bytes (IHDR, PLTE, IDAT, IEND or others)
+     * chunk  =  length bytes
+     * crc    =  4      bytes
+     *
+     * @returns {Promise<string>} chunk type, after any compressed metadata has been decoded
+     */
+    decodeChunk(): Promise<string>;
+    /**
+     * https://www.w3.org/TR/2003/REC-PNG-20031110/#11sRGB
+     * @param {Uint8Array} chunk
+     */
+    decodesRGB(chunk: Uint8Array): void;
+    /**
+     * https://www.w3.org/TR/2003/REC-PNG-20031110/#11tIME
+     * @param {Uint8Array} chunk
+     */
+    decodetIME(chunk: Uint8Array): void;
+    /**
+     * https://www.w3.org/TR/PNG/#11tEXt
+     * @param {Uint8Array} chunk
+     */
+    decodetEXt(chunk: Uint8Array): void;
+    /**
+     * NOTE: untested
+     * https://www.w3.org/TR/PNG/#11iEXt
+     * @param {Uint8Array} chunk
+     */
+    decodeiEXt(chunk: Uint8Array): void;
+    /**
+     * http://www.w3.org/TR/2003/REC-PNG-20031110/#11IHDR
+     * http://www.libpng.org/pub/png/spec/1.2/png-1.2-pdg.html#C.IHDR
+     *
+     * Width               4 bytes
+     * Height              4 bytes
+     * Bit depth           1 byte
+     * Colour type         1 byte
+     * Compression method  1 byte
+     * Filter method       1 byte
+     * Interlace method    1 byte
+     */
+    decodeIHDR(chunk: any): void;
+    /**
+     *
+     * http://www.w3.org/TR/PNG/#11PLTE
+     * @param {Uint8Array} chunk
+     */
+    decodePLTE(chunk: Uint8Array): void;
+    /**
+     * http://www.w3.org/TR/2003/REC-PNG-20031110/#11IDAT
+     */
+    decodeIDAT(chunk: any): void;
+    /**
+     * https://www.w3.org/TR/PNG/#11tRNS
+     * @param {Uint8Array} chunk
+     */
+    decodeTRNS(chunk: Uint8Array): void;
+    /**
+     * http://www.w3.org/TR/2003/REC-PNG-20031110/#11IEND
+     */
+    decodeIEND(): void;
+    /**
+     * Uncompress IDAT chunks
+     * @returns {Promise<void>}
+     */
+    decodePixels(): Promise<void>;
+    /**
+     * Reconstruct a non-interlaced image.
+     *
+     * Filtering is byte-wise, so at bit depths below eight the reconstructed scanline is still packed
+     * and has to be unpacked into the output separately. At eight bits and above the two are the same
+     * thing, and the reconstruction is written straight into the output with no intermediate row.
+     *
+     * @param {Uint8Array} data
+     * @returns {Uint8Array}
+     */
+    interlaceNone(data: Uint8Array): Uint8Array;
+    /**
+     * De-interlace an image according to the Adam7 scheme.
+     *
+     * Each of the seven passes is its own little image with its own scanline width, so its own
+     * filtering and — below eight bits — its own packing. Reconstructed rows land in a two-row scratch
+     * (the filters predict from the previous row of the same pass) and are scattered into the output.
+     *
+     * @param {Uint8Array} data
+     * @returns {Uint8Array}
+     */
+    interlaceAdam7(data: Uint8Array): Uint8Array;
+    /**
+     * Reconstruct one filtered scanline. Kept as a method so the reader's surface is unchanged; the
+     * dispatch itself lives in {@link png_unfilter}.
+     *
+     * @param {number} filter_type
+     * @param {Uint8Array} data
+     * @param {number} scanline_address
+     * @param {Uint8Array} output
+     * @param {number} bytes_per_pixel
+     * @param {number} output_offset
+     * @param {number} output_offset_previous where does result of previous scanline begin in the output? Needed for various filters such as `Up`
+     * @param {number} length
+     *
+     * @see https://www.w3.org/TR/PNG-Filters.html
+     */
+    unFilter(filter_type: number, data: Uint8Array, scanline_address: number, output: Uint8Array, bytes_per_pixel: number, output_offset: number, output_offset_previous: number, length: number): void;
+    /**
+     * Parse the PNG file. Keep this reader and its input buffer unchanged until the promise settles.
+     * @returns {Promise<PNG>}
+     */
+    parse(): Promise<PNG>;
+}
+import { PNG } from './PNG.js';
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+//# sourceMappingURL=PNGReader.d.ts.map

package/src/format/image/png/PNGReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PNGReader.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/png/PNGReader.js"],"names":[],"mappings":"AAyCA;;;;GAIG;AACH,iCAHW,WAAW,QAgCrB;;IAlCD;;;;OAIG;IACH,mBAHW,WAAW,EAgCrB;IA5BG;;;OAGG;IACH,KAFU,GAAG,CAEO;IAEpB;;;OAGG;IACH,YAFU,UAAU,EAAE,CAEF;IAEpB;;;OAGG;IACH,QAFU,YAAY,CAEU;IAOhC;;;OAGG;IACH,aAFU,OAAO,CAEO;IAG5B;;;;OAIG;IACH,kBAHW,MAAM,GACL,UAAU,CAarB;IAED;;OAEG;IACH,qBAcC;IAED;;;;;;;;;OASG;IACH,eAFa,QAAQ,MAAM,CAAC,CA4E3B;IAGD;;;OAGG;IACH,kBAFW,UAAU,QAOpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QAapB;IAED;;;OAGG;IACH,kBAFW,UAAU,QASpB;IACD;;;;OAIG;IACH,kBAFW,UAAU,QAwBpB;IAED;;;;;;;;;;;OAWG;IACH,6BAWC;IAED;;;;OAIG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,6BAGC;IAED;;;OAGG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,mBACC;IAED;;;OAGG;IACH,gBAFa,QAAQ,IAAI,CAAC,CA4BzB;IAID;;;;;;;;;OASG;IACH,oBAHW,UAAU,GACR,UAAU,CAkDtB;IAsDD;;;;;;;;;OASG;IACH,qBAHW,UAAU,GACR,UAAU,CAgHtB;IAID;;;;;;;;;;;;;;OAcG;IACH,sBAXW,MAAM,QACN,UAAU,oBACV,MAAM,UACN,UAAU,mBACV,MAAM,iBACN,MAAM,0BACN,MAAM,UACN,MAAM,QAwBhB;IAED;;;OAGG;IACH,SAFa,QAAQ,GAAG,CAAC,CAqBxB;;oBAloBmB,UAAU;6BAXD,sCAAsC"}

package/src/format/image/png/PNG_HEADER_BYTES.d.ts

@@ -0,0 +1,2 @@
+export const PNG_HEADER_BYTES: number[];
+//# sourceMappingURL=PNG_HEADER_BYTES.d.ts.map

package/src/format/image/png/PNG_HEADER_BYTES.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PNG_HEADER_BYTES.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/png/PNG_HEADER_BYTES.js"],"names":[],"mappings":"AAAA,wCAAiF"}

package/src/format/image/png/chunk/png_chunk_decode_iTXt.d.ts

@@ -0,0 +1,13 @@
+/**
+ * International textual data
+ * @see https://www.w3.org/TR/2003/REC-PNG-20031110/
+ * @param {Uint8Array} chunk
+ * @returns {Promise<{keyword: string, language_tag: string, translated_keyword: string, text: string}>}
+ */
+export function png_chunk_decode_iTXt(chunk: Uint8Array): Promise<{
+    keyword: string;
+    language_tag: string;
+    translated_keyword: string;
+    text: string;
+}>;
+//# sourceMappingURL=png_chunk_decode_iTXt.d.ts.map

package/src/format/image/png/chunk/png_chunk_decode_iTXt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_chunk_decode_iTXt.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/png/chunk/png_chunk_decode_iTXt.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,6CAHW,UAAU,GACR,QAAQ;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC,CAwDtG"}

package/src/format/image/png/chunk/png_chunk_decode_zTXt.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Compressed textual data
+ * @see https://www.w3.org/TR/2003/REC-PNG-20031110/#11zTXt
+ * @param {Uint8Array} chunk
+ * @returns {Promise<{keyword: string, text: string}>}
+ */
+export function png_chunk_decode_zTXt(chunk: Uint8Array): Promise<{
+    keyword: string;
+    text: string;
+}>;
+//# sourceMappingURL=png_chunk_decode_zTXt.d.ts.map

package/src/format/image/png/chunk/png_chunk_decode_zTXt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_chunk_decode_zTXt.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/png/chunk/png_chunk_decode_zTXt.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,6CAHW,UAAU,GACR,QAAQ;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC,CAmCpD"}

package/src/format/image/png/filter/png_filter_unFilterAverage.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The `Average` filter uses the average of the two neighboring pixels (left
+ * and above) to predict the value of a pixel.
+ *
+ * `Average(x) = Raw(x) + floor((Raw(x-bpp)+Prior(x))/2)`
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel
+ * @param {number} offset
+ * @param {number} output_offset_previous pass a negative value when there is no previous scanline
+ * @param {number} length
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterAverage(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
+//# sourceMappingURL=png_filter_unFilterAverage.d.ts.map

package/src/format/image/png/filter/png_filter_unFilterAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_filter_unFilterAverage.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/png/filter/png_filter_unFilterAverage.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,qDAVW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QA8ChB"}

package/src/format/image/png/filter/png_filter_unFilterNone.d.ts

@@ -0,0 +1,19 @@
+/**
+ * With the `None` filter the scanline is transmitted unmodified, so reconstruction is a byte copy.
+ *
+ * Byte-wise, like every other filter: at bit depths below eight a scanline carries several samples
+ * per byte, and unpacking them is {@link png_unpack_samples}' job, done after reconstruction. The
+ * two were once fused here, which is why `None` was the only filter that worked at those depths.
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel, unused by this filter
+ * @param {number} offset
+ * @param {number} output_offset_previous unused by this filter
+ * @param {number} length number of bytes to reconstruct
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterNone(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
+//# sourceMappingURL=png_filter_unFilterNone.d.ts.map

package/src/format/image/png/filter/png_filter_unFilterNone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_filter_unFilterNone.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/png/filter/png_filter_unFilterNone.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,kDAVW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QAgBhB"}

package/src/format/image/png/filter/png_filter_unFilterPaeth.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The `Paeth` filter computes a simple linear function of the three neighboring pixels (left, above, upper left), then chooses as predictor the neighboring pixel closest to the computed value.
+ *
+ * This technique is due to Alan W. Paeth.
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel
+ * @param {number} offset
+ * @param {number} output_offset_previous pass a negative value when there is no previous scanline
+ * @param {number} length
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterPaeth(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
+//# sourceMappingURL=png_filter_unFilterPaeth.d.ts.map

package/src/format/image/png/filter/png_filter_unFilterPaeth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_filter_unFilterPaeth.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/png/filter/png_filter_unFilterPaeth.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,mDAVW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QA8DhB"}

package/src/format/image/png/filter/png_filter_unFilterSub.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The `Sub` filter transmits the difference between each byte and the value
+ * of the corresponding byte of the prior pixel.
+ * `Sub(x) = Raw(x) + Raw(x - bpp)`
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel
+ * @param {number} offset
+ * @param {number} output_offset_previous unused by this filter
+ * @param {number} length
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterSub(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
+//# sourceMappingURL=png_filter_unFilterSub.d.ts.map

package/src/format/image/png/filter/png_filter_unFilterSub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_filter_unFilterSub.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/png/filter/png_filter_unFilterSub.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,iDATW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QAwBhB"}

package/src/format/image/png/filter/png_filter_unFilterUp.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The `Up` filter is just like the Sub() filter except that the pixel
+ * immediately above the current pixel, rather than just to its left, is used
+ * as the predictor.
+ * `Up(x) = Raw(x) + Prior(x)`
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel, unused by this filter
+ * @param {number} offset
+ * @param {number} output_offset_previous pass a negative value when there is no previous scanline
+ * @param {number} length
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterUp(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
+//# sourceMappingURL=png_filter_unFilterUp.d.ts.map

package/src/format/image/png/filter/png_filter_unFilterUp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_filter_unFilterUp.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/png/filter/png_filter_unFilterUp.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,gDATW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QAmChB"}

package/src/format/image/png/filter/png_unfilter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Reconstruct one filtered scanline.
+ *
+ * Operates on bytes throughout. At bit depths below eight the reconstructed bytes still hold
+ * several samples each, and {@link png_unpack_samples} separates them afterwards — which is what
+ * the specification means by filtering happening on the "corresponding byte" rather than on the
+ * sample.
+ *
+ * @param {number} filter_type `0 .. 4`
+ * @param {Uint8Array} data
+ * @param {number} scanline_address index of the first byte of the filtered scanline
+ * @param {Uint8Array} output
+ * @param {number} bytes_per_pixel the specification's `bpp`: whole bytes per pixel, at least one
+ * @param {number} output_offset where this scanline's reconstruction begins in `output`
+ * @param {number} output_offset_previous where the previous scanline's reconstruction begins;
+ *   negative when there is none
+ * @param {number} length number of bytes to reconstruct
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_unfilter(filter_type: number, data: Uint8Array, scanline_address: number, output: Uint8Array, bytes_per_pixel: number, output_offset: number, output_offset_previous: number, length: number): void;
+//# sourceMappingURL=png_unfilter.d.ts.map

package/src/format/image/png/filter/png_unfilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_unfilter.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/png/filter/png_unfilter.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,0CAZW,MAAM,QACN,UAAU,oBACV,MAAM,UACN,UAAU,mBACV,MAAM,iBACN,MAAM,0BACN,MAAM,UAEN,MAAM,QA2BhB"}

package/src/format/image/png/png_inflate.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Inflate a zlib-framed stream that arrived as one or more chunks.
+ *
+ * PNG splits a single zlib stream across however many `IDAT` chunks the encoder felt like, so the
+ * multi-chunk form is the general one; a `zTXt` or `iTXt` payload is simply a stream of one.
+ *
+ * `lenient` abandons the adler32 check, which is the only thing that would otherwise notice a
+ * flipped bit inside the payload: a stream that needs the fallback may decode to wrong bytes rather
+ * than to an error. That trade is deliberate for image data — see the caller — and wrong for
+ * anything where a silently wrong answer is worse than none.
+ *
+ * @param {Uint8Array[]} chunks pieces of one zlib stream, in order; keep unchanged until completion
+ * @param {boolean} [lenient] accept a stream whose adler32 trailer does not check out
+ * @returns {Promise<Uint8Array>}
+ * @throws {Error} if the deflate payload itself cannot be read
+ *
+ * @copyright Company Named Limited (c) 2026
+ */
+export function png_inflate(chunks: Uint8Array[], lenient?: boolean): Promise<Uint8Array>;
+//# sourceMappingURL=png_inflate.d.ts.map

package/src/format/image/png/png_inflate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_inflate.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/png/png_inflate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,oCAPW,UAAU,EAAE,YACZ,OAAO,GACL,QAAQ,UAAU,CAAC,CA8B/B"}

package/src/format/image/png/png_unpack_samples.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Expand samples packed several to a byte into one byte each.
+ *
+ * PNG codes bit depths of 1, 2 and 4 by packing samples into bytes, most significant bits first,
+ * with each scanline starting on a byte boundary. Filtering happens before this, on the packed
+ * bytes; everything downstream — the palette lookup, the sampler the loader builds — wants one
+ * byte per sample.
+ *
+ * Values come out as the depth coded them, not scaled to `0 .. 255`: a palette index has to stay
+ * an index, and rescaling a greyscale sample is a display decision rather than a decoding one.
+ *
+ * @param {Uint8Array} source packed bytes
+ * @param {number} source_offset index of the byte holding the first sample
+ * @param {number} bit_depth `1`, `2` or `4`
+ * @param {number} sample_count number of samples to unpack
+ * @param {Uint8Array} destination
+ * @param {number} destination_offset
+ *
+ * @see https://www.w3.org/TR/2003/REC-PNG-20031110/#7Scanline
+ */
+export function png_unpack_samples(source: Uint8Array, source_offset: number, bit_depth: number, sample_count: number, destination: Uint8Array, destination_offset: number): void;
+//# sourceMappingURL=png_unpack_samples.d.ts.map

package/src/format/image/png/png_unpack_samples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_unpack_samples.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/png/png_unpack_samples.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,2CATW,UAAU,iBACV,MAAM,aACN,MAAM,gBACN,MAAM,eACN,UAAU,sBACV,MAAM,QAqBhB"}

package/src/format/scene/gltf/GLTF_PRIMITIVE_MODE.d.ts

@@ -0,0 +1,19 @@
+/**
+ * *
+ */
+export type GLTF_PRIMITIVE_MODE = number;
+export namespace GLTF_PRIMITIVE_MODE {
+    let POINTS: number;
+    let LINES: number;
+    let LINE_LOOP: number;
+    let LINE_STRIP: number;
+    let TRIANGLES: number;
+    let TRIANGLE_STRIP: number;
+    let TRIANGLE_FAN: number;
+}
+/**
+ * What a primitive that names no mode is, per the specification's default.
+ * @type {GLTF_PRIMITIVE_MODE}
+ */
+export const GLTF_PRIMITIVE_MODE_DEFAULT: GLTF_PRIMITIVE_MODE;
+//# sourceMappingURL=GLTF_PRIMITIVE_MODE.d.ts.map

package/src/format/scene/gltf/GLTF_PRIMITIVE_MODE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GLTF_PRIMITIVE_MODE.d.ts","sourceRoot":"","sources":["../../../../../src/format/scene/gltf/GLTF_PRIMITIVE_MODE.js"],"names":[],"mappings":";;;kCAGU,MAAM;;;;;;;;;;AAehB;;;GAGG;AACH,0CAFU,mBAAmB,CAE4C"}

package/src/format/scene/gltf/coalesce_array_duplicates.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Input array will be modified, removing duplicates
+ * @param {{equals(*):boolean, hash?:function():number}[]} objects
+ */
+export function coalesce_array_duplicates(objects: {
+    equals(): boolean;
+    hash?: () => number;
+}[]): void;
+//# sourceMappingURL=coalesce_array_duplicates.d.ts.map

package/src/format/scene/gltf/coalesce_array_duplicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coalesce_array_duplicates.d.ts","sourceRoot":"","sources":["../../../../../src/format/scene/gltf/coalesce_array_duplicates.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,mDAFW;IAAC,MAAM,CAAC,GAAG,OAAO,CAAC;IAAC,IAAI,CAAC,QAAY,MAAM,CAAA;CAAC,EAAE,QAiDxD"}

package/src/format/scene/gltf/ext/GltfBufferViewExtension.d.ts

@@ -0,0 +1,49 @@
+/**
+ * One glTF extension that produces a bufferView's bytes.
+ *
+ * A bufferView extension says "these bytes are not in the buffer I point at; run this to get them".
+ * `EXT_meshopt_compression` is one, `KHR_meshopt_compression` is another, and a future codec would be
+ * a third; none of them is the parser's business beyond "does anything claim this view, and what
+ * came out".
+ *
+ * A subclass answers two questions and nothing else. It never walks the document, never touches
+ * `json.bufferViews`, and never decides what happens to what it produced - that belongs to
+ * {@link gltf_apply_buffer_view_extensions}, which does it the same way for every extension.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class GltfBufferViewExtension {
+    /**
+     * The key this extension appears under in a bufferView's `extensions` object.
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Produce the bytes the parent bufferView describes.
+     *
+     * Anything wrong with the extension object is wrong with the *file*, so it throws rather than
+     * asserts: `assert` is compiled out of production builds, and a mis-declared view that decodes
+     * to plausible rubbish is worse than one that does not load.
+     *
+     * @param {object} extension this extension's object, taken off the view for you
+     * @param {object} buffer_view the parent, for the layout it declares
+     * @param {Uint8Array[]} buffers the document's resolved buffers, to read the source range from
+     * @param {number} index which bufferView this is, so a message can name it
+     * @returns {Uint8Array} exactly `buffer_view.byteLength` bytes
+     * @throws {Error} if the extension object does not satisfy its specification
+     */
+    decode(extension: object, buffer_view: object, buffers: Uint8Array[], index: number): Uint8Array;
+    /**
+     * Whether this extension marks a buffer as one the file never wrote - a placeholder that exists
+     * only so the views over it have somewhere to point.
+     *
+     * Asking is how a loader avoids requesting a file that was never written. Most extensions have
+     * no opinion, which is why this answers `false` by default.
+     *
+     * @param {object} buffer an entry of `json.buffers`
+     * @returns {boolean}
+     */
+    is_placeholder_buffer(buffer: object): boolean;
+}
+//# sourceMappingURL=GltfBufferViewExtension.d.ts.map

package/src/format/scene/gltf/ext/GltfBufferViewExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GltfBufferViewExtension.d.ts","sourceRoot":"","sources":["../../../../../../src/format/scene/gltf/ext/GltfBufferViewExtension.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;;;;;;;;OAaG;IACH,kBAPW,MAAM,eACN,MAAM,WACN,UAAU,EAAE,SACZ,MAAM,GACJ,UAAU,CAKtB;IAED;;;;;;;;;OASG;IACH,8BAHW,MAAM,GACJ,OAAO,CAInB;CACJ"}