@l1yp/file-viewer 0.1.0

package/dist/lib/rar.js

@@ -0,0 +1,40 @@
+import { createExtractorFromData as e } from "node-unrar-js";
+import t from "node-unrar-js/esm/js/unrar.wasm?url";
+//#region src/lib/rar.ts
+var n = null;
+async function r() {
+	if (!n) {
+		let e = await fetch(t);
+		if (!e.ok) throw Error(`无法加载 unrar.wasm（HTTP ${e.status}）`);
+		n = await e.arrayBuffer();
+	}
+	return n;
+}
+async function i(t) {
+	let n = await e({
+		wasmBinary: await r(),
+		data: t
+	}), i = [...n.getFileList().fileHeaders];
+	return {
+		entries: i.map((e, t) => {
+			let n = e.name.replace(/\\/g, "/").replace(/\/+$/, "");
+			return {
+				path: n,
+				name: n.split("/").pop() ?? n,
+				size: e.flags.directory ? 0 : e.unpSize,
+				isDir: e.flags.directory,
+				ref: t
+			};
+		}),
+		extract(e) {
+			let t = i[e.ref];
+			if (!t || t.flags.directory) return new Uint8Array();
+			if (t.flags.encrypted) throw Error("该条目已加密，无法读取");
+			let r = [...n.extract({ files: [t.name] }).files], a = r.find((e) => e.fileHeader.name === t.name) ?? r[0];
+			if (!a?.extraction) throw Error("解压失败（该条目无数据）");
+			return a.extraction;
+		}
+	};
+}
+//#endregion
+export { i as openRar };

package/dist/lib/rawPreview.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Best-effort camera-RAW preview extraction (zero-dependency).
+ *
+ * Decoding a raw sensor file (CR2/NEF/ARW/DNG/…) into an image requires a full demosaicing pipeline that's
+ * out of scope for the browser. But virtually every RAW embeds a ready-to-view JPEG preview (often full-res).
+ * This walks the file's JPEG streams properly — skipping each marker segment by its length, including the
+ * EXIF thumbnail nested in APP1, so it finds true SOI…EOI boundaries rather than cutting at the first stray
+ * `FF D9` — and returns the LARGEST embedded JPEG (the main preview). Imperfect by nature; a file with no
+ * embedded JPEG yields null.
+ */
+/** Return the bytes of the largest embedded JPEG in `buf` (the RAW's main preview), or null if none. */
+export declare function extractLargestJpeg(buf: ArrayBuffer): Uint8Array | null;

package/dist/lib/rawPreview.js

@@ -0,0 +1,54 @@
+//#region src/lib/rawPreview.ts
+function e(e, t) {
+	let n = t + 2, r = e.length;
+	for (; n < r - 1;) {
+		if (e[n] !== 255) {
+			n++;
+			continue;
+		}
+		let t = e[n + 1];
+		if (t === 255) {
+			n++;
+			continue;
+		}
+		if (t === 217) return n + 2;
+		if (t === 1 || t >= 208 && t <= 215) {
+			n += 2;
+			continue;
+		}
+		if (n + 3 >= r) return -1;
+		let i = e[n + 2] << 8 | e[n + 3];
+		if (i < 2) return -1;
+		if (t === 218) {
+			for (n += 2 + i; n < r - 1;) {
+				if (e[n] === 255) {
+					let t = e[n + 1];
+					if (t !== 0 && !(t >= 208 && t <= 215)) break;
+				}
+				n++;
+			}
+			continue;
+		}
+		n += 2 + i;
+	}
+	return -1;
+}
+function t(t) {
+	let n = new Uint8Array(t), r = n.length, i = null, a = 0;
+	for (; a < r - 1;) {
+		if (n[a] === 255 && n[a + 1] === 216) {
+			let t = e(n, a);
+			if (t > a) {
+				(!i || t - a > i.end - i.start) && (i = {
+					start: a,
+					end: t
+				}), a = t;
+				continue;
+			}
+		}
+		a++;
+	}
+	return i ? n.subarray(i.start, i.end) : null;
+}
+//#endregion
+export { t as extractLargestJpeg };

