token-goat 2.9.2 → 2.9.4

package/dist/{token-goat-chunk-LJ3CHCTT.mjs → token-goat-chunk-CBO45DYZ.mjs}

@@ -96,15 +96,2742 @@ import {
   toDisplayPath,
   toKB,
   withFileLock
-} from "./token-goat-chunk-UZ2NFOOZ.mjs";
+} from "./token-goat-chunk-3ZR4NLB3.mjs";
 import {
   registerReset
-} from "./token-goat-chunk-AO2QD2AG.mjs";
+} from "./token-goat-chunk-EEIDFMEM.mjs";
+import {
+  __commonJS,
+  __toESM,
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// node_modules/omggif/omggif.js
+var require_omggif = __commonJS({
+  "node_modules/omggif/omggif.js"(exports) {
+    "use strict";
+    init_define_import_meta_env();
+    function GifWriter(buf, width, height, gopts) {
+      var p = 0;
+      var gopts = gopts === void 0 ? {} : gopts;
+      var loop_count = gopts.loop === void 0 ? null : gopts.loop;
+      var global_palette = gopts.palette === void 0 ? null : gopts.palette;
+      if (width <= 0 || height <= 0 || width > 65535 || height > 65535)
+        throw new Error("Width/Height invalid.");
+      function check_palette_and_num_colors(palette) {
+        var num_colors = palette.length;
+        if (num_colors < 2 || num_colors > 256 || num_colors & num_colors - 1) {
+          throw new Error(
+            "Invalid code/color length, must be power of 2 and 2 .. 256."
+          );
+        }
+        return num_colors;
+      }
+      buf[p++] = 71;
+      buf[p++] = 73;
+      buf[p++] = 70;
+      buf[p++] = 56;
+      buf[p++] = 57;
+      buf[p++] = 97;
+      var gp_num_colors_pow2 = 0;
+      var background = 0;
+      if (global_palette !== null) {
+        var gp_num_colors = check_palette_and_num_colors(global_palette);
+        while (gp_num_colors >>= 1) ++gp_num_colors_pow2;
+        gp_num_colors = 1 << gp_num_colors_pow2;
+        --gp_num_colors_pow2;
+        if (gopts.background !== void 0) {
+          background = gopts.background;
+          if (background >= gp_num_colors)
+            throw new Error("Background index out of range.");
+          if (background === 0)
+            throw new Error("Background index explicitly passed as 0.");
+        }
+      }
+      buf[p++] = width & 255;
+      buf[p++] = width >> 8 & 255;
+      buf[p++] = height & 255;
+      buf[p++] = height >> 8 & 255;
+      buf[p++] = (global_palette !== null ? 128 : 0) | // Global Color Table Flag.
+      gp_num_colors_pow2;
+      buf[p++] = background;
+      buf[p++] = 0;
+      if (global_palette !== null) {
+        for (var i = 0, il = global_palette.length; i < il; ++i) {
+          var rgb = global_palette[i];
+          buf[p++] = rgb >> 16 & 255;
+          buf[p++] = rgb >> 8 & 255;
+          buf[p++] = rgb & 255;
+        }
+      }
+      if (loop_count !== null) {
+        if (loop_count < 0 || loop_count > 65535)
+          throw new Error("Loop count invalid.");
+        buf[p++] = 33;
+        buf[p++] = 255;
+        buf[p++] = 11;
+        buf[p++] = 78;
+        buf[p++] = 69;
+        buf[p++] = 84;
+        buf[p++] = 83;
+        buf[p++] = 67;
+        buf[p++] = 65;
+        buf[p++] = 80;
+        buf[p++] = 69;
+        buf[p++] = 50;
+        buf[p++] = 46;
+        buf[p++] = 48;
+        buf[p++] = 3;
+        buf[p++] = 1;
+        buf[p++] = loop_count & 255;
+        buf[p++] = loop_count >> 8 & 255;
+        buf[p++] = 0;
+      }
+      var ended = false;
+      this.addFrame = function(x, y, w, h, indexed_pixels, opts) {
+        if (ended === true) {
+          --p;
+          ended = false;
+        }
+        opts = opts === void 0 ? {} : opts;
+        if (x < 0 || y < 0 || x > 65535 || y > 65535)
+          throw new Error("x/y invalid.");
+        if (w <= 0 || h <= 0 || w > 65535 || h > 65535)
+          throw new Error("Width/Height invalid.");
+        if (indexed_pixels.length < w * h)
+          throw new Error("Not enough pixels for the frame size.");
+        var using_local_palette = true;
+        var palette = opts.palette;
+        if (palette === void 0 || palette === null) {
+          using_local_palette = false;
+          palette = global_palette;
+        }
+        if (palette === void 0 || palette === null)
+          throw new Error("Must supply either a local or global palette.");
+        var num_colors = check_palette_and_num_colors(palette);
+        var min_code_size = 0;
+        while (num_colors >>= 1) ++min_code_size;
+        num_colors = 1 << min_code_size;
+        var delay = opts.delay === void 0 ? 0 : opts.delay;
+        var disposal = opts.disposal === void 0 ? 0 : opts.disposal;
+        if (disposal < 0 || disposal > 3)
+          throw new Error("Disposal out of range.");
+        var use_transparency = false;
+        var transparent_index = 0;
+        if (opts.transparent !== void 0 && opts.transparent !== null) {
+          use_transparency = true;
+          transparent_index = opts.transparent;
+          if (transparent_index < 0 || transparent_index >= num_colors)
+            throw new Error("Transparent color index.");
+        }
+        if (disposal !== 0 || use_transparency || delay !== 0) {
+          buf[p++] = 33;
+          buf[p++] = 249;
+          buf[p++] = 4;
+          buf[p++] = disposal << 2 | (use_transparency === true ? 1 : 0);
+          buf[p++] = delay & 255;
+          buf[p++] = delay >> 8 & 255;
+          buf[p++] = transparent_index;
+          buf[p++] = 0;
+        }
+        buf[p++] = 44;
+        buf[p++] = x & 255;
+        buf[p++] = x >> 8 & 255;
+        buf[p++] = y & 255;
+        buf[p++] = y >> 8 & 255;
+        buf[p++] = w & 255;
+        buf[p++] = w >> 8 & 255;
+        buf[p++] = h & 255;
+        buf[p++] = h >> 8 & 255;
+        buf[p++] = using_local_palette === true ? 128 | min_code_size - 1 : 0;
+        if (using_local_palette === true) {
+          for (var i2 = 0, il2 = palette.length; i2 < il2; ++i2) {
+            var rgb2 = palette[i2];
+            buf[p++] = rgb2 >> 16 & 255;
+            buf[p++] = rgb2 >> 8 & 255;
+            buf[p++] = rgb2 & 255;
+          }
+        }
+        p = GifWriterOutputLZWCodeStream(
+          buf,
+          p,
+          min_code_size < 2 ? 2 : min_code_size,
+          indexed_pixels
+        );
+        return p;
+      };
+      this.end = function() {
+        if (ended === false) {
+          buf[p++] = 59;
+          ended = true;
+        }
+        return p;
+      };
+      this.getOutputBuffer = function() {
+        return buf;
+      };
+      this.setOutputBuffer = function(v) {
+        buf = v;
+      };
+      this.getOutputBufferPosition = function() {
+        return p;
+      };
+      this.setOutputBufferPosition = function(v) {
+        p = v;
+      };
+    }
+    function GifWriterOutputLZWCodeStream(buf, p, min_code_size, index_stream) {
+      buf[p++] = min_code_size;
+      var cur_subblock = p++;
+      var clear_code = 1 << min_code_size;
+      var code_mask = clear_code - 1;
+      var eoi_code = clear_code + 1;
+      var next_code = eoi_code + 1;
+      var cur_code_size = min_code_size + 1;
+      var cur_shift = 0;
+      var cur = 0;
+      function emit_bytes_to_buffer(bit_block_size) {
+        while (cur_shift >= bit_block_size) {
+          buf[p++] = cur & 255;
+          cur >>= 8;
+          cur_shift -= 8;
+          if (p === cur_subblock + 256) {
+            buf[cur_subblock] = 255;
+            cur_subblock = p++;
+          }
+        }
+      }
+      function emit_code(c) {
+        cur |= c << cur_shift;
+        cur_shift += cur_code_size;
+        emit_bytes_to_buffer(8);
+      }
+      var ib_code = index_stream[0] & code_mask;
+      var code_table = {};
+      emit_code(clear_code);
+      for (var i = 1, il = index_stream.length; i < il; ++i) {
+        var k = index_stream[i] & code_mask;
+        var cur_key = ib_code << 8 | k;
+        var cur_code = code_table[cur_key];
+        if (cur_code === void 0) {
+          cur |= ib_code << cur_shift;
+          cur_shift += cur_code_size;
+          while (cur_shift >= 8) {
+            buf[p++] = cur & 255;
+            cur >>= 8;
+            cur_shift -= 8;
+            if (p === cur_subblock + 256) {
+              buf[cur_subblock] = 255;
+              cur_subblock = p++;
+            }
+          }
+          if (next_code === 4096) {
+            emit_code(clear_code);
+            next_code = eoi_code + 1;
+            cur_code_size = min_code_size + 1;
+            code_table = {};
+          } else {
+            if (next_code >= 1 << cur_code_size) ++cur_code_size;
+            code_table[cur_key] = next_code++;
+          }
+          ib_code = k;
+        } else {
+          ib_code = cur_code;
+        }
+      }
+      emit_code(ib_code);
+      emit_code(eoi_code);
+      emit_bytes_to_buffer(1);
+      if (cur_subblock + 1 === p) {
+        buf[cur_subblock] = 0;
+      } else {
+        buf[cur_subblock] = p - cur_subblock - 1;
+        buf[p++] = 0;
+      }
+      return p;
+    }
+    function GifReader(buf) {
+      var p = 0;
+      if (buf[p++] !== 71 || buf[p++] !== 73 || buf[p++] !== 70 || buf[p++] !== 56 || (buf[p++] + 1 & 253) !== 56 || buf[p++] !== 97) {
+        throw new Error("Invalid GIF 87a/89a header.");
+      }
+      var width = buf[p++] | buf[p++] << 8;
+      var height = buf[p++] | buf[p++] << 8;
+      var pf0 = buf[p++];
+      var global_palette_flag = pf0 >> 7;
+      var num_global_colors_pow2 = pf0 & 7;
+      var num_global_colors = 1 << num_global_colors_pow2 + 1;
+      var background = buf[p++];
+      buf[p++];
+      var global_palette_offset = null;
+      var global_palette_size = null;
+      if (global_palette_flag) {
+        global_palette_offset = p;
+        global_palette_size = num_global_colors;
+        p += num_global_colors * 3;
+      }
+      var no_eof = true;
+      var frames = [];
+      var delay = 0;
+      var transparent_index = null;
+      var disposal = 0;
+      var loop_count = null;
+      this.width = width;
+      this.height = height;
+      while (no_eof && p < buf.length) {
+        switch (buf[p++]) {
+          case 33:
+            switch (buf[p++]) {
+              case 255:
+                if (buf[p] !== 11 || // 21 FF already read, check block size.
+                // NETSCAPE2.0
+                buf[p + 1] == 78 && buf[p + 2] == 69 && buf[p + 3] == 84 && buf[p + 4] == 83 && buf[p + 5] == 67 && buf[p + 6] == 65 && buf[p + 7] == 80 && buf[p + 8] == 69 && buf[p + 9] == 50 && buf[p + 10] == 46 && buf[p + 11] == 48 && // Sub-block
+                buf[p + 12] == 3 && buf[p + 13] == 1 && buf[p + 16] == 0) {
+                  p += 14;
+                  loop_count = buf[p++] | buf[p++] << 8;
+                  p++;
+                } else {
+                  p += 12;
+                  while (true) {
+                    var block_size = buf[p++];
+                    if (!(block_size >= 0)) throw Error("Invalid block size");
+                    if (block_size === 0) break;
+                    p += block_size;
+                  }
+                }
+                break;
+              case 249:
+                if (buf[p++] !== 4 || buf[p + 4] !== 0)
+                  throw new Error("Invalid graphics extension block.");
+                var pf1 = buf[p++];
+                delay = buf[p++] | buf[p++] << 8;
+                transparent_index = buf[p++];
+                if ((pf1 & 1) === 0) transparent_index = null;
+                disposal = pf1 >> 2 & 7;
+                p++;
+                break;
+              case 254:
+                while (true) {
+                  var block_size = buf[p++];
+                  if (!(block_size >= 0)) throw Error("Invalid block size");
+                  if (block_size === 0) break;
+                  p += block_size;
+                }
+                break;
+              default:
+                throw new Error(
+                  "Unknown graphic control label: 0x" + buf[p - 1].toString(16)
+                );
+            }
+            break;
+          case 44:
+            var x = buf[p++] | buf[p++] << 8;
+            var y = buf[p++] | buf[p++] << 8;
+            var w = buf[p++] | buf[p++] << 8;
+            var h = buf[p++] | buf[p++] << 8;
+            var pf2 = buf[p++];
+            var local_palette_flag = pf2 >> 7;
+            var interlace_flag = pf2 >> 6 & 1;
+            var num_local_colors_pow2 = pf2 & 7;
+            var num_local_colors = 1 << num_local_colors_pow2 + 1;
+            var palette_offset = global_palette_offset;
+            var palette_size = global_palette_size;
+            var has_local_palette = false;
+            if (local_palette_flag) {
+              var has_local_palette = true;
+              palette_offset = p;
+              palette_size = num_local_colors;
+              p += num_local_colors * 3;
+            }
+            var data_offset = p;
+            p++;
+            while (true) {
+              var block_size = buf[p++];
+              if (!(block_size >= 0)) throw Error("Invalid block size");
+              if (block_size === 0) break;
+              p += block_size;
+            }
+            frames.push({
+              x,
+              y,
+              width: w,
+              height: h,
+              has_local_palette,
+              palette_offset,
+              palette_size,
+              data_offset,
+              data_length: p - data_offset,
+              transparent_index,
+              interlaced: !!interlace_flag,
+              delay,
+              disposal
+            });
+            break;
+          case 59:
+            no_eof = false;
+            break;
+          default:
+            throw new Error("Unknown gif block: 0x" + buf[p - 1].toString(16));
+            break;
+        }
+      }
+      this.numFrames = function() {
+        return frames.length;
+      };
+      this.loopCount = function() {
+        return loop_count;
+      };
+      this.frameInfo = function(frame_num) {
+        if (frame_num < 0 || frame_num >= frames.length)
+          throw new Error("Frame index out of range.");
+        return frames[frame_num];
+      };
+      this.decodeAndBlitFrameBGRA = function(frame_num, pixels) {
+        var frame = this.frameInfo(frame_num);
+        var num_pixels = frame.width * frame.height;
+        var index_stream = new Uint8Array(num_pixels);
+        GifReaderLZWOutputIndexStream(
+          buf,
+          frame.data_offset,
+          index_stream,
+          num_pixels
+        );
+        var palette_offset2 = frame.palette_offset;
+        var trans = frame.transparent_index;
+        if (trans === null) trans = 256;
+        var framewidth = frame.width;
+        var framestride = width - framewidth;
+        var xleft = framewidth;
+        var opbeg = (frame.y * width + frame.x) * 4;
+        var opend = ((frame.y + frame.height) * width + frame.x) * 4;
+        var op = opbeg;
+        var scanstride = framestride * 4;
+        if (frame.interlaced === true) {
+          scanstride += width * 4 * 7;
+        }
+        var interlaceskip = 8;
+        for (var i = 0, il = index_stream.length; i < il; ++i) {
+          var index = index_stream[i];
+          if (xleft === 0) {
+            op += scanstride;
+            xleft = framewidth;
+            if (op >= opend) {
+              scanstride = framestride * 4 + width * 4 * (interlaceskip - 1);
+              op = opbeg + (framewidth + framestride) * (interlaceskip << 1);
+              interlaceskip >>= 1;
+            }
+          }
+          if (index === trans) {
+            op += 4;
+          } else {
+            var r = buf[palette_offset2 + index * 3];
+            var g = buf[palette_offset2 + index * 3 + 1];
+            var b = buf[palette_offset2 + index * 3 + 2];
+            pixels[op++] = b;
+            pixels[op++] = g;
+            pixels[op++] = r;
+            pixels[op++] = 255;
+          }
+          --xleft;
+        }
+      };
+      this.decodeAndBlitFrameRGBA = function(frame_num, pixels) {
+        var frame = this.frameInfo(frame_num);
+        var num_pixels = frame.width * frame.height;
+        var index_stream = new Uint8Array(num_pixels);
+        GifReaderLZWOutputIndexStream(
+          buf,
+          frame.data_offset,
+          index_stream,
+          num_pixels
+        );
+        var palette_offset2 = frame.palette_offset;
+        var trans = frame.transparent_index;
+        if (trans === null) trans = 256;
+        var framewidth = frame.width;
+        var framestride = width - framewidth;
+        var xleft = framewidth;
+        var opbeg = (frame.y * width + frame.x) * 4;
+        var opend = ((frame.y + frame.height) * width + frame.x) * 4;
+        var op = opbeg;
+        var scanstride = framestride * 4;
+        if (frame.interlaced === true) {
+          scanstride += width * 4 * 7;
+        }
+        var interlaceskip = 8;
+        for (var i = 0, il = index_stream.length; i < il; ++i) {
+          var index = index_stream[i];
+          if (xleft === 0) {
+            op += scanstride;
+            xleft = framewidth;
+            if (op >= opend) {
+              scanstride = framestride * 4 + width * 4 * (interlaceskip - 1);
+              op = opbeg + (framewidth + framestride) * (interlaceskip << 1);
+              interlaceskip >>= 1;
+            }
+          }
+          if (index === trans) {
+            op += 4;
+          } else {
+            var r = buf[palette_offset2 + index * 3];
+            var g = buf[palette_offset2 + index * 3 + 1];
+            var b = buf[palette_offset2 + index * 3 + 2];
+            pixels[op++] = r;
+            pixels[op++] = g;
+            pixels[op++] = b;
+            pixels[op++] = 255;
+          }
+          --xleft;
+        }
+      };
+    }
+    function GifReaderLZWOutputIndexStream(code_stream, p, output, output_length) {
+      var min_code_size = code_stream[p++];
+      var clear_code = 1 << min_code_size;
+      var eoi_code = clear_code + 1;
+      var next_code = eoi_code + 1;
+      var cur_code_size = min_code_size + 1;
+      var code_mask = (1 << cur_code_size) - 1;
+      var cur_shift = 0;
+      var cur = 0;
+      var op = 0;
+      var subblock_size = code_stream[p++];
+      var code_table = new Int32Array(4096);
+      var prev_code = null;
+      while (true) {
+        while (cur_shift < 16) {
+          if (subblock_size === 0) break;
+          cur |= code_stream[p++] << cur_shift;
+          cur_shift += 8;
+          if (subblock_size === 1) {
+            subblock_size = code_stream[p++];
+          } else {
+            --subblock_size;
+          }
+        }
+        if (cur_shift < cur_code_size)
+          break;
+        var code = cur & code_mask;
+        cur >>= cur_code_size;
+        cur_shift -= cur_code_size;
+        if (code === clear_code) {
+          next_code = eoi_code + 1;
+          cur_code_size = min_code_size + 1;
+          code_mask = (1 << cur_code_size) - 1;
+          prev_code = null;
+          continue;
+        } else if (code === eoi_code) {
+          break;
+        }
+        var chase_code = code < next_code ? code : prev_code;
+        var chase_length = 0;
+        var chase = chase_code;
+        while (chase > clear_code) {
+          chase = code_table[chase] >> 8;
+          ++chase_length;
+        }
+        var k = chase;
+        var op_end = op + chase_length + (chase_code !== code ? 1 : 0);
+        if (op_end > output_length) {
+          console.log("Warning, gif stream longer than expected.");
+          return;
+        }
+        output[op++] = k;
+        op += chase_length;
+        var b = op;
+        if (chase_code !== code)
+          output[op++] = k;
+        chase = chase_code;
+        while (chase_length--) {
+          chase = code_table[chase];
+          output[--b] = chase & 255;
+          chase >>= 8;
+        }
+        if (prev_code !== null && next_code < 4096) {
+          code_table[next_code++] = prev_code << 8 | k;
+          if (next_code >= code_mask + 1 && cur_code_size < 12) {
+            ++cur_code_size;
+            code_mask = code_mask << 1 | 1;
+          }
+        }
+        prev_code = code;
+      }
+      if (op !== output_length) {
+        console.log("Warning, gif stream shorter than expected.");
+      }
+      return output;
+    }
+    try {
+      exports.GifWriter = GifWriter;
+      exports.GifReader = GifReader;
+    } catch (e) {
+    }
+  }
+});
+
+// node_modules/jpeg-js/lib/encoder.js
+var require_encoder = __commonJS({
+  "node_modules/jpeg-js/lib/encoder.js"(exports, module) {
+    init_define_import_meta_env();
+    var btoa = btoa || function(buf) {
+      return Buffer.from(buf).toString("base64");
+    };
+    function JPEGEncoder(quality) {
+      var self = this;
+      var fround = Math.round;
+      var ffloor = Math.floor;
+      var YTable = new Array(64);
+      var UVTable = new Array(64);
+      var fdtbl_Y = new Array(64);
+      var fdtbl_UV = new Array(64);
+      var YDC_HT;
+      var UVDC_HT;
+      var YAC_HT;
+      var UVAC_HT;
+      var bitcode = new Array(65535);
+      var category = new Array(65535);
+      var outputfDCTQuant = new Array(64);
+      var DU = new Array(64);
+      var byteout = [];
+      var bytenew = 0;
+      var bytepos = 7;
+      var YDU = new Array(64);
+      var UDU = new Array(64);
+      var VDU = new Array(64);
+      var clt = new Array(256);
+      var RGB_YUV_TABLE = new Array(2048);
+      var currentQuality;
+      var ZigZag = [
+        0,
+        1,
+        5,
+        6,
+        14,
+        15,
+        27,
+        28,
+        2,
+        4,
+        7,
+        13,
+        16,
+        26,
+        29,
+        42,
+        3,
+        8,
+        12,
+        17,
+        25,
+        30,
+        41,
+        43,
+        9,
+        11,
+        18,
+        24,
+        31,
+        40,
+        44,
+        53,
+        10,
+        19,
+        23,
+        32,
+        39,
+        45,
+        52,
+        54,
+        20,
+        22,
+        33,
+        38,
+        46,
+        51,
+        55,
+        60,
+        21,
+        34,
+        37,
+        47,
+        50,
+        56,
+        59,
+        61,
+        35,
+        36,
+        48,
+        49,
+        57,
+        58,
+        62,
+        63
+      ];
+      var std_dc_luminance_nrcodes = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0];
+      var std_dc_luminance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+      var std_ac_luminance_nrcodes = [0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125];
+      var std_ac_luminance_values = [
+        1,
+        2,
+        3,
+        0,
+        4,
+        17,
+        5,
+        18,
+        33,
+        49,
+        65,
+        6,
+        19,
+        81,
+        97,
+        7,
+        34,
+        113,
+        20,
+        50,
+        129,
+        145,
+        161,
+        8,
+        35,
+        66,
+        177,
+        193,
+        21,
+        82,
+        209,
+        240,
+        36,
+        51,
+        98,
+        114,
+        130,
+        9,
+        10,
+        22,
+        23,
+        24,
+        25,
+        26,
+        37,
+        38,
+        39,
+        40,
+        41,
+        42,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        67,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        99,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        115,
+        116,
+        117,
+        118,
+        119,
+        120,
+        121,
+        122,
+        131,
+        132,
+        133,
+        134,
+        135,
+        136,
+        137,
+        138,
+        146,
+        147,
+        148,
+        149,
+        150,
+        151,
+        152,
+        153,
+        154,
+        162,
+        163,
+        164,
+        165,
+        166,
+        167,
+        168,
+        169,
+        170,
+        178,
+        179,
+        180,
+        181,
+        182,
+        183,
+        184,
+        185,
+        186,
+        194,
+        195,
+        196,
+        197,
+        198,
+        199,
+        200,
+        201,
+        202,
+        210,
+        211,
+        212,
+        213,
+        214,
+        215,
+        216,
+        217,
+        218,
+        225,
+        226,
+        227,
+        228,
+        229,
+        230,
+        231,
+        232,
+        233,
+        234,
+        241,
+        242,
+        243,
+        244,
+        245,
+        246,
+        247,
+        248,
+        249,
+        250
+      ];
+      var std_dc_chrominance_nrcodes = [0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0];
+      var std_dc_chrominance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+      var std_ac_chrominance_nrcodes = [0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119];
+      var std_ac_chrominance_values = [
+        0,
+        1,
+        2,
+        3,
+        17,
+        4,
+        5,
+        33,
+        49,
+        6,
+        18,
+        65,
+        81,
+        7,
+        97,
+        113,
+        19,
+        34,
+        50,
+        129,
+        8,
+        20,
+        66,
+        145,
+        161,
+        177,
+        193,
+        9,
+        35,
+        51,
+        82,
+        240,
+        21,
+        98,
+        114,
+        209,
+        10,
+        22,
+        36,
+        52,
+        225,
+        37,
+        241,
+        23,
+        24,
+        25,
+        26,
+        38,
+        39,
+        40,
+        41,
+        42,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        67,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        99,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        115,
+        116,
+        117,
+        118,
+        119,
+        120,
+        121,
+        122,
+        130,
+        131,
+        132,
+        133,
+        134,
+        135,
+        136,
+        137,
+        138,
+        146,
+        147,
+        148,
+        149,
+        150,
+        151,
+        152,
+        153,
+        154,
+        162,
+        163,
+        164,
+        165,
+        166,
+        167,
+        168,
+        169,
+        170,
+        178,
+        179,
+        180,
+        181,
+        182,
+        183,
+        184,
+        185,
+        186,
+        194,
+        195,
+        196,
+        197,
+        198,
+        199,
+        200,
+        201,
+        202,
+        210,
+        211,
+        212,
+        213,
+        214,
+        215,
+        216,
+        217,
+        218,
+        226,
+        227,
+        228,
+        229,
+        230,
+        231,
+        232,
+        233,
+        234,
+        242,
+        243,
+        244,
+        245,
+        246,
+        247,
+        248,
+        249,
+        250
+      ];
+      function initQuantTables(sf) {
+        var YQT = [
+          16,
+          11,
+          10,
+          16,
+          24,
+          40,
+          51,
+          61,
+          12,
+          12,
+          14,
+          19,
+          26,
+          58,
+          60,
+          55,
+          14,
+          13,
+          16,
+          24,
+          40,
+          57,
+          69,
+          56,
+          14,
+          17,
+          22,
+          29,
+          51,
+          87,
+          80,
+          62,
+          18,
+          22,
+          37,
+          56,
+          68,
+          109,
+          103,
+          77,
+          24,
+          35,
+          55,
+          64,
+          81,
+          104,
+          113,
+          92,
+          49,
+          64,
+          78,
+          87,
+          103,
+          121,
+          120,
+          101,
+          72,
+          92,
+          95,
+          98,
+          112,
+          100,
+          103,
+          99
+        ];
+        for (var i = 0; i < 64; i++) {
+          var t = ffloor((YQT[i] * sf + 50) / 100);
+          if (t < 1) {
+            t = 1;
+          } else if (t > 255) {
+            t = 255;
+          }
+          YTable[ZigZag[i]] = t;
+        }
+        var UVQT = [
+          17,
+          18,
+          24,
+          47,
+          99,
+          99,
+          99,
+          99,
+          18,
+          21,
+          26,
+          66,
+          99,
+          99,
+          99,
+          99,
+          24,
+          26,
+          56,
+          99,
+          99,
+          99,
+          99,
+          99,
+          47,
+          66,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99
+        ];
+        for (var j = 0; j < 64; j++) {
+          var u = ffloor((UVQT[j] * sf + 50) / 100);
+          if (u < 1) {
+            u = 1;
+          } else if (u > 255) {
+            u = 255;
+          }
+          UVTable[ZigZag[j]] = u;
+        }
+        var aasf = [
+          1,
+          1.387039845,
+          1.306562965,
+          1.175875602,
+          1,
+          0.785694958,
+          0.5411961,
+          0.275899379
+        ];
+        var k = 0;
+        for (var row = 0; row < 8; row++) {
+          for (var col = 0; col < 8; col++) {
+            fdtbl_Y[k] = 1 / (YTable[ZigZag[k]] * aasf[row] * aasf[col] * 8);
+            fdtbl_UV[k] = 1 / (UVTable[ZigZag[k]] * aasf[row] * aasf[col] * 8);
+            k++;
+          }
+        }
+      }
+      function computeHuffmanTbl(nrcodes, std_table) {
+        var codevalue = 0;
+        var pos_in_table = 0;
+        var HT = new Array();
+        for (var k = 1; k <= 16; k++) {
+          for (var j = 1; j <= nrcodes[k]; j++) {
+            HT[std_table[pos_in_table]] = [];
+            HT[std_table[pos_in_table]][0] = codevalue;
+            HT[std_table[pos_in_table]][1] = k;
+            pos_in_table++;
+            codevalue++;
+          }
+          codevalue *= 2;
+        }
+        return HT;
+      }
+      function initHuffmanTbl() {
+        YDC_HT = computeHuffmanTbl(std_dc_luminance_nrcodes, std_dc_luminance_values);
+        UVDC_HT = computeHuffmanTbl(std_dc_chrominance_nrcodes, std_dc_chrominance_values);
+        YAC_HT = computeHuffmanTbl(std_ac_luminance_nrcodes, std_ac_luminance_values);
+        UVAC_HT = computeHuffmanTbl(std_ac_chrominance_nrcodes, std_ac_chrominance_values);
+      }
+      function initCategoryNumber() {
+        var nrlower = 1;
+        var nrupper = 2;
+        for (var cat = 1; cat <= 15; cat++) {
+          for (var nr = nrlower; nr < nrupper; nr++) {
+            category[32767 + nr] = cat;
+            bitcode[32767 + nr] = [];
+            bitcode[32767 + nr][1] = cat;
+            bitcode[32767 + nr][0] = nr;
+          }
+          for (var nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) {
+            category[32767 + nrneg] = cat;
+            bitcode[32767 + nrneg] = [];
+            bitcode[32767 + nrneg][1] = cat;
+            bitcode[32767 + nrneg][0] = nrupper - 1 + nrneg;
+          }
+          nrlower <<= 1;
+          nrupper <<= 1;
+        }
+      }
+      function initRGBYUVTable() {
+        for (var i = 0; i < 256; i++) {
+          RGB_YUV_TABLE[i] = 19595 * i;
+          RGB_YUV_TABLE[i + 256 >> 0] = 38470 * i;
+          RGB_YUV_TABLE[i + 512 >> 0] = 7471 * i + 32768;
+          RGB_YUV_TABLE[i + 768 >> 0] = -11059 * i;
+          RGB_YUV_TABLE[i + 1024 >> 0] = -21709 * i;
+          RGB_YUV_TABLE[i + 1280 >> 0] = 32768 * i + 8421375;
+          RGB_YUV_TABLE[i + 1536 >> 0] = -27439 * i;
+          RGB_YUV_TABLE[i + 1792 >> 0] = -5329 * i;
+        }
+      }
+      function writeBits(bs) {
+        var value = bs[0];
+        var posval = bs[1] - 1;
+        while (posval >= 0) {
+          if (value & 1 << posval) {
+            bytenew |= 1 << bytepos;
+          }
+          posval--;
+          bytepos--;
+          if (bytepos < 0) {
+            if (bytenew == 255) {
+              writeByte(255);
+              writeByte(0);
+            } else {
+              writeByte(bytenew);
+            }
+            bytepos = 7;
+            bytenew = 0;
+          }
+        }
+      }
+      function writeByte(value) {
+        byteout.push(value);
+      }
+      function writeWord(value) {
+        writeByte(value >> 8 & 255);
+        writeByte(value & 255);
+      }
+      function fDCTQuant(data, fdtbl) {
+        var d0, d1, d2, d3, d4, d5, d6, d7;
+        var dataOff = 0;
+        var i;
+        var I8 = 8;
+        var I64 = 64;
+        for (i = 0; i < I8; ++i) {
+          d0 = data[dataOff];
+          d1 = data[dataOff + 1];
+          d2 = data[dataOff + 2];
+          d3 = data[dataOff + 3];
+          d4 = data[dataOff + 4];
+          d5 = data[dataOff + 5];
+          d6 = data[dataOff + 6];
+          d7 = data[dataOff + 7];
+          var tmp0 = d0 + d7;
+          var tmp7 = d0 - d7;
+          var tmp1 = d1 + d6;
+          var tmp6 = d1 - d6;
+          var tmp2 = d2 + d5;
+          var tmp5 = d2 - d5;
+          var tmp3 = d3 + d4;
+          var tmp4 = d3 - d4;
+          var tmp10 = tmp0 + tmp3;
+          var tmp13 = tmp0 - tmp3;
+          var tmp11 = tmp1 + tmp2;
+          var tmp12 = tmp1 - tmp2;
+          data[dataOff] = tmp10 + tmp11;
+          data[dataOff + 4] = tmp10 - tmp11;
+          var z1 = (tmp12 + tmp13) * 0.707106781;
+          data[dataOff + 2] = tmp13 + z1;
+          data[dataOff + 6] = tmp13 - z1;
+          tmp10 = tmp4 + tmp5;
+          tmp11 = tmp5 + tmp6;
+          tmp12 = tmp6 + tmp7;
+          var z5 = (tmp10 - tmp12) * 0.382683433;
+          var z2 = 0.5411961 * tmp10 + z5;
+          var z4 = 1.306562965 * tmp12 + z5;
+          var z3 = tmp11 * 0.707106781;
+          var z11 = tmp7 + z3;
+          var z13 = tmp7 - z3;
+          data[dataOff + 5] = z13 + z2;
+          data[dataOff + 3] = z13 - z2;
+          data[dataOff + 1] = z11 + z4;
+          data[dataOff + 7] = z11 - z4;
+          dataOff += 8;
+        }
+        dataOff = 0;
+        for (i = 0; i < I8; ++i) {
+          d0 = data[dataOff];
+          d1 = data[dataOff + 8];
+          d2 = data[dataOff + 16];
+          d3 = data[dataOff + 24];
+          d4 = data[dataOff + 32];
+          d5 = data[dataOff + 40];
+          d6 = data[dataOff + 48];
+          d7 = data[dataOff + 56];
+          var tmp0p2 = d0 + d7;
+          var tmp7p2 = d0 - d7;
+          var tmp1p2 = d1 + d6;
+          var tmp6p2 = d1 - d6;
+          var tmp2p2 = d2 + d5;
+          var tmp5p2 = d2 - d5;
+          var tmp3p2 = d3 + d4;
+          var tmp4p2 = d3 - d4;
+          var tmp10p2 = tmp0p2 + tmp3p2;
+          var tmp13p2 = tmp0p2 - tmp3p2;
+          var tmp11p2 = tmp1p2 + tmp2p2;
+          var tmp12p2 = tmp1p2 - tmp2p2;
+          data[dataOff] = tmp10p2 + tmp11p2;
+          data[dataOff + 32] = tmp10p2 - tmp11p2;
+          var z1p2 = (tmp12p2 + tmp13p2) * 0.707106781;
+          data[dataOff + 16] = tmp13p2 + z1p2;
+          data[dataOff + 48] = tmp13p2 - z1p2;
+          tmp10p2 = tmp4p2 + tmp5p2;
+          tmp11p2 = tmp5p2 + tmp6p2;
+          tmp12p2 = tmp6p2 + tmp7p2;
+          var z5p2 = (tmp10p2 - tmp12p2) * 0.382683433;
+          var z2p2 = 0.5411961 * tmp10p2 + z5p2;
+          var z4p2 = 1.306562965 * tmp12p2 + z5p2;
+          var z3p2 = tmp11p2 * 0.707106781;
+          var z11p2 = tmp7p2 + z3p2;
+          var z13p2 = tmp7p2 - z3p2;
+          data[dataOff + 40] = z13p2 + z2p2;
+          data[dataOff + 24] = z13p2 - z2p2;
+          data[dataOff + 8] = z11p2 + z4p2;
+          data[dataOff + 56] = z11p2 - z4p2;
+          dataOff++;
+        }
+        var fDCTQuant2;
+        for (i = 0; i < I64; ++i) {
+          fDCTQuant2 = data[i] * fdtbl[i];
+          outputfDCTQuant[i] = fDCTQuant2 > 0 ? fDCTQuant2 + 0.5 | 0 : fDCTQuant2 - 0.5 | 0;
+        }
+        return outputfDCTQuant;
+      }
+      function writeAPP0() {
+        writeWord(65504);
+        writeWord(16);
+        writeByte(74);
+        writeByte(70);
+        writeByte(73);
+        writeByte(70);
+        writeByte(0);
+        writeByte(1);
+        writeByte(1);
+        writeByte(0);
+        writeWord(1);
+        writeWord(1);
+        writeByte(0);
+        writeByte(0);
+      }
+      function writeAPP1(exifBuffer) {
+        if (!exifBuffer) return;
+        writeWord(65505);
+        if (exifBuffer[0] === 69 && exifBuffer[1] === 120 && exifBuffer[2] === 105 && exifBuffer[3] === 102) {
+          writeWord(exifBuffer.length + 2);
+        } else {
+          writeWord(exifBuffer.length + 5 + 2);
+          writeByte(69);
+          writeByte(120);
+          writeByte(105);
+          writeByte(102);
+          writeByte(0);
+        }
+        for (var i = 0; i < exifBuffer.length; i++) {
+          writeByte(exifBuffer[i]);
+        }
+      }
+      function writeSOF0(width, height) {
+        writeWord(65472);
+        writeWord(17);
+        writeByte(8);
+        writeWord(height);
+        writeWord(width);
+        writeByte(3);
+        writeByte(1);
+        writeByte(17);
+        writeByte(0);
+        writeByte(2);
+        writeByte(17);
+        writeByte(1);
+        writeByte(3);
+        writeByte(17);
+        writeByte(1);
+      }
+      function writeDQT() {
+        writeWord(65499);
+        writeWord(132);
+        writeByte(0);
+        for (var i = 0; i < 64; i++) {
+          writeByte(YTable[i]);
+        }
+        writeByte(1);
+        for (var j = 0; j < 64; j++) {
+          writeByte(UVTable[j]);
+        }
+      }
+      function writeDHT() {
+        writeWord(65476);
+        writeWord(418);
+        writeByte(0);
+        for (var i = 0; i < 16; i++) {
+          writeByte(std_dc_luminance_nrcodes[i + 1]);
+        }
+        for (var j = 0; j <= 11; j++) {
+          writeByte(std_dc_luminance_values[j]);
+        }
+        writeByte(16);
+        for (var k = 0; k < 16; k++) {
+          writeByte(std_ac_luminance_nrcodes[k + 1]);
+        }
+        for (var l = 0; l <= 161; l++) {
+          writeByte(std_ac_luminance_values[l]);
+        }
+        writeByte(1);
+        for (var m = 0; m < 16; m++) {
+          writeByte(std_dc_chrominance_nrcodes[m + 1]);
+        }
+        for (var n = 0; n <= 11; n++) {
+          writeByte(std_dc_chrominance_values[n]);
+        }
+        writeByte(17);
+        for (var o = 0; o < 16; o++) {
+          writeByte(std_ac_chrominance_nrcodes[o + 1]);
+        }
+        for (var p = 0; p <= 161; p++) {
+          writeByte(std_ac_chrominance_values[p]);
+        }
+      }
+      function writeCOM(comments) {
+        if (typeof comments === "undefined" || comments.constructor !== Array) return;
+        comments.forEach((e) => {
+          if (typeof e !== "string") return;
+          writeWord(65534);
+          var l = e.length;
+          writeWord(l + 2);
+          var i;
+          for (i = 0; i < l; i++)
+            writeByte(e.charCodeAt(i));
+        });
+      }
+      function writeSOS() {
+        writeWord(65498);
+        writeWord(12);
+        writeByte(3);
+        writeByte(1);
+        writeByte(0);
+        writeByte(2);
+        writeByte(17);
+        writeByte(3);
+        writeByte(17);
+        writeByte(0);
+        writeByte(63);
+        writeByte(0);
+      }
+      function processDU(CDU, fdtbl, DC, HTDC, HTAC) {
+        var EOB = HTAC[0];
+        var M16zeroes = HTAC[240];
+        var pos;
+        var I16 = 16;
+        var I63 = 63;
+        var I64 = 64;
+        var DU_DCT = fDCTQuant(CDU, fdtbl);
+        for (var j = 0; j < I64; ++j) {
+          DU[ZigZag[j]] = DU_DCT[j];
+        }
+        var Diff = DU[0] - DC;
+        DC = DU[0];
+        if (Diff == 0) {
+          writeBits(HTDC[0]);
+        } else {
+          pos = 32767 + Diff;
+          writeBits(HTDC[category[pos]]);
+          writeBits(bitcode[pos]);
+        }
+        var end0pos = 63;
+        for (; end0pos > 0 && DU[end0pos] == 0; end0pos--) {
+        }
+        ;
+        if (end0pos == 0) {
+          writeBits(EOB);
+          return DC;
+        }
+        var i = 1;
+        var lng;
+        while (i <= end0pos) {
+          var startpos = i;
+          for (; DU[i] == 0 && i <= end0pos; ++i) {
+          }
+          var nrzeroes = i - startpos;
+          if (nrzeroes >= I16) {
+            lng = nrzeroes >> 4;
+            for (var nrmarker = 1; nrmarker <= lng; ++nrmarker)
+              writeBits(M16zeroes);
+            nrzeroes = nrzeroes & 15;
+          }
+          pos = 32767 + DU[i];
+          writeBits(HTAC[(nrzeroes << 4) + category[pos]]);
+          writeBits(bitcode[pos]);
+          i++;
+        }
+        if (end0pos != I63) {
+          writeBits(EOB);
+        }
+        return DC;
+      }
+      function initCharLookupTable() {
+        var sfcc = String.fromCharCode;
+        for (var i = 0; i < 256; i++) {
+          clt[i] = sfcc(i);
+        }
+      }
+      this.encode = function(image, quality2) {
+        var time_start = (/* @__PURE__ */ new Date()).getTime();
+        if (quality2) setQuality(quality2);
+        byteout = new Array();
+        bytenew = 0;
+        bytepos = 7;
+        writeWord(65496);
+        writeAPP0();
+        writeCOM(image.comments);
+        writeAPP1(image.exifBuffer);
+        writeDQT();
+        writeSOF0(image.width, image.height);
+        writeDHT();
+        writeSOS();
+        var DCY = 0;
+        var DCU = 0;
+        var DCV = 0;
+        bytenew = 0;
+        bytepos = 7;
+        this.encode.displayName = "_encode_";
+        var imageData = image.data;
+        var width = image.width;
+        var height = image.height;
+        var quadWidth = width * 4;
+        var tripleWidth = width * 3;
+        var x, y = 0;
+        var r, g, b;
+        var start, p, col, row, pos;
+        while (y < height) {
+          x = 0;
+          while (x < quadWidth) {
+            start = quadWidth * y + x;
+            p = start;
+            col = -1;
+            row = 0;
+            for (pos = 0; pos < 64; pos++) {
+              row = pos >> 3;
+              col = (pos & 7) * 4;
+              p = start + row * quadWidth + col;
+              if (y + row >= height) {
+                p -= quadWidth * (y + 1 + row - height);
+              }
+              if (x + col >= quadWidth) {
+                p -= x + col - quadWidth + 4;
+              }
+              r = imageData[p++];
+              g = imageData[p++];
+              b = imageData[p++];
+              YDU[pos] = (RGB_YUV_TABLE[r] + RGB_YUV_TABLE[g + 256 >> 0] + RGB_YUV_TABLE[b + 512 >> 0] >> 16) - 128;
+              UDU[pos] = (RGB_YUV_TABLE[r + 768 >> 0] + RGB_YUV_TABLE[g + 1024 >> 0] + RGB_YUV_TABLE[b + 1280 >> 0] >> 16) - 128;
+              VDU[pos] = (RGB_YUV_TABLE[r + 1280 >> 0] + RGB_YUV_TABLE[g + 1536 >> 0] + RGB_YUV_TABLE[b + 1792 >> 0] >> 16) - 128;
+            }
+            DCY = processDU(YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+            DCU = processDU(UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
+            DCV = processDU(VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
+            x += 32;
+          }
+          y += 8;
+        }
+        if (bytepos >= 0) {
+          var fillbits = [];
+          fillbits[1] = bytepos + 1;
+          fillbits[0] = (1 << bytepos + 1) - 1;
+          writeBits(fillbits);
+        }
+        writeWord(65497);
+        if (typeof module === "undefined") return new Uint8Array(byteout);
+        return Buffer.from(byteout);
+        var jpegDataUri = "data:image/jpeg;base64," + btoa(byteout.join(""));
+        byteout = [];
+        var duration = (/* @__PURE__ */ new Date()).getTime() - time_start;
+        return jpegDataUri;
+      };
+      function setQuality(quality2) {
+        if (quality2 <= 0) {
+          quality2 = 1;
+        }
+        if (quality2 > 100) {
+          quality2 = 100;
+        }
+        if (currentQuality == quality2) return;
+        var sf = 0;
+        if (quality2 < 50) {
+          sf = Math.floor(5e3 / quality2);
+        } else {
+          sf = Math.floor(200 - quality2 * 2);
+        }
+        initQuantTables(sf);
+        currentQuality = quality2;
+      }
+      function init() {
+        var time_start = (/* @__PURE__ */ new Date()).getTime();
+        if (!quality) quality = 50;
+        initCharLookupTable();
+        initHuffmanTbl();
+        initCategoryNumber();
+        initRGBYUVTable();
+        setQuality(quality);
+        var duration = (/* @__PURE__ */ new Date()).getTime() - time_start;
+      }
+      init();
+    }
+    if (typeof module !== "undefined") {
+      module.exports = encode;
+    } else if (typeof window !== "undefined") {
+      window["jpeg-js"] = window["jpeg-js"] || {};
+      window["jpeg-js"].encode = encode;
+    }
+    function encode(imgData, qu) {
+      if (typeof qu === "undefined") qu = 50;
+      var encoder = new JPEGEncoder(qu);
+      var data = encoder.encode(imgData, qu);
+      return {
+        data,
+        width: imgData.width,
+        height: imgData.height
+      };
+    }
+  }
+});
+
+// node_modules/jpeg-js/lib/decoder.js
+var require_decoder = __commonJS({
+  "node_modules/jpeg-js/lib/decoder.js"(exports, module) {
+    init_define_import_meta_env();
+    var JpegImage = (function jpegImage() {
+      "use strict";
+      var dctZigZag = new Int32Array([
+        0,
+        1,
+        8,
+        16,
+        9,
+        2,
+        3,
+        10,
+        17,
+        24,
+        32,
+        25,
+        18,
+        11,
+        4,
+        5,
+        12,
+        19,
+        26,
+        33,
+        40,
+        48,
+        41,
+        34,
+        27,
+        20,
+        13,
+        6,
+        7,
+        14,
+        21,
+        28,
+        35,
+        42,
+        49,
+        56,
+        57,
+        50,
+        43,
+        36,
+        29,
+        22,
+        15,
+        23,
+        30,
+        37,
+        44,
+        51,
+        58,
+        59,
+        52,
+        45,
+        38,
+        31,
+        39,
+        46,
+        53,
+        60,
+        61,
+        54,
+        47,
+        55,
+        62,
+        63
+      ]);
+      var dctCos1 = 4017;
+      var dctSin1 = 799;
+      var dctCos3 = 3406;
+      var dctSin3 = 2276;
+      var dctCos6 = 1567;
+      var dctSin6 = 3784;
+      var dctSqrt2 = 5793;
+      var dctSqrt1d2 = 2896;
+      function constructor() {
+      }
+      function buildHuffmanTable(codeLengths, values) {
+        var k = 0, code = [], i, j, length = 16;
+        while (length > 0 && !codeLengths[length - 1])
+          length--;
+        code.push({ children: [], index: 0 });
+        var p = code[0], q;
+        for (i = 0; i < length; i++) {
+          for (j = 0; j < codeLengths[i]; j++) {
+            p = code.pop();
+            p.children[p.index] = values[k];
+            while (p.index > 0) {
+              if (code.length === 0)
+                throw new Error("Could not recreate Huffman Table");
+              p = code.pop();
+            }
+            p.index++;
+            code.push(p);
+            while (code.length <= i) {
+              code.push(q = { children: [], index: 0 });
+              p.children[p.index] = q.children;
+              p = q;
+            }
+            k++;
+          }
+          if (i + 1 < length) {
+            code.push(q = { children: [], index: 0 });
+            p.children[p.index] = q.children;
+            p = q;
+          }
+        }
+        return code[0].children;
+      }
+      function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive, opts) {
+        var precision = frame.precision;
+        var samplesPerLine = frame.samplesPerLine;
+        var scanLines = frame.scanLines;
+        var mcusPerLine = frame.mcusPerLine;
+        var progressive = frame.progressive;
+        var maxH = frame.maxH, maxV = frame.maxV;
+        var startOffset = offset, bitsData = 0, bitsCount = 0;
+        function readBit() {
+          if (bitsCount > 0) {
+            bitsCount--;
+            return bitsData >> bitsCount & 1;
+          }
+          bitsData = data[offset++];
+          if (bitsData == 255) {
+            var nextByte = data[offset++];
+            if (nextByte) {
+              throw new Error("unexpected marker: " + (bitsData << 8 | nextByte).toString(16));
+            }
+          }
+          bitsCount = 7;
+          return bitsData >>> 7;
+        }
+        function decodeHuffman(tree) {
+          var node = tree, bit;
+          while ((bit = readBit()) !== null) {
+            node = node[bit];
+            if (typeof node === "number")
+              return node;
+            if (typeof node !== "object")
+              throw new Error("invalid huffman sequence");
+          }
+          return null;
+        }
+        function receive(length) {
+          var n2 = 0;
+          while (length > 0) {
+            var bit = readBit();
+            if (bit === null) return;
+            n2 = n2 << 1 | bit;
+            length--;
+          }
+          return n2;
+        }
+        function receiveAndExtend(length) {
+          var n2 = receive(length);
+          if (n2 >= 1 << length - 1)
+            return n2;
+          return n2 + (-1 << length) + 1;
+        }
+        function decodeBaseline(component2, zz) {
+          var t = decodeHuffman(component2.huffmanTableDC);
+          var diff = t === 0 ? 0 : receiveAndExtend(t);
+          zz[0] = component2.pred += diff;
+          var k2 = 1;
+          while (k2 < 64) {
+            var rs = decodeHuffman(component2.huffmanTableAC);
+            var s = rs & 15, r = rs >> 4;
+            if (s === 0) {
+              if (r < 15)
+                break;
+              k2 += 16;
+              continue;
+            }
+            k2 += r;
+            var z = dctZigZag[k2];
+            zz[z] = receiveAndExtend(s);
+            k2++;
+          }
+        }
+        function decodeDCFirst(component2, zz) {
+          var t = decodeHuffman(component2.huffmanTableDC);
+          var diff = t === 0 ? 0 : receiveAndExtend(t) << successive;
+          zz[0] = component2.pred += diff;
+        }
+        function decodeDCSuccessive(component2, zz) {
+          zz[0] |= readBit() << successive;
+        }
+        var eobrun = 0;
+        function decodeACFirst(component2, zz) {
+          if (eobrun > 0) {
+            eobrun--;
+            return;
+          }
+          var k2 = spectralStart, e = spectralEnd;
+          while (k2 <= e) {
+            var rs = decodeHuffman(component2.huffmanTableAC);
+            var s = rs & 15, r = rs >> 4;
+            if (s === 0) {
+              if (r < 15) {
+                eobrun = receive(r) + (1 << r) - 1;
+                break;
+              }
+              k2 += 16;
+              continue;
+            }
+            k2 += r;
+            var z = dctZigZag[k2];
+            zz[z] = receiveAndExtend(s) * (1 << successive);
+            k2++;
+          }
+        }
+        var successiveACState = 0, successiveACNextValue;
+        function decodeACSuccessive(component2, zz) {
+          var k2 = spectralStart, e = spectralEnd, r = 0;
+          while (k2 <= e) {
+            var z = dctZigZag[k2];
+            var direction = zz[z] < 0 ? -1 : 1;
+            switch (successiveACState) {
+              case 0:
+                var rs = decodeHuffman(component2.huffmanTableAC);
+                var s = rs & 15, r = rs >> 4;
+                if (s === 0) {
+                  if (r < 15) {
+                    eobrun = receive(r) + (1 << r);
+                    successiveACState = 4;
+                  } else {
+                    r = 16;
+                    successiveACState = 1;
+                  }
+                } else {
+                  if (s !== 1)
+                    throw new Error("invalid ACn encoding");
+                  successiveACNextValue = receiveAndExtend(s);
+                  successiveACState = r ? 2 : 3;
+                }
+                continue;
+              case 1:
+              // skipping r zero items
+              case 2:
+                if (zz[z])
+                  zz[z] += (readBit() << successive) * direction;
+                else {
+                  r--;
+                  if (r === 0)
+                    successiveACState = successiveACState == 2 ? 3 : 0;
+                }
+                break;
+              case 3:
+                if (zz[z])
+                  zz[z] += (readBit() << successive) * direction;
+                else {
+                  zz[z] = successiveACNextValue << successive;
+                  successiveACState = 0;
+                }
+                break;
+              case 4:
+                if (zz[z])
+                  zz[z] += (readBit() << successive) * direction;
+                break;
+            }
+            k2++;
+          }
+          if (successiveACState === 4) {
+            eobrun--;
+            if (eobrun === 0)
+              successiveACState = 0;
+          }
+        }
+        function decodeMcu(component2, decode2, mcu2, row, col) {
+          var mcuRow = mcu2 / mcusPerLine | 0;
+          var mcuCol = mcu2 % mcusPerLine;
+          var blockRow = mcuRow * component2.v + row;
+          var blockCol = mcuCol * component2.h + col;
+          if (component2.blocks[blockRow] === void 0 && opts.tolerantDecoding)
+            return;
+          decode2(component2, component2.blocks[blockRow][blockCol]);
+        }
+        function decodeBlock(component2, decode2, mcu2) {
+          var blockRow = mcu2 / component2.blocksPerLine | 0;
+          var blockCol = mcu2 % component2.blocksPerLine;
+          if (component2.blocks[blockRow] === void 0 && opts.tolerantDecoding)
+            return;
+          decode2(component2, component2.blocks[blockRow][blockCol]);
+        }
+        var componentsLength = components.length;
+        var component, i, j, k, n;
+        var decodeFn;
+        if (progressive) {
+          if (spectralStart === 0)
+            decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
+          else
+            decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
+        } else {
+          decodeFn = decodeBaseline;
+        }
+        var mcu = 0, marker;
+        var mcuExpected;
+        if (componentsLength == 1) {
+          mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
+        } else {
+          mcuExpected = mcusPerLine * frame.mcusPerColumn;
+        }
+        if (!resetInterval) resetInterval = mcuExpected;
+        var h, v;
+        while (mcu < mcuExpected) {
+          for (i = 0; i < componentsLength; i++)
+            components[i].pred = 0;
+          eobrun = 0;
+          if (componentsLength == 1) {
+            component = components[0];
+            for (n = 0; n < resetInterval; n++) {
+              decodeBlock(component, decodeFn, mcu);
+              mcu++;
+            }
+          } else {
+            for (n = 0; n < resetInterval; n++) {
+              for (i = 0; i < componentsLength; i++) {
+                component = components[i];
+                h = component.h;
+                v = component.v;
+                for (j = 0; j < v; j++) {
+                  for (k = 0; k < h; k++) {
+                    decodeMcu(component, decodeFn, mcu, j, k);
+                  }
+                }
+              }
+              mcu++;
+              if (mcu === mcuExpected) break;
+            }
+          }
+          if (mcu === mcuExpected) {
+            do {
+              if (data[offset] === 255) {
+                if (data[offset + 1] !== 0) {
+                  break;
+                }
+              }
+              offset += 1;
+            } while (offset < data.length - 2);
+          }
+          bitsCount = 0;
+          marker = data[offset] << 8 | data[offset + 1];
+          if (marker < 65280) {
+            throw new Error("marker was not found");
+          }
+          if (marker >= 65488 && marker <= 65495) {
+            offset += 2;
+          } else
+            break;
+        }
+        return offset - startOffset;
+      }
+      function buildComponentData(frame, component) {
+        var lines2 = [];
+        var blocksPerLine = component.blocksPerLine;
+        var blocksPerColumn = component.blocksPerColumn;
+        var samplesPerLine = blocksPerLine << 3;
+        var R = new Int32Array(64), r = new Uint8Array(64);
+        function quantizeAndInverse(zz, dataOut, dataIn) {
+          var qt = component.quantizationTable;
+          var v0, v1, v2, v3, v4, v5, v6, v7, t;
+          var p = dataIn;
+          var i2;
+          for (i2 = 0; i2 < 64; i2++)
+            p[i2] = zz[i2] * qt[i2];
+          for (i2 = 0; i2 < 8; ++i2) {
+            var row = 8 * i2;
+            if (p[1 + row] == 0 && p[2 + row] == 0 && p[3 + row] == 0 && p[4 + row] == 0 && p[5 + row] == 0 && p[6 + row] == 0 && p[7 + row] == 0) {
+              t = dctSqrt2 * p[0 + row] + 512 >> 10;
+              p[0 + row] = t;
+              p[1 + row] = t;
+              p[2 + row] = t;
+              p[3 + row] = t;
+              p[4 + row] = t;
+              p[5 + row] = t;
+              p[6 + row] = t;
+              p[7 + row] = t;
+              continue;
+            }
+            v0 = dctSqrt2 * p[0 + row] + 128 >> 8;
+            v1 = dctSqrt2 * p[4 + row] + 128 >> 8;
+            v2 = p[2 + row];
+            v3 = p[6 + row];
+            v4 = dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128 >> 8;
+            v7 = dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128 >> 8;
+            v5 = p[3 + row] << 4;
+            v6 = p[5 + row] << 4;
+            t = v0 - v1 + 1 >> 1;
+            v0 = v0 + v1 + 1 >> 1;
+            v1 = t;
+            t = v2 * dctSin6 + v3 * dctCos6 + 128 >> 8;
+            v2 = v2 * dctCos6 - v3 * dctSin6 + 128 >> 8;
+            v3 = t;
+            t = v4 - v6 + 1 >> 1;
+            v4 = v4 + v6 + 1 >> 1;
+            v6 = t;
+            t = v7 + v5 + 1 >> 1;
+            v5 = v7 - v5 + 1 >> 1;
+            v7 = t;
+            t = v0 - v3 + 1 >> 1;
+            v0 = v0 + v3 + 1 >> 1;
+            v3 = t;
+            t = v1 - v2 + 1 >> 1;
+            v1 = v1 + v2 + 1 >> 1;
+            v2 = t;
+            t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
+            v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
+            v7 = t;
+            t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
+            v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
+            v6 = t;
+            p[0 + row] = v0 + v7;
+            p[7 + row] = v0 - v7;
+            p[1 + row] = v1 + v6;
+            p[6 + row] = v1 - v6;
+            p[2 + row] = v2 + v5;
+            p[5 + row] = v2 - v5;
+            p[3 + row] = v3 + v4;
+            p[4 + row] = v3 - v4;
+          }
+          for (i2 = 0; i2 < 8; ++i2) {
+            var col = i2;
+            if (p[1 * 8 + col] == 0 && p[2 * 8 + col] == 0 && p[3 * 8 + col] == 0 && p[4 * 8 + col] == 0 && p[5 * 8 + col] == 0 && p[6 * 8 + col] == 0 && p[7 * 8 + col] == 0) {
+              t = dctSqrt2 * dataIn[i2 + 0] + 8192 >> 14;
+              p[0 * 8 + col] = t;
+              p[1 * 8 + col] = t;
+              p[2 * 8 + col] = t;
+              p[3 * 8 + col] = t;
+              p[4 * 8 + col] = t;
+              p[5 * 8 + col] = t;
+              p[6 * 8 + col] = t;
+              p[7 * 8 + col] = t;
+              continue;
+            }
+            v0 = dctSqrt2 * p[0 * 8 + col] + 2048 >> 12;
+            v1 = dctSqrt2 * p[4 * 8 + col] + 2048 >> 12;
+            v2 = p[2 * 8 + col];
+            v3 = p[6 * 8 + col];
+            v4 = dctSqrt1d2 * (p[1 * 8 + col] - p[7 * 8 + col]) + 2048 >> 12;
+            v7 = dctSqrt1d2 * (p[1 * 8 + col] + p[7 * 8 + col]) + 2048 >> 12;
+            v5 = p[3 * 8 + col];
+            v6 = p[5 * 8 + col];
+            t = v0 - v1 + 1 >> 1;
+            v0 = v0 + v1 + 1 >> 1;
+            v1 = t;
+            t = v2 * dctSin6 + v3 * dctCos6 + 2048 >> 12;
+            v2 = v2 * dctCos6 - v3 * dctSin6 + 2048 >> 12;
+            v3 = t;
+            t = v4 - v6 + 1 >> 1;
+            v4 = v4 + v6 + 1 >> 1;
+            v6 = t;
+            t = v7 + v5 + 1 >> 1;
+            v5 = v7 - v5 + 1 >> 1;
+            v7 = t;
+            t = v0 - v3 + 1 >> 1;
+            v0 = v0 + v3 + 1 >> 1;
+            v3 = t;
+            t = v1 - v2 + 1 >> 1;
+            v1 = v1 + v2 + 1 >> 1;
+            v2 = t;
+            t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
+            v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
+            v7 = t;
+            t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
+            v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
+            v6 = t;
+            p[0 * 8 + col] = v0 + v7;
+            p[7 * 8 + col] = v0 - v7;
+            p[1 * 8 + col] = v1 + v6;
+            p[6 * 8 + col] = v1 - v6;
+            p[2 * 8 + col] = v2 + v5;
+            p[5 * 8 + col] = v2 - v5;
+            p[3 * 8 + col] = v3 + v4;
+            p[4 * 8 + col] = v3 - v4;
+          }
+          for (i2 = 0; i2 < 64; ++i2) {
+            var sample2 = 128 + (p[i2] + 8 >> 4);
+            dataOut[i2] = sample2 < 0 ? 0 : sample2 > 255 ? 255 : sample2;
+          }
+        }
+        requestMemoryAllocation(samplesPerLine * blocksPerColumn * 8);
+        var i, j;
+        for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
+          var scanLine = blockRow << 3;
+          for (i = 0; i < 8; i++)
+            lines2.push(new Uint8Array(samplesPerLine));
+          for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
+            quantizeAndInverse(component.blocks[blockRow][blockCol], r, R);
+            var offset = 0, sample = blockCol << 3;
+            for (j = 0; j < 8; j++) {
+              var line = lines2[scanLine + j];
+              for (i = 0; i < 8; i++)
+                line[sample + i] = r[offset++];
+            }
+          }
+        }
+        return lines2;
+      }
+      function clampTo8bit(a) {
+        return a < 0 ? 0 : a > 255 ? 255 : a;
+      }
+      constructor.prototype = {
+        load: function load3(path26) {
+          var xhr = new XMLHttpRequest();
+          xhr.open("GET", path26, true);
+          xhr.responseType = "arraybuffer";
+          xhr.onload = (function() {
+            var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer);
+            this.parse(data);
+            if (this.onload)
+              this.onload();
+          }).bind(this);
+          xhr.send(null);
+        },
+        parse: function parse2(data) {
+          var maxResolutionInPixels = this.opts.maxResolutionInMP * 1e3 * 1e3;
+          var offset = 0, length = data.length;
+          function readUint16() {
+            var value = data[offset] << 8 | data[offset + 1];
+            offset += 2;
+            return value;
+          }
+          function readDataBlock() {
+            var length2 = readUint16();
+            var array = data.subarray(offset, offset + length2 - 2);
+            offset += array.length;
+            return array;
+          }
+          function prepareComponents(frame2) {
+            var maxH2 = 1, maxV2 = 1;
+            var component2, componentId2;
+            for (componentId2 in frame2.components) {
+              if (frame2.components.hasOwnProperty(componentId2)) {
+                component2 = frame2.components[componentId2];
+                if (maxH2 < component2.h) maxH2 = component2.h;
+                if (maxV2 < component2.v) maxV2 = component2.v;
+              }
+            }
+            var mcusPerLine = Math.ceil(frame2.samplesPerLine / 8 / maxH2);
+            var mcusPerColumn = Math.ceil(frame2.scanLines / 8 / maxV2);
+            for (componentId2 in frame2.components) {
+              if (frame2.components.hasOwnProperty(componentId2)) {
+                component2 = frame2.components[componentId2];
+                var blocksPerLine = Math.ceil(Math.ceil(frame2.samplesPerLine / 8) * component2.h / maxH2);
+                var blocksPerColumn = Math.ceil(Math.ceil(frame2.scanLines / 8) * component2.v / maxV2);
+                var blocksPerLineForMcu = mcusPerLine * component2.h;
+                var blocksPerColumnForMcu = mcusPerColumn * component2.v;
+                var blocksToAllocate = blocksPerColumnForMcu * blocksPerLineForMcu;
+                var blocks = [];
+                requestMemoryAllocation(blocksToAllocate * 256);
+                for (var i2 = 0; i2 < blocksPerColumnForMcu; i2++) {
+                  var row = [];
+                  for (var j2 = 0; j2 < blocksPerLineForMcu; j2++)
+                    row.push(new Int32Array(64));
+                  blocks.push(row);
+                }
+                component2.blocksPerLine = blocksPerLine;
+                component2.blocksPerColumn = blocksPerColumn;
+                component2.blocks = blocks;
+              }
+            }
+            frame2.maxH = maxH2;
+            frame2.maxV = maxV2;
+            frame2.mcusPerLine = mcusPerLine;
+            frame2.mcusPerColumn = mcusPerColumn;
+          }
+          var jfif = null;
+          var adobe = null;
+          var pixels = null;
+          var frame, resetInterval;
+          var quantizationTables = [], frames = [];
+          var huffmanTablesAC = [], huffmanTablesDC = [];
+          var fileMarker = readUint16();
+          var malformedDataOffset = -1;
+          this.comments = [];
+          if (fileMarker != 65496) {
+            throw new Error("SOI not found");
+          }
+          fileMarker = readUint16();
+          while (fileMarker != 65497) {
+            var i, j, l;
+            switch (fileMarker) {
+              case 65280:
+                break;
+              case 65504:
+              // APP0 (Application Specific)
+              case 65505:
+              // APP1
+              case 65506:
+              // APP2
+              case 65507:
+              // APP3
+              case 65508:
+              // APP4
+              case 65509:
+              // APP5
+              case 65510:
+              // APP6
+              case 65511:
+              // APP7
+              case 65512:
+              // APP8
+              case 65513:
+              // APP9
+              case 65514:
+              // APP10
+              case 65515:
+              // APP11
+              case 65516:
+              // APP12
+              case 65517:
+              // APP13
+              case 65518:
+              // APP14
+              case 65519:
+              // APP15
+              case 65534:
+                var appData = readDataBlock();
+                if (fileMarker === 65534) {
+                  var comment = String.fromCharCode.apply(null, appData);
+                  this.comments.push(comment);
+                }
+                if (fileMarker === 65504) {
+                  if (appData[0] === 74 && appData[1] === 70 && appData[2] === 73 && appData[3] === 70 && appData[4] === 0) {
+                    jfif = {
+                      version: { major: appData[5], minor: appData[6] },
+                      densityUnits: appData[7],
+                      xDensity: appData[8] << 8 | appData[9],
+                      yDensity: appData[10] << 8 | appData[11],
+                      thumbWidth: appData[12],
+                      thumbHeight: appData[13],
+                      thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13])
+                    };
+                  }
+                }
+                if (fileMarker === 65505) {
+                  if (appData[0] === 69 && appData[1] === 120 && appData[2] === 105 && appData[3] === 102 && appData[4] === 0) {
+                    this.exifBuffer = appData.subarray(5, appData.length);
+                  }
+                }
+                if (fileMarker === 65518) {
+                  if (appData[0] === 65 && appData[1] === 100 && appData[2] === 111 && appData[3] === 98 && appData[4] === 101 && appData[5] === 0) {
+                    adobe = {
+                      version: appData[6],
+                      flags0: appData[7] << 8 | appData[8],
+                      flags1: appData[9] << 8 | appData[10],
+                      transformCode: appData[11]
+                    };
+                  }
+                }
+                break;
+              case 65499:
+                var quantizationTablesLength = readUint16();
+                var quantizationTablesEnd = quantizationTablesLength + offset - 2;
+                while (offset < quantizationTablesEnd) {
+                  var quantizationTableSpec = data[offset++];
+                  requestMemoryAllocation(64 * 4);
+                  var tableData = new Int32Array(64);
+                  if (quantizationTableSpec >> 4 === 0) {
+                    for (j = 0; j < 64; j++) {
+                      var z = dctZigZag[j];
+                      tableData[z] = data[offset++];
+                    }
+                  } else if (quantizationTableSpec >> 4 === 1) {
+                    for (j = 0; j < 64; j++) {
+                      var z = dctZigZag[j];
+                      tableData[z] = readUint16();
+                    }
+                  } else
+                    throw new Error("DQT: invalid table spec");
+                  quantizationTables[quantizationTableSpec & 15] = tableData;
+                }
+                break;
+              case 65472:
+              // SOF0 (Start of Frame, Baseline DCT)
+              case 65473:
+              // SOF1 (Start of Frame, Extended DCT)
+              case 65474:
+                readUint16();
+                frame = {};
+                frame.extended = fileMarker === 65473;
+                frame.progressive = fileMarker === 65474;
+                frame.precision = data[offset++];
+                frame.scanLines = readUint16();
+                frame.samplesPerLine = readUint16();
+                frame.components = {};
+                frame.componentsOrder = [];
+                var pixelsInFrame = frame.scanLines * frame.samplesPerLine;
+                if (pixelsInFrame > maxResolutionInPixels) {
+                  var exceededAmount = Math.ceil((pixelsInFrame - maxResolutionInPixels) / 1e6);
+                  throw new Error(`maxResolutionInMP limit exceeded by ${exceededAmount}MP`);
+                }
+                var componentsCount = data[offset++], componentId;
+                var maxH = 0, maxV = 0;
+                for (i = 0; i < componentsCount; i++) {
+                  componentId = data[offset];
+                  var h = data[offset + 1] >> 4;
+                  var v = data[offset + 1] & 15;
+                  var qId = data[offset + 2];
+                  if (h <= 0 || v <= 0) {
+                    throw new Error("Invalid sampling factor, expected values above 0");
+                  }
+                  frame.componentsOrder.push(componentId);
+                  frame.components[componentId] = {
+                    h,
+                    v,
+                    quantizationIdx: qId
+                  };
+                  offset += 3;
+                }
+                prepareComponents(frame);
+                frames.push(frame);
+                break;
+              case 65476:
+                var huffmanLength = readUint16();
+                for (i = 2; i < huffmanLength; ) {
+                  var huffmanTableSpec = data[offset++];
+                  var codeLengths = new Uint8Array(16);
+                  var codeLengthSum = 0;
+                  for (j = 0; j < 16; j++, offset++) {
+                    codeLengthSum += codeLengths[j] = data[offset];
+                  }
+                  requestMemoryAllocation(16 + codeLengthSum);
+                  var huffmanValues = new Uint8Array(codeLengthSum);
+                  for (j = 0; j < codeLengthSum; j++, offset++)
+                    huffmanValues[j] = data[offset];
+                  i += 17 + codeLengthSum;
+                  (huffmanTableSpec >> 4 === 0 ? huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = buildHuffmanTable(codeLengths, huffmanValues);
+                }
+                break;
+              case 65501:
+                readUint16();
+                resetInterval = readUint16();
+                break;
+              case 65500:
+                readUint16();
+                readUint16();
+                break;
+              case 65498:
+                var scanLength = readUint16();
+                var selectorsCount = data[offset++];
+                var components = [], component;
+                for (i = 0; i < selectorsCount; i++) {
+                  component = frame.components[data[offset++]];
+                  var tableSpec = data[offset++];
+                  component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
+                  component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
+                  components.push(component);
+                }
+                var spectralStart = data[offset++];
+                var spectralEnd = data[offset++];
+                var successiveApproximation = data[offset++];
+                var processed = decodeScan(
+                  data,
+                  offset,
+                  frame,
+                  components,
+                  resetInterval,
+                  spectralStart,
+                  spectralEnd,
+                  successiveApproximation >> 4,
+                  successiveApproximation & 15,
+                  this.opts
+                );
+                offset += processed;
+                break;
+              case 65535:
+                if (data[offset] !== 255) {
+                  offset--;
+                }
+                break;
+              default:
+                if (data[offset - 3] == 255 && data[offset - 2] >= 192 && data[offset - 2] <= 254) {
+                  offset -= 3;
+                  break;
+                } else if (fileMarker === 224 || fileMarker == 225) {
+                  if (malformedDataOffset !== -1) {
+                    throw new Error(`first unknown JPEG marker at offset ${malformedDataOffset.toString(16)}, second unknown JPEG marker ${fileMarker.toString(16)} at offset ${(offset - 1).toString(16)}`);
+                  }
+                  malformedDataOffset = offset - 1;
+                  const nextOffset = readUint16();
+                  if (data[offset + nextOffset - 2] === 255) {
+                    offset += nextOffset - 2;
+                    break;
+                  }
+                }
+                throw new Error("unknown JPEG marker " + fileMarker.toString(16));
+            }
+            fileMarker = readUint16();
+          }
+          if (frames.length != 1)
+            throw new Error("only single frame JPEGs supported");
+          for (var i = 0; i < frames.length; i++) {
+            var cp = frames[i].components;
+            for (var j in cp) {
+              cp[j].quantizationTable = quantizationTables[cp[j].quantizationIdx];
+              delete cp[j].quantizationIdx;
+            }
+          }
+          this.width = frame.samplesPerLine;
+          this.height = frame.scanLines;
+          this.jfif = jfif;
+          this.adobe = adobe;
+          this.components = [];
+          for (var i = 0; i < frame.componentsOrder.length; i++) {
+            var component = frame.components[frame.componentsOrder[i]];
+            this.components.push({
+              lines: buildComponentData(frame, component),
+              scaleX: component.h / frame.maxH,
+              scaleY: component.v / frame.maxV
+            });
+          }
+        },
+        getData: function getData(width, height) {
+          var scaleX = this.width / width, scaleY = this.height / height;
+          var component1, component2, component3, component4;
+          var component1Line, component2Line, component3Line, component4Line;
+          var x, y;
+          var offset = 0;
+          var Y, Cb, Cr, K, C, M, Ye, R, G, B;
+          var colorTransform;
+          var dataLength = width * height * this.components.length;
+          requestMemoryAllocation(dataLength);
+          var data = new Uint8Array(dataLength);
+          switch (this.components.length) {
+            case 1:
+              component1 = this.components[0];
+              for (y = 0; y < height; y++) {
+                component1Line = component1.lines[0 | y * component1.scaleY * scaleY];
+                for (x = 0; x < width; x++) {
+                  Y = component1Line[0 | x * component1.scaleX * scaleX];
+                  data[offset++] = Y;
+                }
+              }
+              break;
+            case 2:
+              component1 = this.components[0];
+              component2 = this.components[1];
+              for (y = 0; y < height; y++) {
+                component1Line = component1.lines[0 | y * component1.scaleY * scaleY];
+                component2Line = component2.lines[0 | y * component2.scaleY * scaleY];
+                for (x = 0; x < width; x++) {
+                  Y = component1Line[0 | x * component1.scaleX * scaleX];
+                  data[offset++] = Y;
+                  Y = component2Line[0 | x * component2.scaleX * scaleX];
+                  data[offset++] = Y;
+                }
+              }
+              break;
+            case 3:
+              colorTransform = true;
+              if (this.adobe && this.adobe.transformCode)
+                colorTransform = true;
+              else if (typeof this.opts.colorTransform !== "undefined")
+                colorTransform = !!this.opts.colorTransform;
+              component1 = this.components[0];
+              component2 = this.components[1];
+              component3 = this.components[2];
+              for (y = 0; y < height; y++) {
+                component1Line = component1.lines[0 | y * component1.scaleY * scaleY];
+                component2Line = component2.lines[0 | y * component2.scaleY * scaleY];
+                component3Line = component3.lines[0 | y * component3.scaleY * scaleY];
+                for (x = 0; x < width; x++) {
+                  if (!colorTransform) {
+                    R = component1Line[0 | x * component1.scaleX * scaleX];
+                    G = component2Line[0 | x * component2.scaleX * scaleX];
+                    B = component3Line[0 | x * component3.scaleX * scaleX];
+                  } else {
+                    Y = component1Line[0 | x * component1.scaleX * scaleX];
+                    Cb = component2Line[0 | x * component2.scaleX * scaleX];
+                    Cr = component3Line[0 | x * component3.scaleX * scaleX];
+                    R = clampTo8bit(Y + 1.402 * (Cr - 128));
+                    G = clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));
+                    B = clampTo8bit(Y + 1.772 * (Cb - 128));
+                  }
+                  data[offset++] = R;
+                  data[offset++] = G;
+                  data[offset++] = B;
+                }
+              }
+              break;
+            case 4:
+              if (!this.adobe)
+                throw new Error("Unsupported color mode (4 components)");
+              colorTransform = false;
+              if (this.adobe && this.adobe.transformCode)
+                colorTransform = true;
+              else if (typeof this.opts.colorTransform !== "undefined")
+                colorTransform = !!this.opts.colorTransform;
+              component1 = this.components[0];
+              component2 = this.components[1];
+              component3 = this.components[2];
+              component4 = this.components[3];
+              for (y = 0; y < height; y++) {
+                component1Line = component1.lines[0 | y * component1.scaleY * scaleY];
+                component2Line = component2.lines[0 | y * component2.scaleY * scaleY];
+                component3Line = component3.lines[0 | y * component3.scaleY * scaleY];
+                component4Line = component4.lines[0 | y * component4.scaleY * scaleY];
+                for (x = 0; x < width; x++) {
+                  if (!colorTransform) {
+                    C = component1Line[0 | x * component1.scaleX * scaleX];
+                    M = component2Line[0 | x * component2.scaleX * scaleX];
+                    Ye = component3Line[0 | x * component3.scaleX * scaleX];
+                    K = component4Line[0 | x * component4.scaleX * scaleX];
+                  } else {
+                    Y = component1Line[0 | x * component1.scaleX * scaleX];
+                    Cb = component2Line[0 | x * component2.scaleX * scaleX];
+                    Cr = component3Line[0 | x * component3.scaleX * scaleX];
+                    K = component4Line[0 | x * component4.scaleX * scaleX];
+                    C = 255 - clampTo8bit(Y + 1.402 * (Cr - 128));
+                    M = 255 - clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));
+                    Ye = 255 - clampTo8bit(Y + 1.772 * (Cb - 128));
+                  }
+                  data[offset++] = 255 - C;
+                  data[offset++] = 255 - M;
+                  data[offset++] = 255 - Ye;
+                  data[offset++] = 255 - K;
+                }
+              }
+              break;
+            default:
+              throw new Error("Unsupported color mode");
+          }
+          return data;
+        },
+        copyToImageData: function copyToImageData(imageData, formatAsRGBA) {
+          var width = imageData.width, height = imageData.height;
+          var imageDataArray = imageData.data;
+          var data = this.getData(width, height);
+          var i = 0, j = 0, x, y;
+          var Y, K, C, M, R, G, B;
+          switch (this.components.length) {
+            case 1:
+              for (y = 0; y < height; y++) {
+                for (x = 0; x < width; x++) {
+                  Y = data[i++];
+                  imageDataArray[j++] = Y;
+                  imageDataArray[j++] = Y;
+                  imageDataArray[j++] = Y;
+                  if (formatAsRGBA) {
+                    imageDataArray[j++] = 255;
+                  }
+                }
+              }
+              break;
+            case 3:
+              for (y = 0; y < height; y++) {
+                for (x = 0; x < width; x++) {
+                  R = data[i++];
+                  G = data[i++];
+                  B = data[i++];
+                  imageDataArray[j++] = R;
+                  imageDataArray[j++] = G;
+                  imageDataArray[j++] = B;
+                  if (formatAsRGBA) {
+                    imageDataArray[j++] = 255;
+                  }
+                }
+              }
+              break;
+            case 4:
+              for (y = 0; y < height; y++) {
+                for (x = 0; x < width; x++) {
+                  C = data[i++];
+                  M = data[i++];
+                  Y = data[i++];
+                  K = data[i++];
+                  R = 255 - clampTo8bit(C * (1 - K / 255) + K);
+                  G = 255 - clampTo8bit(M * (1 - K / 255) + K);
+                  B = 255 - clampTo8bit(Y * (1 - K / 255) + K);
+                  imageDataArray[j++] = R;
+                  imageDataArray[j++] = G;
+                  imageDataArray[j++] = B;
+                  if (formatAsRGBA) {
+                    imageDataArray[j++] = 255;
+                  }
+                }
+              }
+              break;
+            default:
+              throw new Error("Unsupported color mode");
+          }
+        }
+      };
+      var totalBytesAllocated = 0;
+      var maxMemoryUsageBytes = 0;
+      function requestMemoryAllocation(increaseAmount = 0) {
+        var totalMemoryImpactBytes = totalBytesAllocated + increaseAmount;
+        if (totalMemoryImpactBytes > maxMemoryUsageBytes) {
+          var exceededAmount = Math.ceil((totalMemoryImpactBytes - maxMemoryUsageBytes) / 1024 / 1024);
+          throw new Error(`maxMemoryUsageInMB limit exceeded by at least ${exceededAmount}MB`);
+        }
+        totalBytesAllocated = totalMemoryImpactBytes;
+      }
+      constructor.resetMaxMemoryUsage = function(maxMemoryUsageBytes_) {
+        totalBytesAllocated = 0;
+        maxMemoryUsageBytes = maxMemoryUsageBytes_;
+      };
+      constructor.getBytesAllocated = function() {
+        return totalBytesAllocated;
+      };
+      constructor.requestMemoryAllocation = requestMemoryAllocation;
+      return constructor;
+    })();
+    if (typeof module !== "undefined") {
+      module.exports = decode;
+    } else if (typeof window !== "undefined") {
+      window["jpeg-js"] = window["jpeg-js"] || {};
+      window["jpeg-js"].decode = decode;
+    }
+    function decode(jpegData, userOpts = {}) {
+      var defaultOpts = {
+        // "undefined" means "Choose whether to transform colors based on the image’s color model."
+        colorTransform: void 0,
+        useTArray: false,
+        formatAsRGBA: true,
+        tolerantDecoding: true,
+        maxResolutionInMP: 100,
+        // Don't decode more than 100 megapixels
+        maxMemoryUsageInMB: 512
+        // Don't decode if memory footprint is more than 512MB
+      };
+      var opts = { ...defaultOpts, ...userOpts };
+      var arr = new Uint8Array(jpegData);
+      var decoder = new JpegImage();
+      decoder.opts = opts;
+      JpegImage.resetMaxMemoryUsage(opts.maxMemoryUsageInMB * 1024 * 1024);
+      decoder.parse(arr);
+      var channels = opts.formatAsRGBA ? 4 : 3;
+      var bytesNeeded = decoder.width * decoder.height * channels;
+      try {
+        JpegImage.requestMemoryAllocation(bytesNeeded);
+        var image = {
+          width: decoder.width,
+          height: decoder.height,
+          exifBuffer: decoder.exifBuffer,
+          data: opts.useTArray ? new Uint8Array(bytesNeeded) : Buffer.alloc(bytesNeeded)
+        };
+        if (decoder.comments.length > 0) {
+          image["comments"] = decoder.comments;
+        }
+      } catch (err) {
+        if (err instanceof RangeError) {
+          throw new Error("Could not allocate enough memory for the image. Required: " + bytesNeeded);
+        }
+        if (err instanceof ReferenceError) {
+          if (err.message === "Buffer is not defined") {
+            throw new Error("Buffer is not globally defined in this environment. Consider setting useTArray to true");
+          }
+        }
+        throw err;
+      }
+      decoder.copyToImageData(image, opts.formatAsRGBA);
+      return image;
+    }
+  }
+});
+
+// node_modules/jpeg-js/index.js
+var require_jpeg_js = __commonJS({
+  "node_modules/jpeg-js/index.js"(exports, module) {
+    init_define_import_meta_env();
+    var encode = require_encoder();
+    var decode = require_decoder();
+    module.exports = {
+      encode,
+      decode
+    };
+  }
+});
+
+// src/docx_extract.ts
+init_define_import_meta_env();
 
 // src/ooxml_extract.ts
