token-goat 2.9.2 → 2.9.3

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

@@ -96,15 +96,2742 @@ import {
   toDisplayPath,
   toKB,
   withFileLock
-} from "./token-goat-chunk-UZ2NFOOZ.mjs";
+} from "./token-goat-chunk-KKHKXUVS.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) {
@@ -3312,6 +6074,7 @@ function emptyIndexMessage(rootDir) {
 }
 
 // src/hint_stats.ts
+init_define_import_meta_env();
 var HINT_CATEGORIES = [
   "bash_redirect",
   "bash_recall",
@@ -3414,7 +6177,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 +6189,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 +6379,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 +6787,7 @@ registerReset(() => {
 });
 
 // src/index_reader.ts
+init_define_import_meta_env();
 function toSymbolEntry(row) {
   return {
     filePath: row.file_path,
@@ -4213,6 +6978,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 +7114,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 +7339,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 +7966,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 +8325,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 +8349,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 +8383,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 +8981,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 +9770,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 +9807,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 +9898,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 +9920,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 +9938,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 +10046,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 +10058,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) {
@@ -7686,14 +11082,17 @@ function _pathPriorityPenalty(filePath) {
 }
 
 // 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 +11322,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 +11677,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 +11879,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 +11909,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 +12031,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 +12267,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 +12479,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 +12609,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;
@@ -10294,11 +13703,13 @@ function postReadHandler(event) {
 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 +13761,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 +14226,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 +14467,7 @@ function formatMemSuggestions(projectRoot) {
 }
 
 // src/untrusted_fence.ts
+init_define_import_meta_env();
 function injectionFencingEnabled() {
   try {
     return loadConfig().injection.enabled;
@@ -11082,6 +14496,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()) {
@@ -11107,14 +14522,17 @@ function getTrackedFiles(cwd = process.cwd()) {
 }
 
 // src/parser_fingerprint.ts
+init_define_import_meta_env();
 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 +14717,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 +14854,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 +14976,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 +15042,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 +15190,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 +15363,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 +15519,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 +15685,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 +15785,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 +15930,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 +16034,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 +16128,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 +16259,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 +16522,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 +16657,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 +16771,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 +16883,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 +17004,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 +17234,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 +17390,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 +17731,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 +17895,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 +18091,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 +20178,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 +20408,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 +20430,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 +21114,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 +21169,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, ".*");