package/dist/lib/rc2.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Compact RC2 (RFC 2268) CBC decryption — no dependency, no WASM.
+ *
+ * Needed for legacy PKCS#12 keystores (see lib/pkcs12.ts): certificate bags are commonly encrypted with
+ * `pbeWithSHA1And40BitRC2-CBC` (or the 128-bit variant), and WebCrypto ships no RC2. Decrypt-only. RC2 is
+ * obsolete — used here ONLY to read existing keystores. Blocks are 8 bytes; words are 16-bit little-endian.
+ */
+/**
+ * RC2-CBC decrypt, no padding removal (the caller strips PKCS#7). `iv` is 8 bytes; `data` must be a whole
+ * number of 8-byte blocks. `effectiveBits` defaults to the key length in bits (PKCS#12 40-bit RC2 passes 40).
+ */
+export declare function rc2CbcDecrypt(key: Uint8Array, iv: Uint8Array, data: Uint8Array, effectiveBits?: number): Uint8Array;

package/dist/lib/rc2.js

@@ -0,0 +1,298 @@
+//#region src/lib/rc2.ts
+var e = new Uint8Array([
+	217,
+	120,
+	249,
+	196,
+	25,
+	221,
+	181,
+	237,
+	40,
+	233,
+	253,
+	121,
+	74,
+	160,
+	216,
+	157,
+	198,
+	126,
+	55,
+	131,
+	43,
+	118,
+	83,
+	142,
+	98,
+	76,
+	100,
+	136,
+	68,
+	139,
+	251,
+	162,
+	23,
+	154,
+	89,
+	245,
+	135,
+	179,
+	79,
+	19,
+	97,
+	69,
+	109,
+	141,
+	9,
+	129,
+	125,
+	50,
+	189,
+	143,
+	64,
+	235,
+	134,
+	183,
+	123,
+	11,
+	240,
+	149,
+	33,
+	34,
+	92,
+	107,
+	78,
+	130,
+	84,
+	214,
+	101,
+	147,
+	206,
+	96,
+	178,
+	28,
+	115,
+	86,
+	192,
+	20,
+	167,
+	140,
+	241,
+	220,
+	18,
+	117,
+	202,
+	31,
+	59,
+	190,
+	228,
+	209,
+	66,
+	61,
+	212,
+	48,
+	163,
+	60,
+	182,
+	38,
+	111,
+	191,
+	14,
+	218,
+	70,
+	105,
+	7,
+	87,
+	39,
+	242,
+	29,
+	155,
+	188,
+	148,
+	67,
+	3,
+	248,
+	17,
+	199,
+	246,
+	144,
+	239,
+	62,
+	231,
+	6,
+	195,
+	213,
+	47,
+	200,
+	102,
+	30,
+	215,
+	8,
+	232,
+	234,
+	222,
+	128,
+	82,
+	238,
+	247,
+	132,
+	170,
+	114,
+	172,
+	53,
+	77,
+	106,
+	42,
+	150,
+	26,
+	210,
+	113,
+	90,
+	21,
+	73,
+	116,
+	75,
+	159,
+	208,
+	94,
+	4,
+	24,
+	164,
+	236,
+	194,
+	224,
+	65,
+	110,
+	15,
+	81,
+	203,
+	204,
+	36,
+	145,
+	175,
+	80,
+	161,
+	244,
+	112,
+	57,
+	153,
+	124,
+	58,
+	133,
+	35,
+	184,
+	180,
+	122,
+	252,
+	2,
+	54,
+	91,
+	37,
+	85,
+	151,
+	49,
+	45,
+	93,
+	250,
+	152,
+	227,
+	138,
+	146,
+	174,
+	5,
+	223,
+	41,
+	16,
+	103,
+	108,
+	186,
+	201,
+	211,
+	0,
+	230,
+	207,
+	225,
+	158,
+	168,
+	44,
+	99,
+	22,
+	1,
+	63,
+	88,
+	226,
+	137,
+	169,
+	13,
+	56,
+	52,
+	27,
+	171,
+	51,
+	255,
+	176,
+	187,
+	72,
+	12,
+	95,
+	185,
+	177,
+	205,
+	46,
+	197,
+	243,
+	219,
+	71,
+	229,
+	165,
+	156,
+	119,
+	10,
+	166,
+	32,
+	104,
+	254,
+	127,
+	193,
+	173
+]);
+function t(t, n) {
+	let r = new Uint8Array(128), i = t.length;
+	r.set(t.subarray(0, i));
+	let a = n, o = a + 7 >> 3, s = 255 >> (8 * o - a & 7);
+	for (let t = i; t < 128; t++) r[t] = e[r[t - 1] + r[t - i] & 255];
+	r[128 - o] = e[r[128 - o] & s];
+	for (let t = 127 - o; t >= 0; t--) r[t] = e[r[t + 1] ^ r[t + o]];
+	let c = new Uint16Array(64);
+	for (let e = 0; e < 64; e++) c[e] = r[2 * e] | r[2 * e + 1] << 8;
+	return c;
+}
+var n = (e, t) => (e >>> t | e << 16 - t) & 65535;
+function r(e, t) {
+	let [r, i, a, o] = e, s = 63, c = () => {
+		o = n(o, 5), o = o - t[s--] - (a & i) - (~a & r) & 65535, a = n(a, 3), a = a - t[s--] - (i & r) - (~i & o) & 65535, i = n(i, 2), i = i - t[s--] - (r & o) - (~r & a) & 65535, r = n(r, 1), r = r - t[s--] - (o & a) - (~o & i) & 65535;
+	}, l = () => {
+		o = o - t[a & 63] & 65535, a = a - t[i & 63] & 65535, i = i - t[r & 63] & 65535, r = r - t[o & 63] & 65535;
+	};
+	for (let e = 0; e < 5; e++) c();
+	l();
+	for (let e = 0; e < 6; e++) c();
+	l();
+	for (let e = 0; e < 5; e++) c();
+	e[0] = r, e[1] = i, e[2] = a, e[3] = o;
+}
+function i(e, n, i, a = e.length * 8) {
+	let o = t(e, a), s = i.length - i.length % 8, c = new Uint8Array(s), l = new Uint8Array(8);
+	l.set(n.subarray(0, 8));
+	let u = [
+		0,
+		0,
+		0,
+		0
+	];
+	for (let e = 0; e < s; e += 8) u[0] = i[e] | i[e + 1] << 8, u[1] = i[e + 2] | i[e + 3] << 8, u[2] = i[e + 4] | i[e + 5] << 8, u[3] = i[e + 6] | i[e + 7] << 8, r(u, o), c[e] = u[0] & 255 ^ l[0], c[e + 1] = u[0] >> 8 & 255 ^ l[1], c[e + 2] = u[1] & 255 ^ l[2], c[e + 3] = u[1] >> 8 & 255 ^ l[3], c[e + 4] = u[2] & 255 ^ l[4], c[e + 5] = u[2] >> 8 & 255 ^ l[5], c[e + 6] = u[3] & 255 ^ l[6], c[e + 7] = u[3] >> 8 & 255 ^ l[7], l.set(i.subarray(e, e + 8));
+	return c;
+}
+//#endregion
+export { i as rc2CbcDecrypt };

