@l1yp/file-viewer 0.1.0

package/dist/lib/encoding.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Decode an archive entry's filename bytes, sniffing the encoding.
+ *
+ * Archive formats store names in whatever byte encoding the producer's OS used: ZIP without its UTF-8 flag and
+ * legacy tar both carry raw bytes, and on Chinese Windows that's usually **GBK** — which turns into mojibake if
+ * force-decoded as UTF-8. So we probe: try strict UTF-8 first (the modern default, and a superset of ASCII); if
+ * the bytes aren't valid UTF-8, try GBK; if neither decodes cleanly, fall back to a lossless `\uXXXX` escape of
+ * the raw bytes so the name is at least unambiguous instead of garbled.
+ *
+ * "Strict" = a `fatal` TextDecoder that throws on an invalid sequence, which is exactly our "is it this
+ * encoding?" probe. Non-streaming `decode()` calls are independent, so the decoders are safely reused.
+ */
+/**
+ * Decode a TEXT file's bytes, sniffing the encoding: UTF-8 → GBK → lenient UTF-8.
+ *
+ * Same probe as {@link decodeFileNameBytes}, but for file *content* (e.g. a `.lrc` lyrics file, which on
+ * Chinese Windows is almost always GBK and turns to mojibake if force-decoded as UTF-8). The last resort
+ * differs: instead of a `\uXXXX` escape (right for a filename) we fall back to a non-fatal UTF-8 decode,
+ * which yields the readable text with `�` for any stray invalid byte — the sane default for prose.
+ */
+export declare function decodeTextSniff(bytes: Uint8Array): string;
+/**
+ * Decode filename bytes as UTF-8 → GBK → `\uXXXX` escape (in that order of preference).
+ *
+ * `normalizeSeparators` rewrites backslashes to '/' on a *successfully decoded* name (ZIP from Windows'
+ * Compress-Archive emits '\'), but never on the escaped fallback — whose own `\u…` backslashes must survive.
+ */
+export declare function decodeFileNameBytes(bytes: Uint8Array, normalizeSeparators?: boolean): string;

package/dist/lib/encoding.js

@@ -0,0 +1,44 @@
+//#region src/lib/encoding.ts
+var e = new TextDecoder("utf-8", { fatal: !0 }), t = null, n = !1;
+function r() {
+	if (!n) {
+		n = !0;
+		try {
+			t = new TextDecoder("gbk", { fatal: !0 });
+		} catch {
+			t = null;
+		}
+	}
+	return t;
+}
+function i(e) {
+	let t = "";
+	for (let n of e) n >= 32 && n < 127 ? t += String.fromCharCode(n) : t += "\\u" + n.toString(16).padStart(4, "0");
+	return t;
+}
+function a(t) {
+	if (t.length === 0) return "";
+	try {
+		return e.decode(t);
+	} catch {}
+	let n = r();
+	if (n) try {
+		return n.decode(t);
+	} catch {}
+	return new TextDecoder("utf-8").decode(t);
+}
+function o(t, n = !1) {
+	if (t.length === 0) return "";
+	try {
+		let r = e.decode(t);
+		return n ? r.replace(/\\/g, "/") : r;
+	} catch {}
+	let a = r();
+	if (a) try {
+		let e = a.decode(t);
+		return n ? e.replace(/\\/g, "/") : e;
+	} catch {}
+	return i(t);
+}
+//#endregion
+export { o as decodeFileNameBytes, a as decodeTextSniff };

