@mastra/server 1.58.0-alpha.1 → 1.58.0-alpha.13

package/dist/sync-djJ8Lmds.js

@@ -0,0 +1,1656 @@
+import { r as __require, t as __commonJSMin } from "./rolldown-runtime-DuvcJU0W.js";
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/ms/2.0.0/a65cc302695e9dde36bdbab59e67a07f313b77a4e7b89957a7bf17f930a58070/node_modules/ms/index.js
+var require_ms = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Helpers.
+	*/
+	var s = 1e3;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var y = d * 365.25;
+	/**
+	* Parse or format the given `val`.
+	*
+	* Options:
+	*
+	*  - `long` verbose formatting [false]
+	*
+	* @param {String|Number} val
+	* @param {Object} [options]
+	* @throws {Error} throw an error if val is not a non-empty string or a number
+	* @return {String|Number}
+	* @api public
+	*/
+	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));
+	};
+	/**
+	* Parse the given `str` and return milliseconds.
+	*
+	* @param {String} str
+	* @return {Number}
+	* @api private
+	*/
+	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]);
+		switch ((match[2] || "ms").toLowerCase()) {
+			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;
+		}
+	}
+	/**
+	* Short format for `ms`.
+	*
+	* @param {Number} ms
+	* @return {String}
+	* @api private
+	*/
+	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";
+	}
+	/**
+	* Long format for `ms`.
+	*
+	* @param {Number} ms
+	* @return {String}
+	* @api private
+	*/
+	function fmtLong(ms) {
+		return plural(ms, d, "day") || plural(ms, h, "hour") || plural(ms, m, "minute") || plural(ms, s, "second") || ms + " ms";
+	}
+	/**
+	* Pluralization helper.
+	*/
+	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";
+	}
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/debug/2.6.9/a0bc530475b72fd78792b0d9ccdc7efe90f67f200072e755bfec415a9ada02ef/node_modules/debug/src/debug.js
+var require_debug = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* This is the common logic for both the Node.js and web browser
+	* implementations of `debug()`.
+	*
+	* Expose `debug()` as the 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();
+	/**
+	* The currently active debug mode names, and names to skip.
+	*/
+	exports.names = [];
+	exports.skips = [];
+	/**
+	* Map of special "%n" handling functions, for the debug "format" argument.
+	*
+	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+	*/
+	exports.formatters = {};
+	/**
+	* Previous log timestamp.
+	*/
+	var prevTime;
+	/**
+	* Select a color.
+	* @param {String} namespace
+	* @return {Number}
+	* @api private
+	*/
+	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];
+	}
+	/**
+	* Create a debugger with the given `namespace`.
+	*
+	* @param {String} namespace
+	* @return {Function}
+	* @api public
+	*/
+	function createDebug(namespace) {
+		function debug() {
+			if (!debug.enabled) return;
+			var self = debug;
+			var curr = +/* @__PURE__ */ new Date();
+			self.diff = curr - (prevTime || curr);
+			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 ("string" !== typeof args[0]) 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 ("function" === typeof formatter) {
+					var val = args[index];
+					match = formatter.call(self, val);
+					args.splice(index, 1);
+					index--;
+				}
+				return match;
+			});
+			exports.formatArgs.call(self, args);
+			(debug.log || exports.log || console.log.bind(console)).apply(self, args);
+		}
+		debug.namespace = namespace;
+		debug.enabled = exports.enabled(namespace);
+		debug.useColors = exports.useColors();
+		debug.color = selectColor(namespace);
+		if ("function" === typeof exports.init) exports.init(debug);
+		return debug;
+	}
+	/**
+	* Enables a debug mode by namespaces. This can include modes
+	* separated by a colon and wildcards.
+	*
+	* @param {String} namespaces
+	* @api public
+	*/
+	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 + "$"));
+		}
+	}
+	/**
+	* Disable debug output.
+	*
+	* @api public
+	*/
+	function disable() {
+		exports.enable("");
+	}
+	/**
+	* Returns true if the given mode name is enabled, false otherwise.
+	*
+	* @param {String} name
+	* @return {Boolean}
+	* @api public
+	*/
+	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;
+	}
+	/**
+	* Coerce `val`.
+	*
+	* @param {Mixed} val
+	* @return {Mixed}
+	* @api private
+	*/
+	function coerce(val) {
+		if (val instanceof Error) return val.stack || val.message;
+		return val;
+	}
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/debug/2.6.9/a0bc530475b72fd78792b0d9ccdc7efe90f67f200072e755bfec415a9ada02ef/node_modules/debug/src/browser.js
+var require_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* This is the web browser implementation of `debug()`.
+	*
+	* Expose `debug()` as the module.
+	*/
+	exports = module.exports = require_debug();
+	exports.log = log;
+	exports.formatArgs = formatArgs;
+	exports.save = save;
+	exports.load = load;
+	exports.useColors = useColors;
+	exports.storage = "undefined" != typeof chrome && "undefined" != typeof chrome.storage ? chrome.storage.local : localstorage();
+	/**
+	* Colors.
+	*/
+	exports.colors = [
+		"lightseagreen",
+		"forestgreen",
+		"goldenrod",
+		"dodgerblue",
+		"darkorchid",
+		"crimson"
+	];
+	/**
+	* Currently only WebKit-based Web Inspectors, Firefox >= v31,
+	* and the Firebug extension (any Firefox version) are known
+	* to support "%c" CSS customizations.
+	*
+	* TODO: add a `localStorage` variable to explicitly enable/disable colors
+	*/
+	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+)/);
+	}
+	/**
+	* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+	*/
+	exports.formatters.j = function(v) {
+		try {
+			return JSON.stringify(v);
+		} catch (err) {
+			return "[UnexpectedJSONParseError]: " + err.message;
+		}
+	};
+	/**
+	* Colorize log arguments if enabled.
+	*
+	* @api public
+	*/
+	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 ("%c" === match) lastC = index;
+		});
+		args.splice(lastC, 0, c);
+	}
+	/**
+	* Invokes `console.log()` when available.
+	* No-op when `console.log` is not a "function".
+	*
+	* @api public
+	*/
+	function log() {
+		return "object" === typeof console && console.log && Function.prototype.apply.call(console.log, console, arguments);
+	}
+	/**
+	* Save `namespaces`.
+	*
+	* @param {String} namespaces
+	* @api private
+	*/
+	function save(namespaces) {
+		try {
+			if (null == namespaces) exports.storage.removeItem("debug");
+			else exports.storage.debug = namespaces;
+		} catch (e) {}
+	}
+	/**
+	* Load `namespaces`.
+	*
+	* @return {String} returns the previously persisted debug modes
+	* @api private
+	*/
+	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;
+	}
+	/**
+	* Enable namespaces listed in `localStorage.debug` initially.
+	*/
+	exports.enable(load());
+	/**
+	* Localstorage attempts to return the localstorage.
+	*
+	* This is necessary because safari throws
+	* when a user disables cookies/localstorage
+	* and you attempt to access it.
+	*
+	* @return {LocalStorage}
+	* @api private
+	*/
+	function localstorage() {
+		try {
+			return window.localStorage;
+		} catch (e) {}
+	}
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/debug/2.6.9/a0bc530475b72fd78792b0d9ccdc7efe90f67f200072e755bfec415a9ada02ef/node_modules/debug/src/node.js
+var require_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	*/
+	var tty = __require("tty");
+	var util = __require("util");
+	/**
+	* This is the Node.js implementation of `debug()`.
+	*
+	* Expose `debug()` as the module.
+	*/
+	exports = module.exports = require_debug();
+	exports.init = init;
+	exports.log = log;
+	exports.formatArgs = formatArgs;
+	exports.save = save;
+	exports.load = load;
+	exports.useColors = useColors;
+	/**
+	* Colors.
+	*/
+	exports.colors = [
+		6,
+		2,
+		3,
+		4,
+		5,
+		1
+	];
+	/**
+	* Build up the default `inspectOpts` object from the environment variables.
+	*
+	*   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+	*/
+	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;
+	}, {});
+	/**
+	* The file descriptor to write the `debug()` calls to.
+	* Set the `DEBUG_FD` env variable to override with another value. i.e.:
+	*
+	*   $ DEBUG_FD=3 node script.js 3>debug.log
+	*/
+	var fd = parseInt(process.env.DEBUG_FD, 10) || 2;
+	if (1 !== fd && 2 !== fd) 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 = 1 === fd ? process.stdout : 2 === fd ? process.stderr : createWritableStdioStream(fd);
+	/**
+	* Is stdout a TTY? Colored output is enabled when `true`.
+	*/
+	function useColors() {
+		return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(fd);
+	}
+	/**
+	* Map %o to `util.inspect()`, all on a single line.
+	*/
+	exports.formatters.o = function(v) {
+		this.inspectOpts.colors = this.useColors;
+		return util.inspect(v, this.inspectOpts).split("\n").map(function(str) {
+			return str.trim();
+		}).join(" ");
+	};
+	/**
+	* Map %o to `util.inspect()`, allowing multiple lines if needed.
+	*/
+	exports.formatters.O = function(v) {
+		this.inspectOpts.colors = this.useColors;
+		return util.inspect(v, this.inspectOpts);
+	};
+	/**
+	* Adds ANSI color escape codes if enabled.
+	*
+	* @api public
+	*/
+	function formatArgs(args) {
+		var name = this.namespace;
+		if (this.useColors) {
+			var c = this.color;
+			var prefix = "  \x1B[3" + c + ";1m" + name + " \x1B[0m";
+			args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+			args.push("\x1B[3" + c + "m+" + exports.humanize(this.diff) + "\x1B[0m");
+		} else args[0] = (/* @__PURE__ */ new Date()).toUTCString() + " " + name + " " + args[0];
+	}
+	/**
+	* Invokes `util.format()` with the specified arguments and writes to `stream`.
+	*/
+	function log() {
+		return stream.write(util.format.apply(util, arguments) + "\n");
+	}
+	/**
+	* Save `namespaces`.
+	*
+	* @param {String} namespaces
+	* @api private
+	*/
+	function save(namespaces) {
+		if (null == namespaces) delete process.env.DEBUG;
+		else process.env.DEBUG = namespaces;
+	}
+	/**
+	* Load `namespaces`.
+	*
+	* @return {String} returns the previously persisted debug modes
+	* @api private
+	*/
+	function load() {
+		return process.env.DEBUG;
+	}
+	/**
+	* Copied from `node/src/node.js`.
+	*
+	* XXX: It's lame that node doesn't expose this API out-of-the-box. It also
+	* relies on the undocumented `tty_wrap.guessHandleType()` which is also lame.
+	*/
+	function createWritableStdioStream(fd) {
+		var stream;
+		switch (process.binding("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":
+				stream = new (__require("fs")).SyncWriteStream(fd, { autoClose: false });
+				stream._type = "fs";
+				break;
+			case "PIPE":
+			case "TCP":
+				stream = new (__require("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;
+	}
+	/**
+	* Init logic for `debug` instances.
+	*
+	* Create a new `inspectOpts` object in case `useColors` is set
+	* differently for a particular `debug` instance.
+	*/
+	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]];
+	}
+	/**
+	* Enable namespaces listed in `process.env.DEBUG` initially.
+	*/
+	exports.enable(load());
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/debug/2.6.9/a0bc530475b72fd78792b0d9ccdc7efe90f67f200072e755bfec415a9ada02ef/node_modules/debug/src/index.js
+var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Detect Electron renderer process, which is node, but we should
+	* treat as a browser.
+	*/
+	if (typeof process !== "undefined" && process.type === "renderer") module.exports = require_browser();
+	else module.exports = require_node();
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/stream-parser/0.3.1/a6d45478f59e8dc0800438d0b3b9ec2db024d1b317d6f81acec51f864078d5ad/node_modules/stream-parser/index.js
+var require_stream_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	*/
+	var assert = __require("assert");
+	var debug = require_src()("stream-parser");
+	/**
+	* Module exports.
+	*/
+	module.exports = Parser;
+	/**
+	* Parser states.
+	*/
+	var INIT = -1;
+	var BUFFERING = 0;
+	var SKIPPING = 1;
+	var PASSTHROUGH = 2;
+	/**
+	* The `Parser` stream mixin works with either `Writable` or `Transform` stream
+	* instances/subclasses. Provides a convenient generic "parsing" API:
+	*
+	*   _bytes(n, cb) - buffers "n" bytes and then calls "cb" with the "chunk"
+	*   _skipBytes(n, cb) - skips "n" bytes and then calls "cb" when done
+	*
+	* If you extend a `Transform` stream, then the `_passthrough()` function is also
+	* added:
+	*
+	*   _passthrough(n, cb) - passes through "n" bytes untouched and then calls "cb"
+	*
+	* @param {Stream} stream Transform or Writable stream instance to extend
+	* @api public
+	*/
+	function Parser(stream) {
+		var isTransform = stream && "function" == typeof stream._transform;
+		var isWritable = stream && "function" == typeof stream._write;
+		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 ("function" == typeof stream.push) stream._parserOutput = stream.push.bind(stream);
+		stream._parserInit = true;
+	}
+	/**
+	* Buffers `n` bytes and then invokes `fn` once that amount has been collected.
+	*
+	* @param {Number} n the number of bytes to buffer
+	* @param {Function} fn callback function to invoke when `n` bytes are buffered
+	* @api public
+	*/
+	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;
+	}
+	/**
+	* Skips over the next `n` bytes, then invokes `fn` once that amount has
+	* been discarded.
+	*
+	* @param {Number} n the number of bytes to discard
+	* @param {Function} fn callback function to invoke when `n` bytes have been skipped
+	* @api public
+	*/
+	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;
+	}
+	/**
+	* Passes through `n` bytes to the readable side of this stream untouched,
+	* then invokes `fn` once that amount has been passed through.
+	*
+	* @param {Number} n the number of bytes to pass through
+	* @param {Function} fn callback function to invoke when `n` bytes have passed through
+	* @api public
+	*/
+	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;
+	}
+	/**
+	* The `_write()` callback function implementation.
+	*
+	* @api private
+	*/
+	function write(chunk, encoding, fn) {
+		if (!this._parserInit) init(this);
+		debug("write(%o bytes)", chunk.length);
+		if ("function" == typeof encoding) fn = encoding;
+		data(this, chunk, null, fn);
+	}
+	/**
+	* The `_transform()` callback function implementation.
+	*
+	* @api private
+	*/
+	function transform(chunk, output, fn) {
+		if (!this._parserInit) init(this);
+		debug("transform(%o bytes)", chunk.length);
+		if ("function" != typeof output) output = this._parserOutput;
+		data(this, chunk, output, fn);
+	}
+	/**
+	* The internal buffering/passthrough logic...
+	*
+	* This `_data` function get's "trampolined" to prevent stack overflows for tight
+	* loops. This technique requires us to return a "thunk" function for any
+	* synchronous action. Async stuff breaks the trampoline, but that's ok since it's
+	* working with a new stack at that point anyway.
+	*
+	* @api private
+	*/
+	function _data(stream, chunk, output, fn) {
+		if (stream._parserBytesLeft <= 0) return fn(/* @__PURE__ */ new Error("got data but not currently parsing anything"));
+		if (chunk.length <= stream._parserBytesLeft) return function() {
+			return process(stream, chunk, output, fn);
+		};
+		else return function() {
+			var b = chunk.slice(0, stream._parserBytesLeft);
+			return process(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);
+				};
+			});
+		};
+	}
+	/**
+	* The internal `process` function gets called by the `data` function when
+	* something "interesting" happens. This function takes care of buffering the
+	* bytes when buffering, passing through the bytes when doing that, and invoking
+	* the user callback when the number of bytes has been reached.
+	*
+	* @api private
+	*/
+	function process(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 (0 === stream._parserBytesLeft) {
+			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);
+	/**
+	* Generic thunk-based "trampoline" helper function.
+	*
+	* @param {Function} input function
+	* @return {Function} "trampolined" function
+	* @api private
+	*/
+	function trampoline(fn) {
+		return function() {
+			var result = fn.apply(this, arguments);
+			while ("function" == typeof result) result = result();
+			return result;
+		};
+	}
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/common.js
+var require_common = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Transform = __require("stream").Transform;
+	var streamParser = require_stream_parser();
+	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 = [], 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;
+	};
+	exports.readUInt16LE = function(data, offset) {
+		return data[offset] | data[offset + 1] << 8;
+	};
+	exports.readUInt16BE = function(data, offset) {
+		return data[offset + 1] | data[offset] << 8;
+	};
+	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 + 3] | data[offset + 2] << 8 | data[offset + 1] << 16 | data[offset] * 16777216;
+	};
+	function ProbeError(message, code, statusCode) {
+		Error.call(this);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+		else this.stack = (/* @__PURE__ */ 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;
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/miaf_utils.js
+var require_miaf_utils = /* @__PURE__ */ __commonJSMin(((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
+		};
+	}
+	module.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;
+	}
+	module.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
+		};
+	};
+	module.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"
+		};
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/exif_utils.js
+var require_exif_utils = /* @__PURE__ */ __commonJSMin(((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*\0" && sig !== "MM\0*") 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] === "\0") 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;
+				}
+			}
+			if (on_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
+			}) === false) {
+				this.aborted = true;
+				return;
+			}
+			offset += 12;
+		}
+		if (ifd_no === 0) this.ifds_to_read.push({
+			id: 1,
+			offset: this.read_uint32(offset)
+		});
+	};
+	module.exports.ExifParser = ExifParser;
+	module.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;
+		}
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/parse_sync/avif.js
+var require_avif = /* @__PURE__ */ __commonJSMin(((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, 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;
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/parse_sync/bmp.js
+var require_bmp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var str2arr = require_common().str2arr;
+	var sliceEq = require_common().sliceEq;
+	var readUInt16LE = require_common().readUInt16LE;
+	var SIG_BM = str2arr("BM");
+	module.exports = function(data) {
+		if (data.length < 26) return;
+		if (!sliceEq(data, 0, SIG_BM)) return;
+		return {
+			width: readUInt16LE(data, 18),
+			height: readUInt16LE(data, 22),
+			type: "bmp",
+			mime: "image/bmp",
+			wUnits: "px",
+			hUnits: "px"
+		};
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/parse_sync/gif.js
+var require_gif = /* @__PURE__ */ __commonJSMin(((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"
+		};
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/parse_sync/ico.js
+var require_ico = /* @__PURE__ */ __commonJSMin(((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;
+		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"
+		};
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/parse_sync/jpeg.js
+var require_jpeg = /* @__PURE__ */ __commonJSMin(((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\0\0");
+	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 (208 <= code && code <= 217 || code === 1) length = 0;
+			else if (192 <= code && 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 && 192 <= code && 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;
+		}
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/parse_sync/png.js
+var require_png = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var str2arr = require_common().str2arr;
+	var sliceEq = require_common().sliceEq;
+	var readUInt32BE = require_common().readUInt32BE;
+	var SIG_PNG = str2arr("‰PNG\r\n\n");
+	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"
+		};
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/parse_sync/psd.js
+var require_psd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var str2arr = require_common().str2arr;
+	var sliceEq = require_common().sliceEq;
+	var readUInt32BE = require_common().readUInt32BE;
+	var SIG_8BPS = str2arr("8BPS\0
");
+	module.exports = function(data) {
+		if (data.length < 22) return;
+		if (!sliceEq(data, 0, SIG_8BPS)) return;
+		return {
+			width: readUInt32BE(data, 18),
+			height: readUInt32BE(data, 14),
+			type: "psd",
+			mime: "image/vnd.adobe.photoshop",
+			wUnits: "px",
+			hUnits: "px"
+		};
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/parse_sync/svg.js
+var require_svg = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function isWhiteSpace(chr) {
+		return chr === 32 || chr === 9 || chr === 13 || chr === 10;
+	}
+	function isFinitePositive(val) {
+		return typeof val === "number" && isFinite(val) && val > 0;
+	}
+	function canBeSvg(buf) {
+		var i = 0, max = buf.length;
+		if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
+		while (i < max && isWhiteSpace(buf[i])) i++;
+		if (i === max) return false;
+		return buf[i] === 60;
+	}
+	var SVG_HEADER_RE = /<[-_.:a-zA-Z0-9][^>]*>/;
+	var SVG_TAG_RE = /^<([-_.:a-zA-Z0-9]+:)?svg\s/;
+	var SVG_WIDTH_RE = /[^-]\bwidth="([^%]+?)"|[^-]\bwidth='([^%]+?)'/;
+	var SVG_HEIGHT_RE = /\bheight="([^%]+?)"|\bheight='([^%]+?)'/;
+	var SVG_VIEWBOX_RE = /\bview[bB]ox="(.+?)"|\bview[bB]ox='(.+?)'/;
+	var SVG_UNITS_RE = /in$|mm$|cm$|pt$|pc$|px$|em$|ex$/;
+	function svgAttrs(str) {
+		var width = str.match(SVG_WIDTH_RE);
+		var height = str.match(SVG_HEIGHT_RE);
+		var viewbox = str.match(SVG_VIEWBOX_RE);
+		return {
+			width: width && (width[1] || width[2]),
+			height: height && (height[1] || height[2]),
+			viewbox: viewbox && (viewbox[1] || viewbox[2])
+		};
+	}
+	function units(str) {
+		if (!SVG_UNITS_RE.test(str)) return "px";
+		return str.match(SVG_UNITS_RE)[0];
+	}
+	module.exports = function(data) {
+		if (!canBeSvg(data)) return;
+		var str = "";
+		for (var i = 0; i < data.length; i++) str += String.fromCharCode(data[i]);
+		var svgTag = (str.match(SVG_HEADER_RE) || [""])[0];
+		if (!SVG_TAG_RE.test(svgTag)) return;
+		var attrs = svgAttrs(svgTag);
+		var width = parseFloat(attrs.width);
+		var height = parseFloat(attrs.height);
+		if (attrs.width && attrs.height) {
+			if (!isFinitePositive(width) || !isFinitePositive(height)) return;
+			return {
+				width,
+				height,
+				type: "svg",
+				mime: "image/svg+xml",
+				wUnits: units(attrs.width),
+				hUnits: units(attrs.height)
+			};
+		}
+		var parts = (attrs.viewbox || "").split(" ");
+		var viewbox = {
+			width: parts[2],
+			height: parts[3]
+		};
+		var vbWidth = parseFloat(viewbox.width);
+		var vbHeight = parseFloat(viewbox.height);
+		if (!isFinitePositive(vbWidth) || !isFinitePositive(vbHeight)) return;
+		if (units(viewbox.width) !== units(viewbox.height)) return;
+		var ratio = vbWidth / vbHeight;
+		if (attrs.width) {
+			if (!isFinitePositive(width)) return;
+			return {
+				width,
+				height: width / ratio,
+				type: "svg",
+				mime: "image/svg+xml",
+				wUnits: units(attrs.width),
+				hUnits: units(attrs.width)
+			};
+		}
+		if (attrs.height) {
+			if (!isFinitePositive(height)) return;
+			return {
+				width: height * ratio,
+				height,
+				type: "svg",
+				mime: "image/svg+xml",
+				wUnits: units(attrs.height),
+				hUnits: units(attrs.height)
+			};
+		}
+		return {
+			width: vbWidth,
+			height: vbHeight,
+			type: "svg",
+			mime: "image/svg+xml",
+			wUnits: units(viewbox.width),
+			hUnits: units(viewbox.height)
+		};
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/parse_sync/tiff.js
+var require_tiff = /* @__PURE__ */ __commonJSMin(((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*\0");
+	var SIG_2 = str2arr("MM\0*");
+	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);
+		if (readUInt32(data, data_offset + 4, is_big_endian) !== 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"
+		};
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/parse_sync/webp.js
+var require_webp = /* @__PURE__ */ __commonJSMin(((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] << offset | 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 >= 9) 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;
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/lib/parsers_sync.js
+var require_parsers_sync = /* @__PURE__ */ __commonJSMin(((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()
+	};
+}));
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/probe-image-size/7.2.3/709fce7441af0bd4eca9e0986826eb4285dfd57d75e823eb9ecd5dec0565501f/node_modules/probe-image-size/sync.js
+var require_sync = /* @__PURE__ */ __commonJSMin(((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) return result;
+		}
+		return null;
+	}
+	module.exports = function get_image_size(src) {
+		return probeBuffer(src);
+	};
+	module.exports.parsers = parsers;
+}));
+//#endregion
+export { require_common as i, require_exif_utils as n, require_miaf_utils as r, require_sync as t };
+
+//# sourceMappingURL=sync-djJ8Lmds.js.map