package/dist/lib/resolveInput.d.ts

@@ -0,0 +1,22 @@
+import type { ViewerInput } from '../types';
+/** A normalized source: always a fetchable URL, plus optional pre-decoded text; `dispose()` frees blob: URLs. */
+export interface ResolvedSource {
+    name: string;
+    mime: string | null;
+    size?: number;
+    /** Always fetchable: the real `src`, or a `blob:` URL for blob/text/load/pre-fetched sources. */
+    url: string;
+    /** Present when the input carried decoded text (text-backed viewers use it directly — no fetch). */
+    text?: string;
+    /** Release any `blob:` URL this created. No-op for a pass-through `src`. */
+    dispose(): void;
+}
+/**
+ * Normalize a {@link ViewerInput} into a fetchable source (see docs/file-viewer-package-design.md §2).
+ *
+ * Async because AUTHENTICATED sources (`fetchConfig`/`load`) are pulled ONCE here and turned into a `blob:`
+ * URL — so the self-fetching sub-viewers keep calling plain `fetch(url)` with no auth knowledge, and the
+ * credentials live in exactly one place. A plain public `src` is passed through unchanged (streaming stays
+ * intact for the big-file viewers). `blob`/`text` become object URLs. Precedence: text > blob > load > src.
+ */
+export declare function resolveInput(input: ViewerInput): Promise<ResolvedSource>;

package/dist/lib/resolveInput.js

