@woosh/meep-engine 3.8.0 → 3.10.0

package/src/engine/asset/loaders/image/png/PNGReader.js

@@ -1,20 +1,16 @@
 /*global Uint8Array:true ArrayBuffer:true */
 "use strict";
 
-import zlib from 'pako';
-import { assert } from "../../../../../core/assert.js";
 import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
 import { EndianType } from "../../../../../core/binary/EndianType.js";
 import { platform_compute_endianness } from "../../../../../core/binary/platform_compute_endianness.js";
 import { isArrayEqualStrict } from "../../../../../core/collection/array/isArrayEqualStrict.js";
 import { png_chunk_decode_iTXt } from "./chunk/png_chunk_decode_iTXt.js";
+import { png_inflate } from "./png_inflate.js";
 import { png_chunk_decode_zTXt } from "./chunk/png_chunk_decode_zTXt.js";
-import { crc32 } from "./crc32.js";
-import { png_filter_unFilterAverage } from "./filter/png_filter_unFilterAverage.js";
-import { png_filter_unFilterNone } from "./filter/png_filter_unFilterNone.js";
-import { png_filter_unFilterPaeth } from "./filter/png_filter_unFilterPaeth.js";
-import { png_filter_unFilterSub } from "./filter/png_filter_unFilterSub.js";
-import { png_filter_unFilterUp } from "./filter/png_filter_unFilterUp.js";
+import { crc32 } from "../../../../../core/binary/hash/crc32.js";
+import { png_unfilter } from "./filter/png_unfilter.js";
+import { png_unpack_samples } from "./png_unpack_samples.js";
 
 import { PNG } from './PNG.js';
 import { PNG_HEADER_BYTES } from "./PNG_HEADER_BYTES.js";
