@l1yp/file-viewer 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @l1yp/file-viewer — public API.
+ *
+ * See docs/file-viewer-package-design.md for the full design. Quick start:
+ *
+ *   import { FileViewer } from '@l1yp/file-viewer'
+ *   import '@l1yp/file-viewer/style.css'
+ *
+ *   <FileViewer :src="url" name="report.csv" theme="dark" />
+ *
+ * Beyond the batteries-included `<FileViewer>`, this barrel also re-exports the shared rendering primitives
+ * (markdown engine, highlight, Icon, formatting, fonts, lightbox, …) that the original app's conversation
+ * shell consumes — so that shell imports them from here instead of keeping its own copies.
+ */
+import './styles/theme.css';
+export { default as FileViewer } from './FileViewer.vue';
+export { default as FileViewerPanel } from './components/FileViewerPanel.vue';
+export { default as FileViewerBody } from './components/FileViewerBody.vue';
+export { default as MissingDependency } from './components/MissingDependency.vue';
+export { default as ImageLightbox } from './components/ImageLightbox.vue';
+export { default as Icon } from './components/icons/Icon.vue';
+export { default as CodeBlock } from './components/CodeBlock.vue';
+export { default as InlineText } from './components/InlineText';
+export { default as MarkdownText } from './components/MarkdownText';
+export { default as MarkdownTable } from './components/MarkdownTable.vue';
+export { default as MindMapView } from './components/MindMapView.vue';
+export { default as ClampBlock } from './components/ui/ClampBlock';
+export * from './composables/useFileViewer';
+export * from './composables/useLightbox';
+export * from './lib/viewerKind';
+export * from './lib/fileType';
+export * from './lib/diagram';
+export * from './lib/resolveInput';
+export * from './lib/optionalDep';
+export * from './lib/format';
+export * from './lib/fonts';
+export * from './lib/markdown/blocks';
+export * from './lib/markdown/inline';
+export * from './lib/markdown/segmentize';
+export * from './components/icons/iconPaths';
+export * from './lib/zip';
+export * from './lib/qmc';
+export * from './lib/sha1';
+export type { ViewerInput, FetchConfig, LoadFn } from './types';

package/dist/index.js

