@l1yp/file-viewer 0.1.0

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

@@ -0,0 +1,191 @@
+import { parseStatementBlock as e } from "./codeDataParser.js";
+import { exprToText as t } from "./textCode.js";
+//#region src/lib/epl/code/codeLines.ts
+function n(e) {
+	return e ? "' " : "";
+}
+function r(e, n) {
+	return e ? t(e, n, 0) : "";
+}
+function i(e, t) {
+	let n = e.texts.length;
+	return e.texts.push(t), n;
+}
+function a(e, t, n) {
+	let r = i(e, t ? "' " + n : "");
+	return t || e.noNos.add(r), r;
+}
+function o(e, t, n, r) {
+	for (let i of e.statements) s(i, t, n, r);
+}
+function s(e, s, l, u) {
+	switch (e.kind) {
+		case "expression": {
+			let r = n(e.mask);
+			e.expr && (r += t(e.expr, s, 0)), e.comment != null && (r += (e.expr == null ? "' " : "  ' ") + e.comment), i(u, r);
+			break;
+		}
+		case "unexamined":
+			i(u, n(e.mask) + e.code);
+			break;
+		case "if": {
+			let t = n(e.mask);
+			t += e.unexaminedCode == null ? ".如果真 (" + r(e.condition, s) + ")" : "." + e.unexaminedCode, e.comment != null && (t += "  ' " + e.comment);
+			let c = i(u, t);
+			o(e.block, s, l + 1, u);
+			let d = a(u, e.mask, ".如果真结束");
+			u.spans.push({
+				col: l,
+				start: c,
+				end: d,
+				tees: [],
+				masked: e.mask
+			});
+			break;
+		}
+		case "ifElse": {
+			let t = n(e.mask);
+			t += e.unexaminedCode == null ? ".如果 (" + r(e.condition, s) + ")" : "." + e.unexaminedCode, e.comment != null && (t += "  ' " + e.comment);
+			let c = i(u, t);
+			o(e.blockOnTrue, s, l + 1, u);
+			let d = i(u, n(e.mask) + ".否则");
+			o(e.blockOnFalse, s, l + 1, u);
+			let f = a(u, e.mask, ".如果结束");
+			u.spans.push({
+				col: l,
+				start: c,
+				end: f,
+				tees: [d],
+				masked: e.mask
+			});
+			break;
+		}
+		case "while": {
+			let t = n(e.maskOnStart);
+			t += e.unexaminedCode == null ? ".判断循环首 (" + r(e.condition, s) + ")" : "." + e.unexaminedCode, e.commentOnStart != null && (t += "  ' " + e.commentOnStart);
+			let a = i(u, t);
+			o(e.block, s, l + 1, u);
+			let c = n(e.maskOnEnd) + ".判断循环尾 ()";
+			e.commentOnEnd != null && (c += "  ' " + e.commentOnEnd);
+			let d = i(u, c);
+			u.spans.push({
+				col: l,
+				start: a,
+				end: d,
+				tees: [],
+				masked: e.maskOnStart
+			});
+			break;
+		}
+		case "doWhile": {
+			let t = n(e.maskOnStart) + ".循环判断首 ()";
+			e.commentOnStart != null && (t += "  ' " + e.commentOnStart);
+			let a = i(u, t);
+			o(e.block, s, l + 1, u);
+			let c = n(e.maskOnEnd);
+			c += e.unexaminedCode == null ? ".循环判断尾 (" + r(e.condition, s) + ")" : "." + e.unexaminedCode, e.commentOnEnd != null && (c += "  ' " + e.commentOnEnd);
+			let d = i(u, c);
+			u.spans.push({
+				col: l,
+				start: a,
+				end: d,
+				tees: [],
+				masked: e.maskOnStart
+			});
+			break;
+		}
+		case "for": {
+			let t = n(e.maskOnStart);
+			e.unexaminedCode == null ? t += ".变量循环首 (" + r(e.start, s) + ", " + r(e.end, s) + ", " + r(e.step, s) + ", " + r(e.var, s) + ")" : t += "." + e.unexaminedCode, e.commentOnStart != null && (t += "  ' " + e.commentOnStart);
+			let a = i(u, t);
+			o(e.block, s, l + 1, u);
+			let c = n(e.maskOnEnd) + ".变量循环尾 ()";
+			e.commentOnEnd != null && (c += "  ' " + e.commentOnEnd);
+			let d = i(u, c);
+			u.spans.push({
+				col: l,
+				start: a,
+				end: d,
+				tees: [],
+				masked: e.maskOnStart
+			});
+			break;
+		}
+		case "counter": {
+			let t = n(e.maskOnStart);
+			e.unexaminedCode == null ? t += ".计次循环首 (" + r(e.count, s) + ", " + r(e.var, s) + ")" : t += "." + e.unexaminedCode, e.commentOnStart != null && (t += "  ' " + e.commentOnStart);
+			let a = i(u, t);
+			o(e.block, s, l + 1, u);
+			let c = n(e.maskOnEnd) + ".计次循环尾 ()";
+			e.commentOnEnd != null && (c += "  ' " + e.commentOnEnd);
+			let d = i(u, c);
+			u.spans.push({
+				col: l,
+				start: a,
+				end: d,
+				tees: [],
+				masked: e.maskOnStart
+			});
+			break;
+		}
+		case "switch":
+			c(e, s, l, u);
+			break;
+	}
+}
+function c(e, t, s, c) {
+	if (e.cases.length === 0) throw Error("CodeData: switch must have a case");
+	let l = e.cases[0], u = n(l.mask);
+	l.unexaminedCode == null ? u += ".判断 (" + r(l.condition, t) + ")" : u += "." + l.unexaminedCode.trimStart(), l.comment != null && (u += "  ' " + l.comment);
+	let d = i(c, u);
+	o(l.block, t, s + 1, c);
+	let f = [];
+	for (let a = 1; a < e.cases.length; a++) {
+		let l = e.cases[a], u = n(l.mask);
+		u += l.unexaminedCode == null ? ".判断 (" + r(l.condition, t) + ")" : "." + l.unexaminedCode, l.comment != null && (u += "  ' " + l.comment), f.push(i(c, u)), o(l.block, t, s + 1, c);
+	}
+	e.defaultBlock.statements.length > 0 && (f.push(i(c, n(l.mask) + ".默认")), o(e.defaultBlock, t, s + 1, c));
+	let p = a(c, l.mask, ".判断结束");
+	c.spans.push({
+		col: s,
+		start: d,
+		end: p,
+		tees: f,
+		masked: l.mask
+	});
+}
+function l(e) {
+	let t = e.texts.map(() => []), n = (e, n, r) => {
+		t[e][n] = r;
+	};
+	for (let r of e.spans) {
+		if (r.masked) {
+			for (let e = r.start; e <= r.end; e++) t[e][r.col] === void 0 && n(e, r.col, "blank");
+			continue;
+		}
+		n(r.start, r.col, "top"), n(r.end, r.col, "bottom");
+		for (let e of r.tees) n(e, r.col, "tee");
+		for (let e = r.start + 1; e < r.end; e++) t[e][r.col] === void 0 && n(e, r.col, "mid");
+	}
+	return t.map((e) => {
+		let t = [];
+		for (let n = 0; n < e.length; n++) t.push(e[n] ?? "mid");
+		return t;
+	});
+}
+function u(t, n, r) {
+	let i = e(t, r), a = {
+		texts: [],
+		spans: [],
+		noNos: /* @__PURE__ */ new Set()
+	};
+	o(i, n, 0, a);
+	let s = l(a);
+	return a.texts.map((e, t) => ({
+		text: e,
+		segs: s[t],
+		noNo: a.noNos.has(t)
+	}));
+}
+//#endregion
+export { u as methodCodeLines };

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

