@fdm-monster/server 2.0.7 → 2.0.8

package/dist/utils/bgcode/bgcode.utils.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get decompressBlock () {
+        return decompressBlock;
+    },
+    get extractMetadataFromBlocks () {
+        return extractMetadataFromBlocks;
+    },
+    get getBlockData () {
+        return getBlockData;
+    },
+    get getBlockParsedParameters () {
+        return getBlockParsedParameters;
+    },
+    get parseBlockHeader () {
+        return parseBlockHeader;
+    },
+    get parseBlockHeaders () {
+        return parseBlockHeaders;
+    },
+    get parseBlockParameters () {
+        return parseBlockParameters;
+    },
+    get parseFileHeader () {
+        return parseFileHeader;
+    }
+});
+const _bgcodeconstants = require("./bgcode.constants");
+const _bgcodetypes = require("./bgcode.types");
+const _nodezlib = require("node:zlib");
+const _heatshrinkdecoder = require("./heatshrink-decoder");
+async function parseFileHeader(fileHandle) {
+    const buffer = Buffer.alloc(_bgcodeconstants.BGCODE_HEADER_SIZE);
+    await fileHandle.read(buffer);
+    if (buffer.length < _bgcodeconstants.BGCODE_HEADER_SIZE) {
+        throw new Error("File too small to be a valid BGCode file");
+    }
+    const magic = buffer.toString("ascii", 0, 4);
+    if (magic !== _bgcodeconstants.BGCODE_HEADER_MARKER) {
+        throw new Error(`Invalid BGCode file: magic number not found (got "${magic}", expected ${_bgcodeconstants.BGCODE_HEADER_MARKER})`);
+    }
+    const version = buffer.readUInt32LE(4);
+    const checksumType = buffer.readUInt16LE(8);
+    return {
+        magic,
+        version,
+        checksumType
+    };
+}
+async function parseBlockHeaders(fileHandle, fileSize, checksumType, skipGcode) {
+    let offset = _bgcodeconstants.BGCODE_HEADER_SIZE;
+    const blockHeaders = [];
+    let currentExpectedHeaderIndex = 0;
+    while(offset < fileSize){
+        const blockHeader = await parseBlockHeader(fileHandle, fileSize, offset, checksumType);
+        if (skipGcode && blockHeader.type == _bgcodetypes.BgCodeBlockTypes.GCode) {
+            break;
+        }
+        const expectedType = _bgcodeconstants.BGCODE_EXPECTED_HEADERS[currentExpectedHeaderIndex];
+        if (blockHeader.type !== expectedType) {
+            const nextExpectedType = _bgcodeconstants.BGCODE_EXPECTED_HEADERS[currentExpectedHeaderIndex + 1];
+            if (blockHeader.type !== nextExpectedType) {
+                throw new Error(`Unexpected header header type ${blockHeader.type}, expected either ${expectedType} or next ${nextExpectedType}`);
+            }
+            currentExpectedHeaderIndex++;
+        }
+        if (Number.isNaN(blockHeader.blockSize)) {
+            throw new Error(`Unexpected blockHeader.blockSize ${blockHeader.blockSize}`);
+        }
+        offset += blockHeader.blockSize;
+        blockHeaders.push(blockHeader);
+    }
+    return blockHeaders;
+}
+async function parseBlockHeader(fileHandle, fileSize, blockStartOffset, checksumType) {
+    if (blockStartOffset + _bgcodeconstants.BGCODE_MAX_BLOCK_HEADER_SIZE > fileSize) {
+        throw new Error("Not enough data for block header");
+    }
+    const buffer = Buffer.alloc(_bgcodeconstants.BGCODE_MAX_BLOCK_HEADER_SIZE);
+    await fileHandle.read({
+        buffer,
+        offset: 0,
+        length: _bgcodeconstants.BGCODE_MAX_BLOCK_HEADER_SIZE,
+        position: blockStartOffset
+    });
+    const type = buffer.readUInt16LE(0);
+    if (type > _bgcodeconstants.BGCODE_MAX_BLOCK_TYPE) {
+        throw new Error(`Block header type ${type} exceeds ${_bgcodeconstants.BGCODE_MAX_BLOCK_TYPE}, cant parse block`);
+    }
+    const compression = buffer.readUInt16LE(2);
+    if (compression > _bgcodeconstants.BGCODE_MAX_COMPRESSION) {
+        throw new Error(`Block header compression ${compression} exceeds ${_bgcodeconstants.BGCODE_MAX_COMPRESSION}, cant parse block`);
+    }
+    const uncompressedSize = buffer.readUInt32LE(4);
+    if (uncompressedSize === 0) {
+        throw new Error(`Uncompressed Size is 0`);
+    }
+    let compressedSize = 0;
+    let headerSize = _bgcodeconstants.BGCODE_MIN_BLOCK_HEADER_SIZE;
+    if (compression > 0) {
+        compressedSize = buffer.readUInt32LE(8);
+        if (compressedSize === 0) {
+            throw new Error(`Compression is ${_bgcodetypes.BgCodeCompressionName[compression]} but compressed size is ${compressedSize}}`);
+        }
+        headerSize = _bgcodeconstants.BGCODE_MAX_BLOCK_HEADER_SIZE;
+    }
+    const checksumSize = calculateChecksumSize(checksumType);
+    const blockSize = calculateBlockSize(checksumSize, type, compression, uncompressedSize, compressedSize);
+    const parameterOffset = blockStartOffset + headerSize;
+    const parametersSize = calculateParameterSize(type);
+    const parameterBuffer = await getBlockParsedParameters(fileHandle, parameterOffset, parametersSize);
+    const parameters = parseBlockParameters(type, parameterBuffer);
+    const dataOffset = parameterOffset + parametersSize;
+    const dataSize = blockSize - parametersSize - checksumSize;
+    const checksumOffset = dataOffset + dataSize;
+    return {
+        type,
+        compression,
+        uncompressedSize,
+        compressedSize,
+        blockSize,
+        blockStartOffset,
+        headerSize,
+        parameterOffset,
+        parameters,
+        parametersSize,
+        dataOffset,
+        dataSize,
+        checksumOffset,
+        checksumSize,
+        checksumType
+    };
+}
+async function getBlockParsedParameters(fileHandle, parameterOffset, parametersSize) {
+    const parameters = Buffer.alloc(parametersSize);
+    if (parametersSize > 0) {
+        await fileHandle.read({
+            buffer: parameters,
+            offset: 0,
+            length: parametersSize,
+            position: parameterOffset
+        });
+    }
+    return parameters;
+}
+async function getBlockData(fileHandle, blockHeader) {
+    if (blockHeader.blockSize === 0) {
+        throw new Error("Cant get block data for block with size 0");
+    }
+    if (blockHeader.blockSize === 1E3) {
+        throw new Error(`Cant get block data for block with size ${blockHeader.blockSize} > ${1E3}`);
+    }
+    const data = Buffer.alloc(blockHeader.dataSize);
+    await fileHandle.read({
+        buffer: data,
+        offset: 0,
+        length: blockHeader.dataSize,
+        position: blockHeader.dataOffset
+    });
+    return data;
+}
+function decompressBlock(compression, data) {
+    const info = _bgcodetypes.BgCodeCompressionInfo[compression];
+    switch(info.kind){
+        case "none":
+            return data;
+        case "deflate":
+            return (0, _nodezlib.inflateSync)(data);
+        case "heatshrink":
+            const decoder = new _heatshrinkdecoder.HeatshrinkDecoder(info.window, info.lookahead);
+            return decoder.decompress(data);
+        default:
+            throw new Error(`Unknown compression type: ${compression}`);
+    }
+}
+function parseBlockParameters(blockType, parameters) {
+    const parameterSize = _bgcodetypes.BgCodeBlockParameterSizes[blockType];
+    if (parameters.length !== parameterSize) {
+        throw new Error(`Block Parameters should be exactly ${parameterSize} bytes long`);
+    }
+    if (blockType === _bgcodetypes.BgCodeBlockTypes.Thumbnail) {
+        return {
+            format: calculateThumbnailFormat(parameters.readUInt16LE(0)),
+            width: parameters.readUInt16LE(2),
+            height: parameters.readUInt16LE(4)
+        };
+    }
+    return {
+        encoding: parameters.readUInt16LE(0)
+    };
+}
+function calculateBlockSize(checksumSize, blockType, compression, uncompressedSize, compressedSize) {
+    const headerSize = compression > 0 ? 12 : 8;
+    const dataSize = compression === 0 ? uncompressedSize : compressedSize;
+    const parametersSize = blockType === _bgcodetypes.BgCodeBlockTypes.Thumbnail ? 6 : 2;
+    return headerSize + parametersSize + dataSize + checksumSize;
+}
+function calculateChecksumSize(checksumType) {
+    if (checksumType > _bgcodeconstants.BGCODE_MAX_CHECKSUM_TYPE) {
+        throw new Error(`Checksum type ${checksumType} exceeds max ${_bgcodeconstants.BGCODE_MAX_CHECKSUM_TYPE}`);
+    }
+    return _bgcodetypes.BgCodeChecksumTypeSize[checksumType];
+}
+function calculateParameterSize(blockType) {
+    if (blockType > _bgcodeconstants.BGCODE_MAX_BLOCK_TYPE) {
+        throw new Error(`Checksum type ${blockType} exceeds max ${_bgcodeconstants.BGCODE_MAX_BLOCK_TYPE}`);
+    }
+    return _bgcodetypes.BgCodeBlockParameterSizes[blockType];
+}
+function calculateThumbnailFormat(formatParameter) {
+    if (formatParameter > _bgcodeconstants.BGCODE_PARAMETER_THUMBNAIL_MAX_FORMAT) {
+        throw new Error(`Thumbnail format type ${formatParameter} exceeds max ${_bgcodeconstants.BGCODE_PARAMETER_THUMBNAIL_MAX_FORMAT}`);
+    }
+    return formatParameter;
+}
+async function extractMetadataFromBlocks(fileHandle, blockHeaders) {
+    const metadata = {};
+    const metadataBlocks = blockHeaders.filter((b)=>b.type === _bgcodetypes.BgCodeBlockTypes.FileMetadata || b.type === _bgcodetypes.BgCodeBlockTypes.SlicerMetadata || b.type === _bgcodetypes.BgCodeBlockTypes.PrinterMetadata || b.type === _bgcodetypes.BgCodeBlockTypes.PrintMetadata);
+    for (const header of metadataBlocks){
+        const blockData = await getBlockData(fileHandle, header);
+        const data = decompressBlock(header.compression, blockData);
+        const text = data.toString("utf8");
+        extractMetadataFromText(text, metadata);
+    }
+    return metadata;
+}
+const METADATA_KEY_NORMALIZATION = {
+    'producer': 'producer',
+    'produced on': 'produced_on',
+    'print time': 'print_time',
+    'estimated printing time (silent mode)': 'estimated_printing_time_silent_mode',
+    'estimated printing time (normal mode)': 'estimated_printing_time_normal_mode',
+    'layer height': 'layer_height',
+    'first layer height': 'first_layer_height',
+    'initial layer height': 'initial_layer_height',
+    'nozzle diameter': 'nozzle_diameter',
+    'filament diameter': 'filament_diameter',
+    'filament density': 'filament_density',
+    'filament used [mm]': 'filament_used_mm',
+    'filament used [cm3]': 'filament_used_cm3',
+    'filament used [g]': 'filament_used_g',
+    'bed temperature': 'bed_temperature',
+    'temperature': 'temperature',
+    'fill density': 'fill_density',
+    'filament type': 'filament_type',
+    'printer model': 'printer_model',
+    'max layer z': 'max_layer_z',
+    'total layers': 'total_layers',
+    'layer count': 'layer_count'
+};
+function extractMetadataFromText(text, metadata) {
+    const lines = text.split('\n');
+    for (const line of lines){
+        const keyValuePair = parseMetadataLine(line);
+        if (!keyValuePair) {
+            continue;
+        }
+        const { key, value } = keyValuePair;
+        metadata[key] = value;
+    }
+}
+function parseMetadataLine(line) {
+    const equalIndex = line.indexOf('=');
+    if (equalIndex === -1) {
+        return null;
+    }
+    const rawKey = line.substring(0, equalIndex).trim().toLowerCase();
+    const value = line.substring(equalIndex + 1).trim();
+    if (!rawKey || !value) {
+        return null;
+    }
+    const normalizedKey = METADATA_KEY_NORMALIZATION[rawKey] || rawKey.replace(/\s+/g, '_');
+    return {
+        key: normalizedKey,
+        value
+    };
+}
+
+//# sourceMappingURL=bgcode.utils.js.map