@@ -0,0 +1,30 @@
+/* empty css             */
+import { resolveInput as e } from "./lib/resolveInput.js";
+import { LARGE_TEXT_BYTES as t, ebookKind as n, fileExt as r, hljsLang as i, isAppxFile as a, isAudioFile as o, isBinaryObjFile as s, isCertFile as c, isCsvFile as l, isDicomFile as u, isDocxFile as d, isDxfFile as f, isEmlFile as p, isEplFile as m, isFontFile as h, isGeoFile as g, isHarFile as _, isHprofFile as v, isHtmlFile as y, isImageFile as b, isJavaClassFile as x, isJksFile as S, isJsonlFile as C, isLogFile as w, isLrcFile as T, isMhtFile as E, isMindMapFile as D, isModelFile as O, isMsiFile as k, isNotebookFile as A, isPdfFile as j, isPptxFile as M, isQmcAudioFile as N, isRarFile as P, isRtfFile as F, isSevenZipFile as I, isSqliteFile as L, isSubtitleFile as R, isSvgFile as z, isTarballFile as B, isTextFile as V, isVideoFile as H, isXlsxFile as U, isXmindFile as W, isZipFile as G, rasterImageKind as K } from "./lib/fileType.js";
+import { isDiagramFile as q, renderDiagram as J } from "./lib/diagram.js";
+import { canToggleView as Y, classifyViewerFile as X, mediaMimeForName as Z, skipsTextLoad as Q } from "./lib/viewerKind.js";
+import $ from "./components/MissingDependency.js";
+import { formatBytes as ee, formatDateTime as te, formatDuration as ne, formatSizeCoarse as re } from "./lib/format.js";
+import { FILL_ICONS as ie, STROKE_ICONS as ae } from "./components/icons/iconPaths.js";
+import oe from "./components/icons/Icon.js";
+import { useFileViewer as se } from "./composables/useFileViewer.js";
+import ce from "./components/ui/ClampBlock.js";
+import le from "./components/CodeBlock.js";
+import { useLightbox as ue } from "./composables/useLightbox.js";
+import { MONO as de, SANS as fe, SERIF as pe } from "./lib/fonts.js";
+import { inline as me, renderInline as he } from "./lib/markdown/inline.js";
+import ge from "./components/InlineText.js";
+import _e from "./components/MarkdownTable.js";
+import { md as ve, mdNodes as ye } from "./lib/markdown/blocks.js";
+import be from "./components/MarkdownText.js";
+import xe from "./components/FileViewerBody.js";
+import Se from "./FileViewer.js";
+import Ce from "./components/FileViewerPanel.js";
+import we from "./components/ImageLightbox.js";
+import Te from "./components/MindMapView.js";
+import { isMissingModule as Ee, loadOptionalDep as De } from "./lib/optionalDep.js";
+import { segmentize as Oe } from "./lib/markdown/segmentize.js";
+import { ZipEncryptedError as ke, ZipPasswordError as Ae, extractZipEntry as je, readZip as Me, zipSupported as Ne } from "./lib/zip.js";
+import { QmcError as Pe, decryptEKey as Fe, decryptQmc as Ie, parseFooter as Le } from "./lib/qmc.js";
+import { Sha1 as Re, sha1 as ze } from "./lib/sha1.js";
+export { ce as ClampBlock, le as CodeBlock, ie as FILL_ICONS, Se as FileViewer, xe as FileViewerBody, Ce as FileViewerPanel, oe as Icon, we as ImageLightbox, ge as InlineText, t as LARGE_TEXT_BYTES, de as MONO, _e as MarkdownTable, be as MarkdownText, Te as MindMapView, $ as MissingDependency, Pe as QmcError, fe as SANS, pe as SERIF, ae as STROKE_ICONS, Re as Sha1, ke as ZipEncryptedError, Ae as ZipPasswordError, Y as canToggleView, X as classifyViewerFile, Fe as decryptEKey, Ie as decryptQmc, n as ebookKind, je as extractZipEntry, r as fileExt, ee as formatBytes, te as formatDateTime, ne as formatDuration, re as formatSizeCoarse, i as hljsLang, me as inline, a as isAppxFile, o as isAudioFile, s as isBinaryObjFile, c as isCertFile, l as isCsvFile, q as isDiagramFile, u as isDicomFile, d as isDocxFile, f as isDxfFile, p as isEmlFile, m as isEplFile, h as isFontFile, g as isGeoFile, _ as isHarFile, v as isHprofFile, y as isHtmlFile, b as isImageFile, x as isJavaClassFile, S as isJksFile, C as isJsonlFile, w as isLogFile, T as isLrcFile, E as isMhtFile, D as isMindMapFile, Ee as isMissingModule, O as isModelFile, k as isMsiFile, A as isNotebookFile, j as isPdfFile, M as isPptxFile, N as isQmcAudioFile, P as isRarFile, F as isRtfFile, I as isSevenZipFile, L as isSqliteFile, R as isSubtitleFile, z as isSvgFile, B as isTarballFile, V as isTextFile, H as isVideoFile, U as isXlsxFile, W as isXmindFile, G as isZipFile, De as loadOptionalDep, ve as md, ye as mdNodes, Z as mediaMimeForName, Le as parseFooter, K as rasterImageKind, Me as readZip, J as renderDiagram, he as renderInline, e as resolveInput, Oe as segmentize, ze as sha1, Q as skipsTextLoad, se as useFileViewer, ue as useLightbox, Ne as zipSupported };

package/dist/lib/aes.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Compact AES shared by the in-browser archive viewers — no dependency, no WASM.
+ *
+ * The FORWARD cipher drives CTR mode (WinZip-AES ZIP extraction, see {@link lib/zip.ts}); the INVERSE
+ * cipher drives CBC decryption (AES-256 encrypted 7z extraction, see {@link lib/sevenZip.ts}). The S-box is
+ * generated from the GF(2^8) affine transform (not tabled); the inverse S-box and the GF multiplies for
+ * InvMixColumns are derived from it. Key derivation (PBKDF2 / SHA-256) stays in each caller via WebCrypto —
+ * this module is pure block/mode math and stays synchronous.
+ *
+ * State layout is column-major: byte `s[4*col + row]`, matching the AES spec's column words. Encrypt and
+ * decrypt share the key schedule and AddRoundKey; only Sub/Shift/Mix differ (forward vs inverse).
+ */
+/** Expand a 16/24/32-byte key into the round-key word schedule. */
+export declare function aesKeySchedule(key: Uint8Array): Uint32Array;
+/** Encrypt one 16-byte block in place into `out` (forward cipher). */
+export declare function aesEncryptBlock(w: Uint32Array, block: Uint8Array, out: Uint8Array): void;
+/** Decrypt one 16-byte block in place into `out` (inverse cipher). */
+export declare function aesDecryptBlock(w: Uint32Array, block: Uint8Array, out: Uint8Array): void;
+/** WinZip AES-CTR keystream (counter is a 16-byte LITTLE-endian integer starting at 1) XORed over `data`. */
+export declare function aesCtrXor(key: Uint8Array, data: Uint8Array): Uint8Array;
+/**
+ * AES-CBC decrypt (no padding removal — 7z stores the real output length separately and its ciphertext is a
+ * whole number of blocks). `iv` is 16 bytes; only full 16-byte blocks of `data` are processed.
+ */
+export declare function aesCbcDecrypt(key: Uint8Array, iv: Uint8Array, data: Uint8Array): Uint8Array;

