@l1yp/file-viewer 0.1.0

package/dist/lib/classfile.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Minimal in-browser Java `.class` STRUCTURE reader — no dependency, no decompilation.
+ *
+ * Mirrors {@link lib/binobj.ts}: hand-rolled big-endian parsing over a DataView, reading only the structural
+ * tables a `javap`-style listing needs — the constant pool, the field table, and the method table. It does
+ * NOT reconstruct method bodies (that's a real decompiler — control-flow recovery, expression rebuilding,
+ * out of scope). The whole thing is "read a few length-prefixed tables and translate type descriptors".
+ *
+ * What it surfaces (see {@link ClassInfo}): the class signature (modifiers + kind + this/super/interfaces),
+ * the bytecode version, every field (modifiers + type + name), and every method (modifiers + return + params),
+ * plus — when the class was compiled with `javac -g` — each method's local variables (from the Code attribute's
+ * LocalVariableTable). Faithfully ported from the project's verified reference parser (docs/java class
+ * decompile.md), validated byte-for-byte against an OpenJDK 21 compiled class.
+ *
+ * Used by ClassViewer (the side viewer's `.class` mode): bytes come from the same download endpoint as any
+ * other file, are parsed entirely client-side, and never leave the browser.
+ */
+export interface ClassField {
+    name: string;
+    /** Human type from the field descriptor (`Ljava/lang/String;` → `String`, `[I` → `int[]`). Generics erased. */
+    type: string;
+    /** Access modifiers in source order: `public`/`private`/`protected`/`static`/`final`/`volatile`/`transient`. */
+    flags: string[];
+}
+export interface ClassLocal {
+    name: string;
+    type: string;
+    /** Local-variable slot index (slot 0 of an instance method is `this`). */
+    slot: number;
+}
+export interface ClassMethod {
+    /** Method name; `<init>` is the constructor, `<clinit>` the static initializer. */
+    name: string;
+    /** Parameter types (descriptor-decoded, generics erased). */
+    params: string[];
+    /** Return type. */
+    ret: string;
+    flags: string[];
+    /** Local variables (from Code/LocalVariableTable, `javac -g` only); null when the table is absent. */
+    locals: ClassLocal[] | null;
+}
+export type ClassKind = 'class' | 'interface' | 'enum' | '@interface';
+export interface ClassInfo {
+    majorVersion: number;
+    minorVersion: number;
+    /** `"major.minor"` raw bytecode version (e.g. `"65.0"`). */
+    version: string;
+    /** Friendly platform label derived from the major version (e.g. `"Java 21"`). */
+    javaLabel: string;
+    /** Whether it's a class / interface / enum / annotation (`@interface`). */
+    kind: ClassKind;
+    /** Class-level modifiers that aren't implied by {@link kind} (e.g. `["public", "final"]`). */
+    modifiers: string[];
+    /** Fully-qualified name of this class (`demo.Sample`). */
+    thisClass: string | null;
+    /** Fully-qualified superclass (`java.lang.Object`); null only for `java.lang.Object` itself. */
+    superClass: string | null;
+    /** Fully-qualified implemented interfaces (for an interface: its extended interfaces). */
+    interfaces: string[];
+    fields: ClassField[];
+    methods: ClassMethod[];
+}
+/** Thrown when the bytes aren't a Java class file (magic mismatch). */
+export declare class NotClassFileError extends Error {
+    constructor(message: string);
+}
+/**
+ * Parse a `.class` file's structure. Input is an ArrayBuffer/Uint8Array of the file bytes. Throws
+ * {@link NotClassFileError} on a magic mismatch; a truncated/corrupt file surfaces as a generic RangeError
+ * (DataView bounds) for the caller to report.
+ */
+export declare function parseClass(input: ArrayBuffer | Uint8Array): ClassInfo;

package/dist/lib/classfile.js

@@ -0,0 +1,210 @@
+//#region src/lib/classfile.ts
+var e = class extends Error {
+	constructor(e) {
+		super(e), this.name = "NotClassFileError";
+	}
+}, t = {
+	B: "byte",
+	C: "char",
+	D: "double",
+	F: "float",
+	I: "int",
+	J: "long",
+	S: "short",
+	Z: "boolean",
+	V: "void"
+};
+function n(e) {
+	return e >= 49 ? `Java ${e - 44}` : {
+		45: "Java 1.1",
+		46: "Java 1.2",
+		47: "Java 1.3",
+		48: "Java 1.4"
+	}[e] ?? `主版本 ${e}`;
+}
+function r(r) {
+	let i = r instanceof Uint8Array ? r : new Uint8Array(r), a = new DataView(i.buffer, i.byteOffset, i.byteLength), o = 0, s = () => a.getUint8(o++), c = () => {
+		let e = a.getUint16(o);
+		return o += 2, e;
+	}, l = () => {
+		let e = a.getUint32(o);
+		return o += 4, e;
+	};
+	if (i.byteLength < 10 || a.getUint32(0) !== 3405691582) throw new e("不是有效的 .class 文件（magic 不匹配 0xCAFEBABE）");
+	o = 4;
+	let u = c(), d = c(), f = c(), p = [], m = new TextDecoder("utf-8");
+	for (let t = 1; t < f; t++) {
+		let n = s();
+		switch (n) {
+			case 1: {
+				let e = c(), r = i.subarray(o, o + e);
+				o += e, p[t] = {
+					tag: n,
+					str: m.decode(r)
+				};
+				break;
+			}
+			case 7:
+				p[t] = {
+					tag: n,
+					nameIndex: c()
+				};
+				break;
+			case 8:
+			case 16:
+			case 19:
+			case 20:
+				p[t] = { tag: n }, c();
+				break;
+			case 9:
+			case 10:
+			case 11:
+			case 12:
+			case 17:
+			case 18:
+				p[t] = { tag: n }, c(), c();
+				break;
+			case 3:
+			case 4:
+				p[t] = { tag: n }, l();
+				break;
+			case 5:
+			case 6:
+				p[t] = { tag: n }, l(), l(), t++;
+				break;
+			case 15:
+				p[t] = { tag: n }, s(), c();
+				break;
+			default: throw new e(`未知常量池标签 ${n} @${t}`);
+		}
+	}
+	let h = (e) => p[e]?.str ?? "", g = (e) => e === 0 ? null : h(p[e]?.nameIndex ?? 0).replace(/\//g, ".");
+	function _(e, n) {
+		let r = 0;
+		for (; e[n] === "[";) r++, n++;
+		let i = e[n++] ?? "", a;
+		if (t[i]) a = t[i];
+		else if (i === "L") {
+			let t = "";
+			for (; n < e.length && e[n] !== ";";) t += e[n++];
+			n++, a = t.replace(/\//g, ".").replace(/^java\.lang\./, "");
+		} else a = i;
+		return {
+			type: a + "[]".repeat(r),
+			next: n
+		};
+	}
+	let v = (e) => _(e, 0).type;
+	function y(e) {
+		let t = 1, n = [];
+		for (; t < e.length && e[t] !== ")";) {
+			let r = _(e, t);
+			n.push(r.type), t = r.next;
+		}
+		return {
+			params: n,
+			ret: _(e, t + 1).type
+		};
+	}
+	let b = (e, t) => [
+		[1, "public"],
+		[2, "private"],
+		[4, "protected"],
+		[8, "static"],
+		[16, "final"],
+		[64, t === "field" ? "volatile" : "bridge"],
+		[128, t === "field" ? "transient" : "varargs"],
+		[256, "native"],
+		[1024, "abstract"],
+		[2048, "strictfp"]
+	].filter(([t]) => (e & t) !== 0).map(([, e]) => e), x = c(), S = g(c()), C = g(c()), w = c(), T = [];
+	for (let e = 0; e < w; e++) {
+		let e = g(c());
+		e && T.push(e);
+	}
+	let E = () => {
+		let e = c(), t = [];
+		for (let n = 0; n < e; n++) {
+			let e = c(), n = l();
+			t.push({
+				name: h(e),
+				start: o,
+				len: n
+			}), o += n;
+		}
+		return t;
+	}, D = c(), O = [];
+	for (let e = 0; e < D; e++) {
+		let e = c(), t = c(), n = c();
+		E(), O.push({
+			name: h(t),
+			type: v(h(n)),
+			flags: b(e, "field")
+		});
+	}
+	let k = c(), A = [];
+	for (let e = 0; e < k; e++) {
+		let e = c(), t = c(), n = c(), r = E(), i = y(h(n)), o = null, s = r.find((e) => e.name === "Code");
+		if (s) {
+			let e = s.start, t = () => {
+				let t = a.getUint16(e);
+				return e += 2, t;
+			}, n = () => {
+				let t = a.getUint32(e);
+				return e += 4, t;
+			};
+			t(), t();
+			let r = n();
+			e += r;
+			let i = t();
+			e += i * 8;
+			let c = t();
+			for (let r = 0; r < c; r++) {
+				let r = h(t()), i = n(), s = e;
+				if (r === "LocalVariableTable") {
+					let t = a.getUint16(e), n = e + 2;
+					o = [];
+					for (let e = 0; e < t; e++) {
+						n += 4;
+						let e = a.getUint16(n);
+						n += 2;
+						let t = a.getUint16(n);
+						n += 2;
+						let r = a.getUint16(n);
+						n += 2, o.push({
+							name: h(e),
+							type: v(h(t)),
+							slot: r
+						});
+					}
+				}
+				e = s + i;
+			}
+		}
+		A.push({
+			name: h(t),
+			params: i.params,
+			ret: i.ret,
+			flags: b(e, "method"),
+			locals: o
+		});
+	}
+	let j = "class";
+	x & 8192 ? j = "@interface" : x & 512 ? j = "interface" : x & 16384 && (j = "enum");
+	let M = [];
+	return x & 1 && M.push("public"), j === "class" && x & 16 && M.push("final"), j === "class" && x & 1024 && M.push("abstract"), {
+		majorVersion: d,
+		minorVersion: u,
+		version: `${d}.${u}`,
+		javaLabel: n(d),
+		kind: j,
+		modifiers: M,
+		thisClass: S,
+		superClass: C,
+		interfaces: T,
+		fields: O,
+		methods: A
+	};
+}
+//#endregion
+export { e as NotClassFileError, r as parseClass };

package/dist/lib/codePreview.d.ts

@@ -0,0 +1,22 @@
+import type { ViewerFile } from '@/composables/useFileViewer';
+/**
+ * Live-preview support for fenced code blocks. A markdown/html/svg fence can be "run" in the side
+ * viewer (FileViewerPanel) with the code itself as inline content — no file, no fetch. This is the
+ * code-block twin of fileType.ts's {@link isHtmlFile}/{@link isSvgFile}: same render modes, but the
+ * input is a fence info-string language token (` ```html `) rather than a filename + mime.
+ */
+export interface CodePreview {
+    /** Synthesized extension for the viewer header (also a sensible name for its download/copy label). */
+    ext: string;
+    /** ViewerFile fields that pick the render mode: `lang` (source-view highlighting) + html/svg flags. */
+    fields: Pick<ViewerFile, 'lang' | 'html' | 'svg'>;
+}
+/**
+ * Map a fenced code block's language to a side-viewer preview, or null when it has no live preview
+ * (most languages — no Run button). Mirrors FileViewerPanel's render modes:
+ *   - html/htm/xhtml → sandboxed iframe   (lang 'xml' so the source toggle still highlights);
+ *   - svg            → picture (data-URL <img>, scripts never run)  (lang 'xml' for source);
+ *   - markdown/md    → rendered document.
+ * Only the first info-string token matters, so ` ```html linenums ` still previews as HTML.
+ */
+export declare function codePreview(lang: string | undefined): CodePreview | null;

package/dist/lib/codePreview.js

@@ -0,0 +1,27 @@
+//#region src/lib/codePreview.ts
+var e = new Set([
+	"html",
+	"htm",
+	"xhtml"
+]), t = new Set(["markdown", "md"]);
+function n(n) {
+	let r = (n || "").trim().toLowerCase().split(/\s+/)[0];
+	return e.has(r) ? {
+		ext: "html",
+		fields: {
+			lang: "xml",
+			html: !0
+		}
+	} : r === "svg" ? {
+		ext: "svg",
+		fields: {
+			lang: "xml",
+			svg: !0
+		}
+	} : t.has(r) ? {
+		ext: "md",
+		fields: { lang: "markdown" }
+	} : null;
+}
+//#endregion
+export { n as codePreview };

package/dist/lib/codefold.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Indentation-based code folding for the source viewer (CodeView.vue).
+ *
+ * Deliberately language-AGNOSTIC: a foldable region is a header line followed by a run of more-deeply-indented
+ * lines (blank lines inside the run don't break it). This covers the requested languages — yaml / json / xml /
+ * html / java / kotlin / python / ts / js — because their block structure is mirrored in indentation, with no
+ * per-language parser or wasm grammar to ship (the codebase's hand-rolled, zero-dependency house style; a
+ * tree-sitter approach would mean bundling a runtime + a grammar per language). Minified or single-line files
+ * simply have nothing to fold.
+ *
+ * Returns a map of header line index (0-based) → the LAST line index belonging to its block, so folding the
+ * header hides lines header+1 … end (inclusive). Tabs are expanded to `tabSize` columns for the comparison.
+ */
+export declare function computeFoldRegions(code: string, tabSize?: number): Map<number, number>;

package/dist/lib/codefold.js

@@ -0,0 +1,30 @@
+//#region src/lib/codefold.ts
+function e(e, n = 2) {
+	let r = e.split("\n"), i = r.map((e) => t(e, n)), a = /* @__PURE__ */ new Map();
+	for (let e = 0; e < r.length; e++) {
+		if (i[e] < 0) continue;
+		let t = e, n = e + 1;
+		for (; n < r.length;) {
+			if (i[n] < 0) {
+				n++;
+				continue;
+			}
+			if (i[n] > i[e]) t = n, n++;
+			else break;
+		}
+		t > e && a.set(e, t);
+	}
+	return a;
+}
+function t(e, t) {
+	let n = 0;
+	for (let r = 0; r < e.length; r++) {
+		let i = e[r];
+		if (i === " ") n++;
+		else if (i === "	") n += t - n % t;
+		else return n;
+	}
+	return -1;
+}
+//#endregion
+export { e as computeFoldRegions };

package/dist/lib/codeformat.d.ts

@@ -0,0 +1,21 @@
+/**
+ * On-demand code formatting for the source viewer (CodeView), powered by Prettier — loaded LAZILY: the library
+ * and the one language plugin needed are dynamic-imported only when the user clicks 格式化, so they never weigh
+ * on the main bundle. Covers the languages Prettier can parse in the browser: js/jsx, ts/tsx, json/json5,
+ * css/scss/less, html/vue, xml/svg (via @prettier/plugin-xml), yaml, markdown, graphql. Other languages
+ * (python/java/kotlin/go/…) have no in-browser Prettier parser, so {@link canFormat} returns false and the
+ * button is hidden — consistent with the codebase's "be honest about what's supported" stance.
+ *
+ * The parser is chosen from the file EXTENSION first (precise — .html, .vue and .xml all collapse to hljs lang
+ * 'xml'), falling back to the hljs language id when no filename is available.
+ */
+/** Whether the source viewer should offer a 格式化 button for this file (Prettier can parse it in-browser). */
+export declare function canFormat(ext: string, lang: string): boolean;
+/**
+ * Format `code` with Prettier, picking the parser by extension (preferred) or hljs lang. Throws if the type is
+ * unsupported or the source doesn't parse (the caller surfaces a brief "格式化失败" and keeps the original).
+ */
+export declare function formatCode(code: string, opts: {
+    ext: string;
+    lang: string;
+}): Promise<string>;

package/dist/lib/codeformat.js

@@ -0,0 +1,130 @@
+//#region src/lib/codeformat.ts
+var e = {
+	parser: "babel",
+	plugins: ["babel", "estree"]
+}, t = {
+	parser: "typescript",
+	plugins: ["typescript", "estree"]
+}, n = {
+	parser: "json",
+	plugins: ["babel", "estree"]
+}, r = {
+	js: e,
+	mjs: e,
+	cjs: e,
+	jsx: e,
+	ts: t,
+	mts: t,
+	cts: t,
+	tsx: t,
+	json: n,
+	jsonc: n,
+	json5: {
+		parser: "json5",
+		plugins: ["babel", "estree"]
+	},
+	css: {
+		parser: "css",
+		plugins: ["postcss"]
+	},
+	scss: {
+		parser: "scss",
+		plugins: ["postcss"]
+	},
+	sass: {
+		parser: "scss",
+		plugins: ["postcss"]
+	},
+	less: {
+		parser: "less",
+		plugins: ["postcss"]
+	},
+	html: {
+		parser: "html",
+		plugins: ["html"]
+	},
+	htm: {
+		parser: "html",
+		plugins: ["html"]
+	},
+	vue: {
+		parser: "vue",
+		plugins: ["html"]
+	},
+	xml: {
+		parser: "xml",
+		plugins: ["xml"]
+	},
+	svg: {
+		parser: "xml",
+		plugins: ["xml"]
+	},
+	yaml: {
+		parser: "yaml",
+		plugins: ["yaml"]
+	},
+	yml: {
+		parser: "yaml",
+		plugins: ["yaml"]
+	},
+	md: {
+		parser: "markdown",
+		plugins: ["markdown"]
+	},
+	markdown: {
+		parser: "markdown",
+		plugins: ["markdown"]
+	},
+	graphql: {
+		parser: "graphql",
+		plugins: ["graphql"]
+	},
+	gql: {
+		parser: "graphql",
+		plugins: ["graphql"]
+	}
+}, i = {
+	javascript: e,
+	typescript: t,
+	json: n,
+	css: r.css,
+	scss: r.scss,
+	less: r.less,
+	yaml: r.yaml,
+	markdown: r.md,
+	graphql: r.graphql,
+	xml: r.xml
+};
+function a(e, t) {
+	return r[e] ?? i[t] ?? null;
+}
+function o(e, t) {
+	return a(e, t) != null;
+}
+function s(e) {
+	switch (e) {
+		case "babel": return import("prettier/plugins/babel");
+		case "estree": return import("prettier/plugins/estree");
+		case "typescript": return import("prettier/plugins/typescript");
+		case "postcss": return import("prettier/plugins/postcss");
+		case "html": return import("prettier/plugins/html");
+		case "yaml": return import("prettier/plugins/yaml");
+		case "markdown": return import("prettier/plugins/markdown");
+		case "graphql": return import("prettier/plugins/graphql");
+		case "xml": return import("@prettier/plugin-xml");
+	}
+}
+async function c(e, t) {
+	let n = a(t.ext, t.lang);
+	if (!n) throw Error("该类型暂不支持格式化");
+	let [r, ...i] = await Promise.all([import("prettier/standalone"), ...n.plugins.map(s)]), o = i.map((e) => e.default ?? e), c = {
+		parser: n.parser,
+		plugins: o,
+		printWidth: 100,
+		tabWidth: 2,
+		xmlWhitespaceSensitivity: "ignore"
+	};
+	return r.format(e, c);
+}
+//#endregion
+export { o as canFormat, c as formatCode };

package/dist/lib/csv.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hand-rolled, zero-dependency CSV / TSV parser for the side viewer's table preview.
+ *
+ * Implements RFC 4180 quoting: a field may be wrapped in double quotes; a literal quote inside such a field is
+ * written doubled (`""` → `"`); a quoted field may contain the delimiter, CR, and LF. Outside quotes, fields
+ * split on the delimiter and rows on CRLF / LF / lone CR. The delimiter is the tab for `.tsv`, otherwise sniffed
+ * (comma / semicolon / tab / pipe — whichever occurs most on the first line, counted OUTSIDE quotes), so
+ * European `;`-separated files and tab files both render correctly. A leading UTF-8 BOM is stripped.
+ *
+ * The viewer (CsvViewer.vue) renders the rows as a table; cell text is escaped by Vue on render, so embedded
+ * markup is inert. We never trust the stored content_type — detection is extension-driven (see isCsvFile).
+ */
+export interface ParsedCsv {
+    rows: string[][];
+    delimiter: string;
+    /** Widest row's column count (shorter rows are padded with empty cells when rendered). */
+    cols: number;
+}
+export declare function parseCsv(text: string, ext?: string): ParsedCsv;

package/dist/lib/csv.js

@@ -0,0 +1,74 @@
+//#region src/lib/csv.ts
+var e = [
+	",",
+	";",
+	"	",
+	"|"
+];
+function t(e, t) {
+	let n = 0, r = !1;
+	for (let i = 0; i < e.length; i++) {
+		let a = e[i];
+		if (a === "\"") {
+			if (r && e[i + 1] === "\"") {
+				i++;
+				continue;
+			}
+			r = !r;
+		} else a === t && !r && n++;
+	}
+	return n;
+}
+function n(n, r) {
+	if (r === "tsv" || r === "tab") return "	";
+	let i = n.indexOf("\n"), a = (i >= 0 ? n.slice(0, i) : n).slice(0, 4096), o = ",", s = -1;
+	for (let n of e) {
+		let e = t(a, n);
+		e > s && (s = e, o = n);
+	}
+	return o;
+}
+function r(e, t) {
+	let r = e.charCodeAt(0) === 65279 ? e.slice(1) : e, i = n(r, t), a = [], o = [], s = "", c = !1, l = !1, u = r.length, d = 0, f = () => {
+		o.push(s), a.push(o), o = [], s = "", l = !1;
+	};
+	for (; d < u;) {
+		let e = r[d];
+		if (c) {
+			if (e === "\"") {
+				if (r[d + 1] === "\"") {
+					s += "\"", d += 2;
+					continue;
+				}
+				c = !1, d++;
+				continue;
+			}
+			s += e, d++;
+			continue;
+		}
+		if (e === "\"" && s === "") {
+			c = !0, l = !0, d++;
+			continue;
+		}
+		if (e === i) {
+			o.push(s), s = "", l = !0, d++;
+			continue;
+		}
+		if (e === "\n") {
+			f(), d++;
+			continue;
+		}
+		if (e === "\r") {
+			f(), r[d + 1] === "\n" ? d += 2 : d++;
+			continue;
+		}
+		s += e, l = !0, d++;
+	}
+	return (l || s !== "" || o.length > 0) && (o.push(s), a.push(o)), {
+		rows: a,
+		delimiter: i,
+		cols: a.reduce((e, t) => Math.max(e, t.length), 0)
+	};
+}
+//#endregion
+export { r as parseCsv };

package/dist/lib/des.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Compact DES / Triple-DES (FIPS 46-3) — no dependency, no WASM.
+ *
+ * Needed for legacy PKCS#12 keystores (see lib/pkcs12.ts): the private key is stored in a
+ * pkcs8ShroudedKeyBag encrypted with `pbeWithSHA1And3-KeyTripleDES-CBC`, and WebCrypto ships no DES. This is
+ * decrypt-oriented (that's all the viewer needs) but the block cipher is symmetric, so an encrypt helper is
+ * exposed too (Triple-DES EDE needs a middle DES *encrypt* during decryption). DES is long obsolete — used
+ * here ONLY to read existing keystores, never for new encryption.
+ *
+ * Implementation is the textbook bit-permutation form (clear + obviously correct); keystores are a few KB, so
+ * the per-block array churn is irrelevant.
+ */
+/**
+ * Triple-DES (EDE) CBC decrypt, no padding removal (the caller strips PKCS#7). `key` is 24 bytes
+ * (K1‖K2‖K3) or 16 bytes (2-key: K3=K1); `iv` is 8 bytes; `data` must be a whole number of 8-byte blocks.
+ */
+export declare function tripleDesCbcDecrypt(key: Uint8Array, iv: Uint8Array, data: Uint8Array): Uint8Array;