package/dist/utils/bgcode/bgcode.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/bgcode/bgcode.utils.ts"],"names":["decompressBlock","extractMetadataFromBlocks","getBlockData","getBlockParsedParameters","parseBlockHeader","parseBlockHeaders","parseBlockParameters","parseFileHeader","fileHandle","buffer","Buffer","alloc","BGCODE_HEADER_SIZE","read","length","Error","magic","toString","BGCODE_HEADER_MARKER","version","readUInt32LE","checksumType","readUInt16LE","fileSize","skipGcode","offset","blockHeaders","currentExpectedHeaderIndex","blockHeader","type","BgCodeBlockTypes","GCode","expectedType","BGCODE_EXPECTED_HEADERS","nextExpectedType","Number","isNaN","blockSize","push","blockStartOffset","BGCODE_MAX_BLOCK_HEADER_SIZE","position","BGCODE_MAX_BLOCK_TYPE","compression","BGCODE_MAX_COMPRESSION","uncompressedSize","compressedSize","headerSize","BGCODE_MIN_BLOCK_HEADER_SIZE","BgCodeCompressionName","checksumSize","calculateChecksumSize","calculateBlockSize","parameterOffset","parametersSize","calculateParameterSize","parameterBuffer","parameters","dataOffset","dataSize","checksumOffset","data","info","BgCodeCompressionInfo","kind","inflateSync","decoder","HeatshrinkDecoder","window","lookahead","decompress","blockType","parameterSize","BgCodeBlockParameterSizes","Thumbnail","format","calculateThumbnailFormat","width","height","encoding","BGCODE_MAX_CHECKSUM_TYPE","BgCodeChecksumTypeSize","formatParameter","BGCODE_PARAMETER_THUMBNAIL_MAX_FORMAT","metadata","metadataBlocks","filter","b","FileMetadata","SlicerMetadata","PrinterMetadata","PrintMetadata","header","blockData","text","extractMetadataFromText","METADATA_KEY_NORMALIZATION","lines","split","line","keyValuePair","parseMetadataLine","key","value","equalIndex","indexOf","rawKey","substring","trim","toLowerCase","normalizedKey","replace"],"mappings":"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"}