package/dist/lib/aes.js

@@ -0,0 +1,99 @@
+//#region src/lib/aes.ts
+var e = /* @__PURE__ */ (() => {
+	let e = new Uint8Array(256), t = (e, t) => (e << t | e >> 8 - t) & 255, n = 1, r = 1;
+	do
+		n = (n ^ n << 1 ^ (n & 128 ? 283 : 0)) & 255, r ^= r << 1, r ^= r << 2, r ^= r << 4, r &= 255, r & 128 && (r ^= 9), r &= 255, e[n] = (r ^ t(r, 1) ^ t(r, 2) ^ t(r, 3) ^ t(r, 4) ^ 99) & 255;
+	while (n !== 1);
+	return e[0] = 99, e;
+})(), t = /* @__PURE__ */ (() => {
+	let t = new Uint8Array(256);
+	for (let n = 0; n < 256; n++) t[e[n]] = n;
+	return t;
+})(), n = new Uint8Array([
+	1,
+	2,
+	4,
+	8,
+	16,
+	32,
+	64,
+	128,
+	27,
+	54,
+	108
+]), r = (e) => (e << 1 ^ (e & 128 ? 283 : 0)) & 255;
+function i(e, t) {
+	let n = 0;
+	for (let r = 0; r < 8 && t; r++) {
+		t & 1 && (n ^= e);
+		let r = e & 128;
+		e = e << 1 & 255, r && (e ^= 27), t >>= 1;
+	}
+	return n & 255;
+}
+function a(t) {
+	let r = t.length / 4, i = r + 6, a = new Uint32Array(4 * (i + 1));
+	for (let e = 0; e < r; e++) a[e] = (t[4 * e] << 24 | t[4 * e + 1] << 16 | t[4 * e + 2] << 8 | t[4 * e + 3]) >>> 0;
+	let o = (t) => (e[t >>> 24 & 255] << 24 | e[t >>> 16 & 255] << 16 | e[t >>> 8 & 255] << 8 | e[t & 255]) >>> 0, s = (e) => (e << 8 | e >>> 24) >>> 0;
+	for (let e = r; e < a.length; e++) {
+		let t = a[e - 1];
+		e % r === 0 ? t = (o(s(t)) ^ n[e / r - 1] << 24) >>> 0 : r > 6 && e % r === 4 && (t = o(t)), a[e] = (a[e - r] ^ t) >>> 0;
+	}
+	return a;
+}
+function o(e, t, n) {
+	for (let r = 0; r < 4; r++) {
+		let i = t[n * 4 + r];
+		e[4 * r] ^= i >>> 24 & 255, e[4 * r + 1] ^= i >>> 16 & 255, e[4 * r + 2] ^= i >>> 8 & 255, e[4 * r + 3] ^= i & 255;
+	}
+}
+function s(t, n, i) {
+	let a = t.length / 4 - 1, s = i;
+	s.set(n), o(s, t, 0);
+	for (let n = 1; n <= a; n++) {
+		for (let t = 0; t < 16; t++) s[t] = e[s[t]];
+		let i = s[1];
+		if (s[1] = s[5], s[5] = s[9], s[9] = s[13], s[13] = i, i = s[2], s[2] = s[10], s[10] = i, i = s[6], s[6] = s[14], s[14] = i, i = s[15], s[15] = s[11], s[11] = s[7], s[7] = s[3], s[3] = i, n < a) for (let e = 0; e < 4; e++) {
+			let t = 4 * e, n = s[t], i = s[t + 1], a = s[t + 2], o = s[t + 3], c = n ^ i ^ a ^ o;
+			s[t] ^= c ^ r(n ^ i), s[t + 1] ^= c ^ r(i ^ a), s[t + 2] ^= c ^ r(a ^ o), s[t + 3] ^= c ^ r(o ^ n);
+		}
+		o(s, t, n);
+	}
+}
+function c(e, n, r) {
+	let a = e.length / 4 - 1, s = r;
+	s.set(n), o(s, e, a);
+	for (let n = a - 1; n >= 0; n--) {
+		let r = s[13];
+		s[13] = s[9], s[9] = s[5], s[5] = s[1], s[1] = r, r = s[2], s[2] = s[10], s[10] = r, r = s[6], s[6] = s[14], s[14] = r, r = s[3], s[3] = s[7], s[7] = s[11], s[11] = s[15], s[15] = r;
+		for (let e = 0; e < 16; e++) s[e] = t[s[e]];
+		if (o(s, e, n), n > 0) for (let e = 0; e < 4; e++) {
+			let t = 4 * e, n = s[t], r = s[t + 1], a = s[t + 2], o = s[t + 3];
+			s[t] = i(n, 14) ^ i(r, 11) ^ i(a, 13) ^ i(o, 9), s[t + 1] = i(n, 9) ^ i(r, 14) ^ i(a, 11) ^ i(o, 13), s[t + 2] = i(n, 13) ^ i(r, 9) ^ i(a, 14) ^ i(o, 11), s[t + 3] = i(n, 11) ^ i(r, 13) ^ i(a, 9) ^ i(o, 14);
+		}
+	}
+}
+function l(e, t) {
+	let n = a(e), r = new Uint8Array(t.length), i = new Uint8Array(16), o = new Uint8Array(16), c = 1;
+	for (let e = 0; e < t.length; e += 16) {
+		let a = c++;
+		for (let e = 0; e < 8; e++) i[e] = a & 255, a = Math.floor(a / 256);
+		s(n, i, o);
+		let l = Math.min(16, t.length - e);
+		for (let n = 0; n < l; n++) r[e + n] = t[e + n] ^ o[n];
+	}
+	return r;
+}
+function u(e, t, n) {
+	let r = a(e), i = n.length - n.length % 16, o = new Uint8Array(i), s = new Uint8Array(16), l = new Uint8Array(16);
+	l.set(t.subarray(0, 16));
+	for (let e = 0; e < i; e += 16) {
+		let t = n.subarray(e, e + 16);
+		c(r, t, s);
+		for (let t = 0; t < 16; t++) o[e + t] = s[t] ^ l[t];
+		l.set(t);
+	}
+	return o;
+}
+//#endregion
+export { u as aesCbcDecrypt, l as aesCtrXor };