@@ -0,0 +1,86 @@
+/**
+ * Code-section structures — ports of `ClassInfo.cs`, `MethodInfo.cs` (+ `MethodCodeData`), `StructInfo.cs`,
+ * `DllDeclareInfo.cs`, `LibraryRefInfo.cs`.
+ *
+ * Classes / methods / structs / DLL declares are read via the id+memory-address block table (no per-block
+ * length); their variable lists reuse {@link readVariables}. The reads run in C# source order — kept here as
+ * explicit statement sequences (not object literals) so the cursor advances identically.
+ */
+import type { BinaryReader } from '../io/binaryReader';
+import { type EplVariable } from './variable';
+export interface LibraryRefInfo {
+    fileName: string;
+    /** Raw GUID string, kept verbatim for faithful round-trip. */
+    guidString: string;
+    version: [number, number];
+    name: string;
+    /** Min command count for the支持库版本检查 (filled by {@link applyCompatibilityInfo}). */
+    minRequiredCmd: number;
+    minRequiredDataType: number;
+    minRequiredConstant: number;
+}
+/** Read the library list: MFC-count-prefixed strings, each `fileName\rguid\rmajor\rminor\rname`. */
+export declare function readLibraries(r: BinaryReader): LibraryRefInfo[];
+/** Attach the per-library min-required counts read separately in the code-section header. */
+export declare function applyCompatibilityInfo(infos: LibraryRefInfo[], minRequiredCmds: number[] | null, minRequiredDataTypes: number[] | null, minRequiredConstants: number[] | null): void;
+export interface ClassInfo {
+    id: number;
+    memoryAddress: number;
+    /** Associated form Id for a window class; 0 otherwise. */
+    form: number;
+    baseClass: number;
+    name: string;
+    comment: string;
+    /** Ids of the methods that belong to this class. */
+    methods: number[];
+    /** Class member variables. */
+    variables: EplVariable[];
+}
+export declare function readClasses(r: BinaryReader): ClassInfo[];
+/** The six raw byte-blobs holding a method's compiled code (parsed by the code-data parser later). */
+export interface MethodCodeData {
+    lineOffset: Uint8Array;
+    blockOffset: Uint8Array;
+    methodReference: Uint8Array;
+    variableReference: Uint8Array;
+    constantReference: Uint8Array;
+    /** The bytecode-like expression stream — decompiled to statements by CodeDataParser. */
+    expressionData: Uint8Array;
+}
+export interface MethodInfo {
+    id: number;
+    memoryAddress: number;
+    /** Owning class Id. */
+    classId: number;
+    flags: number;
+    returnDataType: number;
+    name: string;
+    comment: string;
+    /** Local variables. */
+    variables: EplVariable[];
+    /** Parameters. */
+    parameters: EplVariable[];
+    codeData: MethodCodeData;
+}
+export declare function readMethods(r: BinaryReader): MethodInfo[];
+export interface StructInfo {
+    id: number;
+    memoryAddress: number;
+    flags: number;
+    name: string;
+    comment: string;
+    members: EplVariable[];
+}
+export declare function readStructs(r: BinaryReader): StructInfo[];
+export interface DllDeclareInfo {
+    id: number;
+    memoryAddress: number;
+    flags: number;
+    returnDataType: number;
+    name: string;
+    comment: string;
+    entryPoint: string;
+    libraryName: string;
+    parameters: EplVariable[];
+}
+export declare function readDllDeclares(r: BinaryReader): DllDeclareInfo[];

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

