@l1yp/file-viewer 0.1.0

package/dist/lib/ipynb.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Hand-rolled, zero-dependency Jupyter Notebook (.ipynb) parser for the side viewer.
+ *
+ * A notebook is JSON: a list of cells (markdown / code / raw), each code cell carrying its outputs. This
+ * flattens that into a render-ready shape the viewer can walk — markdown reuses the app's markdown engine,
+ * code reuses highlight.js, and each output is reduced to one best-fit representation (richest mime wins,
+ * mirroring Jupyter's own display priority). nbformat 4 is the target; v3 (worksheets + inline output keys)
+ * is tolerated as a best-effort fallback.
+ *
+ * Rich HTML output is hostile markup (it comes from arbitrary kernels) — the viewer renders it in a fully
+ * sandboxed, script-disabled iframe, so this parser only carries the raw string; it never trusts it.
+ */
+export type NbOutput = {
+    kind: 'stream';
+    text: string;
+    isError: boolean;
+} | {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'json';
+    text: string;
+} | {
+    kind: 'markdown';
+    text: string;
+} | {
+    kind: 'html';
+    html: string;
+} | {
+    kind: 'image';
+    src: string;
+} | {
+    kind: 'error';
+    text: string;
+};
+export interface NbCell {
+    type: 'markdown' | 'code' | 'raw';
+    source: string;
+    executionCount: number | null;
+    outputs: NbOutput[];
+}
+export interface ParsedNotebook {
+    cells: NbCell[];
+    language: string;
+    nbformat: number;
+}
+/** Parse .ipynb source text into a flat, render-ready cell list. Throws on non-notebook JSON. */
+export declare function parseNotebook(text: string): ParsedNotebook;

package/dist/lib/ipynb.js

@@ -0,0 +1,130 @@
+//#region src/lib/ipynb.ts
+function e(e) {
+	return Array.isArray(e) ? e.map((e) => typeof e == "string" ? e : "").join("") : typeof e == "string" ? e : "";
+}
+var t = "\x1B";
+function n(e) {
+	let n = "";
+	for (let r = 0; r < e.length; r++) {
+		if (e[r] !== t) {
+			n += e[r];
+			continue;
+		}
+		if (r++, e[r] === "[") for (r++; r < e.length && !/[A-Za-z]/.test(e[r]);) r++;
+	}
+	return n;
+}
+function r(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+function i(e) {
+	if (r(e.data)) return e.data;
+	let t = {};
+	return e.png && (t["image/png"] = e.png), e.jpeg && (t["image/jpeg"] = e.jpeg), e.gif && (t["image/gif"] = e.gif), e.svg && (t["image/svg+xml"] = e.svg), e.html && (t["text/html"] = e.html), e.latex && (t["text/latex"] = e.latex), e.text && (t["text/plain"] = e.text), t;
+}
+function a(t) {
+	let n = (e) => t[e] != null, r = (n) => e(t[n]);
+	if (n("text/html")) return {
+		kind: "html",
+		html: r("text/html")
+	};
+	if (n("image/svg+xml")) return {
+		kind: "image",
+		src: `data:image/svg+xml,${encodeURIComponent(r("image/svg+xml"))}`
+	};
+	for (let e of [
+		"image/png",
+		"image/jpeg",
+		"image/gif"
+	]) if (n(e)) return {
+		kind: "image",
+		src: `data:${e};base64,${r(e).replace(/\s+/g, "")}`
+	};
+	if (n("text/markdown")) return {
+		kind: "markdown",
+		text: r("text/markdown")
+	};
+	if (n("text/latex")) return {
+		kind: "text",
+		text: r("text/latex")
+	};
+	if (n("application/json")) try {
+		return {
+			kind: "json",
+			text: JSON.stringify(t["application/json"], null, 2)
+		};
+	} catch {
+		return {
+			kind: "text",
+			text: r("application/json")
+		};
+	}
+	return {
+		kind: "text",
+		text: r("text/plain")
+	};
+}
+function o(t) {
+	let r = String(t.output_type ?? "");
+	if (r === "stream") return {
+		kind: "stream",
+		text: e(t.text),
+		isError: t.name === "stderr"
+	};
+	if (r === "error" || r === "pyerr") {
+		let e = Array.isArray(t.traceback) ? t.traceback.join("\n") : "", r = `${t.ename ?? "Error"}: ${t.evalue ?? ""}`.trim();
+		return {
+			kind: "error",
+			text: n(e) || r
+		};
+	}
+	return r === "execute_result" || r === "display_data" || r === "pyout" ? a(i(t)) : null;
+}
+function s(e) {
+	let t = r(e.language_info) ? e.language_info : {}, n = r(e.kernelspec) ? e.kernelspec : {}, i = String(t.name ?? n.language ?? "").toLowerCase();
+	return !i || i === "ipython" ? "python" : i;
+}
+function c(t) {
+	let n = JSON.parse(t), i = r(n.metadata) ? n.metadata : {}, a = Array.isArray(n.cells) ? n.cells : Array.isArray(n.worksheets) ? n.worksheets.flatMap((e) => r(e) && Array.isArray(e.cells) ? e.cells : []) : [];
+	if (!Array.isArray(n.cells) && !Array.isArray(n.worksheets)) throw Error("不是有效的 Jupyter Notebook（缺少 cells）");
+	let c = [];
+	for (let t of a) {
+		if (!r(t)) continue;
+		let n = String(t.cell_type ?? ""), i = e(t.source ?? t.input);
+		if (n === "code") {
+			let e = Array.isArray(t.outputs) ? t.outputs : [], n = [];
+			for (let t of e) {
+				if (!r(t)) continue;
+				let e = o(t);
+				e && n.push(e);
+			}
+			let a = t.execution_count ?? t.prompt_number;
+			c.push({
+				type: "code",
+				source: i,
+				executionCount: typeof a == "number" ? a : null,
+				outputs: n
+			});
+		} else if (n === "markdown" || n === "heading") {
+			let e = typeof t.level == "number" ? "#".repeat(Math.min(6, t.level)) + " " : "";
+			c.push({
+				type: "markdown",
+				source: e + i,
+				executionCount: null,
+				outputs: []
+			});
+		} else c.push({
+			type: "raw",
+			source: i,
+			executionCount: null,
+			outputs: []
+		});
+	}
+	return {
+		cells: c,
+		language: s(i),
+		nbformat: typeof n.nbformat == "number" ? n.nbformat : 4
+	};
+}
+//#endregion
+export { c as parseNotebook };

package/dist/lib/jks.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Zero-dependency reader for Java keystores — JKS (`0xFEEDFEED`) and JCEKS (`0xCECECECE`) — for the keystore
+ * viewer (JksViewer.vue). It parses the proprietary Sun on-disk format (magic / version / entry list / trailing
+ * SHA-1 MAC) into an inventory of aliases, entry kinds, creation dates and certificate chains, and — given the
+ * password — verifies store integrity and decrypts JKS private keys.
+ *
+ * What it can do, entirely in-browser and READ-ONLY:
+ *  - list every entry (private-key / trusted-cert), its alias + creation time, and each entry's X.509 chain
+ *    (certificates are stored UNENCRYPTED, so they always parse — see lib/x509.ts for the field extraction);
+ *  - verify the store password via the format's keyed MAC — SHA1(passwordUtf16BE ‖ "Mighty Aphrodite" ‖ body);
+ *  - decrypt a JKS private key with Sun's KeyProtector (OID 1.3.6.1.4.1.42.2.17.1.1): a SHA-1 keystream XOR
+ *    with a trailing SHA-1 check digest that doubles as the password check. On success the plaintext is a DER
+ *    PKCS#8 PrivateKeyInfo, from which we surface the key algorithm / size.
+ *
+ * Scope: JCEKS trusted certs + integrity parse the same way, but JCEKS private keys use PBEWithMD5AndTripleDES
+ * (a different, heavier scheme) — reported as unsupported rather than decrypted. A JCEKS *secret-key* entry is a
+ * Java-serialized object with no length prefix we can skip, so hitting one stops the entry walk (already-parsed
+ * entries are kept, with a note). PKCS#12 keystores (`.p12`/`.pfx`) are a different format entirely — handled by
+ * the certificate viewer, not here.
+ */
+export declare const JKS_MAGIC = 4277010157;
+export declare const JCEKS_MAGIC = 3469659854;
+export type JksStoreType = 'jks' | 'jceks';
+export type JksEntryType = 'privateKey' | 'trustedCert' | 'secretKey';
+export interface JksCertRef {
+    /** Certificate type as stored (almost always `X.509`). */
+    type: string;
+    der: Uint8Array;
+}
+export interface JksEntry {
+    type: JksEntryType;
+    alias: string;
+    /** Creation time (epoch ms); 0 when unknown. */
+    createdMs: number;
+    /** Trusted-cert: one cert. Private-key: the (possibly empty) chain. Secret-key: none. */
+    certs: JksCertRef[];
+    /** Private-key entries only: the DER EncryptedPrivateKeyInfo (decrypt with {@link decryptPrivateKey}). */
+    encryptedKey?: Uint8Array;
+}
+export interface JksStore {
+    storeType: JksStoreType;
+    version: number;
+    entries: JksEntry[];
+    /** Bytes covered by the integrity MAC — everything except the trailing 20-byte digest. */
+    macData: Uint8Array;
+    /** The trailing 20-byte stored SHA-1 digest (or empty if the file is too short to hold one). */
+    storedDigest: Uint8Array;
+    /** Set when the entry walk stopped early (e.g. an unskippable JCEKS secret-key entry). */
+    truncatedNote?: string;
+}
+export declare class JksError extends Error {
+}
+/**
+ * Parse a JKS/JCEKS keystore from its raw bytes. Certificates and the entry inventory come out regardless of
+ * any password (they're stored in the clear); use {@link verifyStorePassword} / {@link decryptPrivateKey} for
+ * the password-gated parts. Throws {@link JksError} for a bad magic / version / truncated stream.
+ */
+export declare function readJks(buf: ArrayBuffer): JksStore;
+/**
+ * Verify the store-integrity MAC with a candidate password: SHA1(passwordUtf16BE ‖ "Mighty Aphrodite" ‖ body)
+ * must equal the stored trailing digest. Also confirms the store password (keytool defaults it equal to each
+ * key password). Returns false for an empty password or a store with no digest.
+ */
+export declare function verifyStorePassword(store: JksStore, password: string): boolean;
+/** Friendly description of a decrypted PKCS#8 private key. */
+export interface KeyInfo {
+    /** DER PKCS#8 PrivateKeyInfo (the decrypted plaintext). */
+    pkcs8: Uint8Array;
+    algorithm: string;
+    bits?: number;
+    curve?: string;
+}
+export type KeyDecryptResult = {
+    ok: true;
+    key: KeyInfo;
+} | {
+    ok: false;
+    reason: 'wrong-password' | 'unsupported' | 'malformed';
+    detail?: string;
+};
+/**
+ * Decrypt a JKS private key (the DER EncryptedPrivateKeyInfo from {@link JksEntry.encryptedKey}) with Sun's
+ * KeyProtector. The password is verified by the format's own trailing SHA-1 check digest, so a wrong password
+ * yields `wrong-password` (never garbage). Non-JKS protection (e.g. JCEKS PBEWithMD5AndTripleDES) → `unsupported`.
+ */
+export declare function decryptPrivateKey(encryptedKey: Uint8Array, password: string): KeyDecryptResult;

package/dist/lib/jks.js

@@ -0,0 +1,167 @@
+import { Sha1 as e } from "./sha1.js";
+import { decodeAsn1 as t, oidToString as n } from "./asn1.js";
+import { describePrivateKey as r } from "./x509.js";
+//#region src/lib/jks.ts
+var i = 4277010157, a = 3469659854, o = "1.3.6.1.4.1.42.2.17.1.1", s = "1.3.6.1.4.1.42.2.19.1", c = /* @__PURE__ */ new TextEncoder().encode("Mighty Aphrodite"), l = 20, u = 20, d = class extends Error {};
+function f(e, t, n) {
+	let r = "", i = t, a = t + n;
+	for (; i < a;) {
+		let t = e[i];
+		if (t < 128 && t !== 0) r += String.fromCharCode(t), i += 1;
+		else if ((t & 224) == 192) {
+			let n = e[i + 1] ?? 0;
+			r += String.fromCharCode((t & 31) << 6 | n & 63), i += 2;
+		} else if ((t & 240) == 224) {
+			let n = e[i + 1] ?? 0, a = e[i + 2] ?? 0;
+			r += String.fromCharCode((t & 15) << 12 | (n & 63) << 6 | a & 63), i += 3;
+		} else r += String.fromCharCode(t), i += 1;
+	}
+	return r;
+}
+function p(e) {
+	let t = new Uint8Array(e.length * 2);
+	for (let n = 0; n < e.length; n++) {
+		let r = e.charCodeAt(n);
+		t[2 * n] = r >>> 8 & 255, t[2 * n + 1] = r & 255;
+	}
+	return t;
+}
+function m(e, t) {
+	if (e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
+	return !0;
+}
+function h(e) {
+	let t = new Uint8Array(e);
+	if (t.length < 8) throw new d("文件过小，不是有效的 keystore");
+	let n = new DataView(e), r = 0, i = n.getUint32(r);
+	r += 4;
+	let a;
+	if (i === 4277010157) a = "jks";
+	else if (i === 3469659854) a = "jceks";
+	else throw new d(`文件头不匹配（magic=0x${i.toString(16).padStart(8, "0")}）—— 不是 JKS/JCEKS keystore（PKCS#12 的 .p12/.pfx 请用证书查看器打开）`);
+	let o = n.getUint32(r);
+	if (r += 4, o !== 1 && o !== 2) throw new d(`不支持的 keystore 版本 ${o}`);
+	let s = n.getUint32(r);
+	if (r += 4, s > 1e6) throw new d(`条目数异常（${s}）`);
+	let c = () => {
+		if (r + 2 > t.length) throw new d("数据被截断");
+		let e = n.getUint16(r);
+		if (r += 2, r + e > t.length) throw new d("数据被截断");
+		let i = f(t, r, e);
+		return r += e, i;
+	}, l = () => {
+		if (r + 4 > t.length) throw new d("数据被截断");
+		let e = n.getUint32(r);
+		return r += 4, e;
+	}, u = () => {
+		if (r + 8 > t.length) throw new d("数据被截断");
+		let e = Number(n.getBigUint64(r));
+		return r += 8, e;
+	}, p = (e) => {
+		if (e < 0 || r + e > t.length) throw new d("数据被截断");
+		let n = t.slice(r, r + e);
+		return r += e, n;
+	}, m = [], h;
+	for (let e = 0; e < s; e++) {
+		let t = l();
+		if (t === 1) {
+			let e = c(), t = u(), n = p(l()), r = l(), i = [];
+			for (let e = 0; e < r; e++) {
+				let e = o === 2 ? c() : "X.509", t = l();
+				i.push({
+					type: e,
+					der: p(t)
+				});
+			}
+			m.push({
+				type: "privateKey",
+				alias: e,
+				createdMs: t,
+				certs: i,
+				encryptedKey: n
+			});
+		} else if (t === 2) {
+			let e = c(), t = u(), n = o === 2 ? c() : "X.509", r = p(l());
+			m.push({
+				type: "trustedCert",
+				alias: e,
+				createdMs: t,
+				certs: [{
+					type: n,
+					der: r
+				}]
+			});
+		} else if (t === 3 && a === "jceks") {
+			let e = c();
+			m.push({
+				type: "secretKey",
+				alias: e,
+				createdMs: 0,
+				certs: []
+			}), h = `含 JCEKS 密钥条目「${e}」（Java 序列化对象，无法在浏览器内跳过其字节），其后的条目未继续解析。`;
+			break;
+		} else throw new d(`未知条目类型 tag=${t}（第 ${e + 1} 项，偏移 ${r - 4}）`);
+	}
+	let g = t.length, _ = g >= 20;
+	return {
+		storeType: a,
+		version: o,
+		entries: m,
+		macData: _ ? t.slice(0, g - 20) : t.slice(),
+		storedDigest: _ ? t.slice(g - 20) : new Uint8Array(),
+		truncatedNote: h
+	};
+}
+function g(t, n) {
+	if (!n || t.storedDigest.length !== u) return !1;
+	let r = new e();
+	return r.update(p(n)), r.update(c), r.update(t.macData), m(r.digest(), t.storedDigest);
+}
+function _(i, a) {
+	let c = "", d = null;
+	try {
+		let e = t(i)[0], r = (e?.children[0])?.children[0];
+		c = r ? n(r.content) : "";
+		let a = e?.children[1];
+		a && (d = a.content);
+	} catch {
+		return {
+			ok: !1,
+			reason: "malformed"
+		};
+	}
+	if (!d) return {
+		ok: !1,
+		reason: "malformed"
+	};
+	if (c !== o) return {
+		ok: !1,
+		reason: "unsupported",
+		detail: c === s ? "PBEWithMD5AndTripleDES (JCEKS)" : c || "未知算法"
+	};
+	if (d.length < 40) return {
+		ok: !1,
+		reason: "malformed"
+	};
+	let f = p(a), h = d.subarray(0, l), g = d.length - l - u, _ = d.subarray(l, l + g), v = d.subarray(l + g), y = new Uint8Array(g), b = h, x = 0, S = Math.ceil(g / u);
+	for (let t = 0; t < S; t++) {
+		let t = new e();
+		t.update(f), t.update(b), b = t.digest(), y.set(b.subarray(0, Math.min(u, g - x)), x), x += u;
+	}
+	let C = new Uint8Array(g);
+	for (let e = 0; e < g; e++) C[e] = _[e] ^ y[e];
+	let w = new e();
+	return w.update(f), w.update(C), m(w.digest(), v) ? {
+		ok: !0,
+		key: {
+			pkcs8: C,
+			...r(C)
+		}
+	} : {
+		ok: !1,
+		reason: "wrong-password"
+	};
+}
+//#endregion
+export { a as JCEKS_MAGIC, i as JKS_MAGIC, d as JksError, _ as decryptPrivateKey, h as readJks, g as verifyStorePassword };

package/dist/lib/jsonl.d.ts

@@ -0,0 +1,29 @@
+/**
+ * JSON Lines / NDJSON (`.jsonl` / `.ndjson`) parser — one JSON value per physical line.
+ *
+ * Hand-rolled (no dependency, like the other in-browser parsers): split on newlines, skip blank lines, and
+ * `JSON.parse` each remaining line independently. A line that isn't valid JSON is kept as an error record
+ * (with its raw text) rather than aborting the whole file — JSONL is often produced incrementally / by logs,
+ * so a single malformed line shouldn't blank the preview.
+ *
+ * Used by JsonlViewer (the side viewer's render mode): the record LIST shows a truncated one-line preview per
+ * row, and a row expands to its pretty-printed value on demand — so a huge file stays responsive (the full
+ * value of a record is only built when that row is opened).
+ */
+export interface JsonlRecord {
+    /** 1-based physical line number in the file (blank lines are skipped, so numbers may have gaps). */
+    line: number;
+    /** The raw line text (trailing CR stripped) — shown verbatim for error rows. */
+    raw: string;
+    /** Parsed JSON value when the line is valid JSON; undefined when {@link error} is set. */
+    value?: unknown;
+    /** Parse error message when the line isn't valid JSON. */
+    error?: string;
+}
+export interface JsonlDoc {
+    records: JsonlRecord[];
+    /** How many records failed to parse (valid + invalid = records.length). */
+    errorCount: number;
+}
+/** Parse JSONL/NDJSON text into per-line records. Blank/whitespace-only lines are skipped (not recorded). */
+export declare function parseJsonl(text: string): JsonlDoc;

package/dist/lib/jsonl.js

@@ -0,0 +1,24 @@
+//#region src/lib/jsonl.ts
+function e(e) {
+	let t = [], n = 0, r = e.split("\n");
+	for (let e = 0; e < r.length; e++) {
+		let i = r[e].replace(/\r$/, "");
+		if (i.trim() === "") continue;
+		let a = {
+			line: e + 1,
+			raw: i
+		};
+		try {
+			a.value = JSON.parse(i);
+		} catch (e) {
+			a.error = e instanceof Error ? e.message : String(e), n++;
+		}
+		t.push(a);
+	}
+	return {
+		records: t,
+		errorCount: n
+	};
+}
+//#endregion
+export { e as parseJsonl };

package/dist/lib/lrc.d.ts

@@ -0,0 +1,32 @@
+/**
+ * LRC 歌词解析（手写、零依赖）。
+ *
+ * LRC 是行式歌词格式：元信息标签 `[ti:标题] [ar:歌手] [al:专辑] [by:制作] [offset:毫秒]`，加上带时间戳的
+ * 正文行 `[mm:ss.xx]歌词`。一行可带多个时间戳（`[t1][t2]同一句`），表示这句在多处重复出现。
+ *
+ * QQ 音乐导出的 .lrc 常见两个坑，这里都处理：
+ *  - 文本里混入 HTML 数字实体（如 `최` 表示某个 Unicode 码点），需要解码还原；
+ *  - 文件多为 **GBK** 编码（解码交由 {@link decodeTextSniff} 在读盘时完成，本模块只吃已解码的字符串）。
+ *
+ * 仅做解析，渲染在 LrcViewer.vue。无时间戳的纯文本歌词也能正常显示（hasTimings=false）。
+ */
+export interface LrcLine {
+    /** 该行时间戳（毫秒），已叠加全局 offset；纯文本行为 null。 */
+    timeMs: number | null;
+    text: string;
+}
+export interface ParsedLrc {
+    tags: Record<string, string>;
+    title?: string;
+    artist?: string;
+    album?: string;
+    by?: string;
+    /** `[offset:n]` 毫秒（正值表示歌词提前），已并入每行 timeMs。 */
+    offsetMs: number;
+    /** 按时间升序的歌词行（含解析出的纯文本行，timeMs=null 排在最前、保持原序）。 */
+    lines: LrcLine[];
+    /** 是否解析到任何带时间戳的行。 */
+    hasTimings: boolean;
+}
+/** 解析 LRC 文本（已是正确编码的字符串）。 */
+export declare function parseLrc(text: string): ParsedLrc;

package/dist/lib/lrc.js

@@ -0,0 +1,84 @@
+//#region src/lib/lrc.ts
+var e = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: "\xA0"
+};
+function t(t) {
+	return t.includes("&") ? t.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (t, n) => {
+		if (n[0] === "#") {
+			let e = n[1] === "x" || n[1] === "X" ? parseInt(n.slice(2), 16) : parseInt(n.slice(1), 10);
+			if (Number.isFinite(e) && e >= 0 && e <= 1114111) try {
+				return String.fromCodePoint(e);
+			} catch {
+				return t;
+			}
+			return t;
+		}
+		return e[n.toLowerCase()] ?? t;
+	}) : t;
+}
+var n = new Set([
+	"ti",
+	"ar",
+	"al",
+	"by",
+	"offset",
+	"length",
+	"re",
+	"ve",
+	"au",
+	"la"
+]), r = /\[(\d{1,3}):(\d{1,2})(?:[.:](\d{1,3}))?\]/g;
+function i(e) {
+	let i = {}, a = [], o = [], s = 0;
+	for (let c of e.split(/\r\n|\r|\n/)) {
+		let e = c;
+		r.lastIndex = 0;
+		let l = [], u = 0, d;
+		for (; (d = r.exec(e)) !== null && d.index === u;) {
+			let e = parseInt(d[1], 10), t = parseInt(d[2], 10), n = d[3] ? d[3] : "", r = 0;
+			n.length === 1 ? r = parseInt(n, 10) * 100 : n.length === 2 ? r = parseInt(n, 10) * 10 : n.length >= 3 && (r = parseInt(n.slice(0, 3), 10)), l.push(e * 6e4 + t * 1e3 + r), u = d.index + d[0].length;
+		}
+		if (l.length > 0) {
+			let n = t(e.slice(u).trim());
+			for (let e of l) a.push({
+				timeMs: e,
+				text: n
+			});
+			continue;
+		}
+		let f = /^\[([a-zA-Z]+):(.*)\]\s*$/.exec(e.trim());
+		if (f && n.has(f[1].toLowerCase())) {
+			let e = f[1].toLowerCase(), n = t(f[2].trim());
+			if (i[e] = n, e === "offset") {
+				let e = parseInt(n, 10);
+				Number.isFinite(e) && (s = e);
+			}
+			continue;
+		}
+		let p = t(e.trim());
+		p && o.push({
+			timeMs: null,
+			text: p
+		});
+	}
+	if (s !== 0) for (let e of a) e.timeMs != null && (e.timeMs -= s);
+	a.sort((e, t) => (e.timeMs ?? 0) - (t.timeMs ?? 0));
+	let c = a.length > 0 ? a : o;
+	return {
+		tags: i,
+		title: i.ti,
+		artist: i.ar,
+		album: i.al,
+		by: i.by,
+		offsetMs: s,
+		lines: c,
+		hasTimings: a.length > 0
+	};
+}
+//#endregion
+export { i as parseLrc };

package/dist/lib/lzma.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Minimal in-browser LZMA / LZMA2 decoder — no dependency, no WASM.
+ *
+ * Browsers ship a native inflate (DecompressionStream) for ZIP's DEFLATE, but nothing for LZMA — the
+ * codec 7z archives use. So unlike {@link lib/zip.ts}, the 7z reader ({@link lib/sevenZip.ts}) has to
+ * carry its own decompressor. This is a straight port of Igor Pavlov's reference LZMA decoder (the one
+ * in the LZMA SDK / the format spec): a range decoder, the bit-tree / length / distance sub-decoders,
+ * and the literal/match main loop. It decodes into a caller-provided linear output buffer (the total
+ * unpacked size is always known up front from the 7z folder metadata), which doubles as the LZ window.
+ *
+ * Three entry points, all synchronous (pure arithmetic, no async primitive needed):
+ *   - {@link lzmaDecode}   raw LZMA1 stream (7z coder 03 01 01), 5-byte props.
+ *   - {@link lzma2Decode}  LZMA2 chunk stream (7z coder 21), 1-byte props.
+ *   - {@link bcjX86Decode} the x86 BCJ branch filter's decode pass (7z coder 03 03 01 03).
+ *
+ * Encrypted / unusual coders are the 7z reader's concern; here we only fail (throw) on a malformed
+ * stream or an unsupported LZMA2 control byte.
+ */
+/**
+ * The LZMA decoder state. Holds the adaptive probability models, the `state` machine value and the four
+ * recent match distances — all of which LZMA2 keeps alive (and selectively resets) across chunks, so this
+ * is a reusable object rather than a one-shot function.
+ */
+export declare class LzmaState {
+    lc: number;
+    lp: number;
+    pb: number;
+    private literal;
+    private readonly isMatch;
+    private readonly isRep;
+    private readonly isRepG0;
+    private readonly isRepG1;
+    private readonly isRepG2;
+    private readonly isRep0Long;
+    private readonly posSlot;
+    private readonly specPos;
+    private readonly align;
+    private readonly lenCoder;
+    private readonly repLenCoder;
+    state: number;
+    rep0: number;
+    rep1: number;
+    rep2: number;
+    rep3: number;
+    /** Apply the lc/lp/pb properties byte (0..224) and size the literal table accordingly. */
+    setProps(d: number): void;
+    /** Reset all probability models and the state machine (a "reset state" in LZMA2 terms). */
+    resetState(): void;
+    /**
+     * Decode bytes into `out[outPos .. limit)` using `input` as the range-coded source. `dictStart` is the
+     * output offset of the current dictionary's start (for LZMA1 it's `outPos`; for LZMA2 it moves on a dict
+     * reset) — it anchors the position counter that drives posState and bounds back-references. Returns the
+     * new output position (== limit on success).
+     */
+    decode(input: Uint8Array, inStart: number, out: Uint8Array, outPos: number, limit: number, dictStart: number): number;
+}
+/**
+ * Decode a raw LZMA1 stream (7z coder 03 01 01). `props` is the 5-byte property block (lc/lp/pb byte +
+ * little-endian dict size, which we ignore — the linear output buffer is the window). Decodes exactly
+ * `outSize` bytes.
+ */
+export declare function lzmaDecode(input: Uint8Array, props: Uint8Array, outSize: number): Uint8Array;
+/**
+ * Decode an LZMA2 stream (7z coder 21). LZMA2 frames a sequence of chunks — each either an uncompressed
+ * block or an independently range-coded LZMA block — over a shared, selectively-reset dictionary and
+ * decoder state. `props` (1 byte, dict-size code) is unused here. Decodes exactly `outSize` bytes.
+ */
+export declare function lzma2Decode(input: Uint8Array, _props: Uint8Array, outSize: number): Uint8Array;
+/** Apply the x86 BCJ decode pass in place (7z coder 03 03 01 03), with `ip` the stream start address (0). */
+export declare function bcjX86Decode(data: Uint8Array, ip?: number): void;