package/dist/lib/appx.d.ts

@@ -0,0 +1,66 @@
+/**
+ * In-browser APPX / MSIX package reader — no dependency beyond the project's own ZIP reader.
+ *
+ * An `.appx`/`.msix` (and `.appxbundle`/`.msixbundle`) is NOT a PE and NOT an OLE compound file — it's an
+ * **OPC ZIP archive** (the same container `.docx`/`.jar` use). Its metadata lives in an XML manifest inside:
+ *   - a single package: `AppxManifest.xml` — `<Identity>` (name/version/arch/publisher), `<Properties>`
+ *     (display + publisher names), `<Dependencies>` (target OS + package deps), `<Capabilities>`,
+ *     `<Applications>`, and the declared `<Resources>` languages.
+ *   - a bundle: `AppxMetadata/AppxBundleManifest.xml` — `<Identity>` + the list of contained `<Package>`s.
+ *
+ * We decompress just the manifest with the project's ZIP reader (lib/zip.ts — browser-native DEFLATE) and
+ * read the fields with the DOM (namespace-agnostic local-name matching, since real manifests sprinkle uap/
+ * rescap/wincap prefixes). The manifest structure was checked against a real Microsoft Store `.appx`.
+ *
+ * Used by AppxViewer (the side viewer's APPX mode): the bytes come from the same download endpoint as any
+ * other file, are unzipped + parsed entirely client-side, and never leave the browser.
+ */
+export interface AppxVersionRef {
+    name: string;
+    minVersion?: string;
+    maxVersionTested?: string;
+    publisher?: string;
+}
+export interface AppxApp {
+    id: string;
+    displayName?: string;
+    description?: string;
+}
+export interface AppxBundlePackage {
+    type?: string;
+    architecture?: string;
+    version?: string;
+    fileName?: string;
+}
+export interface AppxInfo {
+    kind: 'package' | 'bundle';
+    /** Identity (`<Identity>`): the package family identity. */
+    name?: string;
+    version?: string;
+    architecture?: string;
+    /** Raw publisher distinguished name, e.g. "CN=Microsoft Corporation, …". */
+    publisher?: string;
+    /** `<Properties>` display fields (DisplayName may be an `ms-resource:…` reference we can't resolve here). */
+    displayName?: string;
+    publisherDisplayName?: string;
+    description?: string;
+    /** `<Dependencies>`: target OS families + package dependencies. */
+    targetDeviceFamilies: AppxVersionRef[];
+    packageDependencies: AppxVersionRef[];
+    /** `<Capabilities>` declared capability names (restricted/device ones included). */
+    capabilities: string[];
+    /** `<Applications>` entry points. */
+    applications: AppxApp[];
+    /** Declared resource languages (`<Resources><Resource Language=…>`). */
+    languages: string[];
+    /** For a bundle: the contained packages. */
+    bundlePackages: AppxBundlePackage[];
+    /** Number of files in the archive. */
+    fileCount: number;
+    notes: string[];
+}
+/** Thrown when the bytes aren't an APPX/MSIX (not a zip, or no manifest inside). */
+export declare class NotAppxError extends Error {
+    constructor(message: string);
+}
+export declare function parseAppx(buf: ArrayBuffer): Promise<AppxInfo>;