@@ -0,0 +1,29 @@
+/**
+ * Text-code rendering — port of every `ToTextCode` across `Expressions/`, `Statements/`, the variable
+ * subtypes, ClassInfo / MethodInfo / StructInfo / DllDeclareInfo, and CodeSection.
+ *
+ * Produces the readable 易语言 source: definitions (`.程序集` / `.子程序` / `.局部变量` …), control flow
+ * (`.如果`/`.判断循环首`/`.判断开始` …) and expressions (operators with precedence-aware brackets, calls,
+ * member/array access, literals). Newlines are `\n` (the C# uses Environment.NewLine; callers comparing to a
+ * Windows oracle should normalize). Method bodies are decompiled on demand via {@link parseStatementBlock}.
+ */
+import { gbk } from '../io/encoding';
+import { IdToNameMap } from '../names/idToNameMap';
+import type { Expr, StatementBlock, Stmt } from './ast';
+import type { EplVariable } from './variable';
+import type { ClassInfo, DllDeclareInfo, MethodInfo, StructInfo } from './structures';
+import type { CodeSection } from '../sections/code';
+/** Render a single arbitrary expression. */
+export declare function exprToText(e: Expr, nameMap: IdToNameMap, indent: number): string;
+export declare function formatNumber(v: number): string;
+export declare function formatOADate(oa: number): string;
+export declare function blockToText(block: StatementBlock, nameMap: IdToNameMap, indent: number): string;
+export declare function stmtToText(stmt: Stmt, nameMap: IdToNameMap, indent: number): string;
+export declare function variableToText(v: EplVariable, nameMap: IdToNameMap, indent: number): string;
+export declare function methodToText(m: MethodInfo, nameMap: IdToNameMap, indent: number, dec: TextDecoder, writeCode?: boolean): string;
+export declare function structToText(st: StructInfo, nameMap: IdToNameMap, indent: number): string;
+export declare function dllDeclareToText(d: DllDeclareInfo, nameMap: IdToNameMap, indent: number): string;
+export declare function classToText(c: ClassInfo, nameMap: IdToNameMap, indent: number, codeSection: CodeSection | null, dec: TextDecoder, writeCode?: boolean): string;
+/** Render the whole code section (global vars + classes [+ their methods] + DLL declares + structs). */
+export declare function codeSectionToText(cs: CodeSection, nameMap: IdToNameMap, dec: TextDecoder, indent?: number, writeMethod?: boolean, writeCode?: boolean): string;
+export { gbk };

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