@@ -0,0 +1,55 @@
+//#region src/lib/resolveInput.ts
+var e = () => {};
+function t(e, t) {
+	return e instanceof Blob ? e : new Blob([e], t ? { type: t } : void 0);
+}
+async function n(n) {
+	let r = n.name, i = n.mime && n.mime.trim() ? n.mime : null, a = {
+		name: r,
+		mime: i,
+		size: n.size
+	};
+	if (n.text != null) {
+		let e = URL.createObjectURL(new Blob([n.text], { type: i ?? "text/plain" }));
+		return {
+			...a,
+			url: e,
+			text: n.text,
+			dispose: () => URL.revokeObjectURL(e)
+		};
+	}
+	if (n.blob) {
+		let e = URL.createObjectURL(n.blob);
+		return {
+			...a,
+			url: e,
+			dispose: () => URL.revokeObjectURL(e)
+		};
+	}
+	if (n.load) {
+		let e = URL.createObjectURL(t(await n.load(), i));
+		return {
+			...a,
+			url: e,
+			dispose: () => URL.revokeObjectURL(e)
+		};
+	}
+	if (n.src && n.fetchConfig) {
+		let e = await fetch(n.src, n.fetchConfig);
+		if (!e.ok) throw Error(`HTTP ${e.status} fetching "${r}"`);
+		let t = URL.createObjectURL(await e.blob());
+		return {
+			...a,
+			url: t,
+			dispose: () => URL.revokeObjectURL(t)
+		};
+	}
+	if (n.src) return {
+		...a,
+		url: n.src,
+		dispose: e
+	};
+	throw Error(`ViewerInput for "${r}" has no data source (src / blob / text / load)`);
+}
+//#endregion
+export { n as resolveInput };

package/dist/lib/rtf.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Zero-dependency RTF (Rich Text Format) → HTML renderer for the side viewer's {@link RtfViewer}.
+ *
+ * RTF is a 7-bit-ASCII control-word format — `{\rtf1 … }` groups, `\word`/`\word42` control words, `\'hh` raw
+ * bytes, `\uN` unicode — so (like the eml / mht / har / asn1 parsers) we hand-roll it rather than pull a heavy
+ * canvas-based library. We interpret the document with a group state stack and emit a small, SAFE HTML tree:
+ *
+ *  - paragraphs (`\par`) → `<p>` with text-align; soft breaks (`\line`) → `\n` (the container is white-space:
+ *    pre-wrap, so `\tab`/`\n`/runs of spaces survive without needing `<br>`);
+ *  - character runs → `<span style>` carrying ONLY whitelisted, self-computed values: bold/italic via
+ *    font-weight/style, underline/strike via text-decoration, `\cfN` → `#rrggbb` from the parsed color table,
+ *    `\fsN` → pt, `\fN` → a sanitized font-family stack from the font table, `\super`/`\sub` → vertical-align.
+ *
+ * Security: every byte of text is HTML-escaped and the only attributes we emit are numbers (sizes), `#rrggbb`
+ * colors, and a quote-/bracket-stripped font name — there is NO path for upstream markup, URLs, or scripts to
+ * reach the output, so the component can inline it with `v-html` (same posture as DrawioViewer/WidgetBlock's
+ * self-generated SVG). Unknown control words, binary blobs (`\bin`), pictures and other destinations we don't
+ * render are skipped, never dumped as raw text.
+ *
+ * Charset handling: `\'hh` bytes are decoded with a TextDecoder chosen from the current font's `\fcharset` (or
+ * the document's `\ansicpg`), so CJK / Cyrillic / etc. documents read correctly; `\uN` carries unicode directly
+ * (with `\ucN` fallback bytes skipped). Multi-byte `\'hh` pairs are buffered and decoded together — we only
+ * flush the byte buffer at formatting/group boundaries, never between two adjacent `\'` escapes.
+ */
+/** One styled text run within a paragraph. Booleans/values map 1:1 to a `<span style>` (see {@link runHtml}). */
+export interface RtfRun {
+    text: string;
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    strike: boolean;
+    superscript: boolean;
+    subscript: boolean;
+    /** '#rrggbb' from the color table (`\cfN`), or null for the automatic/default color. */
+    color: string | null;
+    /** Point size (`\fsN` is half-points), or null to inherit the container's size. */
+    size: number | null;
+    /** A sanitized CSS font-family stack (e.g. `'Times New Roman', serif`), or null to inherit. */
+    font: string | null;
+}
+/** A paragraph: its alignment plus the styled runs it holds (empty runs ⇒ a blank line). */
+export interface RtfPara {
+    align: 'left' | 'center' | 'right' | 'justify';
+    runs: RtfRun[];
+}
+export interface RtfDoc {
+    paras: RtfPara[];
+}
+export declare function parseRtf(bytes: Uint8Array): RtfDoc;
+/** Render a parsed document to a safe HTML string (self-generated, fully escaped — see the file header). */
+export declare function rtfToHtml(doc: RtfDoc): string;
+/** Parse + render in one step: RTF bytes → safe HTML. */
+export declare function renderRtf(bytes: Uint8Array): string;