diff --git a/README.md b/README.md
index b50a2dd..237d2d6 100644
--- a/README.md
+++ b/README.md
@@ -25,7 +25,7 @@ Please report any issue you have with those (only for mainstream browsers)
 Also, use this if you plan to use b4k's archive.
 
 - [Install 4chanX (recommended)](https://www.4chan-x.net/builds/4chan-X.user.js)
-- Install the correct WebExtension for your Browser ([Firefox](https://git.coom.tech/fuckjannies/lolipiss/raw/branch/%E4%B8%AD%E5%87%BA%E3%81%97/pngextraembedder-0.288.xpi) or Chrome-based (Down for "maintainance"))
+- Install the correct WebExtension for your Browser ([Firefox](https://git.coom.tech/fuckjannies/lolipiss/raw/branch/%E4%B8%AD%E5%87%BA%E3%81%97/pngextraembedder-0.289.xpi) or Chrome-based (Down for "maintainance"))
 
 For FF users, the extension is signed so you can just drag and drop it on your about:addons tab.
 
diff --git a/chrome/dist/main.js b/chrome/dist/main.js
index cbddff2..e29ae9f 100644
--- a/chrome/dist/main.js
+++ b/chrome/dist/main.js
@@ -73,7 +73,7 @@
   var define_BUILD_VERSION_default;
   var init_define_BUILD_VERSION = __esm({
     "<define:BUILD_VERSION>"() {
-      define_BUILD_VERSION_default = [0, 288];
+      define_BUILD_VERSION_default = [0, 289];
     }
   });
 
@@ -21275,7 +21275,7 @@
       this.flush();
     }
     flush() {
-      this.stream.write(Buffer2.from(this.buffer));
+      this.stream.write(this.buffer);
       this.bufferoffset = 0;
       this.buffer.fill(0);
     }
@@ -21306,8 +21306,6 @@
       this.trans = new Uint16Array(288);
     }
   };
-  var log = (x, ...n) => {
-  };
   var pathMap = /* @__PURE__ */ new Map();
   var getPathTo = (tree, value) => {
     if (tree[0] === value)
@@ -21456,8 +21454,7 @@
     }
   }
   function tinf_getbit(d) {
-    let v = d.source.readSync(1);
-    log(v, "getbit");
+    const v = d.source.readSync(1);
     return v;
   }
   var loff = 0;
@@ -21465,7 +21462,7 @@
   function tinf_read_bits(d, num, base) {
     if (!num)
       return base;
-    let v = d.source.readSync(num) + base;
+    const v = d.source.readSync(num) + base;
     loff = v;
     loffs.push(v);
     if (loffs.length > 4) {
@@ -21477,8 +21474,8 @@
     let sum = 0, cur = 0, len = 0;
     let s = 0;
     do {
-      let b = d.source.readSync(1);
-      copy && d.hidden.write(1, b);
+      const b = d.source.readSync(1);
+      copy && d.hidden?.write(1, b);
       s = s << 1 | b;
       cur = 2 * cur + b;
       ++len;
@@ -21491,25 +21488,26 @@
   }
   function tinf_decode_trees(d, lt, dt, copy = true) {
     let i, num, length;
-    let hlit = tinf_read_bits(d, 5, 257);
+    const hlit = tinf_read_bits(d, 5, 257);
     copy && d.hidden?.write(5, hlit - 257);
-    let hdist = tinf_read_bits(d, 5, 1);
+    const hdist = tinf_read_bits(d, 5, 1);
     copy && d.hidden?.write(5, hdist - 1);
-    let hclen = tinf_read_bits(d, 4, 4);
+    const hclen = tinf_read_bits(d, 4, 4);
     copy && d.hidden?.write(4, hclen - 4);
     for (i = 0; i < 19; ++i)
       lengths[i] = 0;
     for (i = 0; i < hclen; ++i) {
-      let clen = tinf_read_bits(d, 3, 0);
+      const clen = tinf_read_bits(d, 3, 0);
       copy && d.hidden?.write(3, clen);
       lengths[clcidx[i]] = clen;
     }
     tinf_build_tree(code_tree, lengths, 0, 19);
     for (num = 0; num < hlit + hdist; ) {
-      let sym = tinf_decode_symbol(d, code_tree, copy);
+      const sym = tinf_decode_symbol(d, code_tree, copy);
+      let prev;
       switch (sym) {
         case 16:
-          let prev = lengths[num - 1];
+          prev = lengths[num - 1];
           length = tinf_read_bits(d, 2, 3);
           copy && d.hidden?.write(2, length - 3);
           for (; length; --length) {
@@ -21552,7 +21550,7 @@
   var encode_symbol = (sym, tree) => {
     let m;
     if (m = pathMap.get(tree)) {
-      let v2 = m.get(sym);
+      const v2 = m.get(sym);
       if (v2)
         return v2;
     } else {
@@ -21560,7 +21558,7 @@
       pathMap.set(tree, m);
     }
     const code = getPathTo(tree, sym);
-    let v = {
+    const v = {
       length: code?.length,
       val: parseInt(code, 2)
     };
@@ -21577,17 +21575,16 @@
       if (sym < 256) {
         d.dest.push(sym);
       } else {
-        let length, dist, offs2;
         sym -= 257;
-        length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
+        const length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
         if (length_bits[sym])
-          d.hidden.write(length_bits[sym], length - length_base[sym]);
-        let ext = { length: 0, sym: 0 };
-        dist = tinf_decode_symbol(d, dt, false, ext);
+          d.hidden?.write(length_bits[sym], length - length_base[sym]);
+        const ext = { length: 0, sym: 0 };
+        const dist = tinf_decode_symbol(d, dt, false, ext);
         let backoffset = tinf_read_bits(d, dist_bits[dist], dist_base[dist]);
-        offs2 = d.dest.length - backoffset;
+        const offs2 = d.dest.length - backoffset;
         let match;
-        let skip = d.to_hide instanceof BitstreamReader2 && d.to_hide.available == 0;
+        const skip = d.to_hide && d.to_hide instanceof BitstreamReader2 && d.to_hide.available == 0;
         if (!skip && (match = Buffer2.from(d.dest.slice(offs2, offs2 + length))).length == length) {
           let begin = d.dest.length - 32768;
           if (begin < 0)
@@ -21596,7 +21593,7 @@
           let o = 0;
           const slic = Buffer2.from(d.dest.slice(begin + o, d.dest.length));
           while (begin + o < d.dest.length) {
-            let r = slic.slice(o, d.dest.length).indexOf(match);
+            const r = slic.slice(o, d.dest.length).indexOf(match);
             if (r >= 0) {
               matches.push(r + begin + o);
               o += r;
@@ -21624,10 +21621,10 @@
             }
           }
         }
-        let [dsym, dlen, doff] = get_symbol(backoffset, dist_bits, dist_base);
-        let encdist = encode_symbol(dsym, d.rdtree);
-        d.hidden.write(encdist.length, revbyte(encdist.val, encdist.length));
-        d.hidden.write(dlen, doff);
+        const [dsym, dlen, doff] = get_symbol(backoffset, dist_bits, dist_base);
+        const encdist = encode_symbol(dsym, d.rdtree);
+        d.hidden?.write(encdist.length, revbyte(encdist.val, encdist.length));
+        d.hidden?.write(dlen, doff);
         for (let i = offs2; i < offs2 + length; ++i) {
           d.dest.push(d.dest[i]);
         }
@@ -21637,33 +21634,31 @@
   function tinf_inflate_uncompressed_block(d) {
     if (d.source.offset & 7)
       d.source.readSync(8 - d.source.offset & 7);
-    if (d.hidden.offset & 7)
-      d.hidden.write(8 - d.hidden.offset & 7, 0);
-    let length = d.source.readSync(16);
-    d.hidden.write(16, length);
-    let invlength = d.source.readSync(16);
-    d.hidden.write(16, invlength);
+    if (d.hidden && d.hidden.offset & 7)
+      d.hidden?.write(8 - d.hidden.offset & 7, 0);
+    const length = d.source.readSync(16);
+    d.hidden?.write(16, length);
+    const invlength = d.source.readSync(16);
+    d.hidden?.write(16, invlength);
     if (length !== (~invlength & 65535)) {
       return -4;
     }
     for (let i = length; i; --i) {
       const v = d.source.readSync(8);
       d.dest.push(v);
-      d.hidden.write(8, v);
+      d.hidden?.write(8, v);
     }
     return TINF_OK;
   }
   function tinf_uncompress(source, decompressed, to_hide, hidden, opt = 0) {
-    let decomp = new BitstreamWriter2({ write: decompressed || (() => {
-    }) });
-    let hid = new BitstreamWriter2({ write: hidden || (() => {
-    }) }, 4);
-    let d = new Data(source, decomp, to_hide, hid);
+    const decomp = decompressed ? new BitstreamWriter2({ write: decompressed }) : null;
+    const hid = hidden && new BitstreamWriter2({ write: hidden }, 4);
+    const d = new Data(source, decomp, to_hide, hid);
     let res;
     let bfinal, btype;
     do {
       bfinal = tinf_getbit(d);
-      d.hidden.write(1, bfinal);
+      d.hidden?.write(1, bfinal);
       btype = tinf_read_bits(d, 2, 0);
       d.hidden?.write(2, btype);
       switch (btype) {
@@ -21687,8 +21682,8 @@
       if (res !== TINF_OK)
         throw new Error("Data error " + res);
     } while (!bfinal);
-    decomp.end();
-    hid.end();
+    decomp?.end();
+    hid?.end();
   }
   tinf_build_fixed_trees(sltree, sdtree);
   tinf_build_bits_base(length_bits, length_base, 4, 3);
@@ -21754,9 +21749,7 @@
       }
     });
     try {
-      tinf_uncompress(src, () => {
-      }, hidden, () => {
-      });
+      tinf_uncompress(src, void 0, hidden, void 0);
     } catch (e) {
       if (e == "Finish")
         return import_buffer3.Buffer.from(chnks);
@@ -21869,10 +21862,7 @@
     hid.addBuffer(h);
     src.addBuffer(b);
     const chnks = [];
-    const endo = tinf_uncompress(src, () => {
-    }, hid, (c) => chnks.push(c));
-    if (endo)
-      chnks.push(b.slice(endo));
+    tinf_uncompress(src, void 0, hid, (c) => chnks.push(c));
     return import_buffer3.Buffer.concat(chnks);
   };
   var inject_data = async (container, injb) => {
diff --git a/chrome/manifest.json b/chrome/manifest.json
index 860eadc..39aa1de 100644
--- a/chrome/manifest.json
+++ b/chrome/manifest.json
@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "name": "PngExtraEmbedder",
   "description": "Discover embedded files on 4chan and archives!",
-  "version": "0.288",
+  "version": "0.289",
   "icons": {
     "64": "1449696017588.png"
   },
diff --git a/dist/main.js b/dist/main.js
index 82ea68e..5a2ff3c 100644
--- a/dist/main.js
+++ b/dist/main.js
@@ -73,7 +73,7 @@
   var define_BUILD_VERSION_default;
   var init_define_BUILD_VERSION = __esm({
     "<define:BUILD_VERSION>"() {
-      define_BUILD_VERSION_default = [0, 288];
+      define_BUILD_VERSION_default = [0, 289];
     }
   });
 
@@ -21110,7 +21110,7 @@
       this.flush();
     }
     flush() {
-      this.stream.write(Buffer2.from(this.buffer));
+      this.stream.write(this.buffer);
       this.bufferoffset = 0;
       this.buffer.fill(0);
     }
@@ -21141,8 +21141,6 @@
       this.trans = new Uint16Array(288);
     }
   };
-  var log = (x, ...n) => {
-  };
   var pathMap = /* @__PURE__ */ new Map();
   var getPathTo = (tree, value) => {
     if (tree[0] === value)
@@ -21291,8 +21289,7 @@
     }
   }
   function tinf_getbit(d) {
-    let v = d.source.readSync(1);
-    log(v, "getbit");
+    const v = d.source.readSync(1);
     return v;
   }
   var loff = 0;
@@ -21300,7 +21297,7 @@
   function tinf_read_bits(d, num, base) {
     if (!num)
       return base;
-    let v = d.source.readSync(num) + base;
+    const v = d.source.readSync(num) + base;
     loff = v;
     loffs.push(v);
     if (loffs.length > 4) {
@@ -21312,8 +21309,8 @@
     let sum = 0, cur = 0, len = 0;
     let s = 0;
     do {
-      let b = d.source.readSync(1);
-      copy && d.hidden.write(1, b);
+      const b = d.source.readSync(1);
+      copy && d.hidden?.write(1, b);
       s = s << 1 | b;
       cur = 2 * cur + b;
       ++len;
@@ -21326,25 +21323,26 @@
   }
   function tinf_decode_trees(d, lt, dt, copy = true) {
     let i, num, length;
-    let hlit = tinf_read_bits(d, 5, 257);
+    const hlit = tinf_read_bits(d, 5, 257);
     copy && d.hidden?.write(5, hlit - 257);
-    let hdist = tinf_read_bits(d, 5, 1);
+    const hdist = tinf_read_bits(d, 5, 1);
     copy && d.hidden?.write(5, hdist - 1);
-    let hclen = tinf_read_bits(d, 4, 4);
+    const hclen = tinf_read_bits(d, 4, 4);
     copy && d.hidden?.write(4, hclen - 4);
     for (i = 0; i < 19; ++i)
       lengths[i] = 0;
     for (i = 0; i < hclen; ++i) {
-      let clen = tinf_read_bits(d, 3, 0);
+      const clen = tinf_read_bits(d, 3, 0);
       copy && d.hidden?.write(3, clen);
       lengths[clcidx[i]] = clen;
     }
     tinf_build_tree(code_tree, lengths, 0, 19);
     for (num = 0; num < hlit + hdist; ) {
-      let sym = tinf_decode_symbol(d, code_tree, copy);
+      const sym = tinf_decode_symbol(d, code_tree, copy);
+      let prev;
       switch (sym) {
         case 16:
-          let prev = lengths[num - 1];
+          prev = lengths[num - 1];
           length = tinf_read_bits(d, 2, 3);
           copy && d.hidden?.write(2, length - 3);
           for (; length; --length) {
@@ -21387,7 +21385,7 @@
   var encode_symbol = (sym, tree) => {
     let m;
     if (m = pathMap.get(tree)) {
-      let v2 = m.get(sym);
+      const v2 = m.get(sym);
       if (v2)
         return v2;
     } else {
@@ -21395,7 +21393,7 @@
       pathMap.set(tree, m);
     }
     const code = getPathTo(tree, sym);
-    let v = {
+    const v = {
       length: code?.length,
       val: parseInt(code, 2)
     };
@@ -21412,17 +21410,16 @@
       if (sym < 256) {
         d.dest.push(sym);
       } else {
-        let length, dist, offs2;
         sym -= 257;
-        length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
+        const length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
         if (length_bits[sym])
-          d.hidden.write(length_bits[sym], length - length_base[sym]);
-        let ext = { length: 0, sym: 0 };
-        dist = tinf_decode_symbol(d, dt, false, ext);
+          d.hidden?.write(length_bits[sym], length - length_base[sym]);
+        const ext = { length: 0, sym: 0 };
+        const dist = tinf_decode_symbol(d, dt, false, ext);
         let backoffset = tinf_read_bits(d, dist_bits[dist], dist_base[dist]);
-        offs2 = d.dest.length - backoffset;
+        const offs2 = d.dest.length - backoffset;
         let match;
-        let skip = d.to_hide instanceof BitstreamReader2 && d.to_hide.available == 0;
+        const skip = d.to_hide && d.to_hide instanceof BitstreamReader2 && d.to_hide.available == 0;
         if (!skip && (match = Buffer2.from(d.dest.slice(offs2, offs2 + length))).length == length) {
           let begin = d.dest.length - 32768;
           if (begin < 0)
@@ -21431,7 +21428,7 @@
           let o = 0;
           const slic = Buffer2.from(d.dest.slice(begin + o, d.dest.length));
           while (begin + o < d.dest.length) {
-            let r = slic.slice(o, d.dest.length).indexOf(match);
+            const r = slic.slice(o, d.dest.length).indexOf(match);
             if (r >= 0) {
               matches.push(r + begin + o);
               o += r;
@@ -21459,10 +21456,10 @@
             }
           }
         }
-        let [dsym, dlen, doff] = get_symbol(backoffset, dist_bits, dist_base);
-        let encdist = encode_symbol(dsym, d.rdtree);
-        d.hidden.write(encdist.length, revbyte(encdist.val, encdist.length));
-        d.hidden.write(dlen, doff);
+        const [dsym, dlen, doff] = get_symbol(backoffset, dist_bits, dist_base);
+        const encdist = encode_symbol(dsym, d.rdtree);
+        d.hidden?.write(encdist.length, revbyte(encdist.val, encdist.length));
+        d.hidden?.write(dlen, doff);
         for (let i = offs2; i < offs2 + length; ++i) {
           d.dest.push(d.dest[i]);
         }
@@ -21472,33 +21469,31 @@
   function tinf_inflate_uncompressed_block(d) {
     if (d.source.offset & 7)
       d.source.readSync(8 - d.source.offset & 7);
-    if (d.hidden.offset & 7)
-      d.hidden.write(8 - d.hidden.offset & 7, 0);
-    let length = d.source.readSync(16);
-    d.hidden.write(16, length);
-    let invlength = d.source.readSync(16);
-    d.hidden.write(16, invlength);
+    if (d.hidden && d.hidden.offset & 7)
+      d.hidden?.write(8 - d.hidden.offset & 7, 0);
+    const length = d.source.readSync(16);
+    d.hidden?.write(16, length);
+    const invlength = d.source.readSync(16);
+    d.hidden?.write(16, invlength);
     if (length !== (~invlength & 65535)) {
       return -4;
     }
     for (let i = length; i; --i) {
       const v = d.source.readSync(8);
       d.dest.push(v);
-      d.hidden.write(8, v);
+      d.hidden?.write(8, v);
     }
     return TINF_OK;
   }
   function tinf_uncompress(source, decompressed, to_hide, hidden, opt = 0) {
-    let decomp = new BitstreamWriter2({ write: decompressed || (() => {
-    }) });
-    let hid = new BitstreamWriter2({ write: hidden || (() => {
-    }) }, 4);
-    let d = new Data(source, decomp, to_hide, hid);
+    const decomp = decompressed ? new BitstreamWriter2({ write: decompressed }) : null;
+    const hid = hidden && new BitstreamWriter2({ write: hidden }, 4);
+    const d = new Data(source, decomp, to_hide, hid);
     let res;
     let bfinal, btype;
     do {
       bfinal = tinf_getbit(d);
-      d.hidden.write(1, bfinal);
+      d.hidden?.write(1, bfinal);
       btype = tinf_read_bits(d, 2, 0);
       d.hidden?.write(2, btype);
       switch (btype) {
@@ -21522,8 +21517,8 @@
       if (res !== TINF_OK)
         throw new Error("Data error " + res);
     } while (!bfinal);
-    decomp.end();
-    hid.end();
+    decomp?.end();
+    hid?.end();
   }
   tinf_build_fixed_trees(sltree, sdtree);
   tinf_build_bits_base(length_bits, length_base, 4, 3);
@@ -21589,9 +21584,7 @@
       }
     });
     try {
-      tinf_uncompress(src, () => {
-      }, hidden, () => {
-      });
+      tinf_uncompress(src, void 0, hidden, void 0);
     } catch (e) {
       if (e == "Finish")
         return import_buffer3.Buffer.from(chnks);
@@ -21704,10 +21697,7 @@
     hid.addBuffer(h);
     src.addBuffer(b);
     const chnks = [];
-    const endo = tinf_uncompress(src, () => {
-    }, hid, (c) => chnks.push(c));
-    if (endo)
-      chnks.push(b.slice(endo));
+    tinf_uncompress(src, void 0, hid, (c) => chnks.push(c));
     return import_buffer3.Buffer.concat(chnks);
   };
   var inject_data = async (container, injb) => {
diff --git a/efdb47d2f0e04144bbaa-0.254.xpi b/efdb47d2f0e04144bbaa-0.254.xpi
deleted file mode 100644
index b84ecd1..0000000
Binary files a/efdb47d2f0e04144bbaa-0.254.xpi and /dev/null differ
diff --git a/efdb47d2f0e04144bbaa-0.281.xpi b/efdb47d2f0e04144bbaa-0.281.xpi
deleted file mode 100644
index e41b4d6..0000000
Binary files a/efdb47d2f0e04144bbaa-0.281.xpi and /dev/null differ
diff --git a/efdb47d2f0e04144bbaa-0.284.xpi b/efdb47d2f0e04144bbaa-0.284.xpi
deleted file mode 100644
index 59c1308..0000000
Binary files a/efdb47d2f0e04144bbaa-0.284.xpi and /dev/null differ
diff --git a/pngextraembedder-0.287.xpi b/efdb47d2f0e04144bbaa-0.289.xpi
similarity index 84%
rename from pngextraembedder-0.287.xpi
rename to efdb47d2f0e04144bbaa-0.289.xpi
index d22a112..aefc93f 100644
Binary files a/pngextraembedder-0.287.xpi and b/efdb47d2f0e04144bbaa-0.289.xpi differ
diff --git a/firefox/dist/main.js b/firefox/dist/main.js
index bda91e8..cf778eb 100644
--- a/firefox/dist/main.js
+++ b/firefox/dist/main.js
@@ -73,7 +73,7 @@
   var define_BUILD_VERSION_default;
   var init_define_BUILD_VERSION = __esm({
     "<define:BUILD_VERSION>"() {
-      define_BUILD_VERSION_default = [0, 288];
+      define_BUILD_VERSION_default = [0, 289];
     }
   });
 
@@ -21252,7 +21252,7 @@
       this.flush();
     }
     flush() {
-      this.stream.write(Buffer2.from(this.buffer));
+      this.stream.write(this.buffer);
       this.bufferoffset = 0;
       this.buffer.fill(0);
     }
@@ -21283,8 +21283,6 @@
       this.trans = new Uint16Array(288);
     }
   };
-  var log = (x, ...n) => {
-  };
   var pathMap = /* @__PURE__ */ new Map();
   var getPathTo = (tree, value) => {
     if (tree[0] === value)
@@ -21433,8 +21431,7 @@
     }
   }
   function tinf_getbit(d) {
-    let v = d.source.readSync(1);
-    log(v, "getbit");
+    const v = d.source.readSync(1);
     return v;
   }
   var loff = 0;
@@ -21442,7 +21439,7 @@
   function tinf_read_bits(d, num, base) {
     if (!num)
       return base;
-    let v = d.source.readSync(num) + base;
+    const v = d.source.readSync(num) + base;
     loff = v;
     loffs.push(v);
     if (loffs.length > 4) {
@@ -21454,8 +21451,8 @@
     let sum = 0, cur = 0, len = 0;
     let s = 0;
     do {
-      let b = d.source.readSync(1);
-      copy && d.hidden.write(1, b);
+      const b = d.source.readSync(1);
+      copy && d.hidden?.write(1, b);
       s = s << 1 | b;
       cur = 2 * cur + b;
       ++len;
@@ -21468,25 +21465,26 @@
   }
   function tinf_decode_trees(d, lt, dt, copy = true) {
     let i, num, length;
-    let hlit = tinf_read_bits(d, 5, 257);
+    const hlit = tinf_read_bits(d, 5, 257);
     copy && d.hidden?.write(5, hlit - 257);
-    let hdist = tinf_read_bits(d, 5, 1);
+    const hdist = tinf_read_bits(d, 5, 1);
     copy && d.hidden?.write(5, hdist - 1);
-    let hclen = tinf_read_bits(d, 4, 4);
+    const hclen = tinf_read_bits(d, 4, 4);
     copy && d.hidden?.write(4, hclen - 4);
     for (i = 0; i < 19; ++i)
       lengths[i] = 0;
     for (i = 0; i < hclen; ++i) {
-      let clen = tinf_read_bits(d, 3, 0);
+      const clen = tinf_read_bits(d, 3, 0);
       copy && d.hidden?.write(3, clen);
       lengths[clcidx[i]] = clen;
     }
     tinf_build_tree(code_tree, lengths, 0, 19);
     for (num = 0; num < hlit + hdist; ) {
-      let sym = tinf_decode_symbol(d, code_tree, copy);
+      const sym = tinf_decode_symbol(d, code_tree, copy);
+      let prev;
       switch (sym) {
         case 16:
-          let prev = lengths[num - 1];
+          prev = lengths[num - 1];
           length = tinf_read_bits(d, 2, 3);
           copy && d.hidden?.write(2, length - 3);
           for (; length; --length) {
@@ -21529,7 +21527,7 @@
   var encode_symbol = (sym, tree) => {
     let m;
     if (m = pathMap.get(tree)) {
-      let v2 = m.get(sym);
+      const v2 = m.get(sym);
       if (v2)
         return v2;
     } else {
@@ -21537,7 +21535,7 @@
       pathMap.set(tree, m);
     }
     const code = getPathTo(tree, sym);
-    let v = {
+    const v = {
       length: code?.length,
       val: parseInt(code, 2)
     };
@@ -21554,17 +21552,16 @@
       if (sym < 256) {
         d.dest.push(sym);
       } else {
-        let length, dist, offs2;
         sym -= 257;
-        length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
+        const length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
         if (length_bits[sym])
-          d.hidden.write(length_bits[sym], length - length_base[sym]);
-        let ext = { length: 0, sym: 0 };
-        dist = tinf_decode_symbol(d, dt, false, ext);
+          d.hidden?.write(length_bits[sym], length - length_base[sym]);
+        const ext = { length: 0, sym: 0 };
+        const dist = tinf_decode_symbol(d, dt, false, ext);
         let backoffset = tinf_read_bits(d, dist_bits[dist], dist_base[dist]);
-        offs2 = d.dest.length - backoffset;
+        const offs2 = d.dest.length - backoffset;
         let match;
-        let skip = d.to_hide instanceof BitstreamReader2 && d.to_hide.available == 0;
+        const skip = d.to_hide && d.to_hide instanceof BitstreamReader2 && d.to_hide.available == 0;
         if (!skip && (match = Buffer2.from(d.dest.slice(offs2, offs2 + length))).length == length) {
           let begin = d.dest.length - 32768;
           if (begin < 0)
@@ -21573,7 +21570,7 @@
           let o = 0;
           const slic = Buffer2.from(d.dest.slice(begin + o, d.dest.length));
           while (begin + o < d.dest.length) {
-            let r = slic.slice(o, d.dest.length).indexOf(match);
+            const r = slic.slice(o, d.dest.length).indexOf(match);
             if (r >= 0) {
               matches.push(r + begin + o);
               o += r;
@@ -21601,10 +21598,10 @@
             }
           }
         }
-        let [dsym, dlen, doff] = get_symbol(backoffset, dist_bits, dist_base);
-        let encdist = encode_symbol(dsym, d.rdtree);
-        d.hidden.write(encdist.length, revbyte(encdist.val, encdist.length));
-        d.hidden.write(dlen, doff);
+        const [dsym, dlen, doff] = get_symbol(backoffset, dist_bits, dist_base);
+        const encdist = encode_symbol(dsym, d.rdtree);
+        d.hidden?.write(encdist.length, revbyte(encdist.val, encdist.length));
+        d.hidden?.write(dlen, doff);
         for (let i = offs2; i < offs2 + length; ++i) {
           d.dest.push(d.dest[i]);
         }
@@ -21614,33 +21611,31 @@
   function tinf_inflate_uncompressed_block(d) {
     if (d.source.offset & 7)
       d.source.readSync(8 - d.source.offset & 7);
-    if (d.hidden.offset & 7)
-      d.hidden.write(8 - d.hidden.offset & 7, 0);
-    let length = d.source.readSync(16);
-    d.hidden.write(16, length);
-    let invlength = d.source.readSync(16);
-    d.hidden.write(16, invlength);
+    if (d.hidden && d.hidden.offset & 7)
+      d.hidden?.write(8 - d.hidden.offset & 7, 0);
+    const length = d.source.readSync(16);
+    d.hidden?.write(16, length);
+    const invlength = d.source.readSync(16);
+    d.hidden?.write(16, invlength);
     if (length !== (~invlength & 65535)) {
       return -4;
     }
     for (let i = length; i; --i) {
       const v = d.source.readSync(8);
       d.dest.push(v);
-      d.hidden.write(8, v);
+      d.hidden?.write(8, v);
     }
     return TINF_OK;
   }
   function tinf_uncompress(source, decompressed, to_hide, hidden, opt = 0) {
-    let decomp = new BitstreamWriter2({ write: decompressed || (() => {
-    }) });
-    let hid = new BitstreamWriter2({ write: hidden || (() => {
-    }) }, 4);
-    let d = new Data(source, decomp, to_hide, hid);
+    const decomp = decompressed ? new BitstreamWriter2({ write: decompressed }) : null;
+    const hid = hidden && new BitstreamWriter2({ write: hidden }, 4);
+    const d = new Data(source, decomp, to_hide, hid);
     let res;
     let bfinal, btype;
     do {
       bfinal = tinf_getbit(d);
-      d.hidden.write(1, bfinal);
+      d.hidden?.write(1, bfinal);
       btype = tinf_read_bits(d, 2, 0);
       d.hidden?.write(2, btype);
       switch (btype) {
@@ -21664,8 +21659,8 @@
       if (res !== TINF_OK)
         throw new Error("Data error " + res);
     } while (!bfinal);
-    decomp.end();
-    hid.end();
+    decomp?.end();
+    hid?.end();
   }
   tinf_build_fixed_trees(sltree, sdtree);
   tinf_build_bits_base(length_bits, length_base, 4, 3);
@@ -21731,9 +21726,7 @@
       }
     });
     try {
-      tinf_uncompress(src, () => {
-      }, hidden, () => {
-      });
+      tinf_uncompress(src, void 0, hidden, void 0);
     } catch (e) {
       if (e == "Finish")
         return import_buffer3.Buffer.from(chnks);
@@ -21846,10 +21839,7 @@
     hid.addBuffer(h);
     src.addBuffer(b);
     const chnks = [];
-    const endo = tinf_uncompress(src, () => {
-    }, hid, (c) => chnks.push(c));
-    if (endo)
-      chnks.push(b.slice(endo));
+    tinf_uncompress(src, void 0, hid, (c) => chnks.push(c));
     return import_buffer3.Buffer.concat(chnks);
   };
   var inject_data = async (container, injb) => {
diff --git a/firefox/manifest.json b/firefox/manifest.json
index 28cf593..532d415 100644
--- a/firefox/manifest.json
+++ b/firefox/manifest.json
@@ -7,7 +7,7 @@
   },
   "name": "PngExtraEmbedder",
   "description": "Discover embedded files on 4chan and archives!",
-  "version": "0.288",
+  "version": "0.289",
   "icons": {
     "64": "1449696017588.png"
   },
diff --git a/firefox_update.json b/firefox_update.json
index d945c65..8eeeea9 100644
--- a/firefox_update.json
+++ b/firefox_update.json
@@ -1 +1 @@
-{"addons":{"{34ac4994-07f2-44d2-8599-682516a6c6a6}":{"updates":[{"version":"0.288","update_link":"https://git.coom.tech/fuckjannies/lolipiss/raw/branch/%E4%B8%AD%E5%87%BA%E3%81%97/pngextraembedder-0.288.xpi"}]}}}
\ No newline at end of file
+{"addons":{"{34ac4994-07f2-44d2-8599-682516a6c6a6}":{"updates":[{"version":"0.289","update_link":"https://git.coom.tech/fuckjannies/lolipiss/raw/branch/%E4%B8%AD%E5%87%BA%E3%81%97/pngextraembedder-0.289.xpi"}]}}}
\ No newline at end of file
diff --git a/main.meta.js b/main.meta.js
index af504d4..685c768 100644
--- a/main.meta.js
+++ b/main.meta.js
@@ -1,7 +1,7 @@
 // ==UserScript==
 // @name         PNGExtraEmbed
 // @namespace    https://coom.tech/
-// @version      0.288
+// @version      0.289
 // @description  uhh
 // @author       You
 // @match        https://boards.4channel.org/*
diff --git a/main.user.js b/main.user.js
index 7311e6d..13e4e60 100644
--- a/main.user.js
+++ b/main.user.js
@@ -1,7 +1,7 @@
 // ==UserScript==
 // @name         PNGExtraEmbed
 // @namespace    https://coom.tech/
-// @version      0.288
+// @version      0.289
 // @description  uhh
 // @author       You
 // @match        https://boards.4channel.org/*
@@ -109,7 +109,7 @@ const _DOMParser = DOMParser;
   var define_BUILD_VERSION_default;
   var init_define_BUILD_VERSION = __esm({
     "<define:BUILD_VERSION>"() {
-      define_BUILD_VERSION_default = [0, 288];
+      define_BUILD_VERSION_default = [0, 289];
     }
   });
 
@@ -21146,7 +21146,7 @@ const _DOMParser = DOMParser;
       this.flush();
     }
     flush() {
-      this.stream.write(Buffer2.from(this.buffer));
+      this.stream.write(this.buffer);
       this.bufferoffset = 0;
       this.buffer.fill(0);
     }
@@ -21177,8 +21177,6 @@ const _DOMParser = DOMParser;
       this.trans = new Uint16Array(288);
     }
   };
-  var log = (x, ...n) => {
-  };
   var pathMap = /* @__PURE__ */ new Map();
   var getPathTo = (tree, value) => {
     if (tree[0] === value)
@@ -21327,8 +21325,7 @@ const _DOMParser = DOMParser;
     }
   }
   function tinf_getbit(d) {
-    let v = d.source.readSync(1);
-    log(v, "getbit");
+    const v = d.source.readSync(1);
     return v;
   }
   var loff = 0;
@@ -21336,7 +21333,7 @@ const _DOMParser = DOMParser;
   function tinf_read_bits(d, num, base) {
     if (!num)
       return base;
-    let v = d.source.readSync(num) + base;
+    const v = d.source.readSync(num) + base;
     loff = v;
     loffs.push(v);
     if (loffs.length > 4) {
@@ -21348,8 +21345,8 @@ const _DOMParser = DOMParser;
     let sum = 0, cur = 0, len = 0;
     let s = 0;
     do {
-      let b = d.source.readSync(1);
-      copy && d.hidden.write(1, b);
+      const b = d.source.readSync(1);
+      copy && d.hidden?.write(1, b);
       s = s << 1 | b;
       cur = 2 * cur + b;
       ++len;
@@ -21362,25 +21359,26 @@ const _DOMParser = DOMParser;
   }
   function tinf_decode_trees(d, lt, dt, copy = true) {
     let i, num, length;
-    let hlit = tinf_read_bits(d, 5, 257);
+    const hlit = tinf_read_bits(d, 5, 257);
     copy && d.hidden?.write(5, hlit - 257);
-    let hdist = tinf_read_bits(d, 5, 1);
+    const hdist = tinf_read_bits(d, 5, 1);
     copy && d.hidden?.write(5, hdist - 1);
-    let hclen = tinf_read_bits(d, 4, 4);
+    const hclen = tinf_read_bits(d, 4, 4);
     copy && d.hidden?.write(4, hclen - 4);
     for (i = 0; i < 19; ++i)
       lengths[i] = 0;
     for (i = 0; i < hclen; ++i) {
-      let clen = tinf_read_bits(d, 3, 0);
+      const clen = tinf_read_bits(d, 3, 0);
       copy && d.hidden?.write(3, clen);
       lengths[clcidx[i]] = clen;
     }
     tinf_build_tree(code_tree, lengths, 0, 19);
     for (num = 0; num < hlit + hdist; ) {
-      let sym = tinf_decode_symbol(d, code_tree, copy);
+      const sym = tinf_decode_symbol(d, code_tree, copy);
+      let prev;
       switch (sym) {
         case 16:
-          let prev = lengths[num - 1];
+          prev = lengths[num - 1];
           length = tinf_read_bits(d, 2, 3);
           copy && d.hidden?.write(2, length - 3);
           for (; length; --length) {
@@ -21423,7 +21421,7 @@ const _DOMParser = DOMParser;
   var encode_symbol = (sym, tree) => {
     let m;
     if (m = pathMap.get(tree)) {
-      let v2 = m.get(sym);
+      const v2 = m.get(sym);
       if (v2)
         return v2;
     } else {
@@ -21431,7 +21429,7 @@ const _DOMParser = DOMParser;
       pathMap.set(tree, m);
     }
     const code = getPathTo(tree, sym);
-    let v = {
+    const v = {
       length: code?.length,
       val: parseInt(code, 2)
     };
@@ -21448,17 +21446,16 @@ const _DOMParser = DOMParser;
       if (sym < 256) {
         d.dest.push(sym);
       } else {
-        let length, dist, offs2;
         sym -= 257;
-        length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
+        const length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
         if (length_bits[sym])
-          d.hidden.write(length_bits[sym], length - length_base[sym]);
-        let ext = { length: 0, sym: 0 };
-        dist = tinf_decode_symbol(d, dt, false, ext);
+          d.hidden?.write(length_bits[sym], length - length_base[sym]);
+        const ext = { length: 0, sym: 0 };
+        const dist = tinf_decode_symbol(d, dt, false, ext);
         let backoffset = tinf_read_bits(d, dist_bits[dist], dist_base[dist]);
-        offs2 = d.dest.length - backoffset;
+        const offs2 = d.dest.length - backoffset;
         let match;
-        let skip = d.to_hide instanceof BitstreamReader2 && d.to_hide.available == 0;
+        const skip = d.to_hide && d.to_hide instanceof BitstreamReader2 && d.to_hide.available == 0;
         if (!skip && (match = Buffer2.from(d.dest.slice(offs2, offs2 + length))).length == length) {
           let begin = d.dest.length - 32768;
           if (begin < 0)
@@ -21467,7 +21464,7 @@ const _DOMParser = DOMParser;
           let o = 0;
           const slic = Buffer2.from(d.dest.slice(begin + o, d.dest.length));
           while (begin + o < d.dest.length) {
-            let r = slic.slice(o, d.dest.length).indexOf(match);
+            const r = slic.slice(o, d.dest.length).indexOf(match);
             if (r >= 0) {
               matches.push(r + begin + o);
               o += r;
@@ -21495,10 +21492,10 @@ const _DOMParser = DOMParser;
             }
           }
         }
-        let [dsym, dlen, doff] = get_symbol(backoffset, dist_bits, dist_base);
-        let encdist = encode_symbol(dsym, d.rdtree);
-        d.hidden.write(encdist.length, revbyte(encdist.val, encdist.length));
-        d.hidden.write(dlen, doff);
+        const [dsym, dlen, doff] = get_symbol(backoffset, dist_bits, dist_base);
+        const encdist = encode_symbol(dsym, d.rdtree);
+        d.hidden?.write(encdist.length, revbyte(encdist.val, encdist.length));
+        d.hidden?.write(dlen, doff);
         for (let i = offs2; i < offs2 + length; ++i) {
           d.dest.push(d.dest[i]);
         }
@@ -21508,33 +21505,31 @@ const _DOMParser = DOMParser;
   function tinf_inflate_uncompressed_block(d) {
     if (d.source.offset & 7)
       d.source.readSync(8 - d.source.offset & 7);
-    if (d.hidden.offset & 7)
-      d.hidden.write(8 - d.hidden.offset & 7, 0);
-    let length = d.source.readSync(16);
-    d.hidden.write(16, length);
-    let invlength = d.source.readSync(16);
-    d.hidden.write(16, invlength);
+    if (d.hidden && d.hidden.offset & 7)
+      d.hidden?.write(8 - d.hidden.offset & 7, 0);
+    const length = d.source.readSync(16);
+    d.hidden?.write(16, length);
+    const invlength = d.source.readSync(16);
+    d.hidden?.write(16, invlength);
     if (length !== (~invlength & 65535)) {
       return -4;
     }
     for (let i = length; i; --i) {
       const v = d.source.readSync(8);
       d.dest.push(v);
-      d.hidden.write(8, v);
+      d.hidden?.write(8, v);
     }
     return TINF_OK;
   }
   function tinf_uncompress(source, decompressed, to_hide, hidden, opt = 0) {
-    let decomp = new BitstreamWriter2({ write: decompressed || (() => {
-    }) });
-    let hid = new BitstreamWriter2({ write: hidden || (() => {
-    }) }, 4);
-    let d = new Data(source, decomp, to_hide, hid);
+    const decomp = decompressed ? new BitstreamWriter2({ write: decompressed }) : null;
+    const hid = hidden && new BitstreamWriter2({ write: hidden }, 4);
+    const d = new Data(source, decomp, to_hide, hid);
     let res;
     let bfinal, btype;
     do {
       bfinal = tinf_getbit(d);
-      d.hidden.write(1, bfinal);
+      d.hidden?.write(1, bfinal);
       btype = tinf_read_bits(d, 2, 0);
       d.hidden?.write(2, btype);
       switch (btype) {
@@ -21558,8 +21553,8 @@ const _DOMParser = DOMParser;
       if (res !== TINF_OK)
         throw new Error("Data error " + res);
     } while (!bfinal);
-    decomp.end();
-    hid.end();
+    decomp?.end();
+    hid?.end();
   }
   tinf_build_fixed_trees(sltree, sdtree);
   tinf_build_bits_base(length_bits, length_base, 4, 3);
@@ -21625,9 +21620,7 @@ const _DOMParser = DOMParser;
       }
     });
     try {
-      tinf_uncompress(src, () => {
-      }, hidden, () => {
-      });
+      tinf_uncompress(src, void 0, hidden, void 0);
     } catch (e) {
       if (e == "Finish")
         return import_buffer3.Buffer.from(chnks);
@@ -21740,10 +21733,7 @@ const _DOMParser = DOMParser;
     hid.addBuffer(h);
     src.addBuffer(b);
     const chnks = [];
-    const endo = tinf_uncompress(src, () => {
-    }, hid, (c) => chnks.push(c));
-    if (endo)
-      chnks.push(b.slice(endo));
+    tinf_uncompress(src, void 0, hid, (c) => chnks.push(c));
     return import_buffer3.Buffer.concat(chnks);
   };
   var inject_data = async (container, injb) => {
diff --git a/pngextraembedder-0.269.xpi b/pngextraembedder-0.269.xpi
deleted file mode 100644
index c9e9c12..0000000
Binary files a/pngextraembedder-0.269.xpi and /dev/null differ
diff --git a/pngextraembedder-0.271.xpi b/pngextraembedder-0.271.xpi
deleted file mode 100644
index 12c3365..0000000
Binary files a/pngextraembedder-0.271.xpi and /dev/null differ
diff --git a/pngextraembedder-0.273.xpi b/pngextraembedder-0.273.xpi
deleted file mode 100644
index af8256e..0000000
Binary files a/pngextraembedder-0.273.xpi and /dev/null differ
diff --git a/pngextraembedder-0.275.xpi b/pngextraembedder-0.275.xpi
deleted file mode 100644
index 57560f4..0000000
Binary files a/pngextraembedder-0.275.xpi and /dev/null differ
diff --git a/pngextraembedder-0.279.xpi b/pngextraembedder-0.279.xpi
deleted file mode 100644
index 9ebb1da..0000000
Binary files a/pngextraembedder-0.279.xpi and /dev/null differ
diff --git a/pngextraembedder-0.281.xpi b/pngextraembedder-0.281.xpi
deleted file mode 100644
index e41b4d6..0000000
Binary files a/pngextraembedder-0.281.xpi and /dev/null differ
diff --git a/pngextraembedder-0.285.xpi b/pngextraembedder-0.285.xpi
deleted file mode 100644
index 3030bec..0000000
Binary files a/pngextraembedder-0.285.xpi and /dev/null differ
diff --git a/pngextraembedder-0.284.xpi b/pngextraembedder-0.289.xpi
similarity index 59%
rename from pngextraembedder-0.284.xpi
rename to pngextraembedder-0.289.xpi
index 59c1308..aefc93f 100644
Binary files a/pngextraembedder-0.284.xpi and b/pngextraembedder-0.289.xpi differ
diff --git a/src/bitstream.ts b/src/bitstream.ts
index 969a665..7ac3af1 100644
--- a/src/bitstream.ts
+++ b/src/bitstream.ts
@@ -85,7 +85,7 @@ export class BitstreamReader {
 }
 
 export type Writable = {
-    write: (chunk: Buffer) => void;
+    write: (chunk: Uint8Array) => void;
 };
 
 export class BitstreamWriter {
@@ -133,7 +133,7 @@ export class BitstreamWriter {
     }
 
     flush() {
-        this.stream.write(Buffer.from(this.buffer));
+        this.stream.write(this.buffer);
         this.bufferoffset = 0;
         this.buffer.fill(0);
     }
diff --git a/src/dh-deflate.ts b/src/dh-deflate.ts
index e5ec639..e0721bf 100644
--- a/src/dh-deflate.ts
+++ b/src/dh-deflate.ts
@@ -5,23 +5,20 @@ const TINF_DATA_ERROR = -3;
 
 class Tree {
     table = new Uint16Array(16);   /* table of code length counts */
+
     trans = new Uint16Array(288);  /* code -> symbol translation table */
 }
 
 type HCtree = [number | HCtree, (number | HCtree)?];
 
-let log = (x, ...n) => {
-    //console.log('t2', x, ...n);
-}
-
 // these two functions are a big bottleneck because im not clever enough to figure out how to encode 
 // something directly by using the sorted code length/value tables, haha
-let pathMap = new Map<HCtree, Map<number, {
+const pathMap = new Map<HCtree, Map<number, {
     length: number,
     val: number
 }>>();
 
-let getPathTo = (tree: HCtree, value: number): string | undefined => {
+const getPathTo = (tree: HCtree, value: number): string | undefined => {
     if (tree[0] === value)
         return '0';
     if (tree[1] === value)
@@ -43,6 +40,7 @@ let getPathTo = (tree: HCtree, value: number): string | undefined => {
 // from jpeg-js, in turns this means that jpeg-js decoding could be faster
 // if they decoded directly from the symbol tables instead of building a tree
 function buildHuffmanTable(codeLengths: ArrayLike<number>, values: ArrayLike<number>) {
+    // eslint-disable-next-line prefer-const
     let k = 0, code: any = [], i, j, length = 16;
     while (length > 0 && !codeLengths[length - 1])
         length--;
@@ -84,16 +82,18 @@ class Data {
     }
 
     ltree: Tree;
+
     dtree: Tree;
 
     rltree!: HCtree;
+
     rdtree!: HCtree;
 
     adists!: Set<number>;
 
     dest: number[] = [];
 
-    constructor(public source: BitstreamReader, public dests: BitstreamWriter, public to_hide: BitstreamReader | BitstreamWriter, public hidden: BitstreamWriter) {
+    constructor(public source: BitstreamReader, public dests: BitstreamWriter | null, public to_hide?: BitstreamReader | BitstreamWriter, public hidden?: BitstreamWriter) {
         this.ltree = new Tree();  /* dynamic length/symbol tree */
         this.dtree = new Tree();  /* dynamic distance tree */
     }
@@ -103,31 +103,36 @@ class Data {
  * -- uninitialized global data (static structures) -- *
  * --------------------------------------------------- */
 
-let sltree = new Tree();
-let sdtree = new Tree();
+const sltree = new Tree();
+const sdtree = new Tree();
 
+// eslint-disable-next-line prefer-const
 let rltree: HCtree;
+
+// eslint-disable-next-line prefer-const
 let rdtree: HCtree;
+
+// eslint-disable-next-line prefer-const
 let sadist: Set<number>;
 
 /* extra bits and base tables for length codes */
-let length_bits = new Uint8Array(30);
-let length_base = new Uint16Array(30);
+const length_bits = new Uint8Array(30);
+const length_base = new Uint16Array(30);
 
 /* extra bits and base tables for distance codes */
-let dist_bits = new Uint8Array(30);
-let dist_base = new Uint16Array(30);
+const dist_bits = new Uint8Array(30);
+const dist_base = new Uint16Array(30);
 
 /* special ordering of code length codes */
-let clcidx = new Uint8Array([
+const clcidx = new Uint8Array([
     16, 17, 18, 0, 8, 7, 9, 6,
     10, 5, 11, 4, 12, 3, 13, 2,
     14, 1, 15
 ]);
 
 /* used by tinf_decode_trees, avoids allocations every call */
-let code_tree = new Tree();
-let lengths = new Uint8Array(288 + 32);
+const code_tree = new Tree();
+const lengths = new Uint8Array(288 + 32);
 
 /* ----------------------- *
  * -- utility functions -- *
@@ -173,7 +178,7 @@ function tinf_build_fixed_trees(lt: Tree, dt: Tree) {
 }
 
 /* given an array of code lengths, build a tree */
-let offs = new Uint16Array(16);
+const offs = new Uint16Array(16);
 
 function tinf_build_tree(t: Tree, lengths: Uint8Array, off: number, num: number) {
     let i, sum;
@@ -204,19 +209,18 @@ function tinf_build_tree(t: Tree, lengths: Uint8Array, off: number, num: number)
 
 /* get one bit from source stream */
 function tinf_getbit(d: Data) {
-    let v = d.source.readSync(1);
-    log(v, 'getbit');
+    const v = d.source.readSync(1);
     return v;
 }
 
 let loff = 0;
-let loffs: number[] = [];
+const loffs: number[] = [];
 
 /* read a num bit value from a stream and add base */
 function tinf_read_bits(d: Data, num: number, base: number) {
     if (!num)
         return base;
-    let v = d.source.readSync(num) + base;
+    const v = d.source.readSync(num) + base;
     loff = v;
     //console.log(v);
     loffs.push(v);
@@ -233,8 +237,8 @@ function tinf_decode_symbol(d: Data, t: Tree, copy = true, ext: any = {}) {
     /* get more bits while code value is above sum */
     let s = 0;
     do {
-        let b = d.source.readSync(1);
-        copy && d.hidden.write(1, b);
+        const b = d.source.readSync(1);
+        copy && d.hidden?.write(1, b);
         s = (s << 1) | b;
         cur = 2 * cur + b;
         ++len;
@@ -252,7 +256,7 @@ function tinf_decode_symbol2(d: Data, t: Tree) {
 
     /* get more bits while code value is above sum */
     do {
-        let b = d.source.readSync(1);
+        const b = d.source.readSync(1);
         //d.hidden.write(1, b);
         cur = 2 * cur + b;
         ++len;
@@ -268,15 +272,15 @@ function tinf_decode_trees(d: Data, lt: Tree, dt: Tree, copy = true) {
     let i, num, length;
 
     /* get 5 bits HLIT (257-286) */
-    let hlit = tinf_read_bits(d, 5, 257);
+    const hlit = tinf_read_bits(d, 5, 257);
     copy && d.hidden?.write(5, hlit - 257);
 
     /* get 5 bits HDIST (1-32) */
-    let hdist = tinf_read_bits(d, 5, 1);
+    const hdist = tinf_read_bits(d, 5, 1);
     copy && d.hidden?.write(5, hdist - 1);
 
     /* get 4 bits HCLEN (4-19) */
-    let hclen = tinf_read_bits(d, 4, 4);
+    const hclen = tinf_read_bits(d, 4, 4);
     copy && d.hidden?.write(4, hclen - 4);
 
     for (i = 0; i < 19; ++i) lengths[i] = 0;
@@ -284,7 +288,7 @@ function tinf_decode_trees(d: Data, lt: Tree, dt: Tree, copy = true) {
     /* read code lengths for code length alphabet */
     for (i = 0; i < hclen; ++i) {
         /* get 3 bits code length (0-7) */
-        let clen = tinf_read_bits(d, 3, 0);
+        const clen = tinf_read_bits(d, 3, 0);
         copy && d.hidden?.write(3, clen);
 
         lengths[clcidx[i]] = clen;
@@ -295,12 +299,13 @@ function tinf_decode_trees(d: Data, lt: Tree, dt: Tree, copy = true) {
 
     /* decode code lengths for the dynamic trees */
     for (num = 0; num < hlit + hdist;) {
-        let sym = tinf_decode_symbol(d, code_tree, copy);
+        const sym = tinf_decode_symbol(d, code_tree, copy);
+        let prev: number;
 
         switch (sym) {
             case 16:
                 /* copy previous code length 3-6 times (read 2 bits) */
-                let prev = lengths[num - 1];
+                prev = lengths[num - 1];
                 length = tinf_read_bits(d, 2, 3);
                 copy && d.hidden?.write(2, length - 3);
                 for (; length; --length) {
@@ -335,23 +340,22 @@ function tinf_decode_trees(d: Data, lt: Tree, dt: Tree, copy = true) {
     tinf_build_tree(dt, lengths, hlit, hdist);
 }
 
-
 const get_symbol = (value: number, bits_table: Uint8Array, base_table: Uint16Array): [number, number, number] => {
     let i = 0;
     for (i = 0; i < base_table.length; ++i) {
         if (base_table[i] > value) {
             i--;
-            return [i, bits_table[i], value - base_table[i]]
+            return [i, bits_table[i], value - base_table[i]];
         }
     }
     i--;
-    return [i, bits_table[i], value - base_table[i]]
+    return [i, bits_table[i], value - base_table[i]];
 };
 
 const encode_symbol = (sym: number, tree: HCtree) => {
-    let m: Map<number, {length: number, val: number}> | undefined;
+    let m: Map<number, { length: number, val: number }> | undefined;
     if ((m = pathMap.get(tree))) {
-        let v = m.get(sym);
+        const v = m.get(sym);
         if (v) return v;
     } else {
         m = new Map;
@@ -360,7 +364,7 @@ const encode_symbol = (sym: number, tree: HCtree) => {
 
     const code = getPathTo(tree, sym)!;
 
-    let v = {
+    const v = {
         length: code?.length,
         val: parseInt(code, 2)
     };
@@ -374,6 +378,7 @@ const encode_symbol = (sym: number, tree: HCtree) => {
 /* given a stream and two trees, inflate a block of data */
 export let capacity = 0;
 function tinf_inflate_block_data(d: Data, lt: Tree, dt: Tree) {
+    // eslint-disable-next-line no-constant-condition
     while (1) {
         let sym = tinf_decode_symbol(d, lt); // copy
 
@@ -386,30 +391,28 @@ function tinf_inflate_block_data(d: Data, lt: Tree, dt: Tree) {
             d.dest.push(sym);
             // same
         } else {
-            let length, dist, offs;
-
             sym -= 257;
 
             /* possibly get more bits from length code */
-            length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
+            const length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
             //d.hidden.write(length_bits[sym], length - length_base[sym]);
 
             // length is unchanged, so copy as is
             if (length_bits[sym])
-                d.hidden.write(length_bits[sym], length - length_base[sym]);
+                d.hidden?.write(length_bits[sym], length - length_base[sym]);
 
-            let ext = { length: 0, sym: 0 };
-            dist = tinf_decode_symbol(d, dt, false, ext); // don't copy immediately, we may change the code
+            const ext = { length: 0, sym: 0 };
+            const dist = tinf_decode_symbol(d, dt, false, ext); // don't copy immediately, we may change the code
             //ext.sym = revbyte(ext.sym, ext.length);
             //d.hidden.write(ext.length, ext.sym);
             /* possibly get more bits from distance code */
             let backoffset = tinf_read_bits(d, dist_bits[dist], dist_base[dist]);
 
-            offs = d.dest.length - backoffset;
+            const offs = d.dest.length - backoffset;
 
             let match: Buffer;
             // don't consider matches that could be in the lookahead buffer
-            let skip = d.to_hide instanceof BitstreamReader && d.to_hide.available == 0;
+            const skip = d.to_hide && d.to_hide instanceof BitstreamReader && d.to_hide.available == 0;
             if (!skip && (match = Buffer.from(d.dest.slice(offs, offs + length))).length == length) {
                 let begin = d.dest.length - 32768;
                 if (begin < 0)
@@ -418,7 +421,7 @@ function tinf_inflate_block_data(d: Data, lt: Tree, dt: Tree) {
                 let o = 0;
                 const slic = Buffer.from(d.dest.slice(begin + o, d.dest.length));
                 while (begin + o < d.dest.length) {
-                    let r = slic.slice(o, d.dest.length).indexOf(match);
+                    const r = slic.slice(o, d.dest.length).indexOf(match);
                     if (r >= 0) {
                         matches.push(r + begin + o);
                         o += r;
@@ -432,7 +435,7 @@ function tinf_inflate_block_data(d: Data, lt: Tree, dt: Tree) {
                     matches = matches.map(e => -(e - d.dest.length)).filter(e => {
                         const [dsym] = get_symbol(e, dist_bits, dist_base);
                         return d.adists.has(dsym);
-                    })
+                    });
                     matches.reverse();
                     const v = Math.floor(Math.log2(matches.length));
                     capacity += v;
@@ -447,7 +450,7 @@ function tinf_inflate_block_data(d: Data, lt: Tree, dt: Tree) {
                     // extract hidden bit
                     else {
                         const idx = matches.indexOf(backoffset);
-                        d.to_hide.write(v, idx);
+                        d.to_hide!.write(v, idx);
                     }
                 }
             }
@@ -456,11 +459,10 @@ function tinf_inflate_block_data(d: Data, lt: Tree, dt: Tree) {
             //let enclen = encode_symbol(lsym, d.rltree);
             //d.hidden.write(enclen.length, enclen.val);
             //d.hidden.write(llen, loff);
-            let [dsym, dlen, doff] = get_symbol(backoffset, dist_bits, dist_base);
-            let encdist = encode_symbol(dsym, d.rdtree);
-            d.hidden.write(encdist.length, revbyte(encdist.val, encdist.length));
-            d.hidden.write(dlen, doff);
-
+            const [dsym, dlen, doff] = get_symbol(backoffset, dist_bits, dist_base);
+            const encdist = encode_symbol(dsym, d.rdtree);
+            d.hidden?.write(encdist.length, revbyte(encdist.val, encdist.length));
+            d.hidden?.write(dlen, doff);
 
             /* copy match */
             for (let i = offs; i < offs + length; ++i) {
@@ -474,15 +476,15 @@ function tinf_inflate_block_data(d: Data, lt: Tree, dt: Tree) {
 function tinf_inflate_uncompressed_block(d: Data) {
     if (d.source.offset & 7)
         d.source.readSync(8 - d.source.offset & 7);
-    if (d.hidden.offset & 7)
-        d.hidden.write(8 - d.hidden.offset & 7, 0);
+    if (d.hidden && d.hidden.offset & 7)
+        d.hidden?.write(8 - d.hidden.offset & 7, 0);
 
-    let length = d.source.readSync(16);
-    d.hidden.write(16, length);
+    const length = d.source.readSync(16);
+    d.hidden?.write(16, length);
 
     /* get one's complement of length */
-    let invlength = d.source.readSync(16);
-    d.hidden.write(16, invlength);
+    const invlength = d.source.readSync(16);
+    d.hidden?.write(16, invlength);
     /* check length */
     if (length !== (~invlength & 0x0000ffff)) {
         //console.log(length, invlength, loff)
@@ -492,12 +494,13 @@ function tinf_inflate_uncompressed_block(d: Data) {
     for (let i = length; i; --i) {
         const v = d.source.readSync(8);
         d.dest.push(v);
-        d.hidden.write(8, v);
+        d.hidden?.write(8, v);
     }
     return TINF_OK;
 }
 
 function copy_block_data(d: Data, lt: Tree, dt: Tree) {
+    // eslint-disable-next-line no-constant-condition
     while (1) {
         let sym = tinf_decode_symbol(d, lt, false); // copy
 
@@ -510,11 +513,9 @@ function copy_block_data(d: Data, lt: Tree, dt: Tree) {
             //d.dest.push(sym);
             // same
         } else {
-            let length, dist, offs;
-
             sym -= 257;
-            length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
-            dist = tinf_decode_symbol2(d, dt);
+            const length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
+            const dist = tinf_decode_symbol2(d, dt);
             tinf_read_bits(d, dist_bits[dist], dist_base[dist]);
         }
     }
@@ -524,17 +525,17 @@ function copy_uncompressed_block(d: Data) {
     // align
     if (d.source.offset & 7)
         d.source.readSync(8 - d.source.offset & 7);
-    if (d.hidden.offset & 7)
+    if (d.hidden && d.hidden.offset & 7)
         d.hidden.write(8 - d.hidden.offset & 7, 0);
 
-    let length: number;
-    d.hidden.write(16, length = d.source.readSync(16));
-    d.hidden.write(16, d.source.readSync(16));
+    const length: number = d.source.readSync(16);
+    d.hidden?.write(16, length);
+    d.hidden?.write(16, d.source.readSync(16));
 
     let total = length * 8;
     while (total) {
         const r = Math.min(32, total);
-        d.hidden.write(r, d.source.readSync(r));
+        d.hidden?.write(r, d.source.readSync(r));
         total -= r;
     }
     return TINF_OK;
@@ -543,16 +544,16 @@ function copy_uncompressed_block(d: Data) {
 /* inflate stream from source to dest */
 export function tinf_uncompress(source: BitstreamReader,
     // normal decompressed data
-    decompressed: (chunk: Uint8Array) => void,
+    decompressed?: (chunk: Uint8Array) => void,
     // stream of data to hide
-    to_hide: BitstreamReader | BitstreamWriter,
+    to_hide?: BitstreamReader | BitstreamWriter,
     // compressed stream containing hidden data
-    hidden: (chunk: Uint8Array) => void, opt = 0) {
+    hidden?: (chunk: Uint8Array) => void, opt = 0) {
 
-    let decomp = new BitstreamWriter({ write: (decompressed || (() => { })) });
-    let hid = new BitstreamWriter({ write: (hidden || (() => { })) }, 4);
+    const decomp = decompressed ? new BitstreamWriter({ write: decompressed }) : null;
+    const hid = hidden && new BitstreamWriter({ write: hidden }, 4);
 
-    let d = new Data(source, decomp, to_hide, hid);
+    const d = new Data(source, decomp, to_hide, hid);
     let res: number | undefined | true;
     let bfinal: number, btype: number;
 
@@ -561,7 +562,7 @@ export function tinf_uncompress(source: BitstreamReader,
 
         /* read final block flag */
         bfinal = tinf_getbit(d);
-        d.hidden.write(1, bfinal);
+        d.hidden?.write(1, bfinal);
 
         /* read block type (2 bits) */
         btype = tinf_read_bits(d, 2, 0);
@@ -596,9 +597,8 @@ export function tinf_uncompress(source: BitstreamReader,
 
     } while (!bfinal);
 
-    decomp.end();
-    hid.end()
-
+    decomp?.end();
+    hid?.end();
 
     //if (d.dest.byteOffset < d.dest.length) {
     //    if (typeof d.dest.slice === 'function')
diff --git a/src/pngv3.ts b/src/pngv3.ts
index 4e25e01..03cef9c 100644
--- a/src/pngv3.ts
+++ b/src/pngv3.ts
@@ -133,7 +133,7 @@ const extractFromRawDeflate = (b: Buffer) => {
         },
     });
     try {
-        tinf_uncompress(src, () => {/** */ }, hidden, () => {/** */ });
+        tinf_uncompress(src, undefined, hidden, undefined);
     } catch (e) {
         if (e == "Finish")
             return Buffer.from(chnks);
@@ -264,9 +264,7 @@ const embedInRawDeflate = (b: Buffer, h: Buffer) => {
     hid.addBuffer(h);
     src.addBuffer(b);
     const chnks: Uint8Array[] = [];
-    const endo = tinf_uncompress(src, () => { /** */ }, hid, c => chnks.push(c));
-    if (endo)
-        chnks.push(b.slice(endo));
+    tinf_uncompress(src, undefined, hid, c => chnks.push(c));
     return Buffer.concat(chnks);
 };