package/dist/lib/epl/code/ast.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Decompiled code AST — the TS shape of EProjectFile's `Expressions/` and `Statements/` node trees.
+ *
+ * The C# uses a class hierarchy with virtual `ToTextCode`; here the nodes are plain discriminated unions
+ * (`kind`) built by {@link parseStatementBlock} and rendered by the text layer. Two transient markers
+ * (`paramListEnd` / `arrayLiteralEnd`) exist only to signal list termination during parsing and never appear
+ * in a finished tree.
+ */
+export interface NumberExpr {
+    kind: 'number';
+    value: number;
+}
+export interface StringExpr {
+    kind: 'string';
+    value: string;
+}
+export interface BoolExpr {
+    kind: 'bool';
+    value: boolean;
+}
+export interface DateTimeExpr {
+    kind: 'datetime';
+    /** OLE Automation date (days since 1899-12-30); rendered to `[yyyy年MM月dd日…]`. */
+    oa: number;
+}
+/** `#常量` — user constant (libraryId -2) or a support-library constant. */
+export interface ConstantExpr {
+    kind: 'constant';
+    libraryId: number;
+    constantId: number;
+}
+/** `#库类型.成员` — a support-library enum constant. */
+export interface EmnuExpr {
+    kind: 'emnu';
+    libraryId: number;
+    structId: number;
+    memberId: number;
+}
+export interface VariableExpr {
+    kind: 'variable';
+    id: number;
+}
+export interface MethodPtrExpr {
+    kind: 'methodPtr';
+    methodId: number;
+}
+/** Omitted argument — renders as nothing. */
+export interface DefaultExpr {
+    kind: 'default';
+}
+/** `{a, b, c}` array/byte-set literal. */
+export interface ArrayExpr {
+    kind: 'array';
+    items: Expr[];
+}
+/** `target.成员` — member access (libraryId -2 ⇒ user member, otherwise a library type member). */
+export interface AccessMemberExpr {
+    kind: 'accessMember';
+    target: Expr;
+    libraryId: number;
+    structId: number;
+    memberId: number;
+}
+/** `target[index]` — array element access. */
+export interface AccessArrayExpr {
+    kind: 'accessArray';
+    target: Expr;
+    index: Expr;
+}
+/** A call / operator. libraryId: ≥0 library, -1 empty, -2 user method, -3 DLL command. */
+export interface CallExpr {
+    kind: 'call';
+    libraryId: number;
+    methodId: number;
+    /** Skip the vtable (calling a specific parent method). */
+    invokeSpecial: boolean;
+    /** ThisCall target, or null. */
+    target: Expr | null;
+    /** Argument list (each omitted arg is a `default` node), or null when absent. */
+    paramList: Expr[] | null;
+}
+export type Expr = NumberExpr | StringExpr | BoolExpr | DateTimeExpr | ConstantExpr | EmnuExpr | VariableExpr | MethodPtrExpr | DefaultExpr | ArrayExpr | AccessMemberExpr | AccessArrayExpr | CallExpr | {
+    kind: 'paramListEnd';
+} | {
+    kind: 'arrayLiteralEnd';
+};
+export interface StatementBlock {
+    statements: Stmt[];
+}
+/** Shared fields of the four loop statements (判断循环 / 循环判断 / 变量循环 / 计次循环). */
+export interface LoopCommon {
+    block: StatementBlock;
+    unexaminedCode: string | null;
+    commentOnStart: string | null;
+    commentOnEnd: string | null;
+    maskOnStart: boolean;
+    maskOnEnd: boolean;
+}
+export interface CaseInfo {
+    condition: Expr | null;
+    unexaminedCode: string | null;
+    block: StatementBlock;
+    comment: string | null;
+    mask: boolean;
+}
+export type Stmt = {
+    kind: 'expression';
+    expr: CallExpr | null;
+    mask: boolean;
+    comment: string | null;
+} | {
+    kind: 'unexamined';
+    code: string;
+    mask: boolean;
+} | {
+    kind: 'if';
+    condition: Expr | null;
+    unexaminedCode: string | null;
+    block: StatementBlock;
+    comment: string | null;
+    mask: boolean;
+} | {
+    kind: 'ifElse';
+    condition: Expr | null;
+    unexaminedCode: string | null;
+    blockOnTrue: StatementBlock;
+    blockOnFalse: StatementBlock;
+    comment: string | null;
+    mask: boolean;
+} | ({
+    kind: 'while';
+    condition: Expr | null;
+} & LoopCommon) | ({
+    kind: 'doWhile';
+    condition: Expr | null;
+} & LoopCommon) | ({
+    kind: 'for';
+    start: Expr | null;
+    end: Expr | null;
+    step: Expr | null;
+    var: Expr | null;
+} & LoopCommon) | ({
+    kind: 'counter';
+    count: Expr | null;
+    var: Expr | null;
+} & LoopCommon) | {
+    kind: 'switch';
+    cases: CaseInfo[];
+    defaultBlock: StatementBlock;
+};