package/dist/lib/appx.js

@@ -0,0 +1,112 @@
+import { extractZipEntry as e, readZip as t } from "./zip.js";
+//#region src/lib/appx.ts
+var n = class extends Error {
+	constructor(e) {
+		super(e), this.name = "NotAppxError";
+	}
+};
+async function r(r) {
+	let i;
+	try {
+		i = t(r);
+	} catch {
+		throw new n("不是有效的 APPX/MSIX（无法读取 ZIP 容器）");
+	}
+	let a = (e) => i.find((t) => t.path.toLowerCase() === e.toLowerCase()), o = a("AppxManifest.xml"), s = a("AppxMetadata/AppxBundleManifest.xml") ?? a("AppxBundleManifest.xml"), u = o ?? s;
+	if (!u) throw new n("未找到 AppxManifest.xml（不是 APPX/MSIX 包）");
+	let d = await e(r, u), f = new TextDecoder("utf-8").decode(d), p = new DOMParser().parseFromString(f, "application/xml");
+	if (p.getElementsByTagName("parsererror").length > 0) throw new n("AppxManifest.xml 解析失败（XML 无效）");
+	let m = i.filter((e) => !e.isDir).length;
+	return o ? c(p, m) : l(p, m);
+}
+function i(e, t) {
+	let n = e.getElementsByTagName("*"), r = [];
+	for (let e = 0; e < n.length; e++) n[e].localName === t && r.push(n[e]);
+	return r;
+}
+function a(e, t) {
+	if (!e) return null;
+	let n = e.getElementsByTagName("*");
+	for (let e = 0; e < n.length; e++) if (n[e].localName === t) return n[e];
+	return null;
+}
+function o(e, t) {
+	let n = e?.getAttribute(t);
+	return n == null || n === "" ? void 0 : n;
+}
+function s(e, t) {
+	return a(e, t)?.textContent?.trim() || void 0;
+}
+function c(e, t) {
+	let n = a(e, "Identity"), r = a(e, "Properties"), c = i(e, "TargetDeviceFamily").map((e) => ({
+		name: o(e, "Name") ?? "",
+		minVersion: o(e, "MinVersion"),
+		maxVersionTested: o(e, "MaxVersionTested")
+	})), l = i(e, "PackageDependency").map((e) => ({
+		name: o(e, "Name") ?? "",
+		minVersion: o(e, "MinVersion"),
+		publisher: o(e, "Publisher")
+	})), u = [], d = a(e, "Capabilities");
+	if (d) {
+		let e = d.getElementsByTagName("*");
+		for (let t = 0; t < e.length; t++) {
+			let n = o(e[t], "Name");
+			n && !u.includes(n) && u.push(n);
+		}
+	}
+	let f = i(e, "Application").map((e) => {
+		let t = a(e, "VisualElements");
+		return {
+			id: o(e, "Id") ?? "",
+			displayName: o(t, "DisplayName"),
+			description: o(t, "Description")
+		};
+	}), p = [];
+	for (let t of i(e, "Resource")) {
+		let e = o(t, "Language");
+		e && !p.includes(e) && p.push(e);
+	}
+	return {
+		kind: "package",
+		name: o(n, "Name"),
+		version: o(n, "Version"),
+		architecture: o(n, "ProcessorArchitecture"),
+		publisher: o(n, "Publisher"),
+		displayName: s(r, "DisplayName"),
+		publisherDisplayName: s(r, "PublisherDisplayName"),
+		description: s(r, "Description"),
+		targetDeviceFamilies: c,
+		packageDependencies: l,
+		capabilities: u,
+		applications: f,
+		languages: p,
+		bundlePackages: [],
+		fileCount: t,
+		notes: []
+	};
+}
+function l(e, t) {
+	let n = a(e, "Identity"), r = i(e, "Package").map((e) => ({
+		type: o(e, "Type"),
+		architecture: o(e, "Architecture"),
+		version: o(e, "Version"),
+		fileName: o(e, "FileName")
+	}));
+	return {
+		kind: "bundle",
+		name: o(n, "Name"),
+		version: o(n, "Version"),
+		architecture: void 0,
+		publisher: o(n, "Publisher"),
+		targetDeviceFamilies: [],
+		packageDependencies: [],
+		capabilities: [],
+		applications: [],
+		languages: [],
+		bundlePackages: r,
+		fileCount: t,
+		notes: []
+	};
+}
+//#endregion
+export { n as NotAppxError, r as parseAppx };