@@ -0,0 +1,150 @@
+import "../io/encoding.js";
+import { getType as e } from "../model/eplSystemId.js";
+//#region src/lib/epl/code/textCode.ts
+var t = new Map([
+	[15, {
+		op: "*",
+		precedence: 2,
+		type: "multi"
+	}],
+	[16, {
+		op: "/",
+		precedence: 2,
+		type: "multi"
+	}],
+	[17, {
+		op: "\\",
+		precedence: 3,
+		type: "multi"
+	}],
+	[18, {
+		op: "%",
+		precedence: 4,
+		type: "multi"
+	}],
+	[19, {
+		op: "+",
+		precedence: 5,
+		type: "multi"
+	}],
+	[20, {
+		op: "-",
+		precedence: 5,
+		type: "multi"
+	}],
+	[21, {
+		op: "-",
+		precedence: 1,
+		type: "unary"
+	}],
+	[38, {
+		op: "==",
+		precedence: 6,
+		type: "binary"
+	}],
+	[39, {
+		op: "!=",
+		precedence: 6,
+		type: "binary"
+	}],
+	[40, {
+		op: "<",
+		precedence: 6,
+		type: "binary"
+	}],
+	[41, {
+		op: ">",
+		precedence: 6,
+		type: "binary"
+	}],
+	[42, {
+		op: "<=",
+		precedence: 6,
+		type: "binary"
+	}],
+	[43, {
+		op: ">=",
+		precedence: 6,
+		type: "binary"
+	}],
+	[44, {
+		op: "?=",
+		precedence: 6,
+		type: "binary"
+	}],
+	[45, {
+		op: "&&",
+		precedence: 7,
+		type: "multi"
+	}],
+	[46, {
+		op: "||",
+		precedence: 8,
+		type: "multi"
+	}],
+	[52, {
+		op: "=",
+		precedence: 9,
+		type: "binary"
+	}]
+]);
+function n(e, t, n, r) {
+	return e.kind === "call" ? a(e, t, n, r) : o(e, t, n);
+}
+function r(e, t, r, i, a) {
+	let o = a.precedence > i, s = o ? "(" : "", c = e.paramList ?? [];
+	if (a.type === "unary") s += a.op, c.length > 0 && (s += n(c[0], t, r, a.precedence));
+	else if (c.length === 0) s += " " + a.op + " ";
+	else {
+		s += n(c[0], t, r, a.precedence), s += " " + a.op + " ";
+		for (let e = 1; e < c.length; e++) e > 1 && (s += " " + a.op + " "), s += n(c[e], t, r, a.precedence - 1);
+	}
+	return o && (s += ")"), s;
+}
+function i(e, t, n) {
+	return "(" + (e ?? []).map((e) => o(e, t, n)).join(", ") + ")";
+}
+function a(n, a, s, c) {
+	let l = n.target == null && n.libraryId === 0 ? t.get(n.methodId) : void 0;
+	if (l) return r(n, a, s, c, l);
+	let u = "";
+	if (n.target != null && (u += o(n.target, a, s) + "."), n.invokeSpecial && n.libraryId === -2) {
+		let t = a.methodIdToClassId.get(n.methodId);
+		t !== void 0 && e(t) === 1224736768 && (u += a.getUserDefinedName(t) + ".");
+	}
+	return u += n.libraryId === -2 || n.libraryId === -3 ? a.getUserDefinedName(n.methodId) : a.getLibCmdName(n.libraryId, n.methodId), u += " ", u += i(n.paramList, a, s), u;
+}
+function o(e, t, n) {
+	switch (e.kind) {
+		case "number": return c(e.value);
+		case "string": return "“" + e.value + "”";
+		case "bool": return e.value ? "真" : "假";
+		case "datetime": return "[" + u(e.oa) + "]";
+		case "constant": return "#" + (e.libraryId === -2 ? t.getUserDefinedName(e.constantId) : t.getLibConstantName(e.libraryId, e.constantId));
+		case "emnu": return "#" + t.getLibTypeName(e.libraryId, e.structId) + "." + t.getLibTypeMemberName(e.libraryId, e.structId, e.memberId);
+		case "variable": return t.getUserDefinedName(e.id);
+		case "methodPtr": return "&" + t.getUserDefinedName(e.methodId);
+		case "default": return "";
+		case "array": return "{" + e.items.map((e) => o(e, t, n)).join(", ") + "}";
+		case "accessMember": return s(e, t, n);
+		case "accessArray": return o(e.target, t, n) + "[" + o(e.index, t, n) + "]";
+		case "call": return a(e, t, n, 2 ** 53 - 1);
+		default: return "";
+	}
+}
+function s(t, n, r) {
+	let i = "";
+	return t.target.kind === "variable" && e(t.target.id) === 100663296 || (i += o(t.target, n, r) + "."), t.libraryId === -2 ? e(t.structId) === 1375731712 && !(t.memberId & 4278190080) ? i += n.getLibTypeMemberName(0, 0, t.memberId - 1) : i += n.getUserDefinedName(t.memberId) : i += n.getLibTypeMemberName(t.libraryId, t.structId, t.memberId), i;
+}
+function c(e) {
+	return String(e);
+}
+function l(e, t = 2) {
+	return String(e).padStart(t, "0");
+}
+function u(e) {
+	let t = Math.round(e * 864e5) + Date.UTC(1899, 11, 30), n = new Date(t), r = `${l(n.getUTCFullYear(), 4)}年${l(n.getUTCMonth() + 1)}月${l(n.getUTCDate())}日`, i = n.getUTCHours(), a = n.getUTCMinutes(), o = n.getUTCSeconds();
+	return i === 0 && a === 0 && o === 0 ? r : `${r}${l(i)}时${l(a)}分${l(o)}秒`;
+}
+//#endregion
+export { o as exprToText, c as formatNumber, u as formatOADate };

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