package/dist/lib/epl/code/codeDataParser.d.ts

@@ -0,0 +1,3 @@
+import type { StatementBlock } from './ast';
+/** Parse a method's expression-data bytes into a statement block. `dec` = the method's codepage decoder. */
+export declare function parseStatementBlock(expressionData: Uint8Array, dec?: TextDecoder): StatementBlock;

package/dist/lib/epl/code/codeDataParser.js

@@ -0,0 +1,330 @@
+import { gbk as e } from "../io/encoding.js";
+import { BinaryReader as t } from "../io/binaryReader.js";
+import { decomposeLibDataTypeId as n, isLibDataType as r } from "../model/eplSystemId.js";
+//#region src/lib/epl/code/codeDataParser.ts
+var i = new Set([
+	80,
+	81,
+	82,
+	83,
+	84,
+	85,
+	106,
+	107,
+	108,
+	109,
+	110,
+	111,
+	112,
+	113
+]), a = { kind: "paramListEnd" }, o = { kind: "arrayLiteralEnd" }, s = { kind: "default" };
+function c(n, r = e()) {
+	return l(new t(n, r));
+}
+function l(e) {
+	let t = [];
+	for (;;) {
+		let n;
+		for (;;) {
+			if (e.pos >= e.length) return { statements: t };
+			if (n = e.readByte(), i.has(n)) break;
+		}
+		let r = e.pos - 1;
+		if (n === 80 || n === 81 || n === 82 || n === 83 || n === 84 || n === 111 || n === 113) return e.pos = r, { statements: t };
+		if (n === 85) continue;
+		if (n === 109) {
+			if (e.readByte() !== 110) throw Error("CodeData: expected 0x6E after 0x6D");
+			let n = [], r;
+			do {
+				let t = u(e), i = t.exp.paramList?.[0] ?? null, a = l(e);
+				if (n.push({
+					condition: i,
+					unexaminedCode: t.unexaminedCode,
+					block: a,
+					comment: t.comment,
+					mask: t.mask
+				}), e.readByte() !== 83) throw Error("CodeData: expected 0x53 (case end)");
+				r = e.readByte();
+			} while (r === 110);
+			if (r !== 111) throw Error("CodeData: expected 0x6F (default)");
+			let i = l(e);
+			if (e.readByte() !== 84) throw Error("CodeData: expected 0x54 (switch end)");
+			e.readByte(), t.push({
+				kind: "switch",
+				cases: n,
+				defaultBlock: i
+			});
+			continue;
+		}
+		let { exp: a, unexaminedCode: o, comment: s, mask: c } = u(e);
+		switch (n) {
+			case 112: {
+				let n = l(e);
+				if (e.readByte() !== 113) throw Error("CodeData: expected 0x71 (loop end)");
+				let r = u(e);
+				if (a.libraryId !== 0) throw Error("CodeData: bad loop library id");
+				let i = {
+					block: n,
+					unexaminedCode: o,
+					commentOnStart: s,
+					commentOnEnd: r.comment,
+					maskOnStart: c,
+					maskOnEnd: r.mask
+				};
+				switch (a.methodId) {
+					case 3:
+						t.push({
+							kind: "while",
+							condition: a.paramList?.[0] ?? null,
+							...i
+						});
+						break;
+					case 5:
+						t.push({
+							kind: "doWhile",
+							condition: r.exp.paramList?.[0] ?? null,
+							...i,
+							unexaminedCode: r.unexaminedCode
+						});
+						break;
+					case 7:
+						t.push({
+							kind: "counter",
+							count: a.paramList?.[0] ?? null,
+							var: a.paramList?.[1] ?? null,
+							...i
+						});
+						break;
+					case 9:
+						t.push({
+							kind: "for",
+							start: a.paramList?.[0] ?? null,
+							end: a.paramList?.[1] ?? null,
+							step: a.paramList?.[2] ?? null,
+							var: a.paramList?.[3] ?? null,
+							...i
+						});
+						break;
+					default: throw Error(`CodeData: unknown loop methodId ${a.methodId}`);
+				}
+				break;
+			}
+			case 108: {
+				let n = l(e);
+				if (e.readByte() !== 82) throw Error("CodeData: expected 0x52");
+				e.readByte(), t.push({
+					kind: "if",
+					condition: a.paramList?.[0] ?? null,
+					unexaminedCode: o,
+					block: n,
+					comment: s,
+					mask: c
+				});
+				break;
+			}
+			case 107: {
+				let n = l(e);
+				if (e.readByte() !== 80) throw Error("CodeData: expected 0x50");
+				let r = l(e);
+				if (e.readByte() !== 81) throw Error("CodeData: expected 0x51");
+				e.readByte(), t.push({
+					kind: "ifElse",
+					condition: a.paramList?.[0] ?? null,
+					unexaminedCode: o,
+					blockOnTrue: n,
+					blockOnFalse: r,
+					comment: s,
+					mask: c
+				});
+				break;
+			}
+			case 106:
+				o == null ? a.libraryId === -1 ? t.push({
+					kind: "expression",
+					expr: null,
+					mask: !1,
+					comment: s
+				}) : t.push({
+					kind: "expression",
+					expr: a,
+					mask: c,
+					comment: s
+				}) : t.push({
+					kind: "unexamined",
+					code: o,
+					mask: c
+				});
+				break;
+		}
+	}
+}
+function u(e) {
+	let t = e.readInt32(), n = e.readInt16(), r = e.readInt16(), i = e.readBStr(), a = e.readBStr(), o = (r & 32) != 0, s = (r & 16) != 0;
+	if (i != null) {
+		let e = i.indexOf("\0");
+		e !== -1 && (i = i.slice(0, e)), i === "" && (i = null);
+	}
+	if (a != null) {
+		let e = a.indexOf("\0");
+		e !== -1 && (a = a.slice(0, e)), a === "" && (a = null);
+	}
+	let c = {
+		kind: "call",
+		libraryId: n,
+		methodId: t,
+		invokeSpecial: s,
+		target: null,
+		paramList: null
+	};
+	if (e.pos !== e.length) {
+		let t = e.readByte();
+		if (t === 54) c.paramList = d(e);
+		else if (t === 56) --e.pos, c.target = f(e), c.paramList = d(e);
+		else throw --e.pos, Error("CodeData: bad call terminator");
+	}
+	return {
+		exp: c,
+		unexaminedCode: i,
+		comment: a,
+		mask: o
+	};
+}
+function d(e) {
+	let t = [];
+	for (;;) {
+		let n = f(e);
+		if (n === a) break;
+		t.push(n);
+	}
+	return t;
+}
+function f(e, t = !0) {
+	let i;
+	for (;;) {
+		let n = e.readByte();
+		if (n === 1) {
+			i = a;
+			break;
+		} else if (n === 22) {
+			i = s;
+			break;
+		} else if (n === 23) {
+			i = {
+				kind: "number",
+				value: e.readFloat64()
+			};
+			break;
+		} else if (n === 24) {
+			i = {
+				kind: "bool",
+				value: e.readInt16() !== 0
+			};
+			break;
+		} else if (n === 25) {
+			i = {
+				kind: "datetime",
+				oa: e.readFloat64()
+			};
+			break;
+		} else if (n === 26) {
+			i = {
+				kind: "string",
+				value: e.readBStr() ?? ""
+			};
+			break;
+		} else if (n === 27) {
+			i = {
+				kind: "constant",
+				libraryId: -2,
+				constantId: e.readInt32()
+			};
+			break;
+		} else if (n === 28) {
+			i = {
+				kind: "constant",
+				libraryId: e.readInt16() - 1,
+				constantId: e.readInt16() - 1
+			};
+			break;
+		} else if (n === 29) continue;
+		else if (n === 30) {
+			i = {
+				kind: "methodPtr",
+				methodId: e.readInt32()
+			};
+			break;
+		} else if (n === 33) {
+			i = u(e).exp;
+			break;
+		} else if (n === 35) {
+			let t = e.readInt16() - 1;
+			i = {
+				kind: "emnu",
+				libraryId: e.readInt16() - 1,
+				structId: t,
+				memberId: e.readInt32() - 1
+			};
+			break;
+		} else if (n === 55) continue;
+		else if (n === 31) {
+			let t = [], n;
+			for (; (n = f(e)) !== o;) t.push(n);
+			i = {
+				kind: "array",
+				items: t
+			};
+			break;
+		} else if (n === 32) {
+			i = o;
+			break;
+		} else if (n === 56) {
+			let n = e.readInt32();
+			if (n === 83951614) return e.readByte(), f(e, !0);
+			i = {
+				kind: "variable",
+				id: n
+			}, t = !0;
+			break;
+		} else if (n === 59) {
+			i = {
+				kind: "number",
+				value: e.readInt32()
+			};
+			break;
+		} else throw Error(`CodeData: unknown expression type 0x${n.toString(16)}`);
+	}
+	if (t && (i.kind === "variable" || i.kind === "call" || i.kind === "accessMember" || i.kind === "accessArray")) for (; e.pos !== e.length;) {
+		let t = e.readByte();
+		if (t === 57) {
+			let t = e.readInt32(), a = e.readInt32();
+			if (r(a)) {
+				let { lib: e, type: r } = n(a);
+				i = {
+					kind: "accessMember",
+					target: i,
+					libraryId: e,
+					structId: r,
+					memberId: t - 1
+				};
+			} else i = {
+				kind: "accessMember",
+				target: i,
+				libraryId: -2,
+				structId: a,
+				memberId: t
+			};
+		} else if (t === 58) i = {
+			kind: "accessArray",
+			target: i,
+			index: f(e, !1)
+		};
+		else if (t === 55) break;
+		else {
+			--e.pos;
+			break;
+		}
+	}
+	return i;
+}
+//#endregion
+export { c as parseStatementBlock };