package/dist/lib/archive.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A format-agnostic view of a decoded archive, shared by the side viewer's multi-file browsers.
+ *
+ * The two existing browsers (ZipBrowser / SevenZipBrowser) each bake in their own entry type and
+ * extraction call. The newer formats — the tar family (tar/gz/xz/bz2, see {@link lib/tarball}) and rar
+ * (see {@link lib/rar}) — instead expose this common shape so a single {@link ArchiveBrowser} component
+ * can browse any of them: a flat entry list plus an `extract(entry)` that yields one file's bytes.
+ *
+ * `ref` is a producer-private handle (an index into the opener's own metadata) so `extract` can locate a
+ * file's bytes without the consumer knowing the format's internals. Extraction may be sync (tar slices a
+ * decoded buffer) or async (rar calls into a WASM extractor), hence the union return.
+ */
+export interface ArchiveEntry {
+    /** Full path within the archive, forward-slashed, e.g. "src/app.ts". */
+    path: string;
+    /** Basename (last path segment). */
+    name: string;
+    /** Uncompressed size in bytes (0 for directories). */
+    size: number;
+    /** Directory entry. */
+    isDir: boolean;
+    /** Producer-internal handle consumed by {@link OpenedArchive.extract}; opaque to callers. */
+    ref: number;
+}
+export interface OpenedArchive {
+    entries: ArchiveEntry[];
+    /** Yield one entry's decompressed bytes. Returns an empty array for directories. */
+    extract(entry: ArchiveEntry): Uint8Array | Promise<Uint8Array>;
+}

package/dist/lib/asn1.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Minimal, zero-dependency ASN.1 DER decoder for the certificate viewer (lib/x509.ts + CertViewer.vue).
+ *
+ * Decodes the tag/length/value tree; constructed types recurse. Enough to walk X.509 / PKCS#10 / PKCS#7 /
+ * PKCS#12 structures and render a generic, collapsible structure tree. It is NOT a validator — it tolerates
+ * and surfaces partial / malformed input (bailing on no-progress) rather than throwing, so a weird file shows
+ * what could be decoded instead of a blank error.
+ */
+export interface Asn1Node {
+    tagClass: number;
+    constructed: boolean;
+    tagNumber: number;
+    start: number;
+    headerLen: number;
+    length: number;
+    content: Uint8Array;
+    children: Asn1Node[];
+}
+export declare const TAG: {
+    readonly BOOLEAN: 1;
+    readonly INTEGER: 2;
+    readonly BIT_STRING: 3;
+    readonly OCTET_STRING: 4;
+    readonly NULL: 5;
+    readonly OID: 6;
+    readonly UTF8String: 12;
+    readonly SEQUENCE: 16;
+    readonly SET: 17;
+    readonly PrintableString: 19;
+    readonly IA5String: 22;
+    readonly UTCTime: 23;
+    readonly GeneralizedTime: 24;
+};
+/** Decode every TLV in [start, end) into a forest of nodes. */
+export declare function decodeAsn1(buf: Uint8Array, start?: number, end?: number): Asn1Node[];
+/** Display name for a node's tag (universal type name, or `[n]` for context-specific). */
+export declare function tagName(node: Asn1Node): string;
+/** Decode OID content bytes → dotted-decimal string. */
+export declare function oidToString(bytes: Uint8Array): string;
+export declare function bytesToHex(bytes: Uint8Array, sep?: string): string;
+/** Decode a string-typed node's content as UTF-8 text (falls back to hex for odd bytes). */
+export declare function asn1String(node: Asn1Node): string;
+/** Decode a UTCTime / GeneralizedTime node → human text + epoch ms, or null if unparseable. */
+export declare function asn1Time(node: Asn1Node): {
+    text: string;
+    ms: number;
+} | null;

package/dist/lib/asn1.js

@@ -0,0 +1,122 @@
+//#region src/lib/asn1.ts
+var e = {
+	BOOLEAN: 1,
+	INTEGER: 2,
+	BIT_STRING: 3,
+	OCTET_STRING: 4,
+	NULL: 5,
+	OID: 6,
+	UTF8String: 12,
+	SEQUENCE: 16,
+	SET: 17,
+	PrintableString: 19,
+	IA5String: 22,
+	UTCTime: 23,
+	GeneralizedTime: 24
+};
+function t(e, t = 0, r = e.length) {
+	let i = [], a = t;
+	for (; a < r;) {
+		let t = n(e, a, r);
+		if (!t) break;
+		i.push(t);
+		let o = t.start + t.headerLen + t.length;
+		if (o <= a) break;
+		a = o;
+	}
+	return i;
+}
+function n(e, n, r) {
+	let i = n;
+	if (i >= r) return null;
+	let a = e[i++], o = a >> 6, s = (a & 32) != 0, c = a & 31;
+	if (c === 31) for (c = 0; i < r;) {
+		let t = e[i++];
+		if (c = c << 7 | t & 127, !(t & 128)) break;
+	}
+	if (i >= r) return null;
+	let l = e[i++];
+	if (l & 128) {
+		let t = l & 127;
+		if (t === 0 || t > 4 || i + t > r) l = r - i;
+		else {
+			l = 0;
+			for (let n = 0; n < t; n++) l = l * 256 + e[i++];
+		}
+	}
+	let u = i, d = Math.min(r, u + l), f = {
+		tagClass: o,
+		constructed: s,
+		tagNumber: c,
+		start: n,
+		headerLen: u - n,
+		length: d - u,
+		content: e.subarray(u, d),
+		children: []
+	};
+	return s && (f.children = t(e, u, d)), f;
+}
+var r = {
+	1: "BOOLEAN",
+	2: "INTEGER",
+	3: "BIT STRING",
+	4: "OCTET STRING",
+	5: "NULL",
+	6: "OBJECT IDENTIFIER",
+	10: "ENUMERATED",
+	12: "UTF8String",
+	13: "RELATIVE-OID",
+	16: "SEQUENCE",
+	17: "SET",
+	18: "NumericString",
+	19: "PrintableString",
+	20: "TeletexString",
+	22: "IA5String",
+	23: "UTCTime",
+	24: "GeneralizedTime",
+	26: "VisibleString",
+	27: "GeneralString",
+	28: "UniversalString",
+	30: "BMPString"
+};
+function i(e) {
+	return e.tagClass === 2 ? `[${e.tagNumber}]` : e.tagClass === 1 ? `APPLICATION ${e.tagNumber}` : e.tagClass === 3 ? `PRIVATE ${e.tagNumber}` : r[e.tagNumber] ?? `TAG ${e.tagNumber}`;
+}
+function a(e) {
+	if (!e.length) return "";
+	let t = [Math.floor(e[0] / 40), e[0] % 40], n = 0;
+	for (let r = 1; r < e.length; r++) n = n * 128 + (e[r] & 127), e[r] & 128 || (t.push(n), n = 0);
+	return t.join(".");
+}
+function o(e, t = "") {
+	let n = "";
+	for (let r = 0; r < e.length; r++) n += e[r].toString(16).padStart(2, "0"), t && r < e.length - 1 && (n += t);
+	return n;
+}
+function s(e) {
+	try {
+		return new TextDecoder("utf-8").decode(e.content);
+	} catch {
+		return o(e.content);
+	}
+}
+function c(e, t, n, r, i, a) {
+	let o = Date.UTC(e, parseInt(t, 10) - 1, parseInt(n, 10), parseInt(r, 10), parseInt(i, 10), a ? parseInt(a, 10) : 0);
+	return {
+		text: `${e}-${t}-${n} ${r}:${i}:${a ?? "00"} UTC`,
+		ms: o
+	};
+}
+function l(t) {
+	let n = new TextDecoder("latin1").decode(t.content).trim();
+	if (t.tagNumber === e.UTCTime) {
+		let e = n.match(/^(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})?/);
+		if (!e) return null;
+		let t = parseInt(e[1], 10);
+		return c(t < 50 ? 2e3 + t : 1900 + t, e[2], e[3], e[4], e[5], e[6]);
+	}
+	let r = n.match(/^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})?/);
+	return r ? c(parseInt(r[1], 10), r[2], r[3], r[4], r[5], r[6]) : null;
+}
+//#endregion
+export { e as TAG, s as asn1String, l as asn1Time, o as bytesToHex, t as decodeAsn1, a as oidToString, i as tagName };

