@life-palette/media 0.2.1

package/dist/index.cjs

@@ -0,0 +1,1297 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-y5ARvAq5.cjs");
+let metaprobe = require("metaprobe");
+metaprobe = require_rolldown_runtime.__toESM(metaprobe, 1);
+//#region ../../node_modules/arthash/wasm/pkg/arthash_wasm.js
+/**
+* Decode result for [`decode`]. JS sees `{ w, h, rgba }`.
+*/
+var DecodeResult = class DecodeResult {
+	static __wrap(ptr) {
+		const obj = Object.create(DecodeResult.prototype);
+		obj.__wbg_ptr = ptr;
+		DecodeResultFinalization.register(obj, obj.__wbg_ptr, obj);
+		return obj;
+	}
+	__destroy_into_raw() {
+		const ptr = this.__wbg_ptr;
+		this.__wbg_ptr = 0;
+		DecodeResultFinalization.unregister(this);
+		return ptr;
+	}
+	free() {
+		const ptr = this.__destroy_into_raw();
+		wasm.__wbg_decoderesult_free(ptr, 0);
+	}
+	/**
+	* Consume the result and hand back its RGBA bytes (row-major, 4 B/px),
+	* moving the buffer into the returned Uint8Array instead of cloning it.
+	* This frees the `DecodeResult`, so read `w` / `h` BEFORE calling — any
+	* field access afterwards throws (the wasm pointer is taken).
+	* @returns {Uint8Array}
+	*/
+	intoRgba() {
+		const ptr = this.__destroy_into_raw();
+		const ret = wasm.decoderesult_intoRgba(ptr);
+		var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+		wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+		return v1;
+	}
+	/**
+	* @returns {number}
+	*/
+	get h() {
+		return wasm.__wbg_get_decoderesult_h(this.__wbg_ptr) >>> 0;
+	}
+	/**
+	* @returns {number}
+	*/
+	get w() {
+		return wasm.__wbg_get_decoderesult_w(this.__wbg_ptr) >>> 0;
+	}
+};
+if (Symbol.dispose) DecodeResult.prototype[Symbol.dispose] = DecodeResult.prototype.free;
+/**
+* Encode an RGB buffer (row-major, 3 bytes per pixel).
+* @param {Uint8Array} rgb
+* @param {number} w
+* @param {number} h
+* @param {any} codec
+* @param {bigint} seed
+* @param {any} search
+* @returns {Uint8Array}
+*/
+function encodeRgb(rgb, w, h, codec, seed, search) {
+	const ptr0 = passArray8ToWasm0(rgb, wasm.__wbindgen_malloc);
+	const len0 = WASM_VECTOR_LEN;
+	const ret = wasm.encodeRgb(ptr0, len0, w, h, codec, seed, search);
+	if (ret[3]) throw takeFromExternrefTable0(ret[2]);
+	var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+	wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+	return v2;
+}
+function __wbg_get_imports() {
+	return {
+		__proto__: null,
+		"./arthash_wasm_bg.js": {
+			__proto__: null,
+			__wbg_Error_bce6d499ff0a4aff: function(arg0, arg1) {
+				return Error(getStringFromWasm0(arg0, arg1));
+			},
+			__wbg___wbindgen_is_null_2042690d351e14f0: function(arg0) {
+				return arg0 === null;
+			},
+			__wbg___wbindgen_is_undefined_35bb9f4c7fd651d5: function(arg0) {
+				return arg0 === void 0;
+			},
+			__wbg___wbindgen_number_get_f73a1244370fcc2c: function(arg0, arg1) {
+				const obj = arg1;
+				const ret = typeof obj === "number" ? obj : void 0;
+				getDataViewMemory0().setFloat64(arg0 + 8, isLikeNone(ret) ? 0 : ret, true);
+				getDataViewMemory0().setInt32(arg0 + 0, !isLikeNone(ret), true);
+			},
+			__wbg___wbindgen_string_get_d109740c0d18f4d7: function(arg0, arg1) {
+				const obj = arg1;
+				const ret = typeof obj === "string" ? obj : void 0;
+				var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+				var len1 = WASM_VECTOR_LEN;
+				getDataViewMemory0().setInt32(arg0 + 4, len1, true);
+				getDataViewMemory0().setInt32(arg0 + 0, ptr1, true);
+			},
+			__wbg___wbindgen_throw_9c31b086c2b26051: function(arg0, arg1) {
+				throw new Error(getStringFromWasm0(arg0, arg1));
+			},
+			__wbg_from_fa561fa561dc8031: function(arg0) {
+				return Array.from(arg0);
+			},
+			__wbg_get_98fdf51d029a75eb: function(arg0, arg1) {
+				return arg0[arg1 >>> 0];
+			},
+			__wbg_get_dcf82ab8aad1a593: function() {
+				return handleError(function(arg0, arg1) {
+					return Reflect.get(arg0, arg1);
+				}, arguments);
+			},
+			__wbg_instanceof_Uint8Array_abd07d4bd221d50b: function(arg0) {
+				let result;
+				try {
+					result = arg0 instanceof Uint8Array;
+				} catch (_) {
+					result = false;
+				}
+				return result;
+			},
+			__wbg_length_2591a0f4f659a55c: function(arg0) {
+				return arg0.length;
+			},
+			__wbg_length_56fcd3e2b7e0299d: function(arg0) {
+				return arg0.length;
+			},
+			__wbg_prototypesetcall_5f9bdc8d75e07276: function(arg0, arg1, arg2) {
+				Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+			},
+			__wbindgen_cast_0000000000000001: function(arg0, arg1) {
+				return getStringFromWasm0(arg0, arg1);
+			},
+			__wbindgen_init_externref_table: function() {
+				const table = wasm.__wbindgen_externrefs;
+				const offset = table.grow(4);
+				table.set(0, void 0);
+				table.set(offset + 0, void 0);
+				table.set(offset + 1, null);
+				table.set(offset + 2, true);
+				table.set(offset + 3, false);
+			}
+		}
+	};
+}
+const DecodeResultFinalization = typeof FinalizationRegistry === "undefined" ? {
+	register: () => {},
+	unregister: () => {}
+} : new FinalizationRegistry((ptr) => wasm.__wbg_decoderesult_free(ptr, 1));
+function addToExternrefTable0(obj) {
+	const idx = wasm.__externref_table_alloc();
+	wasm.__wbindgen_externrefs.set(idx, obj);
+	return idx;
+}
+function getArrayU8FromWasm0(ptr, len) {
+	ptr = ptr >>> 0;
+	return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+	if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+	return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+	return decodeText(ptr >>> 0, len);
+}
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+	if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+	return cachedUint8ArrayMemory0;
+}
+function handleError(f, args) {
+	try {
+		return f.apply(this, args);
+	} catch (e) {
+		const idx = addToExternrefTable0(e);
+		wasm.__wbindgen_exn_store(idx);
+	}
+}
+function isLikeNone(x) {
+	return x === void 0 || x === null;
+}
+function passArray8ToWasm0(arg, malloc) {
+	const ptr = malloc(arg.length * 1, 1) >>> 0;
+	getUint8ArrayMemory0().set(arg, ptr / 1);
+	WASM_VECTOR_LEN = arg.length;
+	return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+	if (realloc === void 0) {
+		const buf = cachedTextEncoder.encode(arg);
+		const ptr = malloc(buf.length, 1) >>> 0;
+		getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+		WASM_VECTOR_LEN = buf.length;
+		return ptr;
+	}
+	let len = arg.length;
+	let ptr = malloc(len, 1) >>> 0;
+	const mem = getUint8ArrayMemory0();
+	let offset = 0;
+	for (; offset < len; offset++) {
+		const code = arg.charCodeAt(offset);
+		if (code > 127) break;
+		mem[ptr + offset] = code;
+	}
+	if (offset !== len) {
+		if (offset !== 0) arg = arg.slice(offset);
+		ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+		const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+		const ret = cachedTextEncoder.encodeInto(arg, view);
+		offset += ret.written;
+		ptr = realloc(ptr, len, offset, 1) >>> 0;
+	}
+	WASM_VECTOR_LEN = offset;
+	return ptr;
+}
+function takeFromExternrefTable0(idx) {
+	const value = wasm.__wbindgen_externrefs.get(idx);
+	wasm.__externref_table_dealloc(idx);
+	return value;
+}
+let cachedTextDecoder = new TextDecoder("utf-8", {
+	ignoreBOM: true,
+	fatal: true
+});
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+	numBytesDecoded += len;
+	if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+		cachedTextDecoder = new TextDecoder("utf-8", {
+			ignoreBOM: true,
+			fatal: true
+		});
+		cachedTextDecoder.decode();
+		numBytesDecoded = len;
+	}
+	return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+const cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) cachedTextEncoder.encodeInto = function(arg, view) {
+	const buf = cachedTextEncoder.encode(arg);
+	view.set(buf);
+	return {
+		read: arg.length,
+		written: buf.length
+	};
+};
+let WASM_VECTOR_LEN = 0;
+let wasm;
+function __wbg_finalize_init(instance, module) {
+	wasm = instance.exports;
+	cachedDataViewMemory0 = null;
+	cachedUint8ArrayMemory0 = null;
+	wasm.__wbindgen_start();
+	return wasm;
+}
+async function __wbg_load(module, imports) {
+	if (typeof Response === "function" && module instanceof Response) {
+		if (typeof WebAssembly.instantiateStreaming === "function") try {
+			return await WebAssembly.instantiateStreaming(module, imports);
+		} catch (e) {
+			if (module.ok && expectedResponseType(module.type) && module.headers.get("Content-Type") !== "application/wasm") console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+			else throw e;
+		}
+		const bytes = await module.arrayBuffer();
+		return await WebAssembly.instantiate(bytes, imports);
+	} else {
+		const instance = await WebAssembly.instantiate(module, imports);
+		if (instance instanceof WebAssembly.Instance) return {
+			instance,
+			module
+		};
+		else return instance;
+	}
+	function expectedResponseType(type) {
+		switch (type) {
+			case "basic":
+			case "cors":
+			case "default": return true;
+		}
+		return false;
+	}
+}
+async function __wbg_init(module_or_path) {
+	if (wasm !== void 0) return wasm;
+	if (module_or_path !== void 0) {
+		if (Object.getPrototypeOf(module_or_path) === Object.prototype) ({module_or_path} = module_or_path);
+		else console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+	}
+	if (module_or_path === void 0) module_or_path = new URL("arthash_wasm_bg.wasm", require("url").pathToFileURL(__filename).href);
+	const imports = __wbg_get_imports();
+	if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) module_or_path = fetch(module_or_path);
+	const { instance, module } = await __wbg_load(await module_or_path, imports);
+	return __wbg_finalize_init(instance, module);
+}
+//#endregion
+//#region ../../node_modules/arthash/dist/palette.js
+/**
+* Palette type + construction helpers.
+*
+* Lives in its own module so both `index.ts` (which re-exports it on the
+* public surface) and `palettes.ts` (which calls `palette.fromHex` at module
+* top level to build the curated presets) can import it without forming a
+* cycle. Putting `palette` in `index.ts` directly created a circular import:
+* `index.ts → palettes.ts → index.ts`, where `palettes.ts`'s top-level
+* `palette.fromHex(...)` calls executed before `index.ts` had reached its
+* `export const palette = {...}` line, throwing TDZ.
+*/
+const MIN_PALETTE_K = 2;
+const MAX_PALETTE_K = 1024;
+/** Palette construction helpers. */
+const palette = {
+	/** Build a palette from an array of `[r, g, b]` triplets. */
+	fromRgb(colors) {
+		if (colors.length < MIN_PALETTE_K || colors.length > MAX_PALETTE_K) throw new Error(`palette K must be in [${MIN_PALETTE_K}, ${MAX_PALETTE_K}]; got ${colors.length}`);
+		const bytes = new Uint8Array(colors.length * 3);
+		for (let i = 0; i < colors.length; i++) {
+			const c = colors[i];
+			bytes[i * 3] = c[0];
+			bytes[i * 3 + 1] = c[1];
+			bytes[i * 3 + 2] = c[2];
+		}
+		return { bytes };
+	},
+	/** Build a palette from hex color strings (`"#aabbcc"` or `"aabbcc"`). */
+	fromHex(hexes) {
+		const rgb = hexes.map((h) => {
+			const s = h.startsWith("#") ? h.slice(1) : h;
+			if (s.length !== 6) throw new Error(`palette: expected 6-char hex, got ${h}`);
+			return [
+				parseInt(s.slice(0, 2), 16),
+				parseInt(s.slice(2, 4), 16),
+				parseInt(s.slice(4, 6), 16)
+			];
+		});
+		return palette.fromRgb(rgb);
+	}
+};
+//#endregion
+//#region ../../node_modules/arthash/dist/palettes.js
+/**
+* Hand-curated retro / pixel-game palettes for the placeholder hash.
+*
+* Mirrors `arthash.palettes` (Python). These are externally-designed color
+* sets, NOT trained on any image corpus — they're meant to give placeholders
+* a deliberate stylistic feel.
+*
+* References / origins:
+*   gbDmg          Game Boy DMG (1989) — the iconic green-on-green LCD
+*   gbPocket       Game Boy Pocket (1996) — grayscale LCD
+*   cgaMode4P1     IBM CGA mode 4 palette 1 — DOS-era 4-color
+*   pico8          PICO-8 fantasy console (Lexaloffle, 2014)
+*   sweetie16      GrafxKid's modern 16-color indie pixel-art palette
+*   endesga32      Endesga's modern 32-color indie palette (very popular)
+*   nes16          15-color subset commonly used by NES games
+*
+* See https://lospec.com for many more palettes.
+*/
+const h$1 = (...hexes) => palette.fromHex(hexes);
+const gbDmg = h$1("0F380F", "306230", "8BAC0F", "9BBC0F");
+const gbPocket = h$1("000000", "545454", "A9A9A9", "FFFFFF");
+const cgaMode4P1 = h$1("000000", "55FFFF", "FF55FF", "FFFFFF");
+const c64Basic8 = h$1("000000", "FFFFFF", "880000", "AAFFEE", "CC44CC", "00CC55", "0000AA", "EEEE77");
+const pico8 = h$1("000000", "1D2B53", "7E2553", "008751", "AB5236", "5F574F", "C2C3C7", "FFF1E8", "FF004D", "FFA300", "FFEC27", "00E436", "29ADFF", "83769C", "FF77A8", "FFCCAA");
+const sweetie16 = h$1("1A1C2C", "5D275D", "B13E53", "EF7D57", "FFCD75", "A7F070", "38B764", "257179", "29366F", "3B5DC9", "41A6F6", "73EFF7", "F4F4F4", "94B0C2", "566C86", "333C57");
+const nes16 = h$1("000000", "FCFCFC", "F8F8F8", "BCBCBC", "7C7C7C", "A4E4FC", "3CBCFC", "0078F8", "0000FC", "B8B8F8", "6888FC", "0058F8", "0000BC", "D8B8F8", "9878F8", "6844FC");
+const c64 = h$1("000000", "FFFFFF", "880000", "AAFFEE", "CC44CC", "00CC55", "0000AA", "EEEE77", "DD8855", "664400", "FF7777", "333333", "777777", "AAFF66", "0088FF", "BBBBBB");
+const endesga32 = h$1("BE4A2F", "D77643", "EAD4AA", "E4A672", "B86F50", "733E39", "3E2731", "A22633", "E43B44", "F77622", "FEAE34", "FEE761", "63C74D", "3E8948", "265C42", "193C3E", "124E89", "0099DB", "2CE8F5", "FFFFFF", "C0CBDC", "8B9BB4", "5A6988", "3A4466", "262B44", "181425", "FF0044", "68386C", "B55088", "F6757A", "E8B796", "C28569");
+const aapSplendor32 = h$1("050403", "0E0C0C", "2D1B1E", "612721", "B9451D", "F1641F", "FCA570", "FFE0B7", "FFFFFF", "FFF089", "F8C53A", "E88A36", "B05B2C", "672D1F", "452326", "5D3B61", "AD5B91", "DF8BAD", "C2B0D1", "8E7DA5", "65517A", "39314C", "1A1932", "1E3E5E", "1A6291", "30A7D7", "53D2FF", "C3F4FF", "55B57F", "1E7541", "0E3E2C", "192418");
+Object.freeze({
+	gb_dmg: gbDmg,
+	gb_pocket: gbPocket,
+	cga_mode4_p1: cgaMode4P1,
+	c64_basic8: c64Basic8,
+	pico8,
+	sweetie_16: sweetie16,
+	nes_16: nes16,
+	c64,
+	endesga_32: endesga32,
+	aap_splendor_32: aapSplendor32
+});
+//#endregion
+//#region ../../node_modules/arthash/dist/index.js
+/**
+* arthash — TypeScript SDK.
+*
+* Backed by `arthash-rs` compiled to WebAssembly via wasm-bindgen.
+* Works in browser and Node (>= 18, native `Uint8Array` + WebAssembly).
+*
+* Quick start:
+* ```ts
+* import { encode, decode, toSvg, codec, Preset, encodeImage } from "arthash";
+*
+* // Plain RGB buffer
+* const hash = await encode(rgbBytes, width, height, codec.triangle({ n: 64 }));
+* const { w, h, rgba } = await decode(hash, codec.triangle({ n: 64 }));
+*
+* // Named preset
+* const hash2 = await encode(rgbBytes, w, h, codec.preset(Preset.LargeTriangle));
+*
+* // Browser convenience: load image, resize, encode in one call
+* const hash3 = await encodeImage(imgUrl, codec.triangle({ n: 64 }));
+* ```
+*
+* The wasm module loads automatically on first call. If you want to control
+* timing (e.g. preload), call `await init()` explicitly.
+*/
+const Shape = {
+	DCT: "dct",
+	CIRCLE: "circle",
+	TRIANGLE: "triangle",
+	PIXEL: "pixel",
+	SQUARE: "square",
+	RECT: "rect",
+	ROTATED_RECT: "rotrect"
+};
+/** Named codec recipes. Use `codec.preset(Preset.LargeTriangle)`.
+*
+*  Two axes:
+*  - **size** — `Small*` (n=12, pixel n=16, ~50–80 B) → `Medium*` (n=24,
+*    ~100–150 B) → `Large*` (n=64, ~270–400 B).
+*  - **shape** — `Triangle` / `Circle` / `Pixel` / `Rect` / `Square`.
+*
+*  Plus `Preset.Dct` — the frequency-domain placeholder (~21 B), outside the
+*  size axis. Actual byte counts vary ±1 B with image aspect.
+*
+*  Pre-0.3 names (`TinyDct` / `Placeholder*` / `Detail*`) are kept as
+*  deprecated aliases for source compatibility; they will be removed in 1.0. */
+const Preset = {
+	Dct: "dct",
+	SmallTriangle: "small_triangle",
+	SmallCircle: "small_circle",
+	SmallPixel: "small_pixel",
+	SmallRect: "small_rect",
+	SmallSquare: "small_square",
+	MediumTriangle: "medium_triangle",
+	MediumCircle: "medium_circle",
+	MediumPixel: "medium_pixel",
+	MediumRect: "medium_rect",
+	MediumSquare: "medium_square",
+	LargeTriangle: "large_triangle",
+	LargeCircle: "large_circle",
+	LargePixel: "large_pixel",
+	LargeRect: "large_rect",
+	LargeSquare: "large_square",
+	/** @deprecated Renamed to `Preset.Dct`. */
+	TinyDct: "tiny_dct",
+	/** @deprecated Renamed to `Preset.SmallTriangle`. */
+	PlaceholderTriangle: "placeholder_triangle",
+	/** @deprecated Renamed to `Preset.SmallCircle`. */
+	PlaceholderCircle: "placeholder_circle",
+	/** @deprecated Renamed to `Preset.SmallPixel`. */
+	PlaceholderPixel: "placeholder_pixel",
+	/** @deprecated Renamed to `Preset.LargeTriangle`. */
+	DetailTriangle: "detail_triangle",
+	/** @deprecated Renamed to `Preset.LargeCircle`. */
+	DetailCircle: "detail_circle",
+	/** @deprecated Renamed to `Preset.LargePixel`. */
+	DetailPixel: "detail_pixel"
+};
+/** Factory namespace — `codec.dct()`, `codec.triangle({ n: 64 })`, …
+*
+*  Each factory's return type is inferred to its narrowed shape (e.g.
+*  `{ kind: 'rect', n: number, color?: ColorMode }`) rather than the broad
+*  `Codec` union. This narrowing lets `RenderStyle<C>`'s conditional type
+*  enforce `cornerRadius` is only allowed for rect-family codecs at call
+*  sites. Returns are still assignable to `Codec` since every narrow type
+*  is a member of the union. */
+const codec = {
+	dct() {
+		return { kind: "dct" };
+	},
+	circle(opts = {}) {
+		return {
+			kind: "circle",
+			n: opts.n ?? 12,
+			color: opts.color
+		};
+	},
+	triangle(opts = {}) {
+		return {
+			kind: "triangle",
+			n: opts.n ?? 12,
+			color: opts.color
+		};
+	},
+	square(opts = {}) {
+		return {
+			kind: "square",
+			n: opts.n ?? 12,
+			color: opts.color
+		};
+	},
+	rect(opts = {}) {
+		return {
+			kind: "rect",
+			n: opts.n ?? 12,
+			color: opts.color
+		};
+	},
+	rotatedRect(opts = {}) {
+		return {
+			kind: "rotrect",
+			n: opts.n ?? 12,
+			thetaBits: opts.thetaBits,
+			color: opts.color
+		};
+	},
+	pixel(opts = {}) {
+		return {
+			kind: "pixel",
+			n: opts.n ?? 12,
+			gridAspect: opts.gridAspect,
+			color: opts.color
+		};
+	},
+	preset(p) {
+		switch (p) {
+			case Preset.Dct: return codec.dct();
+			case Preset.SmallTriangle: return codec.triangle({ n: 12 });
+			case Preset.SmallCircle: return codec.circle({ n: 12 });
+			case Preset.SmallPixel: return codec.pixel({ n: 16 });
+			case Preset.SmallRect: return codec.rect({ n: 12 });
+			case Preset.SmallSquare: return codec.square({ n: 12 });
+			case Preset.MediumTriangle: return codec.triangle({ n: 24 });
+			case Preset.MediumCircle: return codec.circle({ n: 24 });
+			case Preset.MediumPixel: return codec.pixel({ n: 24 });
+			case Preset.MediumRect: return codec.rect({ n: 24 });
+			case Preset.MediumSquare: return codec.square({ n: 24 });
+			case Preset.LargeTriangle: return codec.triangle({ n: 64 });
+			case Preset.LargeCircle: return codec.circle({ n: 64 });
+			case Preset.LargePixel: return codec.pixel({ n: 64 });
+			case Preset.LargeRect: return codec.rect({ n: 64 });
+			case Preset.LargeSquare: return codec.square({ n: 64 });
+			case Preset.TinyDct: return codec.dct();
+			case Preset.PlaceholderTriangle: return codec.triangle({ n: 12 });
+			case Preset.PlaceholderCircle: return codec.circle({ n: 12 });
+			case Preset.PlaceholderPixel: return codec.pixel({ n: 16 });
+			case Preset.DetailTriangle: return codec.triangle({ n: 64 });
+			case Preset.DetailCircle: return codec.circle({ n: 64 });
+			case Preset.DetailPixel: return codec.pixel({ n: 64 });
+		}
+	},
+	/** Convenience: switch a codec's color mode to palette indexing. */
+	withPalette(c, palette) {
+		if (c.kind === "dct" || c.kind === "raw") return c;
+		return {
+			...c,
+			color: {
+				type: "palette",
+				palette
+			}
+		};
+	},
+	/** Low-level escape hatch — set any SPEC field. For conformance tests and
+	*  advanced controls. Normal users should prefer the named factories. */
+	raw(spec) {
+		return {
+			kind: "raw",
+			spec
+		};
+	},
+	/** True if this codec stores per-shape palette indices instead of full color. */
+	isPaletteMode(c) {
+		if (c.kind === "raw") return c.spec.palette !== void 0;
+		if (c.kind === "dct") return false;
+		return c.color?.type === "palette";
+	},
+	/** Total byte length of a hash produced by this codec (header + body, rounded
+	*  up to the byte). Matches Python's `Codec.bytes_total()` and Rust's
+	*  `Codec::bytes_total()`. */
+	bytesTotal(c) {
+		return computeBytesTotal(codecToSpecFields(c));
+	}
+};
+const DEFAULT_SPEC = {
+	shape: Shape.DCT,
+	nShapes: 12,
+	cxBits: 5,
+	cyBits: 5,
+	rBits: 4,
+	alphaBits: 3,
+	colorBits: 16,
+	thetaBits: 5,
+	paletteK: 0,
+	hasPalette: false
+};
+function codecToSpecFields(c) {
+	if (c.kind === "raw") {
+		const s = c.spec;
+		const paletteLen = s.palette?.length ?? 0;
+		const k = s.paletteK ?? (paletteLen > 0 ? paletteLen / 3 : 0);
+		return {
+			...DEFAULT_SPEC,
+			shape: s.shape,
+			nShapes: s.nShapes ?? DEFAULT_SPEC.nShapes,
+			cxBits: s.cxBits ?? DEFAULT_SPEC.cxBits,
+			cyBits: s.cyBits ?? DEFAULT_SPEC.cyBits,
+			rBits: s.rBits ?? DEFAULT_SPEC.rBits,
+			alphaBits: s.alphaBits ?? DEFAULT_SPEC.alphaBits,
+			colorBits: s.colorBits ?? DEFAULT_SPEC.colorBits,
+			thetaBits: s.thetaBits ?? DEFAULT_SPEC.thetaBits,
+			hasPalette: paletteLen > 0,
+			paletteK: k
+		};
+	}
+	if (c.kind === "dct") return {
+		...DEFAULT_SPEC,
+		shape: Shape.DCT
+	};
+	const out = {
+		...DEFAULT_SPEC,
+		shape: c.kind,
+		nShapes: c.n
+	};
+	if (c.kind === "rotrect" && c.thetaBits !== void 0) out.thetaBits = c.thetaBits;
+	const color = c.color;
+	if (color && color.type === "rgb888") out.colorBits = 24;
+	else if (color && color.type === "palette") {
+		out.hasPalette = true;
+		out.paletteK = color.palette.k ?? color.palette.bytes.length / 3;
+	}
+	return out;
+}
+function colorFieldBits(s) {
+	if (s.hasPalette) {
+		const k = Math.max(2, s.paletteK);
+		return 32 - Math.clz32(k - 1);
+	}
+	return s.colorBits;
+}
+function perShapeBits(s) {
+	const cx = s.cxBits, cy = s.cyBits, r = s.rBits;
+	const col = colorFieldBits(s), a = s.alphaBits;
+	switch (s.shape) {
+		case Shape.CIRCLE:
+		case Shape.SQUARE: return cx + cy + r + col + a;
+		case Shape.RECT: return cx + cy + 2 * r + col + a;
+		case Shape.ROTATED_RECT: return cx + cy + 2 * r + s.thetaBits + col + a;
+		case Shape.TRIANGLE: return 3 * (cx + cy) + col + a;
+		case Shape.PIXEL: return col;
+		case Shape.DCT: return 0;
+	}
+}
+function computeBytesTotal(s) {
+	if (s.shape === Shape.DCT) return Math.ceil(27);
+	const headerBits = s.shape === Shape.PIXEL ? 8 : 8 + colorFieldBits(s);
+	return Math.ceil((headerBits + s.nShapes * perShapeBits(s)) / 8);
+}
+let wasmReady = null;
+async function ready() {
+	if (!wasmReady) wasmReady = __wbg_init().then(() => void 0);
+	await wasmReady;
+}
+/** camelCase → snake_case for FFI key names. `nShapes` → `n_shapes`, `rBits`
+*  → `r_bits`. Acronyms and existing underscores are preserved. */
+function toSnakeCase(key) {
+	return key.replace(/[A-Z]/g, (m) => "_" + m.toLowerCase());
+}
+/** Copy own enumerable keys from `src` into `dst` with camelCase → snake_case
+*  renaming. Skips entries whose value (or transformed value) is `undefined`,
+*  so optional fields don't show up as `null` on the Rust side. Pass a
+*  `transform` map to override specific keys (return `undefined` to skip). */
+function assignSnakeCase(dst, src, transform = {}) {
+	for (const [k, v] of Object.entries(src)) {
+		if (v === void 0) continue;
+		const fn = transform[k];
+		const transformed = fn ? fn(v) : v;
+		if (transformed === void 0) continue;
+		dst[toSnakeCase(k)] = transformed;
+	}
+}
+function codecToFfi(c) {
+	if (c.kind === "raw") {
+		const out = {};
+		assignSnakeCase(out, c.spec, { palette: (v) => {
+			const arr = v;
+			return arr.length > 0 ? arr : void 0;
+		} });
+		return out;
+	}
+	const out = { shape: c.kind };
+	if (c.kind === "dct") return out;
+	out.n_shapes = c.n;
+	if (c.kind === "rotrect" && c.thetaBits !== void 0) out.theta_bits = c.thetaBits;
+	if (c.kind === "pixel" && c.gridAspect !== void 0) out.grid_aspect = c.gridAspect;
+	const color = c.color;
+	if (color === void 0 || color.type === "rgb565") out.color_bits = 16;
+	else if (color.type === "rgb888") out.color_bits = 24;
+	else {
+		out.color_bits = 16;
+		const pal = color.palette;
+		out.palette = pal.bytes;
+		if (pal.k !== void 0) out.palette_k = pal.k;
+	}
+	return out;
+}
+function searchToFfi(s) {
+	if (!s) return void 0;
+	const out = {};
+	assignSnakeCase(out, s);
+	return out;
+}
+/** Encode RGB bytes into a placeholder hash. */
+async function encode(rgb, width, height, c, opts = {}) {
+	await ready();
+	return encodeRgb(rgb, width, height, codecToFfi(c), BigInt(opts.seed ?? 0), searchToFfi(opts.search));
+}
+//#endregion
+//#region ../../node_modules/blurhash/dist/index.mjs
+var q = [
+	"0",
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"8",
+	"9",
+	"A",
+	"B",
+	"C",
+	"D",
+	"E",
+	"F",
+	"G",
+	"H",
+	"I",
+	"J",
+	"K",
+	"L",
+	"M",
+	"N",
+	"O",
+	"P",
+	"Q",
+	"R",
+	"S",
+	"T",
+	"U",
+	"V",
+	"W",
+	"X",
+	"Y",
+	"Z",
+	"a",
+	"b",
+	"c",
+	"d",
+	"e",
+	"f",
+	"g",
+	"h",
+	"i",
+	"j",
+	"k",
+	"l",
+	"m",
+	"n",
+	"o",
+	"p",
+	"q",
+	"r",
+	"s",
+	"t",
+	"u",
+	"v",
+	"w",
+	"x",
+	"y",
+	"z",
+	"#",
+	"$",
+	"%",
+	"*",
+	"+",
+	",",
+	"-",
+	".",
+	":",
+	";",
+	"=",
+	"?",
+	"@",
+	"[",
+	"]",
+	"^",
+	"_",
+	"{",
+	"|",
+	"}",
+	"~"
+];
+var p = (t, e) => {
+	var r = "";
+	for (let n = 1; n <= e; n++) {
+		let l = Math.floor(t) / Math.pow(83, e - n) % 83;
+		r += q[Math.floor(l)];
+	}
+	return r;
+};
+var f = (t) => {
+	let e = t / 255;
+	return e <= .04045 ? e / 12.92 : Math.pow((e + .055) / 1.055, 2.4);
+};
+var h = (t) => {
+	let e = Math.max(0, Math.min(1, t));
+	return e <= .0031308 ? Math.trunc(e * 12.92 * 255 + .5) : Math.trunc((1.055 * Math.pow(e, .4166666666666667) - .055) * 255 + .5);
+};
+var F = (t) => t < 0 ? -1 : 1;
+var M = (t, e) => F(t) * Math.pow(Math.abs(t), e);
+var d = class extends Error {
+	constructor(e) {
+		super(e), this.name = "ValidationError", this.message = e;
+	}
+};
+var A = 4;
+var D = (t, e, r, n) => {
+	let l = 0, m = 0, b = 0, g = e * A;
+	for (let u = 0; u < e; u++) {
+		let c = A * u;
+		for (let s = 0; s < r; s++) {
+			let o = c + s * g, a = n(u, s);
+			l += a * f(t[o]), m += a * f(t[o + 1]), b += a * f(t[o + 2]);
+		}
+	}
+	let i = 1 / (e * r);
+	return [
+		l * i,
+		m * i,
+		b * i
+	];
+};
+var $ = (t) => {
+	let e = h(t[0]), r = h(t[1]), n = h(t[2]);
+	return (e << 16) + (r << 8) + n;
+};
+var H = (t, e) => {
+	let r = Math.floor(Math.max(0, Math.min(18, Math.floor(M(t[0] / e, .5) * 9 + 9.5)))), n = Math.floor(Math.max(0, Math.min(18, Math.floor(M(t[1] / e, .5) * 9 + 9.5)))), l = Math.floor(Math.max(0, Math.min(18, Math.floor(M(t[2] / e, .5) * 9 + 9.5))));
+	return r * 19 * 19 + n * 19 + l;
+};
+var O = (t, e, r, n, l) => {
+	if (n < 1 || n > 9 || l < 1 || l > 9) throw new d("BlurHash must have between 1 and 9 components");
+	if (e * r * 4 !== t.length) throw new d("Width and height must match the pixels array");
+	let m = [];
+	for (let s = 0; s < l; s++) for (let o = 0; o < n; o++) {
+		let a = o == 0 && s == 0 ? 1 : 2, y = D(t, e, r, (B, R) => a * Math.cos(Math.PI * o * B / e) * Math.cos(Math.PI * s * R / r));
+		m.push(y);
+	}
+	let b = m[0], g = m.slice(1), i = "", u = n - 1 + (l - 1) * 9;
+	i += p(u, 1);
+	let c;
+	if (g.length > 0) {
+		let s = Math.max(...g.map((a) => Math.max(...a))), o = Math.floor(Math.max(0, Math.min(82, Math.floor(s * 166 - .5))));
+		c = (o + 1) / 166, i += p(o, 1);
+	} else c = 1, i += p(0, 1);
+	return i += p($(b), 4), g.forEach((s) => {
+		i += p(H(s, c), 2);
+	}), i;
+};
+var S = O;
+//#endregion
+//#region src/hash.ts
+/**
+* Browser-side MD5 hashing (lazy-loaded).
+*
+* spark-md5 是纯 JS 实现，体积小；动态导入让 bundler 不把它打进 dist，
+* consumer 必须把它列为 `peerDependency` 或 `optionalDependencies`。
+*/
+const CHUNK_SIZE = 2097152;
+/**
+* 计算 Blob/File 的 MD5 摘要（hex string）。
+* 静态方法，便于在 Worker / OffscreenCanvas 等环境调用。
+*/
+async function hashBlob(blob, onProgress) {
+	if (typeof blob === "undefined" || blob.size === void 0) throw new TypeError("hashBlob 需要传入 Blob 或 File");
+	const { default: SparkMD5 } = await Promise.resolve().then(() => /* @__PURE__ */ require_rolldown_runtime.__toESM(require("./spark-md5-BgTNfY_D.cjs").default, 1));
+	const hash = new SparkMD5.ArrayBuffer();
+	const total = Math.max(1, Math.ceil(blob.size / CHUNK_SIZE));
+	for (let index = 0; index < total; index += 1) {
+		const start = index * CHUNK_SIZE;
+		const buffer = await blob.slice(start, Math.min(start + CHUNK_SIZE, blob.size)).arrayBuffer();
+		hash.append(buffer);
+		onProgress?.({
+			loaded: index + 1,
+			percent: Math.round((index + 1) / total * 100),
+			total
+		});
+	}
+	return hash.end();
+}
+//#endregion
+//#region src/video-metadata.ts
+/** Video metadata extracted by the local metaprobe WASM package. */
+const num = (v) => {
+	const n = typeof v === "number" ? v : Number(v);
+	return Number.isFinite(n) ? n : void 0;
+};
+const str = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+const date = (v) => {
+	const s = str(v);
+	if (!s) return;
+	const normalized = s.replace(/^UTC\s+/i, "").replace(" ", "T") + (s.match(/^UTC\s+/i) ? "Z" : "");
+	const d = new Date(normalized);
+	return Number.isNaN(d.valueOf()) ? s : d.toISOString();
+};
+const clean = (v) => Object.fromEntries(Object.entries(v).filter(([, x]) => x !== void 0));
+/** Compatibility mapper for callers that still provide the old MediaInfo shape. */
+function mapMediaInfoResult(input) {
+	const tracks = input.media?.track ?? [];
+	if (!tracks.length) return {};
+	const general = tracks.find((t) => t["@type"] === "General") ?? {};
+	const video = tracks.find((t) => t["@type"] === "Video") ?? {};
+	const location = str(general.Recorded_Location)?.match(/([+-]?\d+(?:\.\d+)?)°?\s*([NS]).*?([+-]?\d+(?:\.\d+)?)°?\s*([EW]).*?(\d+(?:\.\d+)?)m/i);
+	return clean({
+		bitrate: num(video.BitRate),
+		codec: str(video.Format),
+		creation_time: date(general.Encoded_Date),
+		duration: num(general.Duration),
+		exif: location ? {
+			altitude: num(location[5]),
+			device_make: str(general.Encoded_Hardware_CompanyName),
+			device_model: str(general.Encoded_Hardware_Name),
+			lat: num(location[1]),
+			lng: num(location[3]),
+			taken_at: date(general.Encoded_Date)
+		} : void 0,
+		frame_rate: num(video.FrameRate),
+		height: num(video.Height),
+		metadata: {
+			general,
+			video
+		},
+		width: num(video.Width)
+	});
+}
+function mapExif(e) {
+	if (!e) return;
+	const v = clean({
+		altitude: num(e.altitude ?? e.GPSAltitude),
+		device_make: str(e.Make),
+		device_model: str(e.Model),
+		exposure_time: str(e.ExposureTime),
+		f_number: str(e.FNumber),
+		focal_length: str(e.FocalLength),
+		iso: num(e.ISO ?? e.PhotographicSensitivity),
+		lat: num(e.latitude ?? e.GPSLatitude),
+		lens_model: str(e.LensModel),
+		lng: num(e.longitude ?? e.GPSLongitude),
+		taken_at: date(e.DateTimeOriginalISO ?? e.DateTimeOriginal)
+	});
+	return Object.keys(v).length ? v : void 0;
+}
+async function loadMediaInfoVideoMetadata(file) {
+	await (0, metaprobe.default)();
+	const m = (0, metaprobe.extractMetaFastSized)(new Uint8Array(await file.arrayBuffer()), file.name ?? "", file.size);
+	return clean({
+		bitrate: num(m.overallBitrate),
+		codec: str(m.codec),
+		creation_time: date(m.creationTime ?? m.containerCreationTime),
+		duration: num(m.duration),
+		exif: mapExif(m.exif),
+		frame_rate: num(m.frameRate),
+		height: num(m.height),
+		metadata: m.metadata,
+		width: num(m.width)
+	});
+}
+//#endregion
+//#region src/analyze.ts
+/**
+* Browser-side media analysis:
+* - images: blurhash / arthash / dominant colors / EXIF
+* - videos: mediainfo metadata + EXIF
+*/
+const MEDIA_ANALYSIS_SCHEMA_VERSION = 1;
+const ARTHASH_CODEC = "rect-v64";
+const IMAGE_TYPES = ["image/"];
+const IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+	"jpg",
+	"jpeg",
+	"png",
+	"gif",
+	"webp",
+	"avif",
+	"heic",
+	"heif",
+	"tif",
+	"tiff",
+	"bmp"
+]);
+const VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([
+	"mov",
+	"mp4",
+	"avi",
+	"mkv",
+	"webm",
+	"m4v"
+]);
+function getExtension(fileName) {
+	const dot = fileName.lastIndexOf(".");
+	return dot >= 0 ? fileName.slice(dot).toLowerCase() : "";
+}
+function isVideoFile(file) {
+	return file.type.startsWith("video/") || VIDEO_EXTENSIONS.has(getExtension(file.name ?? "").slice(1));
+}
+function isImageFile(file) {
+	return IMAGE_TYPES.some((prefix) => file.type.startsWith(prefix)) || IMAGE_EXTENSIONS.has(getExtension(file.name ?? "").slice(1));
+}
+function createCanvas(width, height) {
+	if (typeof OffscreenCanvas !== "undefined") return new OffscreenCanvas(width, height);
+	if (typeof document !== "undefined") {
+		const canvas = document.createElement("canvas");
+		canvas.width = width;
+		canvas.height = height;
+		return canvas;
+	}
+	throw new Error("当前环境不支持 Canvas，无法分析图片");
+}
+function get2DContext(canvas) {
+	const context = canvas.getContext("2d", { willReadFrequently: true });
+	if (!context) throw new Error("无法创建 Canvas 2D 上下文");
+	return context;
+}
+async function decodeImage(file, maxDimension) {
+	if (typeof createImageBitmap === "function") {
+		const bitmap = await createImageBitmap(file, { imageOrientation: "from-image" });
+		try {
+			return rasterize(bitmap, bitmap.width, bitmap.height, maxDimension);
+		} finally {
+			bitmap.close();
+		}
+	}
+	if (typeof Image === "undefined" || typeof URL === "undefined") throw new Error("当前环境不支持图片解码");
+	const url = URL.createObjectURL(file);
+	try {
+		const image = await new Promise((resolve, reject) => {
+			const element = new Image();
+			element.onload = () => resolve(element);
+			element.onerror = () => reject(/* @__PURE__ */ new Error("图片解码失败"));
+			element.src = url;
+		});
+		return rasterize(image, image.naturalWidth, image.naturalHeight, maxDimension);
+	} finally {
+		URL.revokeObjectURL(url);
+	}
+}
+function rasterize(source, sourceWidth, sourceHeight, maxDimension) {
+	const scale = Math.min(1, Math.max(1, maxDimension) / Math.max(sourceWidth, sourceHeight));
+	const width = Math.max(1, Math.round(sourceWidth * scale));
+	const height = Math.max(1, Math.round(sourceHeight * scale));
+	const context = get2DContext(createCanvas(width, height));
+	context.drawImage(source, 0, 0, width, height);
+	return {
+		height,
+		rgba: context.getImageData(0, 0, width, height).data,
+		sourceHeight,
+		sourceWidth,
+		width
+	};
+}
+function rgbBytes(rgba) {
+	const rgb = new Uint8Array(rgba.length / 4 * 3);
+	for (let source = 0, target = 0; source < rgba.length; source += 4, target += 3) {
+		rgb[target] = rgba[source] ?? 0;
+		rgb[target + 1] = rgba[source + 1] ?? 0;
+		rgb[target + 2] = rgba[source + 2] ?? 0;
+	}
+	return rgb;
+}
+function bytesToBase64(bytes) {
+	if (typeof btoa !== "function") throw new Error("当前环境不支持 Base64 编码");
+	let binary = "";
+	const chunkSize = 32768;
+	for (let index = 0; index < bytes.length; index += chunkSize) binary += String.fromCharCode(...bytes.subarray(index, index + chunkSize));
+	return btoa(binary);
+}
+function toHex(value) {
+	return value.toString(16).padStart(2, "0");
+}
+function extractColors(rgba, maxColors) {
+	const colorMap = /* @__PURE__ */ new Map();
+	const totalPixels = rgba.length / 4;
+	const step = totalPixels > 1e5 ? 3 : totalPixels > 5e4 ? 2 : 1;
+	let sampledPixels = 0;
+	for (let pixel = 0; pixel < rgba.length; pixel += 4 * step) {
+		if ((rgba[pixel + 3] ?? 0) < 128) continue;
+		const r = Math.floor((rgba[pixel] ?? 0) / 16) * 16;
+		const g = Math.floor((rgba[pixel + 1] ?? 0) / 16) * 16;
+		const b = Math.floor((rgba[pixel + 2] ?? 0) / 16) * 16;
+		const brightness = (r + g + b) / 3;
+		if (brightness < 10 || brightness > 245) continue;
+		const key = `${r},${g},${b}`;
+		const current = colorMap.get(key);
+		if (current) current.count += 1;
+		else colorMap.set(key, {
+			b,
+			count: 1,
+			g,
+			r
+		});
+		sampledPixels += 1;
+	}
+	if (sampledPixels === 0) return [];
+	return [...colorMap.values()].sort((left, right) => right.count - left.count).slice(0, Math.max(0, maxColors)).map((color, rank) => ({
+		b: color.b,
+		g: color.g,
+		hex: `#${toHex(color.r)}${toHex(color.g)}${toHex(color.b)}`,
+		is_primary: rank === 0,
+		percentage: color.count / sampledPixels * 100,
+		r: color.r,
+		rank
+	}));
+}
+function valueFrom(record, ...keys) {
+	if (!record) return;
+	for (const key of keys) if (record[key] !== void 0 && record[key] !== null) return record[key];
+}
+function numberFrom(value) {
+	const number = typeof value === "number" ? value : Number(value);
+	return Number.isFinite(number) ? number : void 0;
+}
+function stringFrom(value) {
+	if (value instanceof Date) return value.toISOString();
+	if (typeof value === "string" && value.trim()) return value.trim();
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+}
+function dateFrom(value) {
+	if (value instanceof Date && !Number.isNaN(value.valueOf())) return value.toISOString();
+	if (typeof value === "string" && value.trim()) {
+		const date = new Date(value);
+		return Number.isNaN(date.valueOf()) ? value : date.toISOString();
+	}
+}
+async function readExif(file, includeRaw) {
+	try {
+		await (0, metaprobe.default)();
+		const parsed = (0, metaprobe.extractMetaFastSized)(new Uint8Array(await file.arrayBuffer()), file.name ?? "", file.size).exif;
+		const gps = parsed;
+		const exif = {
+			altitude: numberFrom(valueFrom(parsed, "GPSAltitude", "altitude")),
+			device_make: stringFrom(valueFrom(parsed, "Make", "make", "DeviceManufacturer")),
+			device_model: stringFrom(valueFrom(parsed, "Model", "model", "DeviceModel")),
+			exposure_time: stringFrom(valueFrom(parsed, "ExposureTime", "exposure_time")),
+			f_number: stringFrom(valueFrom(parsed, "FNumber", "f_number")),
+			focal_length: stringFrom(valueFrom(parsed, "FocalLength", "focal_length")),
+			iso: numberFrom(valueFrom(parsed, "ISO", "iso")),
+			lat: numberFrom(valueFrom(gps, "latitude", "GPSLatitude", "lat") ?? valueFrom(parsed, "latitude", "GPSLatitude")),
+			lens_model: stringFrom(valueFrom(parsed, "LensModel", "Lens", "lens_model")),
+			lng: numberFrom(valueFrom(gps, "longitude", "GPSLongitude", "lng") ?? valueFrom(parsed, "longitude", "GPSLongitude")),
+			orientation: numberFrom(valueFrom(parsed, "Orientation", "orientation")),
+			taken_at: dateFrom(valueFrom(parsed, "DateTimeOriginal", "CreateDate", "CreationDate", "creation_time"))
+		};
+		if (includeRaw && parsed) exif.raw = parsed;
+		return removeUndefined(exif);
+	} catch (error) {
+		console.error("metaprobe EXIF 解析失败:", error);
+		return {};
+	}
+}
+function removeUndefined(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+}
+async function analyzeImage(file, options) {
+	const raster = await decodeImage(file, options.analysisMaxDimension ?? 100);
+	const componentX = options.blurhashComponentX ?? 4;
+	const componentY = options.blurhashComponentY ?? 3;
+	const blurhash = S(raster.rgba, raster.width, raster.height, componentX, componentY);
+	const hash = await encode(rgbBytes(raster.rgba), raster.width, raster.height, codec.rect({ n: 64 }));
+	const exif = await readExif(file, options.includeRawExif ?? false);
+	return {
+		height: raster.sourceHeight,
+		image: {
+			arthash: bytesToBase64(hash),
+			arthash_codec: ARTHASH_CODEC,
+			blurhash,
+			colors: extractColors(raster.rgba, options.colorCount ?? 5),
+			exif
+		},
+		width: raster.sourceWidth
+	};
+}
+async function analyzeVideo(file, includeRawExif) {
+	const metadata = await loadVideoMetadata(file);
+	const exif = removeUndefined({
+		...metadata.exif,
+		...await readExif(file, includeRawExif)
+	});
+	return { video: removeUndefined({
+		bitrate: metadata.bitrate,
+		codec: metadata.codec,
+		creation_time: metadata.creation_time ?? exif.taken_at,
+		duration: metadata.duration,
+		exif,
+		frame_rate: metadata.frame_rate,
+		height: metadata.height,
+		metadata: removeUndefined({
+			...metadata.metadata,
+			exif: exif.raw
+		}),
+		width: metadata.width
+	}) };
+}
+async function loadVideoElementMetadata(file) {
+	if (typeof document === "undefined" || typeof URL === "undefined") return {};
+	const url = URL.createObjectURL(file);
+	try {
+		const video = document.createElement("video");
+		video.preload = "metadata";
+		video.muted = true;
+		await new Promise((resolve, reject) => {
+			video.onloadedmetadata = () => resolve();
+			video.onerror = () => reject(/* @__PURE__ */ new Error("视频元数据读取失败"));
+			video.src = url;
+		});
+		return removeUndefined({
+			duration: Number.isFinite(video.duration) ? video.duration : void 0,
+			height: video.videoHeight || void 0,
+			width: video.videoWidth || void 0
+		});
+	} finally {
+		URL.revokeObjectURL(url);
+	}
+}
+async function loadVideoMetadata(file) {
+	const browserMetadata = await loadVideoElementMetadata(file).catch(() => ({}));
+	try {
+		const mediaInfoMetadata = await loadMediaInfoVideoMetadata(file);
+		return removeUndefined({
+			...browserMetadata,
+			...mediaInfoMetadata,
+			duration: mediaInfoMetadata.duration ?? browserMetadata.duration,
+			height: mediaInfoMetadata.height ?? browserMetadata.height,
+			width: mediaInfoMetadata.width ?? browserMetadata.width
+		});
+	} catch {
+		return browserMetadata;
+	}
+}
+async function analyzeMedia(file, options = {}) {
+	if (!file || typeof file.arrayBuffer !== "function") throw new TypeError("analyzeMedia 需要传入 File 或 Blob");
+	options.onProgress?.({
+		percent: 0,
+		stage: "md5"
+	});
+	const md5 = await hashBlob(file, ({ percent }) => options.onProgress?.({
+		percent,
+		stage: "md5"
+	}));
+	const result = {
+		basic: {
+			extension: getExtension(file.name ?? ""),
+			md5,
+			name: file.name ?? "",
+			size: file.size,
+			type: file.type || "application/octet-stream"
+		},
+		schema_version: 1
+	};
+	if (isImageFile(file)) {
+		options.onProgress?.({
+			percent: 0,
+			stage: "decode"
+		});
+		const image = await analyzeImage(file, options);
+		result.basic.width = image.width;
+		result.basic.height = image.height;
+		result.image = image.image;
+		options.onProgress?.({
+			percent: 100,
+			stage: "analyze"
+		});
+	} else if (isVideoFile(file)) {
+		const video = await analyzeVideo(file, options.includeRawExif ?? false);
+		result.basic.width = video.video.width;
+		result.basic.height = video.video.height;
+		result.video = video.video;
+		options.onProgress?.({
+			percent: 100,
+			stage: "analyze"
+		});
+	}
+	return result;
+}
+//#endregion
+exports.ARTHASH_CODEC = ARTHASH_CODEC;
+exports.MEDIA_ANALYSIS_SCHEMA_VERSION = MEDIA_ANALYSIS_SCHEMA_VERSION;
+exports.analyzeMedia = analyzeMedia;
+exports.hashBlob = hashBlob;
+exports.loadMediaInfoVideoMetadata = loadMediaInfoVideoMetadata;
+exports.mapMediaInfoResult = mapMediaInfoResult;