@mettlelabs/mettle 0.0.0-beta.1 → 0.0.0-beta.1-linux-x64

package/harness/chunk-nz5sv9as.mjs

@@ -0,0 +1,1642 @@
+import {
+  __commonJS,
+  __require
+} from "./chunk-fjx29qvp.mjs";
+
+// node_modules/.bun/ms@2.0.0/node_modules/ms/index.js
+var require_ms = __commonJS(function(exports, module) {
+  var s = 1000;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var y = d * 365.25;
+  module.exports = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0) {
+      return parse(val);
+    } else if (type === "number" && isNaN(val) === false) {
+      return options.long ? fmtLong(val) : fmtShort(val);
+    }
+    throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
+  };
+  function parse(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
+    }
+    var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);
+    if (!match) {
+      return;
+    }
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return;
+    }
+  }
+  function fmtShort(ms) {
+    if (ms >= d) {
+      return Math.round(ms / d) + "d";
+    }
+    if (ms >= h) {
+      return Math.round(ms / h) + "h";
+    }
+    if (ms >= m) {
+      return Math.round(ms / m) + "m";
+    }
+    if (ms >= s) {
+      return Math.round(ms / s) + "s";
+    }
+    return ms + "ms";
+  }
+  function fmtLong(ms) {
+    return plural(ms, d, "day") || plural(ms, h, "hour") || plural(ms, m, "minute") || plural(ms, s, "second") || ms + " ms";
+  }
+  function plural(ms, n, name) {
+    if (ms < n) {
+      return;
+    }
+    if (ms < n * 1.5) {
+      return Math.floor(ms / n) + " " + name;
+    }
+    return Math.ceil(ms / n) + " " + name + "s";
+  }
+});
+
+// node_modules/.bun/debug@2.6.9/node_modules/debug/src/debug.js
+var require_debug = __commonJS(function(exports, module) {
+  exports = module.exports = createDebug.debug = createDebug["default"] = createDebug;
+  exports.coerce = coerce;
+  exports.disable = disable;
+  exports.enable = enable;
+  exports.enabled = enabled;
+  exports.humanize = require_ms();
+  exports.names = [];
+  exports.skips = [];
+  exports.formatters = {};
+  var prevTime;
+  function selectColor(namespace) {
+    var hash = 0, i;
+    for (i in namespace) {
+      hash = (hash << 5) - hash + namespace.charCodeAt(i);
+      hash |= 0;
+    }
+    return exports.colors[Math.abs(hash) % exports.colors.length];
+  }
+  function createDebug(namespace) {
+    function debug() {
+      if (!debug.enabled)
+        return;
+      var self = debug;
+      var curr = +new Date;
+      var ms = curr - (prevTime || curr);
+      self.diff = ms;
+      self.prev = prevTime;
+      self.curr = curr;
+      prevTime = curr;
+      var args = new Array(arguments.length);
+      for (var i = 0;i < args.length; i++) {
+        args[i] = arguments[i];
+      }
+      args[0] = exports.coerce(args[0]);
+      if (typeof args[0] !== "string") {
+        args.unshift("%O");
+      }
+      var index = 0;
+      args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
+        if (match === "%%")
+          return match;
+        index++;
+        var formatter = exports.formatters[format];
+        if (typeof formatter === "function") {
+          var val = args[index];
+          match = formatter.call(self, val);
+          args.splice(index, 1);
+          index--;
+        }
+        return match;
+      });
+      exports.formatArgs.call(self, args);
+      var logFn = debug.log || exports.log || console.log.bind(console);
+      logFn.apply(self, args);
+    }
+    debug.namespace = namespace;
+    debug.enabled = exports.enabled(namespace);
+    debug.useColors = exports.useColors();
+    debug.color = selectColor(namespace);
+    if (typeof exports.init === "function") {
+      exports.init(debug);
+    }
+    return debug;
+  }
+  function enable(namespaces) {
+    exports.save(namespaces);
+    exports.names = [];
+    exports.skips = [];
+    var split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+    var len = split.length;
+    for (var i = 0;i < len; i++) {
+      if (!split[i])
+        continue;
+      namespaces = split[i].replace(/\*/g, ".*?");
+      if (namespaces[0] === "-") {
+        exports.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
+      } else {
+        exports.names.push(new RegExp("^" + namespaces + "$"));
+      }
+    }
+  }
+  function disable() {
+    exports.enable("");
+  }
+  function enabled(name) {
+    var i, len;
+    for (i = 0, len = exports.skips.length;i < len; i++) {
+      if (exports.skips[i].test(name)) {
+        return false;
+      }
+    }
+    for (i = 0, len = exports.names.length;i < len; i++) {
+      if (exports.names[i].test(name)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function coerce(val) {
+    if (val instanceof Error)
+      return val.stack || val.message;
+    return val;
+  }
+});
+
+// node_modules/.bun/debug@2.6.9/node_modules/debug/src/browser.js
+var require_browser = __commonJS(function(exports, module) {
+  exports = module.exports = require_debug();
+  exports.log = log;
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.storage = typeof chrome != "undefined" && typeof chrome.storage != "undefined" ? chrome.storage.local : localstorage();
+  exports.colors = [
+    "lightseagreen",
+    "forestgreen",
+    "goldenrod",
+    "dodgerblue",
+    "darkorchid",
+    "crimson"
+  ];
+  function useColors() {
+    if (typeof window !== "undefined" && window.process && window.process.type === "renderer") {
+      return true;
+    }
+    return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+  }
+  exports.formatters.j = function(v) {
+    try {
+      return JSON.stringify(v);
+    } catch (err) {
+      return "[UnexpectedJSONParseError]: " + err.message;
+    }
+  };
+  function formatArgs(args) {
+    var useColors = this.useColors;
+    args[0] = (useColors ? "%c" : "") + this.namespace + (useColors ? " %c" : " ") + args[0] + (useColors ? "%c " : " ") + "+" + exports.humanize(this.diff);
+    if (!useColors)
+      return;
+    var c = "color: " + this.color;
+    args.splice(1, 0, c, "color: inherit");
+    var index = 0;
+    var lastC = 0;
+    args[0].replace(/%[a-zA-Z%]/g, function(match) {
+      if (match === "%%")
+        return;
+      index++;
+      if (match === "%c") {
+        lastC = index;
+      }
+    });
+    args.splice(lastC, 0, c);
+  }
+  function log() {
+    return typeof console === "object" && console.log && Function.prototype.apply.call(console.log, console, arguments);
+  }
+  function save(namespaces) {
+    try {
+      if (namespaces == null) {
+        exports.storage.removeItem("debug");
+      } else {
+        exports.storage.debug = namespaces;
+      }
+    } catch (e) {}
+  }
+  function load() {
+    var r;
+    try {
+      r = exports.storage.debug;
+    } catch (e) {}
+    if (!r && typeof process !== "undefined" && "env" in process) {
+      r = process.env.DEBUG;
+    }
+    return r;
+  }
+  exports.enable(load());
+  function localstorage() {
+    try {
+      return window.localStorage;
+    } catch (e) {}
+  }
+});
+
+// node_modules/.bun/debug@2.6.9/node_modules/debug/src/node.js
+var require_node = __commonJS(function(exports, module) {
+  var tty = __require("tty");
+  var util = __require("util");
+  exports = module.exports = require_debug();
+  exports.init = init;
+  exports.log = log;
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.colors = [6, 2, 3, 4, 5, 1];
+  exports.inspectOpts = Object.keys(process.env).filter(function(key) {
+    return /^debug_/i.test(key);
+  }).reduce(function(obj, key) {
+    var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function(_, k) {
+      return k.toUpperCase();
+    });
+    var val = process.env[key];
+    if (/^(yes|on|true|enabled)$/i.test(val))
+      val = true;
+    else if (/^(no|off|false|disabled)$/i.test(val))
+      val = false;
+    else if (val === "null")
+      val = null;
+    else
+      val = Number(val);
+    obj[prop] = val;
+    return obj;
+  }, {});
+  var fd = parseInt(process.env.DEBUG_FD, 10) || 2;
+  if (fd !== 1 && fd !== 2) {
+    util.deprecate(function() {}, "except for stderr(2) and stdout(1), any other usage of DEBUG_FD is deprecated. Override debug.log if you want to use a different log function (https://git.io/debug_fd)")();
+  }
+  var stream = fd === 1 ? process.stdout : fd === 2 ? process.stderr : createWritableStdioStream(fd);
+  function useColors() {
+    return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(fd);
+  }
+  exports.formatters.o = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util.inspect(v, this.inspectOpts).split(`
+`).map(function(str) {
+      return str.trim();
+    }).join(" ");
+  };
+  exports.formatters.O = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util.inspect(v, this.inspectOpts);
+  };
+  function formatArgs(args) {
+    var name = this.namespace;
+    var useColors = this.useColors;
+    if (useColors) {
+      var c = this.color;
+      var prefix = "  \x1B[3" + c + ";1m" + name + " " + "\x1B[0m";
+      args[0] = prefix + args[0].split(`
+`).join(`
+` + prefix);
+      args.push("\x1B[3" + c + "m+" + exports.humanize(this.diff) + "\x1B[0m");
+    } else {
+      args[0] = new Date().toUTCString() + " " + name + " " + args[0];
+    }
+  }
+  function log() {
+    return stream.write(util.format.apply(util, arguments) + `
+`);
+  }
+  function save(namespaces) {
+    if (namespaces == null) {
+      delete process.env.DEBUG;
+    } else {
+      process.env.DEBUG = namespaces;
+    }
+  }
+  function load() {
+    return process.env.DEBUG;
+  }
+  function createWritableStdioStream(fd) {
+    var stream;
+    var tty_wrap = process.binding("tty_wrap");
+    switch (tty_wrap.guessHandleType(fd)) {
+      case "TTY":
+        stream = new tty.WriteStream(fd);
+        stream._type = "tty";
+        if (stream._handle && stream._handle.unref) {
+          stream._handle.unref();
+        }
+        break;
+      case "FILE":
+        var fs = __require("fs");
+        stream = new fs.SyncWriteStream(fd, { autoClose: false });
+        stream._type = "fs";
+        break;
+      case "PIPE":
+      case "TCP":
+        var net = __require("net");
+        stream = new net.Socket({
+          fd,
+          readable: false,
+          writable: true
+        });
+        stream.readable = false;
+        stream.read = null;
+        stream._type = "pipe";
+        if (stream._handle && stream._handle.unref) {
+          stream._handle.unref();
+        }
+        break;
+      default:
+        throw new Error("Implement me. Unknown stream file type!");
+    }
+    stream.fd = fd;
+    stream._isStdio = true;
+    return stream;
+  }
+  function init(debug) {
+    debug.inspectOpts = {};
+    var keys = Object.keys(exports.inspectOpts);
+    for (var i = 0;i < keys.length; i++) {
+      debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+    }
+  }
+  exports.enable(load());
+});
+
+// node_modules/.bun/debug@2.6.9/node_modules/debug/src/index.js
+var require_src = __commonJS(function(exports, module) {
+  if (typeof process !== "undefined" && process.type === "renderer") {
+    module.exports = require_browser();
+  } else {
+    module.exports = require_node();
+  }
+});
+
+// node_modules/.bun/stream-parser@0.3.1/node_modules/stream-parser/index.js
+var require_stream_parser = __commonJS(function(exports, module) {
+  var assert = __require("assert");
+  var debug = require_src()("stream-parser");
+  module.exports = Parser;
+  var INIT = -1;
+  var BUFFERING = 0;
+  var SKIPPING = 1;
+  var PASSTHROUGH = 2;
+  function Parser(stream) {
+    var isTransform = stream && typeof stream._transform == "function";
+    var isWritable = stream && typeof stream._write == "function";
+    if (!isTransform && !isWritable)
+      throw new Error("must pass a Writable or Transform stream in");
+    debug("extending Parser into stream");
+    stream._bytes = _bytes;
+    stream._skipBytes = _skipBytes;
+    if (isTransform)
+      stream._passthrough = _passthrough;
+    if (isTransform) {
+      stream._transform = transform;
+    } else {
+      stream._write = write;
+    }
+  }
+  function init(stream) {
+    debug("initializing parser stream");
+    stream._parserBytesLeft = 0;
+    stream._parserBuffers = [];
+    stream._parserBuffered = 0;
+    stream._parserState = INIT;
+    stream._parserCallback = null;
+    if (typeof stream.push == "function") {
+      stream._parserOutput = stream.push.bind(stream);
+    }
+    stream._parserInit = true;
+  }
+  function _bytes(n, fn) {
+    assert(!this._parserCallback, 'there is already a "callback" set!');
+    assert(isFinite(n) && n > 0, 'can only buffer a finite number of bytes > 0, got "' + n + '"');
+    if (!this._parserInit)
+      init(this);
+    debug("buffering %o bytes", n);
+    this._parserBytesLeft = n;
+    this._parserCallback = fn;
+    this._parserState = BUFFERING;
+  }
+  function _skipBytes(n, fn) {
+    assert(!this._parserCallback, 'there is already a "callback" set!');
+    assert(n > 0, 'can only skip > 0 bytes, got "' + n + '"');
+    if (!this._parserInit)
+      init(this);
+    debug("skipping %o bytes", n);
+    this._parserBytesLeft = n;
+    this._parserCallback = fn;
+    this._parserState = SKIPPING;
+  }
+  function _passthrough(n, fn) {
+    assert(!this._parserCallback, 'There is already a "callback" set!');
+    assert(n > 0, 'can only pass through > 0 bytes, got "' + n + '"');
+    if (!this._parserInit)
+      init(this);
+    debug("passing through %o bytes", n);
+    this._parserBytesLeft = n;
+    this._parserCallback = fn;
+    this._parserState = PASSTHROUGH;
+  }
+  function write(chunk, encoding, fn) {
+    if (!this._parserInit)
+      init(this);
+    debug("write(%o bytes)", chunk.length);
+    if (typeof encoding == "function")
+      fn = encoding;
+    data(this, chunk, null, fn);
+  }
+  function transform(chunk, output, fn) {
+    if (!this._parserInit)
+      init(this);
+    debug("transform(%o bytes)", chunk.length);
+    if (typeof output != "function") {
+      output = this._parserOutput;
+    }
+    data(this, chunk, output, fn);
+  }
+  function _data(stream, chunk, output, fn) {
+    if (stream._parserBytesLeft <= 0) {
+      return fn(new Error("got data but not currently parsing anything"));
+    }
+    if (chunk.length <= stream._parserBytesLeft) {
+      return function() {
+        return process2(stream, chunk, output, fn);
+      };
+    } else {
+      return function() {
+        var b = chunk.slice(0, stream._parserBytesLeft);
+        return process2(stream, b, output, function(err) {
+          if (err)
+            return fn(err);
+          if (chunk.length > b.length) {
+            return function() {
+              return _data(stream, chunk.slice(b.length), output, fn);
+            };
+          }
+        });
+      };
+    }
+  }
+  function process2(stream, chunk, output, fn) {
+    stream._parserBytesLeft -= chunk.length;
+    debug("%o bytes left for stream piece", stream._parserBytesLeft);
+    if (stream._parserState === BUFFERING) {
+      stream._parserBuffers.push(chunk);
+      stream._parserBuffered += chunk.length;
+    } else if (stream._parserState === PASSTHROUGH) {
+      output(chunk);
+    }
+    if (stream._parserBytesLeft === 0) {
+      var cb = stream._parserCallback;
+      if (cb && stream._parserState === BUFFERING && stream._parserBuffers.length > 1) {
+        chunk = Buffer.concat(stream._parserBuffers, stream._parserBuffered);
+      }
+      if (stream._parserState !== BUFFERING) {
+        chunk = null;
+      }
+      stream._parserCallback = null;
+      stream._parserBuffered = 0;
+      stream._parserState = INIT;
+      stream._parserBuffers.splice(0);
+      if (cb) {
+        var args = [];
+        if (chunk) {
+          args.push(chunk);
+        }
+        if (output) {
+          args.push(output);
+        }
+        var async = cb.length > args.length;
+        if (async) {
+          args.push(trampoline(fn));
+        }
+        var rtn = cb.apply(stream, args);
+        if (!async || fn === rtn)
+          return fn;
+      }
+    } else {
+      return fn;
+    }
+  }
+  var data = trampoline(_data);
+  function trampoline(fn) {
+    return function() {
+      var result = fn.apply(this, arguments);
+      while (typeof result == "function") {
+        result = result();
+      }
+      return result;
+    };
+  }
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/common/read_le_be.js
+var require_read_le_be = __commonJS(function(exports) {
+  exports.readUInt16LE = function(data, offset) {
+    return data[offset] | data[offset + 1] << 8;
+  };
+  exports.readUInt16BE = function(data, offset) {
+    return data[offset] << 8 | data[offset + 1];
+  };
+  exports.readInt16LE = function(data, offset) {
+    return exports.readUInt16LE(data, offset) << 16 >> 16;
+  };
+  exports.readInt16BE = function(data, offset) {
+    return exports.readUInt16BE(data, offset) << 16 >> 16;
+  };
+  exports.readUInt32LE = function(data, offset) {
+    return (data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16) + data[offset + 3] * 16777216;
+  };
+  exports.readUInt32BE = function(data, offset) {
+    return data[offset] * 16777216 + (data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]);
+  };
+  exports.readInt32LE = function(data, offset) {
+    return exports.readUInt32LE(data, offset) | 0;
+  };
+  exports.readInt32BE = function(data, offset) {
+    return exports.readUInt32BE(data, offset) | 0;
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/common/index.js
+var require_common = __commonJS(function(exports) {
+  var Transform = __require("stream").Transform;
+  var streamParser = require_stream_parser();
+  var readLeBe = require_read_le_be();
+  function ParserStream() {
+    Transform.call(this, { readableObjectMode: true });
+  }
+  ParserStream.prototype = Object.create(Transform.prototype);
+  ParserStream.prototype.constructor = ParserStream;
+  streamParser(ParserStream.prototype);
+  exports.ParserStream = ParserStream;
+  exports.sliceEq = function(src, start, dest) {
+    for (var i = start, j = 0;j < dest.length; ) {
+      if (src[i++] !== dest[j++])
+        return false;
+    }
+    return true;
+  };
+  exports.str2arr = function(str, format) {
+    var arr = [];
+    var i = 0;
+    if (format && format === "hex") {
+      while (i < str.length) {
+        arr.push(parseInt(str.slice(i, i + 2), 16));
+        i += 2;
+      }
+    } else {
+      for (;i < str.length; i++) {
+        arr.push(str.charCodeAt(i) & 255);
+      }
+    }
+    return arr;
+  };
+  function ProbeError(message, code, statusCode) {
+    Error.call(this);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error().stack || "";
+    }
+    this.name = this.constructor.name;
+    this.message = message;
+    if (code)
+      this.code = code;
+    if (statusCode)
+      this.statusCode = statusCode;
+  }
+  ProbeError.prototype = Object.create(Error.prototype);
+  ProbeError.prototype.constructor = ProbeError;
+  exports.ProbeError = ProbeError;
+  exports.readUInt16LE = readLeBe.readUInt16LE;
+  exports.readUInt16BE = readLeBe.readUInt16BE;
+  exports.readInt16LE = readLeBe.readInt16LE;
+  exports.readInt16BE = readLeBe.readInt16BE;
+  exports.readUInt32LE = readLeBe.readUInt32LE;
+  exports.readUInt32BE = readLeBe.readUInt32BE;
+  exports.readInt32LE = readLeBe.readInt32LE;
+  exports.readInt32BE = readLeBe.readInt32BE;
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/miaf_utils.js
+var require_miaf_utils = __commonJS(function(exports, module) {
+  var readUInt16BE = require_common().readUInt16BE;
+  var readUInt32BE = require_common().readUInt32BE;
+  function unbox(data, offset) {
+    if (data.length < 4 + offset)
+      return null;
+    var size = readUInt32BE(data, offset);
+    if (data.length < size + offset || size < 8)
+      return null;
+    return {
+      boxtype: String.fromCharCode.apply(null, data.slice(offset + 4, offset + 8)),
+      data: data.slice(offset + 8, offset + size),
+      end: offset + size
+    };
+  }
+  exports.unbox = unbox;
+  function scan_ipco(data, sandbox) {
+    var offset = 0;
+    for (;; ) {
+      var box = unbox(data, offset);
+      if (!box)
+        break;
+      switch (box.boxtype) {
+        case "ispe":
+          sandbox.sizes.push({
+            width: readUInt32BE(box.data, 4),
+            height: readUInt32BE(box.data, 8)
+          });
+          break;
+        case "irot":
+          sandbox.transforms.push({
+            type: "irot",
+            value: box.data[0] & 3
+          });
+          break;
+        case "imir":
+          sandbox.transforms.push({
+            type: "imir",
+            value: box.data[0] & 1
+          });
+          break;
+      }
+      offset = box.end;
+    }
+  }
+  function readUIntBE(data, offset, size) {
+    var result = 0;
+    for (var i = 0;i < size; i++) {
+      result = result * 256 + (data[offset + i] || 0);
+    }
+    return result;
+  }
+  function scan_iloc(data, sandbox) {
+    var offset_size = data[4] >> 4 & 15;
+    var length_size = data[4] & 15;
+    var base_offset_size = data[5] >> 4 & 15;
+    var item_count = readUInt16BE(data, 6);
+    var offset = 8;
+    for (var i = 0;i < item_count; i++) {
+      var item_ID = readUInt16BE(data, offset);
+      offset += 2;
+      var data_reference_index = readUInt16BE(data, offset);
+      offset += 2;
+      var base_offset = readUIntBE(data, offset, base_offset_size);
+      offset += base_offset_size;
+      var extent_count = readUInt16BE(data, offset);
+      offset += 2;
+      if (data_reference_index === 0 && extent_count === 1) {
+        var first_extent_offset = readUIntBE(data, offset, offset_size);
+        var first_extent_length = readUIntBE(data, offset + offset_size, length_size);
+        sandbox.item_loc[item_ID] = { length: first_extent_length, offset: first_extent_offset + base_offset };
+      }
+      offset += extent_count * (offset_size + length_size);
+    }
+  }
+  function scan_iinf(data, sandbox) {
+    var item_count = readUInt16BE(data, 4);
+    var offset = 6;
+    for (var i = 0;i < item_count; i++) {
+      var box = unbox(data, offset);
+      if (!box)
+        break;
+      if (box.boxtype === "infe") {
+        var item_id = readUInt16BE(box.data, 4);
+        var item_name = "";
+        for (var pos = 8;pos < box.data.length && box.data[pos]; pos++) {
+          item_name += String.fromCharCode(box.data[pos]);
+        }
+        sandbox.item_inf[item_name] = item_id;
+      }
+      offset = box.end;
+    }
+  }
+  function scan_iprp(data, sandbox) {
+    var offset = 0;
+    for (;; ) {
+      var box = unbox(data, offset);
+      if (!box)
+        break;
+      if (box.boxtype === "ipco")
+        scan_ipco(box.data, sandbox);
+      offset = box.end;
+    }
+  }
+  function scan_meta(data, sandbox) {
+    var offset = 4;
+    for (;; ) {
+      var box = unbox(data, offset);
+      if (!box)
+        break;
+      if (box.boxtype === "iprp")
+        scan_iprp(box.data, sandbox);
+      if (box.boxtype === "iloc")
+        scan_iloc(box.data, sandbox);
+      if (box.boxtype === "iinf")
+        scan_iinf(box.data, sandbox);
+      offset = box.end;
+    }
+  }
+  function getMaxSize(sizes) {
+    var maxWidthSize = sizes.reduce(function(a, b) {
+      return a.width > b.width || a.width === b.width && a.height > b.height ? a : b;
+    });
+    var maxHeightSize = sizes.reduce(function(a, b) {
+      return a.height > b.height || a.height === b.height && a.width > b.width ? a : b;
+    });
+    var maxSize;
+    if (maxWidthSize.width > maxHeightSize.height || maxWidthSize.width === maxHeightSize.height && maxWidthSize.height > maxHeightSize.width) {
+      maxSize = maxWidthSize;
+    } else {
+      maxSize = maxHeightSize;
+    }
+    return maxSize;
+  }
+  exports.readSizeFromMeta = function(data) {
+    var sandbox = {
+      sizes: [],
+      transforms: [],
+      item_inf: {},
+      item_loc: {}
+    };
+    scan_meta(data, sandbox);
+    if (!sandbox.sizes.length)
+      return;
+    var maxSize = getMaxSize(sandbox.sizes);
+    var orientation = 1;
+    sandbox.transforms.forEach(function(transform) {
+      var rotate_ccw = { 1: 6, 2: 5, 3: 8, 4: 7, 5: 4, 6: 3, 7: 2, 8: 1 };
+      var mirror_vert = { 1: 4, 2: 3, 3: 2, 4: 1, 5: 6, 6: 5, 7: 8, 8: 7 };
+      if (transform.type === "imir") {
+        if (transform.value === 0) {
+          orientation = mirror_vert[orientation];
+        } else {
+          orientation = mirror_vert[orientation];
+          orientation = rotate_ccw[orientation];
+          orientation = rotate_ccw[orientation];
+        }
+      }
+      if (transform.type === "irot") {
+        for (var i = 0;i < transform.value; i++) {
+          orientation = rotate_ccw[orientation];
+        }
+      }
+    });
+    var exif_location = null;
+    if (sandbox.item_inf.Exif) {
+      exif_location = sandbox.item_loc[sandbox.item_inf.Exif];
+    }
+    return {
+      width: maxSize.width,
+      height: maxSize.height,
+      orientation: sandbox.transforms.length ? orientation : null,
+      variants: sandbox.sizes,
+      exif_location
+    };
+  };
+  exports.getMimeType = function(data) {
+    var brand = String.fromCharCode.apply(null, data.slice(0, 4));
+    var compat = {};
+    compat[brand] = true;
+    for (var i = 8;i < data.length; i += 4) {
+      compat[String.fromCharCode.apply(null, data.slice(i, i + 4))] = true;
+    }
+    if (!compat.mif1 && !compat.msf1 && !compat.miaf)
+      return;
+    if (brand === "avif" || brand === "avis" || brand === "avio") {
+      return { type: "avif", mime: "image/avif" };
+    }
+    if (brand === "heic" || brand === "heix") {
+      return { type: "heic", mime: "image/heic" };
+    }
+    if (brand === "hevc" || brand === "hevx") {
+      return { type: "heic", mime: "image/heic-sequence" };
+    }
+    if (compat.avif || compat.avis) {
+      return { type: "avif", mime: "image/avif" };
+    }
+    if (compat.heic || compat.heix || compat.hevc || compat.hevx || compat.heis) {
+      if (compat.msf1) {
+        return { type: "heif", mime: "image/heif-sequence" };
+      }
+      return { type: "heif", mime: "image/heif" };
+    }
+    return { type: "avif", mime: "image/avif" };
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/exif_utils.js
+var require_exif_utils = __commonJS(function(exports, module) {
+  function error(message, code) {
+    var err = new Error(message);
+    err.code = code;
+    return err;
+  }
+  function utf8_decode(str) {
+    try {
+      return decodeURIComponent(escape(str));
+    } catch (_) {
+      return str;
+    }
+  }
+  function ExifParser(jpeg_bin, exif_start, exif_end) {
+    this.input = jpeg_bin.subarray(exif_start, exif_end);
+    this.start = exif_start;
+    var sig = String.fromCharCode.apply(null, this.input.subarray(0, 4));
+    if (sig !== "II*\x00" && sig !== "MM\x00*") {
+      throw error("invalid TIFF signature", "EBADDATA");
+    }
+    this.big_endian = sig[0] === "M";
+  }
+  ExifParser.prototype.each = function(on_entry) {
+    this.aborted = false;
+    var offset = this.read_uint32(4);
+    this.ifds_to_read = [{
+      id: 0,
+      offset
+    }];
+    while (this.ifds_to_read.length > 0 && !this.aborted) {
+      var i = this.ifds_to_read.shift();
+      if (!i.offset)
+        continue;
+      this.scan_ifd(i.id, i.offset, on_entry);
+    }
+  };
+  ExifParser.prototype.read_uint16 = function(offset) {
+    var d = this.input;
+    if (offset + 2 > d.length)
+      throw error("unexpected EOF", "EBADDATA");
+    return this.big_endian ? d[offset] * 256 + d[offset + 1] : d[offset] + d[offset + 1] * 256;
+  };
+  ExifParser.prototype.read_uint32 = function(offset) {
+    var d = this.input;
+    if (offset + 4 > d.length)
+      throw error("unexpected EOF", "EBADDATA");
+    return this.big_endian ? d[offset] * 16777216 + d[offset + 1] * 65536 + d[offset + 2] * 256 + d[offset + 3] : d[offset] + d[offset + 1] * 256 + d[offset + 2] * 65536 + d[offset + 3] * 16777216;
+  };
+  ExifParser.prototype.is_subifd_link = function(ifd, tag) {
+    return ifd === 0 && tag === 34665 || ifd === 0 && tag === 34853 || ifd === 34665 && tag === 40965;
+  };
+  ExifParser.prototype.exif_format_length = function(format) {
+    switch (format) {
+      case 1:
+      case 2:
+      case 6:
+      case 7:
+        return 1;
+      case 3:
+      case 8:
+        return 2;
+      case 4:
+      case 9:
+      case 11:
+        return 4;
+      case 5:
+      case 10:
+      case 12:
+        return 8;
+      default:
+        return 0;
+    }
+  };
+  ExifParser.prototype.exif_format_read = function(format, offset) {
+    var v;
+    switch (format) {
+      case 1:
+      case 2:
+        v = this.input[offset];
+        return v;
+      case 6:
+        v = this.input[offset];
+        return v | (v & 128) * 33554430;
+      case 3:
+        v = this.read_uint16(offset);
+        return v;
+      case 8:
+        v = this.read_uint16(offset);
+        return v | (v & 32768) * 131070;
+      case 4:
+        v = this.read_uint32(offset);
+        return v;
+      case 9:
+        v = this.read_uint32(offset);
+        return v | 0;
+      case 5:
+      case 10:
+      case 11:
+      case 12:
+        return null;
+      case 7:
+        return null;
+      default:
+        return null;
+    }
+  };
+  ExifParser.prototype.scan_ifd = function(ifd_no, offset, on_entry) {
+    var entry_count = this.read_uint16(offset);
+    offset += 2;
+    for (var i = 0;i < entry_count; i++) {
+      var tag = this.read_uint16(offset);
+      var format = this.read_uint16(offset + 2);
+      var count = this.read_uint32(offset + 4);
+      var comp_length = this.exif_format_length(format);
+      var data_length = count * comp_length;
+      var data_offset = data_length <= 4 ? offset + 8 : this.read_uint32(offset + 8);
+      var is_subifd_link = false;
+      if (data_offset + data_length > this.input.length) {
+        throw error("unexpected EOF", "EBADDATA");
+      }
+      var value = [];
+      var comp_offset = data_offset;
+      for (var j = 0;j < count; j++, comp_offset += comp_length) {
+        var item = this.exif_format_read(format, comp_offset);
+        if (item === null) {
+          value = null;
+          break;
+        }
+        value.push(item);
+      }
+      if (Array.isArray(value) && format === 2) {
+        value = utf8_decode(String.fromCharCode.apply(null, value));
+        if (value && value[value.length - 1] === "\x00")
+          value = value.slice(0, -1);
+      }
+      if (this.is_subifd_link(ifd_no, tag)) {
+        if (Array.isArray(value) && Number.isInteger(value[0]) && value[0] > 0) {
+          this.ifds_to_read.push({
+            id: tag,
+            offset: value[0]
+          });
+          is_subifd_link = true;
+        }
+      }
+      var entry = {
+        is_big_endian: this.big_endian,
+        ifd: ifd_no,
+        tag,
+        format,
+        count,
+        entry_offset: offset + this.start,
+        data_length,
+        data_offset: data_offset + this.start,
+        value,
+        is_subifd_link
+      };
+      if (on_entry(entry) === false) {
+        this.aborted = true;
+        return;
+      }
+      offset += 12;
+    }
+    if (ifd_no === 0) {
+      this.ifds_to_read.push({
+        id: 1,
+        offset: this.read_uint32(offset)
+      });
+    }
+  };
+  exports.ExifParser = ExifParser;
+  exports.get_orientation = function(data) {
+    var orientation = 0;
+    try {
+      new ExifParser(data, 0, data.length).each(function(entry) {
+        if (entry.ifd === 0 && entry.tag === 274 && Array.isArray(entry.value)) {
+          orientation = entry.value[0];
+          return false;
+        }
+      });
+      return orientation;
+    } catch (err) {
+      return -1;
+    }
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/parse_sync/avif.js
+var require_avif = __commonJS(function(exports, module) {
+  var str2arr = require_common().str2arr;
+  var sliceEq = require_common().sliceEq;
+  var readUInt32BE = require_common().readUInt32BE;
+  var miaf = require_miaf_utils();
+  var exif = require_exif_utils();
+  var SIG_FTYP = str2arr("ftyp");
+  module.exports = function(data) {
+    if (!sliceEq(data, 4, SIG_FTYP))
+      return;
+    var firstBox = miaf.unbox(data, 0);
+    if (!firstBox)
+      return;
+    var fileType = miaf.getMimeType(firstBox.data);
+    if (!fileType)
+      return;
+    var meta;
+    var offset = firstBox.end;
+    for (;; ) {
+      var box = miaf.unbox(data, offset);
+      if (!box)
+        break;
+      offset = box.end;
+      if (box.boxtype === "mdat")
+        return;
+      if (box.boxtype === "meta") {
+        meta = box.data;
+        break;
+      }
+    }
+    if (!meta)
+      return;
+    var imgSize = miaf.readSizeFromMeta(meta);
+    if (!imgSize)
+      return;
+    var result = {
+      width: imgSize.width,
+      height: imgSize.height,
+      type: fileType.type,
+      mime: fileType.mime,
+      wUnits: "px",
+      hUnits: "px"
+    };
+    if (imgSize.variants.length > 1) {
+      result.variants = imgSize.variants;
+    }
+    if (imgSize.orientation) {
+      result.orientation = imgSize.orientation;
+    }
+    if (imgSize.exif_location && imgSize.exif_location.offset + imgSize.exif_location.length <= data.length) {
+      var sig_offset = readUInt32BE(data, imgSize.exif_location.offset);
+      var exif_data = data.slice(imgSize.exif_location.offset + sig_offset + 4, imgSize.exif_location.offset + imgSize.exif_location.length);
+      var orientation = exif.get_orientation(exif_data);
+      if (orientation > 0)
+        result.orientation = orientation;
+    }
+    return result;
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/parse_sync/bmp.js
+var require_bmp = __commonJS(function(exports, module) {
+  var str2arr = require_common().str2arr;
+  var sliceEq = require_common().sliceEq;
+  var readInt16LE = require_common().readInt16LE;
+  var readInt32LE = require_common().readInt32LE;
+  var readUInt32LE = require_common().readUInt32LE;
+  var SIG_BM = str2arr("BM");
+  module.exports = function(data) {
+    if (data.length < 26)
+      return;
+    if (!sliceEq(data, 0, SIG_BM))
+      return;
+    var h;
+    var w;
+    var headerSize = readUInt32LE(data, 14);
+    if (headerSize === 12) {
+      w = readInt16LE(data, 18);
+      h = readInt16LE(data, 20);
+    } else if (headerSize > 12) {
+      w = readInt32LE(data, 18);
+      h = readInt32LE(data, 22);
+    } else {
+      return;
+    }
+    return {
+      width: w,
+      height: Math.abs(h),
+      type: "bmp",
+      mime: "image/bmp",
+      wUnits: "px",
+      hUnits: "px"
+    };
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/parse_sync/gif.js
+var require_gif = __commonJS(function(exports, module) {
+  var str2arr = require_common().str2arr;
+  var sliceEq = require_common().sliceEq;
+  var readUInt16LE = require_common().readUInt16LE;
+  var SIG_GIF87a = str2arr("GIF87a");
+  var SIG_GIF89a = str2arr("GIF89a");
+  module.exports = function(data) {
+    if (data.length < 10)
+      return;
+    if (!sliceEq(data, 0, SIG_GIF87a) && !sliceEq(data, 0, SIG_GIF89a))
+      return;
+    return {
+      width: readUInt16LE(data, 6),
+      height: readUInt16LE(data, 8),
+      type: "gif",
+      mime: "image/gif",
+      wUnits: "px",
+      hUnits: "px"
+    };
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/parse_sync/ico.js
+var require_ico = __commonJS(function(exports, module) {
+  var readUInt16LE = require_common().readUInt16LE;
+  var HEADER = 0;
+  var TYPE_ICO = 1;
+  var INDEX_SIZE = 16;
+  module.exports = function(data) {
+    var header = readUInt16LE(data, 0);
+    var type = readUInt16LE(data, 2);
+    var numImages = readUInt16LE(data, 4);
+    if (header !== HEADER || type !== TYPE_ICO || !numImages) {
+      return;
+    }
+    if (data.length < 6 + numImages * INDEX_SIZE)
+      return;
+    var variants = [];
+    var maxSize = { width: 0, height: 0 };
+    for (var i = 0;i < numImages; i++) {
+      var width = data[6 + INDEX_SIZE * i] || 256;
+      var height = data[6 + INDEX_SIZE * i + 1] || 256;
+      var size = { width, height };
+      variants.push(size);
+      if (width > maxSize.width || height > maxSize.height) {
+        maxSize = size;
+      }
+    }
+    return {
+      width: maxSize.width,
+      height: maxSize.height,
+      variants,
+      type: "ico",
+      mime: "image/x-icon",
+      wUnits: "px",
+      hUnits: "px"
+    };
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/parse_sync/jpeg.js
+var require_jpeg = __commonJS(function(exports, module) {
+  var readUInt16BE = require_common().readUInt16BE;
+  var str2arr = require_common().str2arr;
+  var sliceEq = require_common().sliceEq;
+  var exif = require_exif_utils();
+  var SIG_EXIF = str2arr("Exif\x00\x00");
+  module.exports = function(data) {
+    if (data.length < 2)
+      return;
+    if (data[0] !== 255 || data[1] !== 216 || data[2] !== 255)
+      return;
+    var offset = 2;
+    for (;; ) {
+      for (;; ) {
+        if (data.length - offset < 2)
+          return;
+        if (data[offset++] === 255)
+          break;
+      }
+      var code = data[offset++];
+      var length;
+      while (code === 255)
+        code = data[offset++];
+      if (code >= 208 && code <= 217 || code === 1) {
+        length = 0;
+      } else if (code >= 192 && code <= 254) {
+        if (data.length - offset < 2)
+          return;
+        length = readUInt16BE(data, offset) - 2;
+        offset += 2;
+      } else {
+        return;
+      }
+      if (code === 217 || code === 218) {
+        return;
+      }
+      var orientation;
+      if (code === 225 && length >= 10 && sliceEq(data, offset, SIG_EXIF)) {
+        orientation = exif.get_orientation(data.slice(offset + 6, offset + length));
+      }
+      if (length >= 5 && (code >= 192 && code <= 207) && code !== 196 && code !== 200 && code !== 204) {
+        if (data.length - offset < length)
+          return;
+        var result = {
+          width: readUInt16BE(data, offset + 3),
+          height: readUInt16BE(data, offset + 1),
+          type: "jpg",
+          mime: "image/jpeg",
+          wUnits: "px",
+          hUnits: "px"
+        };
+        if (orientation > 0) {
+          result.orientation = orientation;
+        }
+        return result;
+      }
+      offset += length;
+    }
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/parse_sync/png.js
+var require_png = __commonJS(function(exports, module) {
+  var str2arr = require_common().str2arr;
+  var sliceEq = require_common().sliceEq;
+  var readUInt32BE = require_common().readUInt32BE;
+  var SIG_PNG = str2arr(`‰PNG\r
+\x1A
+`);
+  var SIG_IHDR = str2arr("IHDR");
+  module.exports = function(data) {
+    if (data.length < 24)
+      return;
+    if (!sliceEq(data, 0, SIG_PNG))
+      return;
+    if (!sliceEq(data, 12, SIG_IHDR))
+      return;
+    return {
+      width: readUInt32BE(data, 16),
+      height: readUInt32BE(data, 20),
+      type: "png",
+      mime: "image/png",
+      wUnits: "px",
+      hUnits: "px"
+    };
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/parse_sync/psd.js
+var require_psd = __commonJS(function(exports, module) {
+  var str2arr = require_common().str2arr;
+  var sliceEq = require_common().sliceEq;
+  var readUInt32BE = require_common().readUInt32BE;
+  var SIG_8BPS = str2arr("8BPS\x00\x01");
+  module.exports = function(data) {
+    if (data.length < 6 + 16)
+      return;
+    if (!sliceEq(data, 0, SIG_8BPS))
+      return;
+    return {
+      width: readUInt32BE(data, 6 + 12),
+      height: readUInt32BE(data, 6 + 8),
+      type: "psd",
+      mime: "image/vnd.adobe.photoshop",
+      wUnits: "px",
+      hUnits: "px"
+    };
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/common/svg_header.js
+var require_svg_header = __commonJS(function(exports) {
+  exports.MAX_DATA_LENGTH = 1024 * 10;
+  var attr_name = "[a-zA-Z_:][a-zA-Z0-9:._-]*";
+  var unquoted = "[^\"'=<>`\\x00-\\x20]+";
+  var single_quoted = "'[^']*'";
+  var double_quoted = '"[^"]*"';
+  var attr_value = "(?:" + unquoted + "|" + single_quoted + "|" + double_quoted + ")";
+  var attribute = "(?:\\s+" + attr_name + "(?:\\s*=\\s*" + attr_value + ")?)";
+  var pi = "<[?][\\s\\S]*?[?]>";
+  var comment = "<!--(?:[^-]|-[^-]|--[^>])*-->";
+  var cdata = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>";
+  var doctype = "<![A-Za-z][^[>]*(?:\\[[\\s\\S]*?\\][^>]*)?>";
+  var PROLOG_RE = new RegExp("^(?:\\s+|" + pi + "|" + comment + "|" + cdata + "|" + doctype + ")*");
+  var ROOT_RE = new RegExp("^<(" + attr_name + ")(" + attribute + "*)\\s*/?>");
+  var ATTR_RE = new RegExp("\\s+(" + attr_name + ")(?:\\s*=\\s*(?:(" + unquoted + `)|'([^']*)'|"([^"]*)"))?`, "g");
+  var SVG_UNITS_RE = /in$|mm$|cm$|pt$|pc$|px$|em$|ex$/;
+  function isFinitePositive(val) {
+    return typeof val === "number" && isFinite(val) && val > 0;
+  }
+  function units(str) {
+    var suffix = str.slice(-2);
+    var m = suffix.match(SVG_UNITS_RE);
+    return m === null ? "px" : m[0];
+  }
+  exports.parse = function(str) {
+    var prolog = str.match(PROLOG_RE)[0];
+    var root = ROOT_RE.exec(prolog.length ? str.slice(prolog.length) : str);
+    if (!root)
+      return;
+    var tag = root[1];
+    if (tag !== "svg" && tag.slice(-4) !== ":svg")
+      return;
+    var attrs = {};
+    var m;
+    ATTR_RE.lastIndex = 0;
+    while ((m = ATTR_RE.exec(root[2])) !== null) {
+      attrs[m[1]] = m[2] !== undefined ? m[2] : m[3] !== undefined ? m[3] : m[4];
+    }
+    var wAttr = attrs.width;
+    var hAttr = attrs.height;
+    var vbAttr = attrs.viewBox || attrs.viewbox;
+    if (wAttr && wAttr.indexOf("%") !== -1)
+      wAttr = undefined;
+    if (hAttr && hAttr.indexOf("%") !== -1)
+      hAttr = undefined;
+    var width = parseFloat(wAttr);
+    var height = parseFloat(hAttr);
+    if (wAttr && hAttr) {
+      if (!isFinitePositive(width) || !isFinitePositive(height))
+        return;
+      return {
+        width,
+        height,
+        type: "svg",
+        mime: "image/svg+xml",
+        wUnits: units(wAttr),
+        hUnits: units(hAttr)
+      };
+    }
+    var parts = (vbAttr || "").trim().split(/[\s,]+/);
+    var vbWidth = parseFloat(parts[2]);
+    var vbHeight = parseFloat(parts[3]);
+    if (!isFinitePositive(vbWidth) || !isFinitePositive(vbHeight))
+      return;
+    if (units(parts[2]) !== units(parts[3]))
+      return;
+    var ratio = vbWidth / vbHeight;
+    if (wAttr) {
+      if (!isFinitePositive(width))
+        return;
+      return {
+        width,
+        height: width / ratio,
+        type: "svg",
+        mime: "image/svg+xml",
+        wUnits: units(wAttr),
+        hUnits: units(wAttr)
+      };
+    }
+    if (hAttr) {
+      if (!isFinitePositive(height))
+        return;
+      return {
+        width: height * ratio,
+        height,
+        type: "svg",
+        mime: "image/svg+xml",
+        wUnits: units(hAttr),
+        hUnits: units(hAttr)
+      };
+    }
+    return {
+      width: vbWidth,
+      height: vbHeight,
+      type: "svg",
+      mime: "image/svg+xml",
+      wUnits: units(parts[2]),
+      hUnits: units(parts[3])
+    };
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/parse_sync/svg.js
+var require_svg = __commonJS(function(exports, module) {
+  var parseSvgHeader = require_svg_header().parse;
+  var MAX_DATA_LENGTH = require_svg_header().MAX_DATA_LENGTH;
+  module.exports = function(data) {
+    var start = 0;
+    if (data[0] === 239 && data[1] === 187 && data[2] === 191)
+      start = 3;
+    var str = "";
+    var max = Math.min(data.length, start + MAX_DATA_LENGTH);
+    for (var i = start;i < max; i++) {
+      str += String.fromCharCode(data[i]);
+    }
+    return parseSvgHeader(str);
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/parse_sync/tiff.js
+var require_tiff = __commonJS(function(exports, module) {
+  var str2arr = require_common().str2arr;
+  var sliceEq = require_common().sliceEq;
+  var readUInt16LE = require_common().readUInt16LE;
+  var readUInt16BE = require_common().readUInt16BE;
+  var readUInt32LE = require_common().readUInt32LE;
+  var readUInt32BE = require_common().readUInt32BE;
+  var SIG_1 = str2arr("II*\x00");
+  var SIG_2 = str2arr("MM\x00*");
+  function readUInt16(buffer, offset, is_big_endian) {
+    return is_big_endian ? readUInt16BE(buffer, offset) : readUInt16LE(buffer, offset);
+  }
+  function readUInt32(buffer, offset, is_big_endian) {
+    return is_big_endian ? readUInt32BE(buffer, offset) : readUInt32LE(buffer, offset);
+  }
+  function readIFDValue(data, data_offset, is_big_endian) {
+    var type = readUInt16(data, data_offset + 2, is_big_endian);
+    var values = readUInt32(data, data_offset + 4, is_big_endian);
+    if (values !== 1 || type !== 3 && type !== 4)
+      return null;
+    if (type === 3) {
+      return readUInt16(data, data_offset + 8, is_big_endian);
+    }
+    return readUInt32(data, data_offset + 8, is_big_endian);
+  }
+  module.exports = function(data) {
+    if (data.length < 8)
+      return;
+    if (!sliceEq(data, 0, SIG_1) && !sliceEq(data, 0, SIG_2))
+      return;
+    var is_big_endian = data[0] === 77;
+    var count = readUInt32(data, 4, is_big_endian) - 8;
+    if (count < 0)
+      return;
+    var offset = count + 8;
+    if (data.length - offset < 2)
+      return;
+    var ifd_size = readUInt16(data, offset + 0, is_big_endian) * 12;
+    if (ifd_size <= 0)
+      return;
+    offset += 2;
+    if (data.length - offset < ifd_size)
+      return;
+    var i, width, height, tag;
+    for (i = 0;i < ifd_size; i += 12) {
+      tag = readUInt16(data, offset + i, is_big_endian);
+      if (tag === 256) {
+        width = readIFDValue(data, offset + i, is_big_endian);
+      } else if (tag === 257) {
+        height = readIFDValue(data, offset + i, is_big_endian);
+      }
+    }
+    if (width && height) {
+      return {
+        width,
+        height,
+        type: "tiff",
+        mime: "image/tiff",
+        wUnits: "px",
+        hUnits: "px"
+      };
+    }
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/parse_sync/webp.js
+var require_webp = __commonJS(function(exports, module) {
+  var str2arr = require_common().str2arr;
+  var sliceEq = require_common().sliceEq;
+  var readUInt16LE = require_common().readUInt16LE;
+  var readUInt32LE = require_common().readUInt32LE;
+  var exif = require_exif_utils();
+  var SIG_RIFF = str2arr("RIFF");
+  var SIG_WEBP = str2arr("WEBP");
+  function parseVP8(data, offset) {
+    if (data[offset + 3] !== 157 || data[offset + 4] !== 1 || data[offset + 5] !== 42) {
+      return;
+    }
+    return {
+      width: readUInt16LE(data, offset + 6) & 16383,
+      height: readUInt16LE(data, offset + 8) & 16383,
+      type: "webp",
+      mime: "image/webp",
+      wUnits: "px",
+      hUnits: "px"
+    };
+  }
+  function parseVP8L(data, offset) {
+    if (data[offset] !== 47)
+      return;
+    var bits = readUInt32LE(data, offset + 1);
+    return {
+      width: (bits & 16383) + 1,
+      height: (bits >> 14 & 16383) + 1,
+      type: "webp",
+      mime: "image/webp",
+      wUnits: "px",
+      hUnits: "px"
+    };
+  }
+  function parseVP8X(data, offset) {
+    return {
+      width: (data[offset + 6] << 16 | data[offset + 5] << 8 | data[offset + 4]) + 1,
+      height: (data[offset + 9] << 16 | data[offset + 8] << 8 | data[offset + 7]) + 1,
+      type: "webp",
+      mime: "image/webp",
+      wUnits: "px",
+      hUnits: "px"
+    };
+  }
+  module.exports = function(data) {
+    if (data.length < 16)
+      return;
+    if (!sliceEq(data, 0, SIG_RIFF) || !sliceEq(data, 8, SIG_WEBP))
+      return;
+    var offset = 12;
+    var result = null;
+    var exif_orientation = 0;
+    var fileLength = readUInt32LE(data, 4) + 8;
+    if (fileLength > data.length)
+      return;
+    while (offset + 8 < fileLength) {
+      if (data[offset] === 0) {
+        offset++;
+        continue;
+      }
+      var header = String.fromCharCode.apply(null, data.slice(offset, offset + 4));
+      var length = readUInt32LE(data, offset + 4);
+      if (header === "VP8 " && length >= 10) {
+        result = result || parseVP8(data, offset + 8);
+      } else if (header === "VP8L" && length >= 5) {
+        result = result || parseVP8L(data, offset + 8);
+      } else if (header === "VP8X" && length >= 10) {
+        result = result || parseVP8X(data, offset + 8);
+      } else if (header === "EXIF") {
+        exif_orientation = exif.get_orientation(data.slice(offset + 8, offset + 8 + length));
+        offset = Infinity;
+      }
+      offset += 8 + length;
+    }
+    if (!result)
+      return;
+    if (exif_orientation > 0) {
+      result.orientation = exif_orientation;
+    }
+    return result;
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/lib/parsers_sync.js
+var require_parsers_sync = __commonJS(function(exports, module) {
+  module.exports = {
+    avif: require_avif(),
+    bmp: require_bmp(),
+    gif: require_gif(),
+    ico: require_ico(),
+    jpeg: require_jpeg(),
+    png: require_png(),
+    psd: require_psd(),
+    svg: require_svg(),
+    tiff: require_tiff(),
+    webp: require_webp()
+  };
+});
+
+// node_modules/.bun/probe-image-size@7.4.0/node_modules/probe-image-size/sync.js
+var require_sync = __commonJS(function(exports, module) {
+  var parsers = require_parsers_sync();
+  function probeBuffer(buffer) {
+    var parser_names = Object.keys(parsers);
+    for (var i = 0;i < parser_names.length; i++) {
+      var result = parsers[parser_names[i]](buffer);
+      if (result) {
+        if (result.width > 0 && result.height > 0)
+          return result;
+        return null;
+      }
+    }
+    return null;
+  }
+  module.exports = function get_image_size(src) {
+    return probeBuffer(src);
+  };
+  module.exports.parsers = parsers;
+});
+
+export { require_common, require_miaf_utils, require_exif_utils, require_svg_header, require_sync };