package/dist/lib/binobj.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Minimal in-browser ELF / PE symbol reader — no dependency, no WASM.
+ *
+ * Parses just enough of the container to list its *function symbols* — name, virtual address, and
+ * (when the table records it) size. Mirrors {@link lib/zip.ts}: hand-rolled structural parsing over a
+ * DataView, decoding only what conversation artifacts actually ship — `.so` shared objects (ELF) and
+ * `.dll` libraries (PE). It deliberately does NOT disassemble: turning machine code into mnemonics
+ * needs a real engine (Capstone/WASM), which is out of scope for this "what functions are in here?" view.
+ *
+ *  - ELF: walks the section table and reads `.symtab` (full symbols) or, when stripped, `.dynsym`
+ *         (dynamic/exported symbols only), keeping the `STT_FUNC`/`STT_GNU_IFUNC` entries that are
+ *         defined in this object (not undefined imports).
+ *  - PE:  reads the export directory — the only symbols a DLL normally carries without a separate PDB.
+ *
+ * Beyond symbols it also lifts human-facing METADATA (see {@link BinMeta}):
+ *  - ELF: header type/ABI/entry, the program interpreter (PT_INTERP), and the dynamic section's SONAME /
+ *         NEEDED libraries / RPATH-RUNPATH, plus the GNU build-id note.
+ *  - PE:  the COFF/optional-header subsystem + kind + link time, and — parsed from the resource directory —
+ *         the VS_VERSIONINFO strings (company / product / version / copyright …) and the embedded ICON, which
+ *         is repackaged into a tiny .ico and surfaced as a data URL for inline display.
+ *
+ * Used by BinObjBrowser (the side viewer's binary-object mode): the bytes come from the same download
+ * endpoint as any other file, are parsed entirely client-side, and never leave the browser.
+ */
+export type BinObjFormat = 'elf' | 'pe';
+/** A human-facing metadata row (label + value) shown above the symbol list. */
+export interface BinMeta {
+    label: string;
+    value: string;
+}
+export interface BinSymbol {
+    /** Symbol name as stored — NOT demangled (C++ names stay mangled, e.g. `_ZN3foo3barEv`). */
+    name: string;
+    /** Virtual address (ELF `st_value`) or RVA (PE export). For a PIC `.so` this is a load-base offset. */
+    address: number;
+    /** Size in bytes when the table records it (ELF `st_size`); undefined for PE exports. */
+    size?: number;
+    /** Symbol kind: ELF type lowercased (`func` / `ifunc`), or `export` for PE. */
+    kind: string;
+    /** ELF binding (`local` / `global` / `weak`); undefined for PE. */
+    bind?: string;
+    /** Where it came from: `.symtab` / `.dynsym` (ELF) or `export` (PE). */
+    source: string;
+    /** PE export ordinal (Base + index), when applicable. */
+    ordinal?: number;
+}
+export interface BinObjInfo {
+    format: BinObjFormat;
+    /** Human architecture label, e.g. `x86-64`, `aarch64`, `i386`, `arm`. */
+    arch: string;
+    bits: 32 | 64;
+    endian: 'le' | 'be';
+    /** True when no full symbol table was available (ELF: only `.dynsym`; PE: always — exports only). */
+    stripped: boolean;
+    /** Defined function symbols, sorted by address. */
+    symbols: BinSymbol[];
+    /** Human note explaining an empty/partial list (e.g. fully stripped, or a PE with no exports). */
+    note?: string;
+    /** Human-facing metadata rows (ELF header/dynamic, PE version-info), shown as a card above the symbols. */
+    meta: BinMeta[];
+    /** PE icon repackaged as a tiny .ico and encoded as a data URL, when an icon resource was decoded. */
+    iconDataUrl?: string;
+}
+/** Thrown when the bytes aren't a recognized ELF or PE container. */
+export declare class UnsupportedBinaryError extends Error {
+    constructor(message: string);
+}
+/** Recognize the container by magic and dispatch. Throws {@link UnsupportedBinaryError} otherwise. */
+export declare function parseBinObj(buf: ArrayBuffer): BinObjInfo;