@@ -0,0 +1,25 @@
+/**
+ * Variable info — port of `VariableInfo/AbstractVariableInfo.cs` (+ its subtypes Global/Local/Class/
+ * StructMember/MethodParameter/DllParameter).
+ *
+ * All variable kinds share ONE binary layout (read via the id+offset block table): dataType(int32),
+ * flags(int16), uBound(int32[readByte]), name(CString), comment(CString). The subtypes differ only in how
+ * their `flags` bits are interpreted and which keyword they emit as text — captured here by {@link EplVarKind}
+ * and resolved in the name/text layer, so the structural read stays uniform.
+ */
+import type { BinaryReader } from '../io/binaryReader';
+/** Which variable list a row came from — drives the text keyword + flag-bit meaning later. */
+export type EplVarKind = 'global' | 'local' | 'classMember' | 'structMember' | 'methodParameter' | 'dllParameter';
+export interface EplVariable {
+    kind: EplVarKind;
+    id: number;
+    /** Data-type Id (a system DATATYPE_*, a struct/class Id, or a library data type). */
+    dataType: number;
+    flags: number;
+    /** Array dimensions (UBound): length 0 ⇒ scalar; `[0]` ⇒ dynamic array; otherwise fixed bounds. */
+    uBound: number[];
+    name: string;
+    comment: string;
+}
+/** Read a variable block table (C# AbstractVariableInfo.ReadVariables) tagging each row with `kind`. */
+export declare function readVariables(r: BinaryReader, kind: EplVarKind): EplVariable[];

