Some little optimizations, nothing fancy yet

2 years ago · 71cbad1f5b
24 changed files with 252 additions and 294 deletions
--- 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.

--- 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) => {
--- 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"
  },
--- 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) => {
--- a/efdb47d2f0e04144bbaa-0.254.xpi
+++ b/efdb47d2f0e04144bbaa-0.254.xpi
--- a/efdb47d2f0e04144bbaa-0.281.xpi
+++ b/efdb47d2f0e04144bbaa-0.281.xpi
--- a/efdb47d2f0e04144bbaa-0.284.xpi
+++ b/efdb47d2f0e04144bbaa-0.284.xpi
--- a/efdb47d2f0e04144bbaa-0.289.xpi
+++ b/efdb47d2f0e04144bbaa-0.289.xpi
--- 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) => {
--- 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"
  },
--- 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"}]}}}
+{"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"}]}}}
--- 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/*
--- 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) => {
--- a/pngextraembedder-0.269.xpi
+++ b/pngextraembedder-0.269.xpi
--- a/pngextraembedder-0.271.xpi
+++ b/pngextraembedder-0.271.xpi
--- a/pngextraembedder-0.273.xpi
+++ b/pngextraembedder-0.273.xpi
--- a/pngextraembedder-0.275.xpi
+++ b/pngextraembedder-0.275.xpi
--- a/pngextraembedder-0.279.xpi
+++ b/pngextraembedder-0.279.xpi
--- a/pngextraembedder-0.281.xpi
+++ b/pngextraembedder-0.281.xpi
--- a/pngextraembedder-0.285.xpi
+++ b/pngextraembedder-0.285.xpi
--- a/pngextraembedder-0.289.xpi
+++ b/pngextraembedder-0.289.xpi
--- 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);
    }
--- 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')
--- 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);
 };