+init_define_import_meta_env();
 import * as fs from "node:fs";
 
 // src/lazy_module.ts
+init_define_import_meta_env();
 function createLazyModuleLoader(load3, errorLabel) {
   let cache;
   return async () => {
@@ -121,6 +2848,7 @@ function createLazyModuleLoader(load3, errorLabel) {
 }
 
 // src/xml_parser.ts
+init_define_import_meta_env();
 var MAX_XML_DEPTH = 512;
 var NAMED_ENTITIES = {
   lt: "<",
@@ -331,6 +3059,7 @@ function parseXml(xml) {
 }
 
 // src/zip_bounds.ts
+init_define_import_meta_env();
 var MAX_ZIP_INPUT_BYTES = 50 * 1024 * 1024;
 var MAX_ZIP_OUTPUT_BYTES = 500 * 1024 * 1024;
 var STREAM_CHUNK_BYTES = 64 * 1024;
@@ -541,6 +3270,7 @@ async function docxText(filePath) {
 }
 
 // src/pptx_extract.ts
+init_define_import_meta_env();
 function shapePlaceholderType(shape) {
   const sp = shape;
   return sp["p:nvSpPr"]?.["p:nvPr"]?.["p:ph"]?.["@_type"];
@@ -699,7 +3429,20 @@ async function pptxTextGrep(filePath, pattern) {
   return out;
 }
 
+// src/csv_query.ts
+init_define_import_meta_env();
+
+// node_modules/csv-parse/lib/sync.js
+init_define_import_meta_env();
+
+// node_modules/csv-parse/lib/api/index.js
+init_define_import_meta_env();
+
+// node_modules/csv-parse/lib/api/normalize_columns_array.js
+init_define_import_meta_env();
+
 // node_modules/csv-parse/lib/api/CsvError.js
+init_define_import_meta_env();
 var CsvError = class _CsvError extends Error {
   constructor(code, message, options, ...contexts) {
     if (Array.isArray(message)) message = message.join(" ").trim();
@@ -718,6 +3461,7 @@ var CsvError = class _CsvError extends Error {
 };
 
 // node_modules/csv-parse/lib/utils/is_object.js
+init_define_import_meta_env();
 var is_object = function(obj) {
   return typeof obj === "object" && obj !== null && !Array.isArray(obj);
 };
@@ -751,7 +3495,11 @@ var normalize_columns_array = function(columns) {
   return normalizedColumns;
 };
 
+// node_modules/csv-parse/lib/api/init_state.js
+init_define_import_meta_env();
+
 // node_modules/csv-parse/lib/utils/ResizeableBuffer.js
+init_define_import_meta_env();
 var ResizeableBuffer = class {
   constructor(size = 100) {
     this.size = size;
@@ -930,7 +3678,11 @@ var init_state = function(options) {
   };
 };
 
+// node_modules/csv-parse/lib/api/normalize_options.js
+init_define_import_meta_env();
+
 // node_modules/csv-parse/lib/utils/underscore.js
+init_define_import_meta_env();
 var underscore = function(str) {
   return str.replace(/([A-Z])/g, function(_, match) {
     return "_" + match.toLowerCase();
@@ -1524,6 +4276,7 @@ var normalize_options = function(opts) {
 };
 
 // node_modules/csv-parse/lib/utils/delimiter_discover.js
+init_define_import_meta_env();
 var delimiter_discover = function(records, options) {
   if (!options) {
     ({ delimiter_auto: options } = normalize_options({ delimiter_auto: true }));
@@ -2581,7 +5334,11 @@ function formatCsvProfile(profiles) {
   }).join("\n\n");
 }
 
+// src/xlsx_extract.ts
+init_define_import_meta_env();
+
 // src/xlsx_reader.ts
+init_define_import_meta_env();
 var EMPTY_CELL = Object.freeze({ value: null, text: "" });
 function asArray(val) {
   if (val === void 0 || val === null) return [];
@@ -3004,10 +5761,12 @@ async function querySheet(filePath, sheetName, opts) {
 }
 
 // src/doc_embed_extract.ts
+init_define_import_meta_env();
 import * as fs2 from "node:fs";
 import * as path from "node:path";
 
 // src/pdf_extract.ts
+init_define_import_meta_env();
 var loadPdfjs = createLazyModuleLoader(async () => {
   const mod = await import("pdfjs-dist/legacy/build/pdf.mjs");
   if (typeof import.meta.resolve === "function") {
@@ -3218,9 +5977,11 @@ ${body}`);
 }
 
 // src/index_health.ts
+init_define_import_meta_env();
 import * as fs4 from "fs";
 
 // src/sql_path.ts
+init_define_import_meta_env();
 function pathEqClause(column) {
   return isCaseInsensitiveFs() ? `TG_LOWER(${column}) = ?` : `${column} = ?`;
 }
@@ -3251,6 +6012,7 @@ function projectScopeClause(column) {
 }
 
 // src/walk_mode.ts
+init_define_import_meta_env();
 import * as fs3 from "fs";
 import * as path2 from "path";
 function detectWalkMode(cwd) {
@@ -3295,6 +6057,18 @@ function getEmbeddingCoverage(dbPath, rootDir) {
     embeddedFiles: countScoped("SELECT COUNT(DISTINCT file_path) as c FROM chunks", "file_path")
   };
 }
+function getParserFreshness(dbPath, parserSha, rootDir) {
+  const db = getDb(dbPath);
+  const count = (extra, params) => {
+    if (rootDir === void 0) {
+      return db.prepare(`SELECT COUNT(*) as c FROM files${extra === "" ? "" : ` WHERE ${extra}`}`).get(...params).c;
+    }
+    const scope = projectScopeClause("path");
+    const where = extra === "" ? scope.clause : `${scope.clause} AND ${extra}`;
+    return db.prepare(`SELECT COUNT(*) as c FROM files WHERE ${where}`).get(...scope.params(rootDir), ...params).c;
+  };
+  return { indexedFiles: count("", []), currentFiles: count("parser_sha = ?", [parserSha]) };
+}
 function isIndexEmptyForProject(dbPath, rootDir) {
   if (!fs4.existsSync(dbPath)) return true;
   try {
@@ -3312,6 +6086,7 @@ function emptyIndexMessage(rootDir) {
 }
 
 // src/hint_stats.ts
+init_define_import_meta_env();
 var HINT_CATEGORIES = [
   "bash_redirect",
   "bash_recall",
@@ -3414,7 +6189,7 @@ function logHintEmission(category, sessionId, correlator, compensateSelfResolve
     const db = getDb(globalDbPath());
     const resolved = correlator === null ? 1 : 0;
     const actedOn = resolved === 1 && isSuppressionCategory(category) ? 1 : 0;
-    const window = ACTED_ON_WINDOW + (compensateSelfResolve ? 1 : 0);
+    const window2 = ACTED_ON_WINDOW + (compensateSelfResolve ? 1 : 0);
     db.prepare(
       `INSERT INTO hint_emissions (category, session_id, harness, correlator, emitted_at, resolved, acted_on, calls_remaining, bytes_emitted)
        VALUES (@category, @sessionId, @harness, @correlator, @emittedAt, @resolved, @actedOn, @callsRemaining, @bytesEmitted)`
@@ -3426,7 +6201,7 @@ function logHintEmission(category, sessionId, correlator, compensateSelfResolve
       emittedAt: Date.now(),
       resolved,
       actedOn,
-      callsRemaining: correlator === null ? 0 : window,
+      callsRemaining: correlator === null ? 0 : window2,
       bytesEmitted
     });
   } catch {
@@ -3616,6 +6391,7 @@ function markCategoryIneffective(category) {
 }
 
 // src/session.ts
+init_define_import_meta_env();
 import { randomBytes, randomUUID } from "node:crypto";
 import * as fs5 from "node:fs";
 var _files = /* @__PURE__ */ new Map();
@@ -4023,6 +6799,7 @@ registerReset(() => {
 });
 
 // src/index_reader.ts
+init_define_import_meta_env();
 function toSymbolEntry(row) {
   return {
     filePath: row.file_path,
@@ -4213,6 +6990,7 @@ function searchSymbolsFts(query, limit = 50, dbPath = globalDbPath(), rootDir) {
 }
 
 // src/recall_index.ts
+init_define_import_meta_env();
 var VALID_TYPES = ["bash", "web", "mcp"];
 var RECALL_DEFAULT_LIMIT = 10;
 function isRecallCacheType(value) {
@@ -4348,10 +7126,12 @@ function searchRecall(query, opts = {}) {
 }
 
 // src/bash_output_cache.ts
+init_define_import_meta_env();
 import { readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync4 } from "fs";
 import { resolve } from "path";
 
 // src/disk_cache.ts
+init_define_import_meta_env();
 import * as fs6 from "node:fs";
 import * as path3 from "node:path";
 import * as os from "node:os";
@@ -4571,6 +7351,7 @@ function sweepCacheRoots(extraRoots = []) {
 }
 
 // src/hints/lang_patterns.ts
+init_define_import_meta_env();
 var LOCK_FILE_NAMES = /* @__PURE__ */ new Set([
   "package-lock.json",
   "yarn.lock",
@@ -5197,6 +7978,7 @@ registerReset(() => {
 });
 
 // src/session_store.ts
+init_define_import_meta_env();
 import { createHash } from "node:crypto";
 import * as fs7 from "node:fs";
 import * as path4 from "node:path";
@@ -5555,6 +8337,7 @@ function saveSessionState(sessionId) {
 }
 
 // src/injection_scan.ts
+init_define_import_meta_env();
 var INJECTION_PATTERNS = [
   { name: "ignore-previous-instructions", re: /ignore\s+(all\s+)?(prior|previous|above)\s+instructions/i },
   { name: "disregard-previous-instructions", re: /disregard\s+(all\s+|the\s+)?(prior|previous|above)\s+instructions/i },
@@ -5578,7 +8361,12 @@ var UNTRUSTED_WEB_TAG = "untrusted-web-content";
 function neutralizeFenceMarkers(text, tag) {
   const escapedTag = tag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const marker = new RegExp(`<\\s*/?\\s*${escapedTag}(?=[\\s/>])[^>]*>`, "gi");
-  return text.replace(marker, (m) => m.replace(/</g, "&lt;").replace(/>/g, "&gt;"));
+  return neutralizeSpokenMarkers(
+    text.replace(marker, (m) => m.replace(/</g, "&lt;").replace(/>/g, "&gt;"))
+  );
+}
+function neutralizeSpokenMarkers(text) {
+  return text.replace(/\[\s*token-goat\b/gi, (m) => m.replace("[", "&#91;"));
 }
 function fenceUntrustedContent(text, matchedPatternNames, tag = UNTRUSTED_WEB_TAG) {
   const label = matchedPatternNames.length === 1 ? "pattern" : "patterns";
@@ -5607,6 +8395,7 @@ var UNTRUSTED_TOOL_TAG = "untrusted-tool-output";
 var UNTRUSTED_GITHUB_TAG = "untrusted-github-content";
 
 // src/skill_cache.ts
+init_define_import_meta_env();
 import * as fs8 from "fs/promises";
 import { resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
@@ -6204,11 +8993,570 @@ function pruneSkillOutputs(maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_
 }
 
 // src/image_shrink.ts
+init_define_import_meta_env();
+var import_omggif2 = __toESM(require_omggif(), 1);
 import { createHash as createHash3 } from "node:crypto";
 import * as fs10 from "node:fs";
 import * as path6 from "node:path";
 
+// src/image_engine.ts
+init_define_import_meta_env();
+var import_jpeg_js = __toESM(require_jpeg_js(), 1);
+var import_omggif = __toESM(require_omggif(), 1);
+import * as zlib from "node:zlib";
+var MAX_DECODED_BYTES = 256 * 1024 * 1024;
+function assertDecodableSize(what, width, height, bytesPerPixel, frames = 1) {
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0 || frames <= 0) {
+    throw new Error(`Invalid ${what} dimensions: ${width}x${height} (${frames} frame(s))`);
+  }
+  const bytes = width * height * bytesPerPixel * frames;
+  if (bytes > MAX_DECODED_BYTES) {
+    throw new Error(
+      `${what} would allocate ${Math.round(bytes / 1048576)}MB, over the ${MAX_DECODED_BYTES / 1048576}MB decode ceiling`
+    );
+  }
+}
+var CRC_TABLE = new Int32Array(256);
+for (let i = 0; i < 256; i++) {
+  let c = i;
+  for (let k = 0; k < 8; k++) {
+    c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+  }
+  CRC_TABLE[i] = c;
+}
+function crc32(buf) {
+  let crc = -1;
+  for (let i = 0; i < buf.length; i++) {
+    const byte = buf[i] ?? 0;
+    crc = (CRC_TABLE[(crc ^ byte) & 255] ?? 0) ^ crc >>> 8;
+  }
+  return (crc ^ -1) >>> 0;
+}
+function paethPredictor(a, b, c) {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  if (pa <= pb && pa <= pc) return a;
+  if (pb <= pc) return b;
+  return c;
+}
+function probeBufferMeta(buf) {
+  if (buf.length < 8) return null;
+  if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71 && buf[4] === 13 && buf[5] === 10 && buf[6] === 26 && buf[7] === 10) {
+    if (buf.length < 24) return null;
+    const width = buf.readUInt32BE(16);
+    const height = buf.readUInt32BE(20);
+    return { width, height, format: "png", pages: 1 };
+  }
+  if (buf[0] === 255 && buf[1] === 216 && buf[2] === 255) {
+    let pos = 2;
+    let width = 0;
+    let height = 0;
+    let orientation = 1;
+    while (pos < buf.length - 1) {
+      if (buf[pos] !== 255) {
+        pos++;
+        continue;
+      }
+      const marker = buf[pos + 1];
+      if (marker === void 0) break;
+      pos += 2;
+      if (marker === 216 || marker === 217 || marker === 0 || marker >= 208 && marker <= 215) {
+        continue;
+      }
+      if (pos + 2 > buf.length) break;
+      const length = buf.readUInt16BE(pos);
+      if (length < 2 || pos + length > buf.length) break;
+      if (marker === 225 && length >= 14) {
+        const exifHeader = buf.toString("ascii", pos + 2, pos + 6);
+        if (exifHeader === "Exif") {
+          const tiffStart = pos + 8;
+          if (tiffStart + 8 <= buf.length) {
+            const isLE = buf[tiffStart] === 73 && buf[tiffStart + 1] === 73;
+            const ifdOffset = isLE ? buf.readUInt32LE(tiffStart + 4) : buf.readUInt32BE(tiffStart + 4);
+            let ifdPos = tiffStart + ifdOffset;
+            if (ifdPos + 2 <= buf.length) {
+              const numEntries = isLE ? buf.readUInt16LE(ifdPos) : buf.readUInt16BE(ifdPos);
+              ifdPos += 2;
+              for (let e = 0; e < numEntries && ifdPos + 12 <= buf.length; e++, ifdPos += 12) {
+                const tag = isLE ? buf.readUInt16LE(ifdPos) : buf.readUInt16BE(ifdPos);
+                if (tag === 274) {
+                  orientation = isLE ? buf.readUInt16LE(ifdPos + 8) : buf.readUInt16BE(ifdPos + 8);
+                  break;
+                }
+              }
+            }
+          }
+        }
+      }
+      const isSof = marker >= 192 && marker <= 195 || marker >= 197 && marker <= 199 || marker >= 201 && marker <= 203 || marker >= 205 && marker <= 207;
+      if (isSof && length >= 7) {
+        height = buf.readUInt16BE(pos + 3);
+        width = buf.readUInt16BE(pos + 5);
+        break;
+      }
+      pos += length;
+    }
+    if (width > 0 && height > 0) {
+      if (orientation >= 5 && orientation <= 8) {
+        return { width: height, height: width, format: "jpeg", pages: 1 };
+      }
+      return { width, height, format: "jpeg", pages: 1 };
+    }
+    return null;
+  }
+  const gifSig = buf.toString("ascii", 0, 6);
+  if (gifSig === "GIF87a" || gifSig === "GIF89a") {
+    const width = buf.readUInt16LE(6);
+    const height = buf.readUInt16LE(8);
+    let pages;
+    try {
+      const reader = new import_omggif.default.GifReader(buf);
+      pages = reader.numFrames();
+    } catch {
+      let count = 0;
+      for (let i = 13; i < buf.length - 9; i++) {
+        if (buf[i] === 44) count++;
+      }
+      pages = Math.max(1, count);
+    }
+    return { width, height, format: "gif", pages };
+  }
+  if (buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WEBP") {
+    const chunkType = buf.toString("ascii", 12, 16);
+    if (chunkType === "VP8 " && buf.length >= 30) {
+      const width = buf.readUInt16LE(26) & 16383;
+      const height = buf.readUInt16LE(28) & 16383;
+      return { width, height, format: "webp", pages: 1 };
+    }
+    if (chunkType === "VP8L" && buf.length >= 25) {
+      const b1 = buf[21] ?? 0;
+      const b2 = buf[22] ?? 0;
+      const b3 = buf[23] ?? 0;
+      const b4 = buf[24] ?? 0;
+      const width = 1 + ((b2 & 63) << 8 | b1);
+      const height = 1 + ((b4 & 15) << 10 | b3 << 2 | (b2 & 192) >> 6);
+      return { width, height, format: "webp", pages: 1 };
+    }
+    if (chunkType === "VP8X" && buf.length >= 30) {
+      const b24 = buf[24] ?? 0;
+      const b25 = buf[25] ?? 0;
+      const b26 = buf[26] ?? 0;
+      const b27 = buf[27] ?? 0;
+      const b28 = buf[28] ?? 0;
+      const b29 = buf[29] ?? 0;
+      const b20 = buf[20] ?? 0;
+      const width = 1 + (b24 | b25 << 8 | b26 << 16);
+      const height = 1 + (b27 | b28 << 8 | b29 << 16);
+      const isAnimated = (b20 & 2) !== 0;
+      let pages = 1;
+      if (isAnimated) {
+        let count = 0;
+        let pos = 30;
+        while (pos < buf.length - 8) {
+          const type = buf.toString("ascii", pos, pos + 4);
+          const len = buf.readUInt32LE(pos + 4);
+          if (type === "ANMF") count++;
+          pos += 8 + len + (len & 1);
+        }
+        pages = Math.max(1, count);
+      }
+      return { width, height, format: "webp", pages };
+    }
+  }
+  if (buf[0] === 66 && buf[1] === 77 && buf.length >= 26) {
+    const width = buf.readInt32LE(18);
+    const height = Math.abs(buf.readInt32LE(22));
+    return { width, height, format: "bmp", pages: 1 };
+  }
+  const isTiffLE = buf[0] === 73 && buf[1] === 73 && buf[2] === 42 && buf[3] === 0;
+  const isTiffBE = buf[0] === 77 && buf[1] === 77 && buf[2] === 0 && buf[3] === 42;
+  if (isTiffLE || isTiffBE) {
+    const isLE = isTiffLE;
+    let ifdOffset = isLE ? buf.readUInt32LE(4) : buf.readUInt32BE(4);
+    let width = 0;
+    let height = 0;
+    let pages = 0;
+    const seenIfdOffsets = /* @__PURE__ */ new Set();
+    while (ifdOffset > 0 && ifdOffset + 2 <= buf.length) {
+      if (seenIfdOffsets.has(ifdOffset)) break;
+      seenIfdOffsets.add(ifdOffset);
+      pages++;
+      const numEntries = isLE ? buf.readUInt16LE(ifdOffset) : buf.readUInt16BE(ifdOffset);
+      let ifdPos = ifdOffset + 2;
+      for (let e = 0; e < numEntries && ifdPos + 12 <= buf.length; e++, ifdPos += 12) {
+        const tag = isLE ? buf.readUInt16LE(ifdPos) : buf.readUInt16BE(ifdPos);
+        if (tag === 256 && width === 0) {
+          const type = isLE ? buf.readUInt16LE(ifdPos + 2) : buf.readUInt16BE(ifdPos + 2);
+          width = type === 3 ? isLE ? buf.readUInt16LE(ifdPos + 8) : buf.readUInt16BE(ifdPos + 8) : isLE ? buf.readUInt32LE(ifdPos + 8) : buf.readUInt32BE(ifdPos + 8);
+        } else if (tag === 257 && height === 0) {
+          const type = isLE ? buf.readUInt16LE(ifdPos + 2) : buf.readUInt16BE(ifdPos + 2);
+          height = type === 3 ? isLE ? buf.readUInt16LE(ifdPos + 8) : buf.readUInt16BE(ifdPos + 8) : isLE ? buf.readUInt32LE(ifdPos + 8) : buf.readUInt32BE(ifdPos + 8);
+        }
+      }
+      const nextIfdPos = ifdOffset + 2 + numEntries * 12;
+      if (nextIfdPos + 4 <= buf.length) {
+        ifdOffset = isLE ? buf.readUInt32LE(nextIfdPos) : buf.readUInt32BE(nextIfdPos);
+      } else {
+        break;
+      }
+    }
+    if (width > 0 && height > 0) {
+      return { width, height, format: "tiff", pages: Math.max(1, pages) };
+    }
+  }
+  const sample = buf.subarray(0, Math.min(buf.length, 4096)).toString("utf8");
+  if (sample.includes("<svg")) {
+    const widthMatch = /width=["']([0-9.]+)(px)?["']/i.exec(sample);
+    const heightMatch = /height=["']([0-9.]+)(px)?["']/i.exec(sample);
+    const viewBoxMatch = /viewBox=["']([0-9. -]+)["']/i.exec(sample);
+    let width = widthMatch && widthMatch[1] ? parseFloat(widthMatch[1]) : 0;
+    let height = heightMatch && heightMatch[1] ? parseFloat(heightMatch[1]) : 0;
+    if ((!width || !height) && viewBoxMatch && viewBoxMatch[1]) {
+      const parts = viewBoxMatch[1].trim().split(/[\s,]+/).map(parseFloat);
+      if (parts.length === 4 && parts[2] !== void 0 && parts[3] !== void 0) {
+        width = parts[2];
+        height = parts[3];
+      }
+    }
+    if (width > 0 && height > 0) {
+      return { width: Math.round(width), height: Math.round(height), format: "svg", pages: 1 };
+    }
+    return { width: 100, height: 100, format: "svg", pages: 1 };
+  }
+  return null;
+}
+function decodePng(buf) {
+  if (buf.length < 8 || buf[0] !== 137 || buf[1] !== 80 || buf[2] !== 78 || buf[3] !== 71) {
+    throw new Error("Invalid PNG signature");
+  }
+  let pos = 8;
+  let width = 0;
+  let height = 0;
+  let colorType = 6;
+  const idatChunks = [];
+  let palette = null;
+  let trns = null;
+  while (pos < buf.length) {
+    const len = buf.readUInt32BE(pos);
+    const type = buf.toString("ascii", pos + 4, pos + 8);
+    const data = buf.subarray(pos + 8, pos + 8 + len);
+    pos += 8 + len + 4;
+    if (type === "IHDR") {
+      width = data.readUInt32BE(0);
+      height = data.readUInt32BE(4);
+      const bitDepth = data[8] ?? 8;
+      colorType = data[9] ?? 6;
+      if (bitDepth !== 8) {
+        throw new Error("Unsupported PNG bit depth: " + bitDepth);
+      }
+      const interlace = data[12] ?? 0;
+      if (interlace !== 0) {
+        throw new Error("Unsupported PNG interlace method: " + interlace);
+      }
+    } else if (type === "PLTE") {
+      palette = data;
+    } else if (type === "tRNS") {
+      trns = data;
+    } else if (type === "IDAT") {
+      idatChunks.push(data);
+    } else if (type === "IEND") {
+      break;
+    }
+  }
+  if (width === 0 || height === 0) {
+    throw new Error("Missing PNG IHDR chunk");
+  }
+  let bpp = 4;
+  if (colorType === 0) bpp = 1;
+  else if (colorType === 2) bpp = 3;
+  else if (colorType === 3) bpp = 1;
+  else if (colorType === 4) bpp = 2;
+  else if (colorType === 6) bpp = 4;
+  assertDecodableSize("PNG", width, height, 4);
+  const rowBytes = width * bpp;
+  const rowSize = 1 + rowBytes;
+  const maxRawBytes = height * rowSize;
+  const compressed = Buffer.concat(idatChunks);
+  let decompressed;
+  try {
+    decompressed = zlib.inflateSync(compressed, { maxOutputLength: maxRawBytes });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`PNG image data exceeds the ${maxRawBytes} bytes its ${width}x${height} header allows: ${msg}`, {
+      cause: err
+    });
+  }
+  const outRgba = Buffer.alloc(width * height * 4);
+  const priorRow = Buffer.alloc(rowBytes);
+  const currRow = Buffer.alloc(rowBytes);
+  for (let y = 0; y < height; y++) {
+    const filter = decompressed[y * rowSize] ?? 0;
+    const rawOffset = y * rowSize + 1;
+    for (let x = 0; x < rowBytes; x++) {
+      const rawVal = decompressed[rawOffset + x] ?? 0;
+      const a = x >= bpp ? currRow[x - bpp] ?? 0 : 0;
+      const b = priorRow[x] ?? 0;
+      const c = x >= bpp ? priorRow[x - bpp] ?? 0 : 0;
+      let val = rawVal;
+      if (filter === 0) {
+        val = rawVal;
+      } else if (filter === 1) {
+        val = rawVal + a & 255;
+      } else if (filter === 2) {
+        val = rawVal + b & 255;
+      } else if (filter === 3) {
+        val = rawVal + Math.floor((a + b) / 2) & 255;
+      } else if (filter === 4) {
+        val = rawVal + paethPredictor(a, b, c) & 255;
+      }
+      currRow[x] = val;
+    }
+    for (let x = 0; x < width; x++) {
+      const outIdx = (y * width + x) * 4;
+      if (colorType === 6) {
+        outRgba[outIdx] = currRow[x * 4] ?? 0;
+        outRgba[outIdx + 1] = currRow[x * 4 + 1] ?? 0;
+        outRgba[outIdx + 2] = currRow[x * 4 + 2] ?? 0;
+        outRgba[outIdx + 3] = currRow[x * 4 + 3] ?? 255;
+      } else if (colorType === 2) {
+        outRgba[outIdx] = currRow[x * 3] ?? 0;
+        outRgba[outIdx + 1] = currRow[x * 3 + 1] ?? 0;
+        outRgba[outIdx + 2] = currRow[x * 3 + 2] ?? 0;
+        outRgba[outIdx + 3] = 255;
+      } else if (colorType === 0) {
+        const g = currRow[x] ?? 0;
+        outRgba[outIdx] = g;
+        outRgba[outIdx + 1] = g;
+        outRgba[outIdx + 2] = g;
+        outRgba[outIdx + 3] = 255;
+      } else if (colorType === 4) {
+        const g = currRow[x * 2] ?? 0;
+        outRgba[outIdx] = g;
+        outRgba[outIdx + 1] = g;
+        outRgba[outIdx + 2] = g;
+        outRgba[outIdx + 3] = currRow[x * 2 + 1] ?? 255;
+      } else if (colorType === 3 && palette) {
+        const pVal = currRow[x] ?? 0;
+        const pIdx = pVal * 3;
+        outRgba[outIdx] = palette[pIdx] ?? 0;
+        outRgba[outIdx + 1] = palette[pIdx + 1] ?? 0;
+        outRgba[outIdx + 2] = palette[pIdx + 2] ?? 0;
+        outRgba[outIdx + 3] = trns && trns.length > pVal ? trns[pVal] ?? 255 : 255;
+      }
+    }
+    currRow.copy(priorRow);
+  }
+  return { width, height, data: outRgba };
+}
+function makePngChunk(type, data) {
+  const len = data.length;
+  const chunk = Buffer.alloc(8 + len + 4);
+  chunk.writeUInt32BE(len, 0);
+  chunk.write(type, 4, 4, "ascii");
+  Buffer.from(data.buffer, data.byteOffset, data.byteLength).copy(chunk, 8);
+  const typeAndData = chunk.subarray(4, 8 + len);
+  chunk.writeUInt32BE(crc32(typeAndData), 8 + len);
+  return chunk;
+}
+function encodePng(width, height, rgba) {
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  const rowSize = 1 + width * 4;
+  const rawData = Buffer.alloc(rowSize * height);
+  for (let y = 0; y < height; y++) {
+    const rowOffset = y * rowSize;
+    rawData[rowOffset] = 0;
+    Buffer.from(rgba.buffer, rgba.byteOffset + y * width * 4, width * 4).copy(rawData, rowOffset + 1);
+  }
+  const idatData = zlib.deflateSync(rawData, { level: 6 });
+  const signature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+  const ihdrChunk = makePngChunk("IHDR", ihdr);
+  const idatChunk = makePngChunk("IDAT", idatData);
+  const iendChunk = makePngChunk("IEND", Buffer.alloc(0));
+  return Buffer.concat([signature, ihdrChunk, idatChunk, iendChunk]);
+}
+function decodeBmp(buf) {
+  if (buf.length < 54 || buf[0] !== 66 || buf[1] !== 77) {
+    throw new Error("Invalid BMP signature");
+  }
+  const pixelOffset = buf.readUInt32LE(10);
+  const width = buf.readInt32LE(18);
+  let height = buf.readInt32LE(22);
+  const topDown = height < 0;
+  height = Math.abs(height);
+  const bpp = buf.readUInt16LE(28);
+  const compression = buf.readUInt32LE(30);
+  if (compression !== 0 && compression !== 3) {
+    throw new Error("Unsupported BMP compression: " + compression);
+  }
+  if (bpp !== 24 && bpp !== 32) {
+    throw new Error("Unsupported BMP bit depth: " + bpp);
+  }
+  assertDecodableSize("BMP", width, height, 4);
+  const outRgba = Buffer.alloc(width * height * 4);
+  const rowStride = Math.floor((bpp * width + 31) / 32) * 4;
+  for (let y = 0; y < height; y++) {
+    const srcY = topDown ? y : height - 1 - y;
+    const rowOffset = pixelOffset + srcY * rowStride;
+    for (let x = 0; x < width; x++) {
+      const outIdx = (y * width + x) * 4;
+      if (bpp === 24) {
+        const pxOffset = rowOffset + x * 3;
+        outRgba[outIdx] = buf[pxOffset + 2] ?? 0;
+        outRgba[outIdx + 1] = buf[pxOffset + 1] ?? 0;
+        outRgba[outIdx + 2] = buf[pxOffset] ?? 0;
+        outRgba[outIdx + 3] = 255;
+      } else if (bpp === 32) {
+        const pxOffset = rowOffset + x * 4;
+        outRgba[outIdx] = buf[pxOffset + 2] ?? 0;
+        outRgba[outIdx + 1] = buf[pxOffset + 1] ?? 0;
+        outRgba[outIdx + 2] = buf[pxOffset] ?? 0;
+        outRgba[outIdx + 3] = buf[pxOffset + 3] ?? 255;
+      }
+    }
+  }
+  return { width, height, data: outRgba };
+}
+function decodeGif(buf, opts) {
+  const reader = new import_omggif.default.GifReader(buf);
+  const width = reader.width;
+  const height = reader.height;
+  const wanted = Math.min(reader.numFrames(), opts?.maxFrames ?? Number.POSITIVE_INFINITY);
+  assertDecodableSize("GIF", width, height, 4, wanted);
+  const frames = [];
+  for (let i = 0; i < wanted; i++) {
+    const frameInfo = reader.frameInfo(i);
+    const frameRgba = Buffer.alloc(width * height * 4);
+    reader.decodeAndBlitFrameRGBA(i, frameRgba);
+    frames.push({
+      width,
+      height,
+      x: frameInfo.x,
+      y: frameInfo.y,
+      delay: frameInfo.delay,
+      disposal: frameInfo.disposal,
+      data: frameRgba
+    });
+  }
+  return { width, height, frames };
+}
+function quantizeRgbaToIndexed(rgba, width, height) {
+  const palette = [];
+  for (let r = 0; r < 8; r++) {
+    for (let g = 0; g < 8; g++) {
+      for (let b = 0; b < 4; b++) {
+        const red = Math.round(r / 7 * 255);
+        const green = Math.round(g / 7 * 255);
+        const blue = Math.round(b / 3 * 255);
+        palette.push(red << 16 | green << 8 | blue);
+      }
+    }
+  }
+  const numPixels = width * height;
+  const indexedPixels = new Array(numPixels);
+  for (let i = 0; i < numPixels; i++) {
+    const r = rgba[i * 4] ?? 0;
+    const g = rgba[i * 4 + 1] ?? 0;
+    const b = rgba[i * 4 + 2] ?? 0;
+    const rIdx = Math.min(7, Math.floor(r / 256 * 8));
+    const gIdx = Math.min(7, Math.floor(g / 256 * 8));
+    const bIdx = Math.min(3, Math.floor(b / 256 * 4));
+    indexedPixels[i] = rIdx << 5 | gIdx << 2 | bIdx;
+  }
+  return { indexedPixels, palette };
+}
+function decodeJpeg(buf) {
+  const decoded = import_jpeg_js.default.decode(buf, { useTArray: true });
+  return {
+    width: decoded.width,
+    height: decoded.height,
+    data: Buffer.from(decoded.data)
+  };
+}
+function encodeJpeg(width, height, rgba, quality = 80) {
+  const encoded = import_jpeg_js.default.encode({
+    data: Buffer.from(rgba.buffer, rgba.byteOffset, rgba.byteLength),
+    width,
+    height
+  }, quality);
+  return encoded.data;
+}
+function resizeRgba(srcRgba, srcW, srcH, dstW, dstH) {
+  if (srcW === dstW && srcH === dstH) {
+    return Buffer.from(srcRgba.buffer, srcRgba.byteOffset, srcRgba.byteLength);
+  }
+  const dst = Buffer.alloc(dstW * dstH * 4);
+  const scaleX = srcW / dstW;
+  const scaleY = srcH / dstH;
+  for (let dy = 0; dy < dstH; dy++) {
+    const srcY = (dy + 0.5) * scaleY - 0.5;
+    const y0 = Math.max(0, Math.min(srcH - 1, Math.floor(srcY)));
+    const y1 = Math.max(0, Math.min(srcH - 1, y0 + 1));
+    const fy = Math.max(0, Math.min(1, srcY - y0));
+    const fy1 = 1 - fy;
+    const dstRowOffset = dy * dstW * 4;
+    const srcRow0 = y0 * srcW * 4;
+    const srcRow1 = y1 * srcW * 4;
+    for (let dx = 0; dx < dstW; dx++) {
+      const srcX = (dx + 0.5) * scaleX - 0.5;
+      const x0 = Math.max(0, Math.min(srcW - 1, Math.floor(srcX)));
+      const x1 = Math.max(0, Math.min(srcW - 1, x0 + 1));
+      const fx = Math.max(0, Math.min(1, srcX - x0));
+      const fx1 = 1 - fx;
+      const w00 = fx1 * fy1;
+      const w10 = fx * fy1;
+      const w01 = fx1 * fy;
+      const w11 = fx * fy;
+      const idx00 = srcRow0 + x0 * 4;
+      const idx10 = srcRow0 + x1 * 4;
+      const idx01 = srcRow1 + x0 * 4;
+      const idx11 = srcRow1 + x1 * 4;
+      const p00_r = srcRgba[idx00] ?? 0;
+      const p00_g = srcRgba[idx00 + 1] ?? 0;
+      const p00_b = srcRgba[idx00 + 2] ?? 0;
+      const p00_a = srcRgba[idx00 + 3] ?? 255;
+      const p10_r = srcRgba[idx10] ?? 0;
+      const p10_g = srcRgba[idx10 + 1] ?? 0;
+      const p10_b = srcRgba[idx10 + 2] ?? 0;
+      const p10_a = srcRgba[idx10 + 3] ?? 255;
+      const p01_r = srcRgba[idx01] ?? 0;
+      const p01_g = srcRgba[idx01 + 1] ?? 0;
+      const p01_b = srcRgba[idx01 + 2] ?? 0;
+      const p01_a = srcRgba[idx01 + 3] ?? 255;
+      const p11_r = srcRgba[idx11] ?? 0;
+      const p11_g = srcRgba[idx11 + 1] ?? 0;
+      const p11_b = srcRgba[idx11 + 2] ?? 0;
+      const p11_a = srcRgba[idx11 + 3] ?? 255;
+      const dstIdx = dstRowOffset + dx * 4;
+      dst[dstIdx] = Math.round(w00 * p00_r + w10 * p10_r + w01 * p01_r + w11 * p11_r);
+      dst[dstIdx + 1] = Math.round(w00 * p00_g + w10 * p10_g + w01 * p01_g + w11 * p11_g);
+      dst[dstIdx + 2] = Math.round(w00 * p00_b + w10 * p10_b + w01 * p01_b + w11 * p11_b);
+      dst[dstIdx + 3] = Math.round(w00 * p00_a + w10 * p10_a + w01 * p01_a + w11 * p11_a);
+    }
+  }
+  return dst;
+}
+function calculateFitInside(width, height, maxDimension) {
+  if (width <= maxDimension && height <= maxDimension) {
+    return { width, height };
+  }
+  const scale = maxDimension / Math.max(width, height);
+  return {
+    width: Math.max(1, Math.round(width * scale)),
+    height: Math.max(1, Math.round(height * scale))
+  };
+}
+
 // src/image_ocr.ts
+init_define_import_meta_env();
 import { spawn } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import * as fs9 from "node:fs";
@@ -6434,36 +9782,34 @@ function formatShrinkSummary(result, subject) {
   const dataUrl = `data:image/${result.format};base64,${result.data.toString("base64")}`;
   return { summary, dataUrl };
 }
-var loadSharp = createLazyModuleLoader(async () => {
-  const mod = await import("sharp");
-  return mod.default;
-}, "image shrink disabled (sharp unavailable)");
 function isImagePath(p) {
   return IMAGE_EXTENSIONS.has(path6.extname(p).toLowerCase());
 }
 var ImageDecodeError = class extends Error {
 };
 async function probeImageMeta(input) {
-  const sharp = await loadSharp();
-  if (sharp === null) return null;
-  try {
-    const cfg = loadConfig().image_shrink;
-    const limitInputPixels = cfg.max_image_pixels > 0 ? cfg.max_image_pixels : false;
-    const meta = await sharp(input, { limitInputPixels }).metadata();
-    return { width: meta.width ?? 0, height: meta.height ?? 0, format: meta.format ?? null, pages: meta.pages ?? 1 };
-  } catch (e) {
-    throw new ImageDecodeError(e?.message ?? "image could not be decoded");
+  const meta = probeBufferMeta(input);
+  if (meta === null) {
+    throw new ImageDecodeError("image could not be decoded");
+  }
+  const cfg = loadConfig().image_shrink;
+  const limitInputPixels = cfg.max_image_pixels > 0 ? cfg.max_image_pixels : false;
+  if (limitInputPixels !== false && meta.width * meta.height > limitInputPixels) {
+    throw new ImageDecodeError(`Input image exceeds pixel limit ${limitInputPixels}`);
   }
+  return {
+    width: meta.width,
+    height: meta.height,
+    format: meta.format,
+    pages: meta.pages
+  };
 }
 async function imageQualifiesForShrink(input) {
   if (input.length >= DEFAULT_SIZE_THRESHOLD_BYTES) return true;
-  const sharp = await loadSharp();
-  if (sharp === null) return false;
   try {
-    const cfg = loadConfig().image_shrink;
-    const limitInputPixels = cfg.max_image_pixels > 0 ? cfg.max_image_pixels : false;
-    const meta = await sharp(input, { limitInputPixels }).metadata();
-    return Math.max(meta.width ?? 0, meta.height ?? 0) > DEFAULT_MAX_DIMENSION;
+    const meta = await probeImageMeta(input);
+    if (meta === null) return false;
+    return Math.max(meta.width, meta.height) > DEFAULT_MAX_DIMENSION;
   } catch {
     return false;
   }
@@ -6473,34 +9819,77 @@ async function shrinkImage(input, opts) {
   const maxDimension = opts?.maxDimension ?? DEFAULT_MAX_DIMENSION;
   const quality = opts?.quality ?? cfg.jpeg_quality;
   const sizeThreshold = opts?.sizeThresholdBytes ?? DEFAULT_SIZE_THRESHOLD_BYTES;
-  const limitInputPixels = cfg.max_image_pixels > 0 ? cfg.max_image_pixels : false;
   const originalBytes = input.length;
   if (originalBytes < sizeThreshold) return null;
-  const sharp = await loadSharp();
-  if (sharp === null) return null;
+  let inputMeta;
+  try {
+    inputMeta = await probeImageMeta(input);
+  } catch {
+    return null;
+  }
+  if (!inputMeta || inputMeta.width <= 0 || inputMeta.height <= 0) return null;
   try {
-    const inputMeta = await sharp(input, { limitInputPixels }).metadata();
     const isAnimated = (inputMeta.pages ?? 1) > 1;
-    const webpBuf = await sharp(input, { limitInputPixels, animated: isAnimated }).rotate().resize({ width: maxDimension, height: maxDimension, fit: "inside", withoutEnlargement: true }).webp({ quality }).toBuffer();
-    let data = webpBuf;
-    let format = "webp";
-    if (!isAnimated) {
-      const jpegBuf = await sharp(input, { limitInputPixels }).rotate().resize({ width: maxDimension, height: maxDimension, fit: "inside", withoutEnlargement: true }).jpeg({ quality, mozjpeg: true }).toBuffer();
-      if (jpegBuf.length < webpBuf.length) {
-        data = jpegBuf;
-        format = "jpeg";
+    const { width: targetW, height: targetH } = calculateFitInside(inputMeta.width, inputMeta.height, maxDimension);
+    if (isAnimated && inputMeta.format === "gif") {
+      const decodedGif = decodeGif(input);
+      assertDecodableSize("GIF output", targetW, targetH, 5, decodedGif.frames.length);
+      const outBuf = Buffer.alloc(targetW * targetH * 5 * decodedGif.frames.length + 4096);
+      const gifWriter = new import_omggif2.default.GifWriter(outBuf, targetW, targetH, { loop: 0 });
+      for (const frame of decodedGif.frames) {
+        const resizedFrameRgba = resizeRgba(frame.data, frame.width, frame.height, targetW, targetH);
+        const { indexedPixels, palette } = quantizeRgbaToIndexed(resizedFrameRgba, targetW, targetH);
+        gifWriter.addFrame(0, 0, targetW, targetH, indexedPixels, {
+          palette,
+          delay: frame.delay,
+          disposal: frame.disposal
+        });
       }
+      const data2 = outBuf.subarray(0, gifWriter.end());
+      if (data2.length >= originalBytes) return null;
+      return {
+        data: data2,
+        originalBytes,
+        shrunkBytes: data2.length,
+        originalWidth: inputMeta.width,
+        originalHeight: inputMeta.height,
+        width: targetW,
+        height: targetH,
+        format: "gif"
+      };
+    }
+    let srcRgba;
+    if (inputMeta.format === "png") {
+      srcRgba = decodePng(input).data;
+    } else if (inputMeta.format === "jpeg") {
+      srcRgba = decodeJpeg(input).data;
+    } else if (inputMeta.format === "bmp") {
+      srcRgba = decodeBmp(input).data;
+    } else if (inputMeta.format === "gif") {
+      const firstFrame = decodeGif(input, { maxFrames: 1 }).frames[0];
+      if (!firstFrame) return null;
+      srcRgba = firstFrame.data;
+    } else {
+      return null;
+    }
+    const dstRgba = resizeRgba(srcRgba, inputMeta.width, inputMeta.height, targetW, targetH);
+    const jpegBuf = encodeJpeg(targetW, targetH, dstRgba, quality);
+    const pngBuf = encodePng(targetW, targetH, dstRgba);
+    let data = jpegBuf;
+    let format = "jpeg";
+    if (pngBuf.length < jpegBuf.length) {
+      data = pngBuf;
+      format = "png";
     }
     if (data.length >= originalBytes) return null;
-    const meta = await sharp(data).metadata();
     return {
       data,
       originalBytes,
       shrunkBytes: data.length,
-      originalWidth: inputMeta.width ?? 0,
-      originalHeight: inputMeta.height ?? 0,
-      width: meta.width ?? 0,
-      height: meta.height ?? 0,
+      originalWidth: inputMeta.width,
+      originalHeight: inputMeta.height,
+      width: targetW,
+      height: targetH,
       format
     };
   } catch {
@@ -6521,6 +9910,17 @@ function imageShrinkCacheDir() {
 function shrinkCacheKey(originalPath, size, mtimeMs, quality) {
   return createHash3("sha256").update(`${originalPath}:${size}:${mtimeMs}:${quality}`).digest("hex").slice(0, 16);
 }
+var SHRINK_CACHE_EXTENSION = /* @__PURE__ */ new Map([
+  ["jpeg", ".jpg"],
+  ["png", ".png"],
+  ["gif", ".gif"]
+]);
+var SHRINK_CACHE_FORMAT = /* @__PURE__ */ new Map([
+  [".jpg", "jpeg"],
+  [".png", "png"],
+  [".gif", "gif"],
+  [".webp", "webp"]
+]);
 function findCachedShrink(originalPath, size, mtimeMs, quality) {
   const prefix = `token-goat-shrink-${shrinkCacheKey(originalPath, size, mtimeMs, quality)}-`;
   const dir = imageShrinkCacheDir();
@@ -6532,11 +9932,13 @@ function findCachedShrink(originalPath, size, mtimeMs, quality) {
   }
   for (const file of entries) {
     if (!file.startsWith(prefix)) continue;
-    const m = /^(\d+)x(\d+)(\.webp|\.jpg)$/.exec(file.slice(prefix.length));
+    const m = /^(\d+)x(\d+)(\.webp|\.jpg|\.png|\.gif)$/.exec(file.slice(prefix.length));
     if (m === null) continue;
+    const format = SHRINK_CACHE_FORMAT.get(m[3] ?? "");
+    if (format === void 0) continue;
     return {
       filePath: path6.join(dir, file),
-      format: m[3] === ".jpg" ? "jpeg" : "webp",
+      format,
       originalWidth: Number(m[1]),
       originalHeight: Number(m[2])
     };
@@ -6548,7 +9950,8 @@ function writeCachedShrink(originalPath, result, mtimeMs, quality) {
     const dir = imageShrinkCacheDir();
     ensureDirSync(dir);
     const key = shrinkCacheKey(originalPath, result.originalBytes, mtimeMs, quality);
-    const ext = result.format === "jpeg" ? ".jpg" : ".webp";
+    const ext = SHRINK_CACHE_EXTENSION.get(result.format);
+    if (ext === void 0) return;
     atomicWriteBytes(path6.join(dir, `token-goat-shrink-${key}-${result.originalWidth}x${result.originalHeight}${ext}`), result.data);
   } catch {
   }
@@ -6655,7 +10058,11 @@ async function preReadImageHandler(event) {
 }
 registerHook("pre_tool_use", preReadImageHandler, { toolName: "Read" });
 
+// src/embeddings.ts
+init_define_import_meta_env();
+
 // src/embed_model.ts
+init_define_import_meta_env();
 import { createHash as createHash4 } from "node:crypto";
 import * as fs11 from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
@@ -6663,6 +10070,7 @@ import * as path7 from "node:path";
 import { pipeline } from "node:stream/promises";
 
 // src/embed_tokenizer.ts
+init_define_import_meta_env();
 var MAX_SEQUENCE_TOKENS = 512;
 var UnsupportedTokenizerError = class extends Error {
   constructor(message) {
@@ -7685,15 +11093,22 @@ function _pathPriorityPenalty(filePath) {
   return 0;
 }
 
+// src/parser_fingerprint.ts
+init_define_import_meta_env();
+var PARSER_FINGERPRINT = "4659c517f042a452";
+
 // src/hooks_read.ts
+init_define_import_meta_env();
 import * as fs17 from "node:fs";
 import * as path13 from "node:path";
 
 // src/compact.ts
+init_define_import_meta_env();
 import * as fs12 from "node:fs";
 import * as path8 from "node:path";
 
 // src/overflow_guard.ts
+init_define_import_meta_env();
 function estimateTokensFromLength(length) {
   return Math.max(1, Math.floor(Math.max(0, length) / 3) + 1);
 }
@@ -7923,8 +11338,8 @@ function getContextPressure(cache) {
     const rawTotal = pressureRawTotal(cache);
     const baseline = cache.pressureBaselineTokens ?? 0;
     const total = Math.max(0, rawTotal - baseline);
-    const window = getEffectiveAutoTriggerWindow();
-    const fill = total / window;
+    const window2 = getEffectiveAutoTriggerWindow();
+    const fill = total / window2;
     return {
       fillFraction: fill,
       tier: tierForFraction(fill)
@@ -8278,6 +11693,7 @@ function buildManifestWithCount(sessionId, opts) {
 }
 
 // src/snapshots.ts
+init_define_import_meta_env();
 import * as fs13 from "node:fs";
 import * as path9 from "node:path";
 var MAX_SNAPSHOTS_PER_SESSION = 150;
@@ -8479,6 +11895,7 @@ function cleanup_stale(maxAgeHours = 24) {
 }
 
 // src/hints.ts
+init_define_import_meta_env();
 var HINT_PRIORITY_MEDIUM = 3;
 function buildPackageManifestHint(options) {
   try {
@@ -8508,7 +11925,11 @@ function _sanitizeHintPath(path26) {
   return path26.replace(/[\x00]/g, "").slice(0, 200);
 }
 
+// src/hints/markdown_hints.ts
+init_define_import_meta_env();
+
 // src/markdown_lines.ts
+init_define_import_meta_env();
 function* eachUnfencedLine(lines2) {
   let fence = null;
   for (let i = 0; i < lines2.length; i++) {
@@ -8626,6 +12047,7 @@ function extractChangelogVersionHint(content, filePath) {
 }
 
 // src/hints/file_type_handler.ts
+init_define_import_meta_env();
 var FILE_TYPE_THRESHOLDS = {
   pdf: 0,
   // always intercept (any size)
@@ -8861,6 +12283,7 @@ function dispatchFileTypeHandler(filePath, content, contentLengthHint) {
 }
 
 // src/doc_compact.ts
+init_define_import_meta_env();
 import * as fs14 from "fs";
 import * as path10 from "path";
 var defaultSentencesPerSection = 2;
@@ -9072,6 +12495,7 @@ function compactDoc(filePath, heading) {
 }
 
 // src/evidence_cache.ts
+init_define_import_meta_env();
 import crypto from "node:crypto";
 import fs15 from "node:fs";
 import path11 from "node:path";
@@ -9201,6 +12625,7 @@ ${changed.map((entry) => `- ${entry.source} (use a fresh surgical read)`).join("
 }
 
 // src/notebook_compact.ts
+init_define_import_meta_env();
 import * as fs16 from "node:fs";
 import * as path12 from "node:path";
 var NB_STRIP_MIN_SAVINGS = 4096;
@@ -9294,6 +12719,120 @@ function getOrCreateSidecar(rawBytes, cacheRoot, opts = {}) {
   return [sidecarPath, true];
 }
 
+// src/code_fold.ts
+init_define_import_meta_env();
+var FOLDABLE_KINDS = /* @__PURE__ */ new Set(["function", "method", "func", "def", "fn", "procedure", "constructor", "variable"]);
+var MIN_FOLDED_ROWS = 3;
+function planBodyFolds(rows, spans, keep, minSpan) {
+  if (rows.length === 0 || spans.length === 0 || keep < 1) return [];
+  const rowAt = /* @__PURE__ */ new Map();
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    if (row !== void 0) rowAt.set(row.no, i);
+  }
+  const ordered = [...spans].sort((a, b) => a.lineStart - b.lineStart || b.lineEnd - a.lineEnd);
+  const folds = [];
+  let foldedThrough = -1;
+  for (const span of ordered) {
+    if (!FOLDABLE_KINDS.has(span.kind)) continue;
+    if (span.lineEnd - span.lineStart + 1 < minSpan) continue;
+    if (span.lineStart <= foldedThrough) continue;
+    const firstFolded = span.lineStart + keep;
+    if (firstFolded > span.lineEnd) continue;
+    let startIdx = -1;
+    let endIdx = -1;
+    for (let line = firstFolded; line <= span.lineEnd; line++) {
+      const idx = rowAt.get(line);
+      if (idx === void 0) continue;
+      if (startIdx < 0) startIdx = idx;
+      endIdx = idx;
+    }
+    if (startIdx < 0 || endIdx < startIdx) continue;
+    const len = endIdx - startIdx + 1;
+    const firstRow = rows[startIdx];
+    const lastRow = rows[endIdx];
+    if (firstRow === void 0 || lastRow === void 0) continue;
+    if (lastRow.no - firstRow.no + 1 !== len) continue;
+    if (len < MIN_FOLDED_ROWS) continue;
+    folds.push({ startIdx, len, name: span.name, kind: "body", firstLine: firstRow.no, lastLine: lastRow.no });
+    foldedThrough = span.lineEnd;
+  }
+  return folds;
+}
+var SLASH_STAR = { line: ["//"], open: "/*", close: "*/" };
+var HASH = { line: ["#"] };
+var DOUBLE_DASH = { line: ["--"] };
+var COMMENT_SYNTAX = new Map([
+  ...["ts", "tsx", "js", "jsx", "mjs", "cjs", "java", "c", "h", "cc", "cpp", "hpp", "cs", "go", "rs", "swift", "kt", "scala", "php", "dart"].map(
+    (ext) => [ext, SLASH_STAR]
+  ),
+  ...["py", "rb", "sh", "bash", "zsh", "pl", "r"].map((ext) => [ext, HASH]),
+  ...["sql", "lua", "hs"].map((ext) => [ext, DOUBLE_DASH])
+]);
+function commentSyntaxFor(path26) {
+  const dot = path26.lastIndexOf(".");
+  if (dot < 0) return null;
+  return COMMENT_SYNTAX.get(path26.slice(dot + 1).toLowerCase()) ?? null;
+}
+function planCommentFolds(rows, syntax, commentKeep, commentMinBlock, occupied) {
+  if (syntax === null || rows.length === 0 || commentKeep < 1 || commentMinBlock < 1) return [];
+  const folds = [];
+  let i = 0;
+  let inBlock = false;
+  while (i < rows.length) {
+    const start = i;
+    while (i < rows.length) {
+      const text = rows[i]?.text ?? "";
+      const trimmed = text.trim();
+      if (inBlock) {
+        if (syntax.close !== void 0 && trimmed.includes(syntax.close)) inBlock = false;
+        i++;
+        continue;
+      }
+      if (syntax.open !== void 0 && trimmed.startsWith(syntax.open)) {
+        if (syntax.close === void 0 || !trimmed.slice(syntax.open.length).includes(syntax.close)) inBlock = true;
+        i++;
+        continue;
+      }
+      if (syntax.line.some((p) => trimmed.startsWith(p))) {
+        i++;
+        continue;
+      }
+      break;
+    }
+    const runLen = i - start;
+    if (runLen >= commentMinBlock) {
+      const foldStart = start + commentKeep;
+      const len = i - foldStart;
+      const firstRow = rows[foldStart];
+      const lastRow = rows[i - 1];
+      if (len >= MIN_FOLDED_ROWS && firstRow !== void 0 && lastRow !== void 0 && lastRow.no - firstRow.no + 1 === len) {
+        let clear = true;
+        for (let k = foldStart; k < i; k++) {
+          if (occupied.has(k)) {
+            clear = false;
+            break;
+          }
+        }
+        if (clear) folds.push({ startIdx: foldStart, len, name: "comment", kind: "comment", firstLine: firstRow.no, lastLine: lastRow.no });
+      }
+    }
+    if (i === start) i++;
+  }
+  return folds;
+}
+function mergeFolds(body, comment) {
+  const merged = [...body, ...comment].sort((a, b) => a.startIdx - b.startIdx || b.len - a.len);
+  const out = [];
+  let through = -1;
+  for (const fold of merged) {
+    if (fold.startIdx <= through) continue;
+    out.push(fold);
+    through = fold.startIdx + fold.len - 1;
+  }
+  return out;
+}
+
 // src/hooks_read.ts
 function isTsConfigFile(basename12) {
   const lower = basename12.toLowerCase();
@@ -9348,6 +12887,15 @@ function readIntToolInput(event, key) {
   }
   return void 0;
 }
+function readStartLine(event) {
+  const resp = event.raw["tool_response"];
+  if (resp === null || typeof resp !== "object") return 1;
+  const file = resp["file"];
+  if (file === null || typeof file !== "object") return 1;
+  const start = file["startLine"];
+  if (typeof start === "number" && Number.isSafeInteger(start) && start >= 1) return start;
+  return 1;
+}
 var SLICE_ESTIMATE_SCAN_CAP_BYTES = 2 * 1024 * 1024;
 var NEAR_SINGLE_LINE_SCAN_THRESHOLD = 20;
 function scanRequestedSlice(absPath, offset, limit) {
@@ -9637,7 +13185,8 @@ function preReadHandlerInner(event) {
     } catch {
     }
   }
-  if (event.toolName !== "Grep" && loadConfig().hints.stable_doc_compacts && _isDocFile(normalized)) {
+  const compactUnrangedRead = readIntToolInput(event, "offset") === void 0 && readIntToolInput(event, "limit") === void 0;
+  if (event.toolName !== "Grep" && compactUnrangedRead && loadConfig().hints.stable_doc_compacts && _isDocFile(normalized)) {
     const compactPath = compactPathFor(normalized);
     if (isCompactFresh(compactPath, normalized)) {
       const compactBody = readCompactBody(compactPath);
@@ -9647,7 +13196,7 @@ function preReadHandlerInner(event) {
         const savedBytes = counterfactualCredit(fullSize, compactBody.length);
         recordStat("session_hint", savedBytes, savedTokensFromBytes(savedBytes));
         return denyOutput(
-          "Serving the extractive compact sidecar in place of the full file (source unchanged since the last `compact-doc` build):\n\n" + fenceUntrustedFileContent(compactBody) + '\n\nUse `token-goat compact-doc "' + shown + '" --force` to rebuild it, or `token-goat compact-doc "' + shown + '" --show` to view it directly. ' + editAnywayHint(normalized)
+          "Serving the extractive compact sidecar in place of the full file (source unchanged since the last `compact-doc` build):\n\n" + fenceUntrustedFileContent(compactBody) + '\n\nThis is a lossy extract, not the whole file: front matter and any prose before the first heading are dropped entirely, each section is cut to its opening sentences, and long code fences are truncated. If you need content it left out, re-read with offset/limit for a line window, or `token-goat section "' + shown + '::Heading"` for one section in full. Use `token-goat compact-doc "' + shown + '" --force` to rebuild it, or `token-goat compact-doc "' + shown + '" --show` to view it directly. ' + editAnywayHint(normalized)
         );
       }
     }
@@ -10112,7 +13661,7 @@ function alreadyServedOutputId(event, normalized) {
     return null;
   }
 }
-function recordReadAsServedOutput(event) {
+function recordReadAsServedOutput(event, deliveredRaw = null) {
   try {
     const cfg = loadConfig().bash_compress;
     if (!cfg.enabled) return;
@@ -10122,7 +13671,7 @@ function recordReadAsServedOutput(event) {
     if (isImagePath(normalized)) return;
     const respText = extractReadOutput(event.raw);
     if (respText.includes("[Truncated:") || respText.includes("Truncated: PARTIAL view")) return;
-    const served = readWindowFromDisk(event, normalized);
+    const served = deliveredRaw ?? readWindowFromDisk(event, normalized);
     if (served === null) return;
     if (Buffer.byteLength(served, "utf-8") < Math.max(cfg.cache_min_bytes, IDENTICAL_READ_MIN_BODY_BYTES)) return;
     const id = storeBashOutputSync("Read " + normalized, served, 0, getCwd(event) ?? process.cwd());
@@ -10131,7 +13680,7 @@ function recordReadAsServedOutput(event) {
   }
 }
 var READ_NUMBERED_ROW_RE = /^\s*(\d+)[\t→](.*)$/;
-function parseNumberedReadResult(respText) {
+function parseNumberedReadResult(respText, firstLine = 1) {
   const lines2 = respText.split("\n");
   const header = [];
   const rows = [];
@@ -10156,7 +13705,10 @@ function parseNumberedReadResult(respText) {
     rows.push({ no: prev.no + 1, text: m[2] ?? "", raw: line });
   }
   for (; i < lines2.length; i++) trailer.push(lines2[i] ?? "");
-  return rows.length > 0 ? { header, rows, trailer } : null;
+  if (rows.length > 0) return { header, rows, trailer };
+  if (respText === "") return null;
+  const plain = lines2.map((text, idx) => ({ no: firstLine + idx, text, raw: text }));
+  return { header: [], rows: plain, trailer: [] };
 }
 var SERVED_RUN_COMPARISON_BUDGET = 4e5;
 var SERVED_RUN_ANCHORS_PER_LINE = 32;
@@ -10211,7 +13763,7 @@ function elideAlreadyServedLines(event, respText) {
   if (respText.includes("[Truncated:") || respText.includes("Truncated: PARTIAL view")) return null;
   const ids = getFileServedOutputs(normalized);
   if (ids.length === 0) return null;
-  const parsed = parseNumberedReadResult(respText);
+  const parsed = parseNumberedReadResult(respText, readStartLine(event));
   if (parsed === null) return null;
   if (redactSecrets(respText).count > 0) return null;
   const bodies = [];
@@ -10285,20 +13837,102 @@ function elideAlreadyServedLines(event, respText) {
   }
   return emitRewrite(rewritten, "read", { kind: "read:served_elide", originalBytes });
 }
+var BODY_FOLD_KEEP_LINES = 8;
+var BODY_FOLD_MIN_SPAN = 20;
+var COMMENT_FOLD_KEEP_LINES = 2;
+var COMMENT_FOLD_MIN_BLOCK = 12;
+var BODY_FOLD_SYMBOL_LIMIT = 1e4;
+function bodyFoldNotice(name, firstLine, lastLine, shownPath) {
+  const n = lastLine - firstLine + 1;
+  return `... ${n} more lines of ${name} (${firstLine}-${lastLine}) folded -- token-goat read "${shownPath}::${name}"`;
+}
+function commentFoldNotice(firstLine, lastLine, shownPath) {
+  const n = lastLine - firstLine + 1;
+  return `... ${n} more comment lines (${firstLine}-${lastLine}) folded -- Read "${shownPath}" with offset=${firstLine}, limit=${n}`;
+}
+function foldCodeBodies(event, respText) {
+  if (!loadConfig().hints.fold_code_bodies) return null;
+  const filePath = getFilePath(event);
+  if (filePath === void 0) return null;
+  const normalized = normalizePath(filePath);
+  if (isImagePath(normalized)) return null;
+  if (readIntToolInput(event, "offset") !== void 0 || readIntToolInput(event, "limit") !== void 0) return null;
+  if (respText.includes("[Truncated:") || respText.includes("Truncated: PARTIAL view")) return null;
+  if (redactSecrets(respText).count > 0) return null;
+  const parsed = parseNumberedReadResult(respText, readStartLine(event));
+  if (parsed === null) return null;
+  let spans = [];
+  try {
+    const entry = getFileEntry(normalized);
+    if (entry !== null && entry.sha !== "" && entry.sha === fingerprintFile(normalized) && entry.parserSha === PARSER_FINGERPRINT) {
+      spans = querySymbols({ filePath: normalized, limit: BODY_FOLD_SYMBOL_LIMIT });
+    }
+  } catch {
+    spans = [];
+  }
+  const bodyFolds = planBodyFolds(parsed.rows, spans, BODY_FOLD_KEEP_LINES, BODY_FOLD_MIN_SPAN);
+  const claimed = /* @__PURE__ */ new Set();
+  for (const fold of bodyFolds) for (let i = fold.startIdx; i < fold.startIdx + fold.len; i++) claimed.add(i);
+  const commentFolds = planCommentFolds(
+    parsed.rows,
+    commentSyntaxFor(normalized),
+    COMMENT_FOLD_KEEP_LINES,
+    COMMENT_FOLD_MIN_BLOCK,
+    claimed
+  );
+  const folds = mergeFolds(bodyFolds, commentFolds);
+  if (folds.length === 0) return null;
+  const shown = displaySafePath(normalized);
+  const out = [...parsed.header];
+  const rawOut = [];
+  let at = 0;
+  for (const fold of folds) {
+    for (let i = at; i < fold.startIdx; i++) {
+      out.push(parsed.rows[i]?.raw ?? "");
+      rawOut.push(parsed.rows[i]?.text ?? "");
+    }
+    out.push(fold.kind === "comment" ? commentFoldNotice(fold.firstLine, fold.lastLine, shown) : bodyFoldNotice(fold.name, fold.firstLine, fold.lastLine, shown));
+    at = fold.startIdx + fold.len;
+  }
+  for (let i = at; i < parsed.rows.length; i++) {
+    out.push(parsed.rows[i]?.raw ?? "");
+    rawOut.push(parsed.rows[i]?.text ?? "");
+  }
+  out.push(...parsed.trailer);
+  const rewritten = out.join("\n");
+  const originalBytes = Buffer.byteLength(respText, "utf-8");
+  if (!isRewriteWorthwhile({
+    originalBytes,
+    rewrittenBytes: Buffer.byteLength(rewritten, "utf-8"),
+    noticeBytes: 0,
+    minNetSavingsBytes: resolveMinNetSavingsBytes()
+  })) {
+    return null;
+  }
+  return {
+    output: emitRewrite(rewritten, "read", { kind: "read:body_fold", originalBytes }),
+    deliveredRaw: rawOut.join("\n")
+  };
+}
 function postReadHandler(event) {
-  const elided = elideAlreadyServedLines(event, extractReadOutput(event.raw));
-  const out = applyHintTracking(event, postReadHandlerInner(event, elided !== null), classifyReadHint);
-  recordReadAsServedOutput(event);
-  return elided ?? out;
+  const respText = extractReadOutput(event.raw);
+  const elided = elideAlreadyServedLines(event, respText);
+  const folded = elided === null ? foldCodeBodies(event, respText) : null;
+  const rewrite = elided ?? folded?.output ?? null;
+  const out = applyHintTracking(event, postReadHandlerInner(event, rewrite !== null), classifyReadHint);
+  recordReadAsServedOutput(event, folded?.deliveredRaw ?? null);
+  return rewrite ?? out;
 }
 registerHook("post_tool_use", postReadHandler, { toolName: "Read" });
 
 // src/cli_context_stats.ts
+init_define_import_meta_env();
 import * as fs19 from "node:fs";
 import * as os2 from "node:os";
 import * as path15 from "node:path";
 
 // src/confirm_apply.ts
+init_define_import_meta_env();
 import * as readline from "node:readline";
 async function defaultConfirm(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -10350,6 +13984,7 @@ ${diff}
 }
 
 // src/memory_prune.ts
+init_define_import_meta_env();
 import * as fs18 from "node:fs";
 import * as path14 from "node:path";
 var ENTRY_RE = /^\s*-\s*\[(?<title>[^\]]+)\]\((?<target>[^)]+?\.md)\)/;
@@ -10814,6 +14449,7 @@ async function runContextStats(opts = {}) {
 }
 
 // src/baseline.ts
+init_define_import_meta_env();
 import * as fs20 from "node:fs";
 import * as path16 from "node:path";
 var SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -11054,6 +14690,7 @@ function formatMemSuggestions(projectRoot) {
 }
 
 // src/untrusted_fence.ts
+init_define_import_meta_env();
 function injectionFencingEnabled() {
   try {
     return loadConfig().injection.enabled;
@@ -11082,6 +14719,7 @@ function scanAndRecord(text) {
 }
 
 // src/repomap.ts
+init_define_import_meta_env();
 import * as fs21 from "fs";
 import * as path17 from "path";
 function getTrackedFiles(cwd = process.cwd()) {
@@ -11106,15 +14744,14 @@ function getTrackedFiles(cwd = process.cwd()) {
   }
 }
 
-// src/parser_fingerprint.ts
-var PARSER_FINGERPRINT = "4659c517f042a452";
-
 // src/parser.ts
+init_define_import_meta_env();
 import * as fs22 from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import * as path22 from "node:path";
 
 // src/languages/csharp.ts
+init_define_import_meta_env();
 var IDENT = "@?[A-Za-z_][A-Za-z0-9_]*";
 var DOTTED_IDENT = `${IDENT}(?:\\.${IDENT})*`;
 function stripVerbatim(name) {
@@ -11299,6 +14936,7 @@ function extractCsharp(content, filePath) {
 }
 
 // src/languages/php.ts
+init_define_import_meta_env();
 var NAMESPACE_RE2 = /^namespace\s+([\w\\]+)\s*;/;
 var CLASS_RE = /^(?:(?:abstract|final|readonly)\s+)*(class|interface|trait|enum)\s+([A-Za-z_][A-Za-z0-9_]*)/;
 var METHOD_RE2 = new RegExp(
@@ -11435,6 +15073,7 @@ function extractPhp(content, filePath) {
 }
 
 // src/languages/html.ts
+init_define_import_meta_env();
 var ID_RE = /(?<![\w-])id=(["'])((?:(?!\1)[\s\S])+)\1/gi;
 var CLASS_RE2 = /(?<![\w-])class=(["'])((?:(?!\1)[\s\S])+)\1/gi;
 var LINK_RE = /<link[^>]*href=(["'])((?:(?!\1)[\s\S])+)\1/gi;
@@ -11556,6 +15195,7 @@ function extractHtml(content, filePath) {
 }
 
 // src/languages/liquid.ts
+init_define_import_meta_env();
 import * as path18 from "node:path";
 var INCLUDE_RE = /{%-?\s*include\s+(['"])((?:(?!\1)[\s\S])+?)\1/gi;
 var SECTION_RE = /{%-?\s*section\s+(['"])((?:(?!\1)[\s\S])+?)\1/gi;
@@ -11621,6 +15261,7 @@ function extractLiquid(content, filePath, relPath) {
 }
 
 // src/languages/kotlin.ts
+init_define_import_meta_env();
 var IMPORT_RE = /^import\s+([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*(?:\.\*)?)/;
 var LEADING_ANNOTATION_RE = /^\s*(?:@[A-Za-z_][A-Za-z0-9_.]*(?::[A-Za-z_][A-Za-z0-9_]*)?(?:\([^()]*\))?\s+)+/;
 function stripLeadingAnnotations(s) {
@@ -11768,6 +15409,7 @@ function extractKotlin(content, filePath) {
 }
 
 // src/languages/swift.ts
+init_define_import_meta_env();
 var IDENT_START = "A-Za-z_\\u00C0-\\uFFFF";
 var IDENT_CONT = "A-Za-z0-9_\\u00C0-\\uFFFF";
 var IDENT2 = `(?:\`[^\`]+\`|[${IDENT_START}][${IDENT_CONT}]*)`;
@@ -11940,6 +15582,7 @@ function extractSwift(content, filePath) {
 }
 
 // src/languages/scala.ts
+init_define_import_meta_env();
 var IMPORT_RE3 = /^import\s+([A-Za-z_][A-Za-z0-9_.]*(?:\._)?)/;
 var BRACE_IMPORT_RE = /^import\s+([A-Za-z_][A-Za-z0-9_.]*)\.\{([^}]*)\}/;
 var MODS = "(?:(?:implicit|lazy|sealed|abstract|final|private|protected|override|covariant|contravariant|case)\\s+)*";
@@ -12095,6 +15738,7 @@ function extractScala(content, filePath) {
 }
 
 // src/languages/lua.ts
+init_define_import_meta_env();
 function nearestFunctionName(stack) {
   for (let i = stack.length - 1; i >= 0; i--) {
     const frame = stack[i];
@@ -12260,6 +15904,7 @@ function extractLua(content, filePath) {
 }
 
 // src/languages/elixir.ts
+init_define_import_meta_env();
 function nearestDefName(stack) {
   for (let i = stack.length - 1; i >= 0; i--) {
     const frame = stack[i];
@@ -12359,6 +16004,7 @@ function extractElixir(content, filePath) {
 }
 
 // src/languages/dart.ts
+init_define_import_meta_env();
 var CLASS_RE4 = /^(?:(?:abstract|base|interface|final|sealed|mixin)\s+)*class\s+([A-Za-z_][A-Za-z0-9_]*)/;
 var ENUM_RE2 = /^enum\s+([A-Za-z_][A-Za-z0-9_]*)/;
 var MIXIN_RE = /^(?:base\s+)?mixin\s+([A-Za-z_][A-Za-z0-9_]*)/;
@@ -12503,6 +16149,7 @@ function extractDart(content, filePath) {
 }
 
 // src/languages/zig.ts
+init_define_import_meta_env();
 var VAR_PREFIX = String.raw`(?:pub\s+)?(?:export\s+|extern\s+(?:"[^"]*"\s+)?)?(?:threadlocal\s+)?`;
 var FN_PREFIX = String.raw`(?:pub\s+)?(?:export\s+|extern\s+(?:"[^"]*"\s+)?|inline\s+|noinline\s+)?`;
 var NAME2 = String.raw`([A-Za-z_][A-Za-z0-9_]*)`;
@@ -12606,6 +16253,7 @@ function extractZig(content, filePath) {
 }
 
 // src/languages/r.ts
+init_define_import_meta_env();
 var FUNC_ASSIGN_RE = /^(?:`([^`]+)`|([A-Za-z._][A-Za-z0-9_.]*))\s*(?:<-|=)\s*(?:function|\\)\s*\(/;
 var SETCLASS_RE = /^(?:[A-Za-z_][A-Za-z0-9_.]*\s*(?:<-|=)\s*)?setClass\s*\(\s*["']([A-Za-z_][A-Za-z0-9_.]*)/;
 var SETMETHOD_RE = /^(?:[A-Za-z_][A-Za-z0-9_.]*\s*(?:<-|=)\s*)?setMethod\s*\(\s*["']([A-Za-z_][A-Za-z0-9_.]*)/;
@@ -12699,6 +16347,7 @@ function extractR(content, filePath) {
 }
 
 // src/languages/graphql_idx.ts
+init_define_import_meta_env();
 function findUnquotedHash(line) {
   for (let i = 0; i < line.length; i++) {
     if (line[i] === "#" && !isInsideStringLiteral(line, i)) return i;
@@ -12829,6 +16478,7 @@ function extractGraphql(content, filePath) {
 }
 
 // src/languages/sql_idx.ts
+init_define_import_meta_env();
 var MAX_SYMBOLS3 = 500;
 var MAX_HEADING_LEN2 = 128;
 var BARE = "[A-Za-z_][A-Za-z0-9_$]*";
@@ -13091,6 +16741,7 @@ function extractSql(content, filePath) {
 }
 
 // src/languages/bash_idx.ts
+init_define_import_meta_env();
 var MAX_SYMBOLS4 = 500;
 var FUNC_NAME = "[A-Za-z_][A-Za-z0-9_.+:-]*";
 var FUNC_KEYWORD_RE = new RegExp(`^function\\s+(${FUNC_NAME})\\s*(?:\\(\\s*\\))?`);
@@ -13225,6 +16876,7 @@ function extractBash(content, filePath) {
 }
 
 // src/languages/makefile_idx.ts
+init_define_import_meta_env();
 var MAX_SYMBOLS5 = 500;
 var MAX_HEADING_LEN3 = 120;
 function stripComments(text) {
@@ -13338,6 +16990,7 @@ function extractMakefile(content, filePath) {
 }
 
 // src/languages/proto_idx.ts
+init_define_import_meta_env();
 var MAX_SYMBOLS6 = 500;
 var MAX_HEADING_LEN4 = 120;
 function stripComments2(text) {
@@ -13449,6 +17102,7 @@ function extractProto(content, filePath) {
 }
 
 // src/languages/terraform_idx.ts
+init_define_import_meta_env();
 var MAX_SYMBOLS7 = 500;
 var MAX_HEADING_LEN5 = 120;
 var HEREDOC_START_RE = /<<-?([A-Za-z_][A-Za-z0-9_]*)/g;
@@ -13569,6 +17223,7 @@ function extractTerraform(content, filePath) {
 }
 
 // src/languages/powershell_idx.ts
+init_define_import_meta_env();
 var MAX_SYMBOLS8 = 500;
 var IDENT_START2 = "A-Za-z_\\u00C0-\\uFFFF";
 var IDENT_CONT2 = "A-Za-z0-9_\\u00C0-\\uFFFF";
@@ -13798,6 +17453,7 @@ function extractPowershell(content, filePath) {
 }
 
 // src/languages/apex.ts
+init_define_import_meta_env();
 var MAX_SYMBOLS9 = 500;
 var IDENT4 = "[A-Za-z_][A-Za-z0-9_]*";
 var MODIFIER = "(?:public|private|protected|global|static|final|override|virtual|abstract|webservice|testMethod|transient|with|without|inherited|sharing)";
@@ -13953,6 +17609,7 @@ function extractApex(content, filePath) {
 }
 
 // src/languages/salesforce_metadata.ts
+init_define_import_meta_env();
 import * as path19 from "node:path";
 var MAX_SYMBOLS10 = 1e3;
 var MAX_REFS = 1e3;
@@ -14293,6 +17950,7 @@ function extractSalesforceMetadata(rawContent, filePath) {
 }
 
 // src/languages/salesforce_frontend.ts
+init_define_import_meta_env();
 import * as path20 from "node:path";
 function lines(content) {
   return content.split("\n");
@@ -14456,6 +18114,7 @@ function extractSalesforceMarkup(content, filePath) {
 }
 
 // src/languages/sfc_idx.ts
+init_define_import_meta_env();
 import * as path21 from "node:path";
 var MAX_SYMBOLS11 = 500;
 function dedupe2(values, key) {
@@ -14651,6 +18310,7 @@ function extractAstro(content, filePath) {
 }
 
 // src/languages/ipynb_idx.ts
+init_define_import_meta_env();
 function normalizeSource(source) {
   if (typeof source === "string") return source;
   if (!Array.isArray(source)) return "";
@@ -16737,6 +20397,7 @@ function safeMtime(filePath) {
 }
 
 // src/index_prune.ts
+init_define_import_meta_env();
 import * as fs23 from "node:fs";
 import * as path23 from "node:path";
 function removeFileFromIndex(db, filePath) {
@@ -16966,6 +20627,7 @@ function recordKnownRootThrottled(filePath, dir = dataDir(), dbPath = globalDbPa
 }
 
 // src/process_priority.ts
+init_define_import_meta_env();
 import * as os3 from "node:os";
 var PRIORITY_BY_NAME = {
   normal: os3.constants.priority.PRIORITY_NORMAL,
@@ -16987,6 +20649,7 @@ function applyIndexingPriority() {
 }
 
 // src/worker.ts
+init_define_import_meta_env();
 import { spawn as spawn2 } from "node:child_process";
 import * as fs24 from "node:fs";
 import * as path24 from "node:path";
@@ -17670,6 +21333,7 @@ function runDetachedWorkerDaemon() {
 }
 
 // src/hooks_index.ts
+init_define_import_meta_env();
 import * as fs25 from "node:fs";
 import * as path25 from "node:path";
 function dirtyQueuePath() {
@@ -17724,6 +21388,7 @@ function preCompactIndexHandler(_event) {
 registerHook("pre_compact", preCompactIndexHandler, { advisory: true });
 
 // src/url_policy.ts
+init_define_import_meta_env();
 import { domainToUnicode } from "node:url";
 function wildcardToRegExp(pattern) {
   const escaped = pattern.replace(/[.+^${}()|[\]\\?]/g, "\\$&").replace(/\*/g, ".*");
@@ -17941,12 +21606,14 @@ export {
   detectWalkMode,
   getProjectIndexCounts,
   getEmbeddingCoverage,
+  getParserFreshness,
   isIndexEmptyForProject,
   emptyIndexMessage,
   isHintCategory,
   classifyBashHint,
   classifyEditHint,
   applyHintTracking,
+  isSuppressionCategory,
   meetsSavingsFloor,
   getHintStatsSummary,
   getHintStatsTotals,
@@ -18096,6 +21763,7 @@ export {
   embeddingsDepsAvailable,
   searchEvidenceSemantically,
   buildDeltaCapsule,
+  PARSER_FINGERPRINT,
   buildLineDiff,
   confirmAndApply,
   findContentDuplicates,
@@ -18117,7 +21785,6 @@ export {
   fenceWithMatches,
   scanAndRecord,
   getTrackedFiles,
-  PARSER_FINGERPRINT,
   stripLeadingAttributes2 as stripLeadingAttributes,
   IMPORT_RE2 as IMPORT_RE,
   yamlOpenQuoteAfter,