package/dist/utils/bgcode/heatshrink-decoder.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HeatshrinkDecoder", {
+    enumerable: true,
+    get: function() {
+        return HeatshrinkDecoder;
+    }
+});
+var HSState = /*#__PURE__*/ function(HSState) {
+    HSState[HSState["TAG_BIT"] = 0] = "TAG_BIT";
+    HSState[HSState["YIELD_LITERAL"] = 1] = "YIELD_LITERAL";
+    HSState[HSState["BACKREF_INDEX_MSB"] = 2] = "BACKREF_INDEX_MSB";
+    HSState[HSState["BACKREF_INDEX_LSB"] = 3] = "BACKREF_INDEX_LSB";
+    HSState[HSState["BACKREF_COUNT_MSB"] = 4] = "BACKREF_COUNT_MSB";
+    HSState[HSState["BACKREF_COUNT_LSB"] = 5] = "BACKREF_COUNT_LSB";
+    HSState[HSState["YIELD_BACKREF"] = 6] = "YIELD_BACKREF";
+    return HSState;
+}(HSState || {});
+class HeatshrinkDecoder {
+    windowBits;
+    lookaheadBits;
+    windowSize;
+    window;
+    head = 0;
+    state = 0;
+    outputIndex = 0;
+    outputCount = 0;
+    inputBuffer;
+    inputIndex = 0;
+    bitAccumulator = 0;
+    bitsAvailable = 0;
+    constructor(windowBits, lookaheadBits){
+        this.windowBits = windowBits;
+        this.lookaheadBits = lookaheadBits;
+        this.windowSize = 1 << windowBits;
+        this.window = Buffer.alloc(this.windowSize);
+        this.inputBuffer = Buffer.alloc(0);
+    }
+    decompress(input) {
+        this.inputBuffer = input;
+        this.inputIndex = 0;
+        this.bitAccumulator = 0;
+        this.bitsAvailable = 0;
+        this.head = 0;
+        this.state = 0;
+        const output = [];
+        while(this.inputIndex < this.inputBuffer.length || this.bitsAvailable > 0){
+            const result = this.step();
+            if (result === null) {
+                break;
+            }
+            if (result >= 0) {
+                output.push(result);
+            }
+        }
+        return Buffer.from(output);
+    }
+    step() {
+        switch(this.state){
+            case 0:
+                return this.handleTagBit();
+            case 1:
+                return this.handleYieldLiteral();
+            case 2:
+                return this.handleBackrefIndexMSB();
+            case 3:
+                return this.handleBackrefIndexLSB();
+            case 4:
+                return this.handleBackrefCountMSB();
+            case 5:
+                return this.handleBackrefCountLSB();
+            case 6:
+                return this.handleYieldBackref();
+            default:
+                return null;
+        }
+    }
+    readBits(count) {
+        while(this.bitsAvailable < count && this.inputIndex < this.inputBuffer.length){
+            this.bitAccumulator = this.bitAccumulator << 8 | this.inputBuffer[this.inputIndex++];
+            this.bitsAvailable += 8;
+        }
+        if (this.bitsAvailable < count) {
+            return null;
+        }
+        this.bitsAvailable -= count;
+        const result = this.bitAccumulator >> this.bitsAvailable & (1 << count) - 1;
+        this.bitAccumulator &= (1 << this.bitsAvailable) - 1;
+        return result;
+    }
+    handleTagBit() {
+        const bit = this.readBits(1);
+        if (bit === null) return null;
+        if (bit === 1) {
+            this.state = 1;
+        } else {
+            if (this.windowBits > 8) {
+                this.state = 2;
+            } else {
+                this.outputIndex = 0;
+                this.state = 3;
+            }
+        }
+        return -1;
+    }
+    handleYieldLiteral() {
+        const byte = this.readBits(8);
+        if (byte === null) return null;
+        this.pushByte(byte);
+        this.state = 0;
+        return byte;
+    }
+    handleBackrefIndexMSB() {
+        const msb = this.readBits(this.windowBits - 8);
+        if (msb === null) return null;
+        this.outputIndex = msb << 8;
+        this.state = 3;
+        return -1;
+    }
+    handleBackrefIndexLSB() {
+        const bits = this.windowBits > 8 ? 8 : this.windowBits;
+        const lsb = this.readBits(bits);
+        if (lsb === null) return null;
+        this.outputIndex |= lsb;
+        this.outputCount = 0;
+        if (this.lookaheadBits > 8) {
+            this.state = 4;
+        } else {
+            this.state = 5;
+        }
+        return -1;
+    }
+    handleBackrefCountMSB() {
+        const msb = this.readBits(this.lookaheadBits - 8);
+        if (msb === null) return null;
+        this.outputCount = msb << 8;
+        this.state = 5;
+        return -1;
+    }
+    handleBackrefCountLSB() {
+        const bits = this.lookaheadBits > 8 ? 8 : this.lookaheadBits;
+        const lsb = this.readBits(bits);
+        if (lsb === null) return null;
+        this.outputCount |= lsb;
+        this.outputCount += 1;
+        this.outputIndex += 1;
+        this.state = 6;
+        return -1;
+    }
+    handleYieldBackref() {
+        if (this.outputCount === 0) {
+            this.state = 0;
+            return -1;
+        }
+        const pos = (this.head - this.outputIndex + this.windowSize) % this.windowSize;
+        const byte = this.window[pos];
+        this.pushByte(byte);
+        this.outputCount--;
+        if (this.outputCount === 0) {
+            this.state = 0;
+        }
+        return byte;
+    }
+    pushByte(byte) {
+        this.window[this.head] = byte;
+        this.head = (this.head + 1) % this.windowSize;
+    }
+}
+
+//# sourceMappingURL=heatshrink-decoder.js.map