package/dist/lib/epl/code/codeLines.d.ts

@@ -0,0 +1,20 @@
+import type { IdToNameMap } from '../names/idToNameMap';
+/**
+ * One guide column's visual on a given line, forming a continuous bracket down a block's own column:
+ *  - `top` ┌ — the block's header (the vertical drops in here, with a tick toward the keyword).
+ *  - `bottom` └ — the block's end (the vertical arrives from above and turns toward the row).
+ *  - `tee` ├ — a branch divider inside the block (否则 / 判断 case / 默认): the vertical passes through.
+ *  - `mid` │ — a plain pass-through (a body line, or an enclosing block's column running past this row).
+ *  - `blank` — the column is occupied (so the body stays indented) but no line is drawn: a commented-out
+ *    (masked) control-flow block keeps its nesting but shows no guide.
+ */
+export type GuideSeg = 'top' | 'bottom' | 'mid' | 'tee' | 'blank';
+/** One rendered source line: the text + one guide segment per enclosing/own block column (left to right). */
+export interface CodeLine {
+    text: string;
+    segs: GuideSeg[];
+    /** A hidden control-flow terminator row (carries only the └ guide): rendered, but takes no line number. */
+    noNo?: boolean;
+}
+/** Decompile a method's expression data into IDE-style display lines (text + guide segments). */
+export declare function methodCodeLines(expressionData: Uint8Array, nm: IdToNameMap, dec: TextDecoder): CodeLine[];