@@ -49,18 +45,6 @@ function readUInt8(buffer, offset) {
  * @constructor
  */
 export function PNGReader(bytes) {
-    /**
-     * current pointer
-     * @type {number}
-     */
-    this.i = 0;
-
-    /**
-     * bytes buffer
-     * @type {Uint8Array}
-     */
-    this.bytes = new Uint8Array(bytes);
-
     /**
      * Output object
      * @type {PNG}
@@ -89,12 +73,6 @@ export function PNGReader(bytes) {
      * @type {boolean}
      */
     this.crc_enabled = false;
-
-    /**
-     *
-     * @type {Uint8Array}
-     */
-    this.header = new Uint8Array(8);
 }
 
 /**
@@ -120,15 +98,11 @@ PNGReader.prototype.readBytes = function (length) {
  */
 PNGReader.prototype.decodeHeader = function () {
 
-    if (this.i !== 0) {
-        throw new Error('file pointer should be at 0 to read the header');
-    }
-
     const buffer = this.buffer;
 
-    const header = this.header;
+    const header = new Uint8Array(PNG_HEADER_BYTES.length);
 
-    buffer.readBytes(header, 0, 8)
+    buffer.readBytes(header, 0, header.length);
 
     // see https://www.w3.org/TR/PNG-Structure.html
     if (!isArrayEqualStrict(header, PNG_HEADER_BYTES)) {
@@ -356,41 +330,10 @@ PNGReader.prototype.decodeIEND = function () {
 PNGReader.prototype.decodePixels = function () {
     const png = this.png;
 
-    const chunks = this.dataChunks;
-    const chunk_count = chunks.length;
-
-    // First, try standard zlib-framed inflate. This verifies the adler32 trailer,
-    // which is the right behaviour for spec-compliant PNGs.
-    const inflator = new zlib.Inflate();
-    for (let i = 0; i < chunk_count; i++) {
-        inflator.push(chunks[i]);
-    }
-
-    let decompressed_data;
-
-    if (inflator.err === 0) {
-        decompressed_data = inflator.result;
-    } else {
-        // Some real-world encoders emit IDAT streams with a corrupt adler32 trailer
-        // (the deflate payload itself is fine). Chrome and libpng accept these, so
-        // we mirror that leniency: concatenate the IDAT bytes, strip the 2-byte
-        // zlib header, and inflate as raw deflate (which doesn't check the trailer).
-        let total = 0;
-        for (let i = 0; i < chunk_count; i++) total += chunks[i].length;
-        const concatenated = new Uint8Array(total);
-        let off = 0;
-        for (let i = 0; i < chunk_count; i++) {
-            concatenated.set(chunks[i], off);
-            off += chunks[i].length;
-        }
-        try {
-            decompressed_data = zlib.inflateRaw(concatenated.subarray(2));
-        } catch (raw_err) {
-            // The deflate payload itself is broken; re-throw with the original
-            // pako message for diagnostics.
-            throw new Error(`Failed to inflate IDAT stream: ${inflator.msg || inflator.err}`);
-        }
-    }
+    // leniently: a corrupt adler32 trailer over a sound deflate payload is common enough in the
+    // wild that Chrome and libpng both accept it, and a texture that refuses to load is worse than
+    // one whose checksum nobody reads
+    const decompressed_data = png_inflate(this.dataChunks, true);
 
     // https://www.w3.org/TR/png-3/#8InterlaceMethods
     if (png.getInterlaceMethod() === 0) {
@@ -415,48 +358,58 @@ PNGReader.prototype.decodePixels = function () {
 // Different interlace methods
 
 /**
+ * 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}
  */
 PNGReader.prototype.interlaceNone = function (data) {
 
     const png = this.png;
 
     const depth = png.bitDepth;
-    const bits_per_line = png.colors * depth;
-    const bytes_per_pixel = bits_per_line / 8;
+    const channels = png.colors;
 
     const width = png.width;
     const height = png.height;
 
-    // color bytes per row
-    const color_bytes_per_row = Math.ceil(bytes_per_pixel * width);
+    // the specification's `bpp`: whole bytes per pixel, and never less than one
+    const bytes_per_pixel = Math.max(1, Math.ceil(channels * depth / 8));
+
+    const bytes_per_row = Math.ceil(channels * depth * width / 8);
 
-    const pixels = new Uint8Array(color_bytes_per_row * height);
+    if (depth < 8) {
+        return interlace_none_packed(data, depth, channels * width, bytes_per_pixel, bytes_per_row, height);
+    }
+
+    const pixels = new Uint8Array(bytes_per_row * height);
 
     let offset = 0;
 
     const data_length = data.length;
 
-    for (let i = 0; i < data_length; i += color_bytes_per_row + 1) {
+    for (let i = 0; i < data_length; i += bytes_per_row + 1) {
 
         const scanline_address = i + 1;
 
-        // scanline = slice.call(data, scanline_address, scanline_address + cpr);
-
-        const filter_type = readUInt8(data, i);
+        const filter_type = data[i];
 
-        this.unFilter(
+        png_unfilter(
             filter_type,
             data,
             scanline_address,
             pixels,
-            Math.max(1, Math.ceil(bytes_per_pixel)),
+            bytes_per_pixel,
             offset,
-            offset - color_bytes_per_row,
-            color_bytes_per_row
+            offset - bytes_per_row,
+            bytes_per_row
         );
 
-        offset += color_bytes_per_row;
+        offset += bytes_per_row;
 
     }
 
@@ -464,18 +417,87 @@ PNGReader.prototype.interlaceNone = function (data) {
 
 };
 
+/**
+ * The sub-byte half of {@link PNGReader#interlaceNone}.
+ *
+ * Two packed rows are kept, alternating, because the `Up`, `Average` and `Paeth` filters predict
+ * from the previous scanline as it was *packed*, not as it was unpacked.
+ *
+ * @param {Uint8Array} data
+ * @param {number} depth `1`, `2` or `4`
+ * @param {number} samples_per_row
+ * @param {number} bytes_per_pixel
+ * @param {number} bytes_per_row packed
+ * @param {number} height
+ * @returns {Uint8Array} one byte per sample
+ */
+function interlace_none_packed(data, depth, samples_per_row, bytes_per_pixel, bytes_per_row, height) {
+    const pixels = new Uint8Array(samples_per_row * height);
+
+    const rows = new Uint8Array(bytes_per_row * 2);
+
+    const rows_available = Math.floor(data.length / (bytes_per_row + 1));
+    const row_count = height < rows_available ? height : rows_available;
+
+    let at = 0;
+    let previous_row_offset = -1;
+
+    for (let y = 0; y < row_count; y++) {
+        const filter_type = data[at++];
+
+        const row_offset = (y & 1) * bytes_per_row;
+
+        png_unfilter(
+            filter_type,
+            data,
+            at,
+            rows,
+            bytes_per_pixel,
+            row_offset,
+            previous_row_offset,
+            bytes_per_row
+        );
+
+        at += bytes_per_row;
+
+        png_unpack_samples(rows, row_offset, depth, samples_per_row, pixels, y * samples_per_row);
+
+        previous_row_offset = row_offset;
+    }
+
+    return pixels;
+}
+
 
 /**
- * De-interlace image according to Adam 7 scheme
+ * 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}
  */
 PNGReader.prototype.interlaceAdam7 = function (data) {
 
     const png = this.png;
 
-    const bytes_per_pixel = png.colors * png.bitDepth / 8;
+    const depth = png.bitDepth;
+    const channels = png.colors;
+
+    const width = png.width;
+    const height = png.height;
+
+    const packed = depth < 8;
 
-    const pixels = new Uint8Array(bytes_per_pixel * png.width * png.height);
+    // the specification's `bpp`, used for filtering
+    const bytes_per_pixel = Math.max(1, Math.ceil(channels * depth / 8));
+
+    // bytes a pixel occupies in the *output*, where sub-byte samples have been expanded
+    const output_pixel_bytes = channels * (depth === 16 ? 2 : 1);
+
+    const pixels = new Uint8Array(output_pixel_bytes * width * height);
 
     // Adam7 interlacing pattern
     const passes = [
@@ -488,13 +510,13 @@ PNGReader.prototype.interlaceAdam7 = function (data) {
         { x: 0, y: 1, xStep: 1, yStep: 2 }, // Pass 7
     ];
 
-    const width = png.width;
-    const height = png.height;
-
     let offset = 0;
 
-    // Create a new line for the unfiltered data
-    const line_bytes_buffer = new Uint8Array(width * bytes_per_pixel);
+    // two reconstructed rows, alternating, so that the previous one is still there to predict from
+    const line_bytes_buffer = new Uint8Array(Math.ceil(channels * depth * width / 8) * 2);
+
+    // one unpacked row, used only below eight bits
+    const sample_buffer = packed ? new Uint8Array(channels * width) : null;
 
     // Process each pass
     for (let passIndex = 0; passIndex < 7; passIndex++) {
@@ -508,7 +530,8 @@ PNGReader.prototype.interlaceAdam7 = function (data) {
             continue;
         }
 
-        const passLineBytes = pass_width * bytes_per_pixel;
+        const pass_samples = channels * pass_width;
+        const pass_line_bytes = Math.ceil(pass_samples * depth / 8);
 
         // Indicate to unfiltering that this is the first line (no previous line)
         let previous_line_offset = -1;
@@ -520,10 +543,9 @@ PNGReader.prototype.interlaceAdam7 = function (data) {
             const filter_type = data[offset++];
 
             // we use alternating line offsets to save on memory allocations
-            const line_offset = (y % 2) * passLineBytes;
+            const line_offset = (y % 2) * pass_line_bytes;
 
-            // Apply the appropriate unfilter
-            this.unFilter(
+            png_unfilter(
                 filter_type,
                 data,
                 offset,
@@ -531,12 +553,23 @@ PNGReader.prototype.interlaceAdam7 = function (data) {
                 bytes_per_pixel,
                 line_offset,
                 previous_line_offset,
-                passLineBytes,
+                pass_line_bytes
             );
 
-            offset += passLineBytes;
+            offset += pass_line_bytes;
             previous_line_offset = line_offset;
 
+            // below eight bits the reconstruction is still packed, so expand it before scattering
+            let source = line_bytes_buffer;
+            let source_offset = line_offset;
+
+            if (packed) {
+                png_unpack_samples(line_bytes_buffer, line_offset, depth, pass_samples, sample_buffer, 0);
+
+                source = sample_buffer;
+                source_offset = 0;
+            }
+
             for (let x = 0; x < pass_width; x++) {
 
                 const outputX = pass.x + x * pass.xStep;
@@ -546,10 +579,10 @@ PNGReader.prototype.interlaceAdam7 = function (data) {
                     continue;
                 }
 
-                for (let i = 0; i < bytes_per_pixel; i++) {
-                    const out_offset = (outputY * width + outputX) * bytes_per_pixel + i;
+                for (let i = 0; i < output_pixel_bytes; i++) {
+                    const out_offset = (outputY * width + outputX) * output_pixel_bytes + i;
 
-                    pixels[out_offset] = line_bytes_buffer[line_offset + x * bytes_per_pixel + i];
+                    pixels[out_offset] = source[source_offset + x * output_pixel_bytes + i];
                 }
             }
         }
@@ -561,6 +594,8 @@ PNGReader.prototype.interlaceAdam7 = function (data) {
 // Unfiltering
 
 /**
+ * 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
@@ -583,68 +618,16 @@ PNGReader.prototype.unFilter = function (
     output_offset_previous,
     length
 ) {
-    assert.isInteger(filter_type, 'filter_type');
-    assert.isNonNegativeInteger(scanline_address, 'scanline_address');
-    assert.isNonNegativeInteger(bytes_per_pixel, 'bytes_per_pixel');
-    assert.isNonNegativeInteger(output_offset, 'output_offset');
-    assert.isNonNegativeInteger(length, 'length');
-
-    switch (filter_type) {
-        case 0:
-            png_filter_unFilterNone(
-                data,
-                scanline_address,
-                output,
-                output_offset,
-                length,
-                this.png.bitDepth
-            );
-            break;
-        case 1:
-            png_filter_unFilterSub(
-                data,
-                scanline_address,
-                output,
-                bytes_per_pixel,
-                output_offset,
-                length
-            );
-            break;
-        case 2:
-            png_filter_unFilterUp(
-                data,
-                scanline_address,
-                output,
-                output_offset,
-                output_offset_previous,
-                length
-            );
-            break;
-        case 3:
-            png_filter_unFilterAverage(
-                data,
-                scanline_address,
-                output,
-                bytes_per_pixel,
-                output_offset,
-                output_offset_previous,
-                length
-            );
-            break;
-        case 4:
-            png_filter_unFilterPaeth(
-                data,
-                scanline_address,
-                output,
-                bytes_per_pixel,
-                output_offset,
-                output_offset_previous,
-                length
-            );
-            break;
-        default:
-            throw new Error(`unknown filtered scanline type '${filter_type}'`);
-    }
+    png_unfilter(
+        filter_type,
+        data,
+        scanline_address,
+        output,
+        bytes_per_pixel,
+        output_offset,
+        output_offset_previous,
+        length
+    );
 }
 
 /**

package/src/engine/asset/loaders/image/png/chunk/png_chunk_decode_iTXt.js

@@ -1,5 +1,5 @@
 import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
-import { inflate } from "../inflate.js";
+import { png_inflate } from "../png_inflate.js";
 
 /**
  * International textual data
@@ -35,9 +35,9 @@ export function png_chunk_decode_iTXt(chunk) {
             throw new Error('only compression_method 0 is supported');
         }
 
-        const decoded = inflate(new Uint8Array(buffer.data, buffer.position, remaining_bytes));
+        const decoded = png_inflate([new Uint8Array(buffer.data, buffer.position, remaining_bytes)]);
 
-        buffer.fromArrayBuffer(decoded);
+        buffer.fromArrayBuffer(decoded.buffer);
 
         text = buffer.readASCIICharacters(decoded.byteLength);
     } else {

package/src/engine/asset/loaders/image/png/chunk/png_chunk_decode_zTXt.js

@@ -1,5 +1,5 @@
 import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
-import { inflate } from "../inflate.js";
+import { png_inflate } from "../png_inflate.js";
 
 /**
  * Compressed textual data
@@ -26,9 +26,9 @@ export function png_chunk_decode_zTXt(chunk) {
         const local_offset = buffer.position - chunk_byte_offset;
         const encoded_chunk = new Uint8Array(chunk_buffer, buffer.position, chunk_size  - local_offset);
 
-        const decompressed_data = inflate(encoded_chunk);
+        const decompressed_data = png_inflate([encoded_chunk]);
 
-        buffer.fromArrayBuffer(decompressed_data);
+        buffer.fromArrayBuffer(decompressed_data.buffer);
 
         value = buffer.readASCIICharacters(decompressed_data.byteLength);
     } else {

package/src/engine/asset/loaders/image/png/crc32.d.ts

@@ -1,16 +1,2 @@
-/**
- * 32-bit Cyclic Redundancy Checksum.
- * @see https://en.wikipedia.org/wiki/Cyclic_redundancy_check
- * @param {Uint8Array} buffer byte buffer
- * @param {number} [offset=0] where to start in the input buffer
- * @param {number} [length=buffer.length] how many bytes to include in checksum calculation
- * @return {number} Unsigned 32-bit integer value
- * @copyright Company Named Limited (c) 2026
- *
- * @example
- *      const buffer = new BinaryBuffer();
- *      buffer.writeASCIIString("Hello World");
- *      const checksum = crc32(buffer.raw_bytes, 0, buffer.position);
- */
-export function crc32(buffer: Uint8Array, offset?: number, length?: number): number;
+export { crc32 } from "../../../../../core/binary/hash/crc32.js";
 //# sourceMappingURL=crc32.d.ts.map

package/src/engine/asset/loaders/image/png/crc32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crc32.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/crc32.js"],"names":[],"mappings":"AAuEA;;;;;;;;;;;;;GAaG;AACH,8BAXW,UAAU,WACV,MAAM,WACN,MAAM,GACL,MAAM,CAcjB"}
+{"version":3,"file":"crc32.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/crc32.js"],"names":[],"mappings":""}

package/src/engine/asset/loaders/image/png/crc32.js

@@ -1,92 +1,8 @@
-import { assert } from "../../../../../core/assert.js";
-
-/*
- * Ported from C source at https://www.w3.org/TR/PNG-CRCAppendix.html
- * See also ISO 3309 [ISO-3309] or ITU-T V.42 [ITU-V42] for a formal specification
- */
-
-/**
- *
- * @type {Uint32Array}
- */
-const crc_table = new Uint32Array(256);
-
-// Precompute checksum table
-for (let n = 0; n < 256; n++) {
-    let c = n;
-
-    for (let k = 0; k < 8; k++) {
-
-        if ((c & 1) !== 0) {
-            // CRC32b polynomial
-            c = 0xedb88320 ^ (c >>> 1);
-        } else {
-            c = c >>> 1;
-        }
-
-    }
-
-    crc_table[n] = c;
-}
-
-const INITIAL = 0xffffffff;
-
-/**
- * Update a running CRC with the bytes buf[0..len-1]--the CRC
- * should be initialized to all 1's, and the transmitted value
- * is the 1's complement of the final running CRC (see the crc32() routine below)).
- * @param {number} input_crc starting CRC value
- * @param {Uint8Array} buffer
- * @param {number} offset
- * @param {number} length
- * @return {number}
- */
-function update_crc(
-    input_crc,
-    buffer,
-    offset,
-    length,
-) {
-    assert.isNonNegativeInteger(input_crc, 'input_crc');
-    assert.defined(buffer, 'buffer');
-    assert.isNonNegativeInteger(offset, 'offset');
-    assert.isNonNegativeInteger(length, 'length');
-
-    let crc = input_crc;
-
-    const end = offset + length;
-
-    for (let n = offset; n < end; n++) {
-
-        const byte = buffer[n];
-
-        const lookup_index = (crc ^ byte) & 0xff;
-
-        crc = crc_table[lookup_index] ^ (crc >>> 8);
-
-    }
-
-    return crc;
-}
-
 /**
- * 32-bit Cyclic Redundancy Checksum.
- * @see https://en.wikipedia.org/wiki/Cyclic_redundancy_check
- * @param {Uint8Array} buffer byte buffer
- * @param {number} [offset=0] where to start in the input buffer
- * @param {number} [length=buffer.length] how many bytes to include in checksum calculation
- * @return {number} Unsigned 32-bit integer value
- * @copyright Company Named Limited (c) 2026
+ * @deprecated Moved to `core/binary/hash/crc32.js`. CRC-32/ISO-3309 is not a PNG algorithm — PNG
+ * merely happens to be the first thing in the tree that needed it.
  *
- * @example
- *      const buffer = new BinaryBuffer();
- *      buffer.writeASCIIString("Hello World");
- *      const checksum = crc32(buffer.raw_bytes, 0, buffer.position);
+ * Kept as a re-export rather than removed: this is a library, and an import path is as much a
+ * published interface as a function signature.
  */
-export function crc32(
-    buffer,
-    offset=0,
-    length=buffer.length,
-) {
-    return (update_crc(INITIAL, buffer, offset, length) ^ INITIAL) >>> 0;
-}
+export { crc32 } from "../../../../../core/binary/hash/crc32.js";

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterNone.d.ts

@@ -1,17 +1,19 @@
 /**
- * With the None filter, the scanline is transmitted unmodified; it is only necessary to insert a filter type byte before the data.
+ * With the `None` filter the scanline is transmitted unmodified, so reconstruction is a byte copy.
  *
- * For depths < 8 the scanline byte is unpacked into individual samples; for depths 8 and 16 the bytes are copied straight through
- * (16-bit samples are stored as two big-endian bytes per channel — the filter layer still operates byte-wise).
+ * 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} data
- * @param {number} scanline_address
- * @param {Uint8Array} output
- * @param {number} output_offset
- * @param {number} length number of bytes (depth >= 8) or samples (depth < 8) to produce
- * @param {number} bit_depth one of 1, 2, 4, 8, 16
+ * @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(data: Uint8Array, scanline_address: number, output: Uint8Array, output_offset: number, length: number, bit_depth: number): void;
+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/engine/asset/loaders/image/png/filter/png_filter_unFilterNone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"png_filter_unFilterNone.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/asset/loaders/image/png/filter/png_filter_unFilterNone.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,8CATW,UAAU,oBACV,MAAM,UACN,UAAU,iBACV,MAAM,UACN,MAAM,aACN,MAAM,QA2ChB"}
+{"version":3,"file":"png_filter_unFilterNone.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/asset/loaders/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"}