package/dist/utils/bgcode/heatshrink-decoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/bgcode/heatshrink-decoder.ts"],"names":["HeatshrinkDecoder","HSState","windowBits","lookaheadBits","windowSize","window","head","state","outputIndex","outputCount","inputBuffer","inputIndex","bitAccumulator","bitsAvailable","Buffer","alloc","decompress","input","output","length","result","step","push","from","handleTagBit","handleYieldLiteral","handleBackrefIndexMSB","handleBackrefIndexLSB","handleBackrefCountMSB","handleBackrefCountLSB","handleYieldBackref","readBits","count","bit","byte","pushByte","msb","bits","lsb","pos"],"mappings":"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"}

package/dist/utils/bgcode/png-encoder.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "encodePNG", {
+    enumerable: true,
+    get: function() {
+        return encodePNG;
+    }
+});
+const _nodezlib = require("node:zlib");
+const PNG_SIGNATURE = Buffer.from([
+    0x89,
+    0x50,
+    0x4E,
+    0x47,
+    0x0D,
+    0x0A,
+    0x1A,
+    0x0A
+]);
+function crc32(buffer) {
+    let crc = 0xffffffff;
+    for(let i = 0; i < buffer.length; i++){
+        crc ^= buffer[i];
+        for(let j = 0; j < 8; j++){
+            crc = crc >>> 1 ^ 0xedb88320 & -(crc & 1);
+        }
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function writeChunk(type, data) {
+    const typeBuffer = Buffer.from(type, 'ascii');
+    const length = Buffer.alloc(4);
+    length.writeUInt32BE(data.length, 0);
+    const crcBuffer = Buffer.concat([
+        typeBuffer,
+        data
+    ]);
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(crc32(crcBuffer), 0);
+    return Buffer.concat([
+        length,
+        typeBuffer,
+        data,
+        crc
+    ]);
+}
+function encodePNG(width, height, rgba) {
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(width, 0);
+    ihdr.writeUInt32BE(height, 4);
+    ihdr.writeUInt8(8, 8);
+    ihdr.writeUInt8(6, 9);
+    ihdr.writeUInt8(0, 10);
+    ihdr.writeUInt8(0, 11);
+    ihdr.writeUInt8(0, 12);
+    const bytesPerPixel = 4;
+    const scanlineLength = width * bytesPerPixel;
+    const filteredData = Buffer.alloc(height * (scanlineLength + 1));
+    for(let y = 0; y < height; y++){
+        const scanlineOffset = y * (scanlineLength + 1);
+        filteredData[scanlineOffset] = 0;
+        rgba.copy(filteredData, scanlineOffset + 1, y * scanlineLength, (y + 1) * scanlineLength);
+    }
+    const compressed = (0, _nodezlib.deflateSync)(filteredData);
+    const chunks = [
+        PNG_SIGNATURE,
+        writeChunk('IHDR', ihdr),
+        writeChunk('IDAT', compressed),
+        writeChunk('IEND', Buffer.alloc(0))
+    ];
+    return Buffer.concat(chunks);
+}
+
+//# sourceMappingURL=png-encoder.js.map

package/dist/utils/bgcode/png-encoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/bgcode/png-encoder.ts"],"names":["encodePNG","PNG_SIGNATURE","Buffer","from","crc32","buffer","crc","i","length","j","writeChunk","type","data","typeBuffer","alloc","writeUInt32BE","crcBuffer","concat","width","height","rgba","ihdr","writeUInt8","bytesPerPixel","scanlineLength","filteredData","y","scanlineOffset","copy","compressed","deflateSync","chunks"],"mappings":";;;;+BAiCgBA;;;eAAAA;;;0BA5BY;AAE5B,MAAMC,gBAAgBC,OAAOC,IAAI,CAAC;IAAC;IAAM;IAAM;IAAM;IAAM;IAAM;IAAM;IAAM;CAAK;AAElF,SAASC,MAAMC,MAAc;IAE3B,IAAIC,MAAM;IACV,IAAK,IAAIC,IAAI,GAAGA,IAAIF,OAAOG,MAAM,EAAED,IAAK;QACtCD,OAAOD,MAAM,CAACE,EAAE;QAChB,IAAK,IAAIE,IAAI,GAAGA,IAAI,GAAGA,IAAK;YAC1BH,MAAM,AAACA,QAAQ,IAAM,aAAa,CAAEA,CAAAA,MAAM,CAAA;QAC5C;IACF;IACA,OAAO,AAACA,CAAAA,MAAM,UAAS,MAAO;AAChC;AAEA,SAASI,WAAWC,IAAY,EAAEC,IAAY;IAC5C,MAAMC,aAAaX,OAAOC,IAAI,CAACQ,MAAM;IACrC,MAAMH,SAASN,OAAOY,KAAK,CAAC;IAC5BN,OAAOO,aAAa,CAACH,KAAKJ,MAAM,EAAE;IAElC,MAAMQ,YAAYd,OAAOe,MAAM,CAAC;QAACJ;QAAYD;KAAK;IAClD,MAAMN,MAAMJ,OAAOY,KAAK,CAAC;IACzBR,IAAIS,aAAa,CAACX,MAAMY,YAAY;IAEpC,OAAOd,OAAOe,MAAM,CAAC;QAACT;QAAQK;QAAYD;QAAMN;KAAI;AACtD;AAEO,SAASN,UAAUkB,KAAa,EAAEC,MAAc,EAAEC,IAAY;IACnE,MAAMC,OAAOnB,OAAOY,KAAK,CAAC;IAC1BO,KAAKN,aAAa,CAACG,OAAO;IAC1BG,KAAKN,aAAa,CAACI,QAAQ;IAC3BE,KAAKC,UAAU,CAAC,GAAG;IACnBD,KAAKC,UAAU,CAAC,GAAG;IACnBD,KAAKC,UAAU,CAAC,GAAG;IACnBD,KAAKC,UAAU,CAAC,GAAG;IACnBD,KAAKC,UAAU,CAAC,GAAG;IAGnB,MAAMC,gBAAgB;IACtB,MAAMC,iBAAiBN,QAAQK;IAC/B,MAAME,eAAevB,OAAOY,KAAK,CAACK,SAAUK,CAAAA,iBAAiB,CAAA;IAE7D,IAAK,IAAIE,IAAI,GAAGA,IAAIP,QAAQO,IAAK;QAC/B,MAAMC,iBAAiBD,IAAKF,CAAAA,iBAAiB,CAAA;QAC7CC,YAAY,CAACE,eAAe,GAAG;QAC/BP,KAAKQ,IAAI,CAACH,cAAcE,iBAAiB,GAAGD,IAAIF,gBAAgB,AAACE,CAAAA,IAAI,CAAA,IAAKF;IAC5E;IAGA,MAAMK,aAAaC,IAAAA,qBAAW,EAACL;IAG/B,MAAMM,SAAS;QACb9B;QACAS,WAAW,QAAQW;QACnBX,WAAW,QAAQmB;QACnBnB,WAAW,QAAQR,OAAOY,KAAK,CAAC;KACjC;IAED,OAAOZ,OAAOe,MAAM,CAACc;AACvB"}