package/dist/lib/epl/eplDocument.d.ts

@@ -0,0 +1,21 @@
+import type { GeneralSection } from './model/section';
+import { EplEncryptedError, NotEplFileError } from './projectFileReader';
+import { type CodeSection } from './sections/code';
+import { type ESystemInfoSection } from './sections/esystemInfo';
+import { type ProjectConfigSection } from './sections/projectConfig';
+import { type LosableSection } from './sections/losable';
+import { type ResourceSection } from './sections/resource';
+export type EplSection = ESystemInfoSection | ProjectConfigSection | CodeSection | ResourceSection | LosableSection | GeneralSection;
+export interface EplDocument {
+    /** All parsed sections in file order (end-of-file section excluded). */
+    sections: EplSection[];
+    /** Convenience handles for the common sections (filled after parsing). */
+    systemInfo?: ESystemInfoSection;
+    projectConfig?: ProjectConfigSection;
+    code?: CodeSection;
+    resource?: ResourceSection;
+    losable?: LosableSection;
+}
+/** Parse a `.e`/`.ec` byte buffer into its sections. Throws {@link EplEncryptedError} / {@link NotEplFileError}. */
+export declare function loadEpl(bytes: Uint8Array): EplDocument;
+export { EplEncryptedError, NotEplFileError };

package/dist/lib/epl/eplDocument.js

@@ -0,0 +1,36 @@
+import { ProjectFileReader as e } from "./projectFileReader.js";
+//#region src/lib/epl/eplDocument.ts
+var t = 117469977, n = new Map([
+	[ESystemInfoKey.key, ESystemInfoKey],
+	[ProjectConfigKey.key, ProjectConfigKey],
+	[CodeSectionKey.key, CodeSectionKey],
+	[ResourceSectionKey.key, ResourceSectionKey],
+	[LosableSectionKey.key, LosableSectionKey]
+]);
+function r(r) {
+	let i = new e(r), a = gbk(), o = [];
+	for (; !i.isFinish;) {
+		let e = i.readSection();
+		if (e.key === t) break;
+		let r = n.get(e.key), s;
+		if (r) {
+			let t = {
+				dec: a,
+				cryptEC: i.cryptEC
+			};
+			s = r.parse(e.data, t);
+		} else s = {
+			kind: "general",
+			sectionKey: e.key,
+			sectionName: e.name,
+			isOptional: e.isOptional,
+			data: e.data
+		};
+		s.kind === "systemInfo" && (a = decoderForLanguage(s.language)), o.push(s);
+	}
+	let s = { sections: o };
+	for (let e of o) e.kind === "systemInfo" ? s.systemInfo = e : e.kind === "projectConfig" ? s.projectConfig = e : e.kind === "code" ? s.code = e : e.kind === "resource" ? s.resource = e : e.kind === "losable" && (s.losable = e);
+	return s;
+}
+//#endregion
+export { r as loadEpl };

package/dist/lib/epl/imageList.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 易语言 图片组 (picture group) decoder. A 图片组 image constant stores a Windows common-control ImageList
+ * stream (the same bytes `ImageList_Write` emits) wrapped in an 8-byte 易语言 header `"MITL" + 00 00 00 FF`:
+ *
+ *   off 0   "MITL" + 4 bytes                     (易语言 wrapper)
+ *   off 8   ILHEAD (28 bytes): u16 magic 'IL'(0x4C49) · u16 version · u16 cCurImage · u16 cMaxImage ·
+ *           u16 cGrow · u16 cx · u16 cy · u32 bkColor · u16 flags · i16 overlays[4]
+ *   off 36  color bitmap (BMP) — all frames packed left→right, top→bottom in a `cols = bmpW/cx` grid
+ *   …       mask bitmap (BMP, 1bpp) — unused here; the 32bpp color bitmap carries its own alpha
+ *
+ * We parse the header, decode the uncompressed color BMP to top-down RGBA, then slice it into the `cCurImage`
+ * frames of `cx × cy`. Pure logic (no DOM) so it stays testable; the component turns each frame's RGBA into a
+ * canvas. Returns null for anything that isn't a well-formed MITL ImageList so the caller falls back to treating
+ * the bytes as a single image.
+ */
+export interface EplImageFrame {
+    width: number;
+    height: number;
+    /** RGBA, top-down, length = width*height*4. */
+    rgba: Uint8ClampedArray;
+}
+export interface EplImageList {
+    cx: number;
+    cy: number;
+    frames: EplImageFrame[];
+}
+/** Parse a 图片组 (MITL ImageList) into its frames, or null if the bytes aren't one. */
+export declare function parseEplImageList(bytes: Uint8Array): EplImageList | null;

package/dist/lib/epl/imageList.js

@@ -0,0 +1,66 @@
+//#region src/lib/epl/imageList.ts
+function e(e, t) {
+	return e[t] | e[t + 1] << 8;
+}
+function t(e, t) {
+	return e[t] | e[t + 1] << 8 | e[t + 2] << 16 | e[t + 3] << 24;
+}
+function n(n, r) {
+	if (n[r] !== 66 || n[r + 1] !== 77) return null;
+	let i = t(n, r + 10) >>> 0, a = t(n, r + 18), o = t(n, r + 22), s = e(n, r + 28);
+	if (t(n, r + 30) >>> 0 || s !== 32 && s !== 24) return null;
+	let c = o < 0;
+	if (o = Math.abs(o), a <= 0 || o <= 0 || a > 8192 || o > 8192) return null;
+	let l = s >> 3, u = ((a * s + 31) / 32 | 0) * 4, d = r + i;
+	if (d + u * o > n.length) return null;
+	let f = new Uint8ClampedArray(a * o * 4), p = !1;
+	for (let e = 0; e < o; e++) {
+		let t = d + (c ? e : o - 1 - e) * u, r = e * a * 4;
+		for (let e = 0; e < a; e++) {
+			f[r] = n[t + 2], f[r + 1] = n[t + 1], f[r + 2] = n[t];
+			let e = s === 32 ? n[t + 3] : 255;
+			e !== 0 && (p = !0), f[r + 3] = e, t += l, r += 4;
+		}
+	}
+	if (!p) for (let e = 3; e < f.length; e += 4) f[e] = 255;
+	return {
+		width: a,
+		height: o,
+		rgba: f
+	};
+}
+function r(t) {
+	if (t.length < 64 || t[0] !== 77 || t[1] !== 73 || t[2] !== 84 || t[3] !== 76) return null;
+	let r = -1;
+	for (let e = 4; e < 24; e++) if (t[e] === 73 && t[e + 1] === 76) {
+		r = e;
+		break;
+	}
+	if (r < 0) return null;
+	let i = e(t, r + 4), a = e(t, r + 10), o = e(t, r + 12);
+	if (i <= 0 || i > 4096 || a <= 0 || o <= 0 || a > 1024 || o > 1024) return null;
+	let s = n(t, r + 28);
+	if (!s) return null;
+	let c = Math.max(1, Math.floor(s.width / a)), l = [];
+	for (let e = 0; e < i; e++) {
+		let t = e % c * a, n = Math.floor(e / c) * o;
+		if (t + a > s.width || n + o > s.height) break;
+		let r = new Uint8ClampedArray(a * o * 4);
+		for (let e = 0; e < o; e++) {
+			let i = ((n + e) * s.width + t) * 4, o = e * a * 4;
+			for (let e = 0; e < a * 4; e++) r[o++] = s.rgba[i++];
+		}
+		l.push({
+			width: a,
+			height: o,
+			rgba: r
+		});
+	}
+	return l.length > 0 ? {
+		cx: a,
+		cy: o,
+		frames: l
+	} : null;
+}
+//#endregion
+export { r as parseEplImageList };