@applemusic-like-lyrics/lyric 1.0.2 → 1.1.0

package/dist/amll-lyric.cjs

@@ -19,8 +19,16 @@ const createWord = (word) => ({
 	...word
 });
 const parseTime = (time) => Math.round(time.split(":").map(Number).reverse().reduce((acc, cur, idx) => acc + cur * 60 ** idx, 0) * 1e3);
+/**
+* 将一个时间戳的分、秒、毫秒三段文本转换为毫秒。
+*
+* 毫秒段可以省略，省略时按 `0` 计；
+* 毫秒不足三位时视为在后位省略了 `0`，即 `.1` 为 100 毫秒、`.02` 为 20 毫秒；
+* 超过三位的部分直接截断。
+*/
+const parseTimestampParts = (minStr, secStr, msStr = "") => parseInt(minStr, 10) * 6e4 + parseInt(secStr, 10) * 1e3 + parseInt(`${msStr}000`.slice(0, 3), 10);
 const formatTime = (ms) => {
-	return `${Math.floor(ms / 6e4).toString().padStart(2, "0")}:${Math.floor(ms % 6e4 / 1e3).toString().padStart(2, "0")}.${Math.round(ms % 1e3).toString().padStart(3, "0")}`;
+	return `${Math.floor(ms / 6e4).toString().padStart(2, "0")}:${Math.floor(ms % 6e4 / 1e3).toString().padStart(2, "0")}.${Math.floor(ms % 1e3).toString().padStart(3, "0")}`;
 };
 const normalizeTimestamp = (ms) => {
 	if (!Number.isFinite(ms) || ms < 0) return 0;
@@ -30,22 +38,19 @@ const normalizeDuration = (duration) => {
 	if (!Number.isFinite(duration) || duration < 0) return 0;
 	return duration;
 };
-const MAX_LRC_TIMESTAMP = 60039999;
-const clampTimestamp = (ms, max = MAX_LRC_TIMESTAMP) => Math.min(max, normalizeTimestamp(ms));
 /**
-* Returns consecutive pairs from the given iterable.
+* LRC 家族时间戳可表示的最大值，即 `999:59.999`
 *
-* Example: `0, 1, 2, 3` -> `[0, 1], [1, 2], [2, 3]`
+* 时间戳的分钟为 1 至 3 位、秒为 1 至 2 位、毫秒为 1 至 6 位，
+* 因此能写出来又读得回来的最大时间就到这里
 */
-function* pairwise(iterable) {
-	let prev;
-	let hasPrev = false;
-	for (const curr of iterable) {
-		if (hasPrev) yield [prev, curr];
-		prev = curr;
-		hasPrev = true;
-	}
-}
+const MAX_LRC_TIMESTAMP = parseTimestampParts("999", "59", "999");
+/**
+* 将时间钳制到 LRC 家族可表示的范围内
+* @param ms 时间，单位为毫秒
+* @returns 钳制后的时间
+*/
+const clampTimestamp = (ms) => Math.min(MAX_LRC_TIMESTAMP, normalizeTimestamp(ms));
 //#endregion
 //#region src/formats/ass.ts
 function writeASSTimestamp(ms) {
@@ -922,7 +927,7 @@ function rotateLeft28Bit(value, amount) {
 * @param mode 加密或解密模式
 */
 function keySchedule(key, mode) {
-	const schedule = new Int32Array(32);
+	const schedule = /* @__PURE__ */ new Int32Array(32);
 	const c0 = permuteFromKeyBytes(key, KEY_PERM_C);
 	const d0 = permuteFromKeyBytes(key, KEY_PERM_D);
 	let c = c0 << 4n;
@@ -1082,10 +1087,10 @@ const INV_IP_RULE = [
 	60,
 	28
 ];
-const IP_LEFT_TABLE = new Int32Array(2048);
-const IP_RIGHT_TABLE = new Int32Array(2048);
-const INV_IP_LEFT_TABLE = new Int32Array(2048);
-const INV_IP_RIGHT_TABLE = new Int32Array(2048);
+const IP_LEFT_TABLE = /* @__PURE__ */ new Int32Array(2048);
+const IP_RIGHT_TABLE = /* @__PURE__ */ new Int32Array(2048);
+const INV_IP_LEFT_TABLE = /* @__PURE__ */ new Int32Array(2048);
+const INV_IP_RIGHT_TABLE = /* @__PURE__ */ new Int32Array(2048);
 function generatePermutationTables() {
 	const applyPermutation = (input, rule) => {
 		let output = 0n;
@@ -1129,7 +1134,7 @@ function applyQqPboxPermutation(input) {
 	}
 	return output;
 }
-const SP_TABLE = new Int32Array(512);
+const SP_TABLE = /* @__PURE__ */ new Int32Array(512);
 /**
 * 生成 S-P 盒合并查找表以提高性能。
 */
@@ -1141,8 +1146,8 @@ function generateSpTables() {
 	}
 }
 generateSpTables();
-const EBOX_HIGH_TABLE = new Int32Array(1024);
-const EBOX_LOW_TABLE = new Int32Array(1024);
+const EBOX_HIGH_TABLE = /* @__PURE__ */ new Int32Array(1024);
+const EBOX_LOW_TABLE = /* @__PURE__ */ new Int32Array(1024);
 function generateEBoxTables() {
 	for (let chunkIdx = 0; chunkIdx < 4; chunkIdx++) {
 		const shiftIn32 = (3 - chunkIdx) * 8;
@@ -1273,8 +1278,8 @@ var QqMusicCodec = class {
 	* 解密一个8字节的数据块。
 	*/
 	decryptBlock(input, output) {
-		const temp1 = new Uint8Array(8);
-		const temp2 = new Uint8Array(8);
+		const temp1 = /* @__PURE__ */ new Uint8Array(8);
+		const temp2 = /* @__PURE__ */ new Uint8Array(8);
 		desCrypt(input, temp1, this.decryptSchedule[0]);
 		desCrypt(temp1, temp2, this.decryptSchedule[1]);
 		desCrypt(temp2, output, this.decryptSchedule[2]);
@@ -1283,8 +1288,8 @@ var QqMusicCodec = class {
 	* 加密一个8字节的数据块。
 	*/
 	encryptBlock(input, output) {
-		const temp1 = new Uint8Array(8);
-		const temp2 = new Uint8Array(8);
+		const temp1 = /* @__PURE__ */ new Uint8Array(8);
+		const temp2 = /* @__PURE__ */ new Uint8Array(8);
 		desCrypt(input, temp1, this.encryptSchedule[0]);
 		desCrypt(temp1, temp2, this.encryptSchedule[1]);
 		desCrypt(temp2, output, this.encryptSchedule[2]);
@@ -1338,7 +1343,8 @@ function decryptQrcHex(encryptedHexString) {
 * @returns 十六进制格式的字符串，代表被加密的歌词数据
 */
 function encryptQrcHex(plaintext) {
-	const paddedData = zeroPad((0, pako.deflate)(new TextEncoder().encode(plaintext)), DES_BLOCK_SIZE);
+	const textBytes = new TextEncoder().encode(plaintext);
+	const paddedData = zeroPad((0, pako.deflate)(textBytes), DES_BLOCK_SIZE);
 	const encryptedData = new Uint8Array(paddedData.length);
 	for (let i = 0; i < paddedData.length; i += DES_BLOCK_SIZE) {
 		const chunk = paddedData.subarray(i, i + DES_BLOCK_SIZE);
@@ -1348,75 +1354,6 @@ function encryptQrcHex(plaintext) {
 	return uint8ArrayToHex(encryptedData);
 }
 //#endregion
-//#region src/formats/eslrc.ts
-const TIME_REGEX = /^\[((?:\d+:)*\d+(?:\.\d+)?)\]/;
-function parseTimestampPrefix(src) {
-	const match = src.match(TIME_REGEX);
-	if (!match) return null;
-	const [raw, timeStr] = match;
-	return {
-		time: parseTime(timeStr),
-		length: raw.length
-	};
-}
-function parseEslrcLine(rawLine) {
-	let src = rawLine.trim();
-	const first = parseTimestampPrefix(src);
-	if (!first) return null;
-	src = src.slice(first.length);
-	let startTime = first.time;
-	if (!src.trim()) return null;
-	const words = [];
-	while (src.trim().length > 0) {
-		const nextTimePos = src.indexOf("[");
-		if (nextTimePos <= 0) return null;
-		const word = src.slice(0, nextTimePos);
-		const nextTime = parseTimestampPrefix(src.slice(nextTimePos));
-		if (!nextTime) return null;
-		words.push(createWord({
-			word,
-			startTime,
-			endTime: nextTime.time
-		}));
-		src = src.slice(nextTimePos + nextTime.length);
-		startTime = nextTime.time;
-	}
-	return createLine({ words });
-}
-/**
-* 解析 ESLyric 逐词歌词格式字符串
-* @param eslrc 歌词字符串
-* @returns 成功解析出来的歌词
-*/
-function parseEslrc(eslrc) {
-	const result = [];
-	for (const rawLine of eslrc.split(/\r?\n/)) {
-		const line = parseEslrcLine(rawLine);
-		if (line) result.push(line);
-	}
-	result.sort((a, b) => (a.words[0]?.startTime ?? Number.MAX_SAFE_INTEGER) - (b.words[0]?.startTime ?? Number.MAX_SAFE_INTEGER));
-	for (const line of result) {
-		for (const word of line.words) {
-			word.startTime = clampTimestamp(word.startTime);
-			word.endTime = clampTimestamp(word.endTime);
-		}
-		line.startTime = clampTimestamp(line.words[0]?.startTime ?? 0);
-		line.endTime = clampTimestamp(line.words[line.words.length - 1]?.endTime ?? 0);
-	}
-	return result;
-}
-/**
-* 将歌词数组转换为 ESLyric 逐词歌词格式字符串
-* @param lines 歌词数组
-* @returns ESLyric 逐词歌词格式字符串
-*/
-function stringifyEslrc(lines) {
-	return lines.map((line) => {
-		if (!line.words.length) return "";
-		return `[${formatTime(clampTimestamp(line.words[0].startTime))}]${line.words.map((word) => `${word.word}[${formatTime(clampTimestamp(word.endTime))}]`).join("")}`;
-	}).filter(Boolean).join("\n");
-}
-//#endregion
 //#region src/formats/lys.ts
 /**
 * 解析 LYS 格式中的属性值
@@ -1593,147 +1530,701 @@ function stringifyLqe(lines) {
 	].filter((section) => section !== null).join("\n\n\n")].join("\n\n");
 }
 //#endregion
-//#region src/formats/lrc.ts
+//#region src/formats/lrc/helpers.ts
 /**
-* 解析 LyRiC 格式的歌词字符串
-* @param lrc 歌词字符串
-* @returns 成功解析出来的歌词
+* 复制一行歌词并归一化其中所有的时间
+* @param line 一行歌词
+* @returns 归一化后的副本
 */
-function parseLrc(lrc) {
-	const tagRegex = /^\[([a-z]+):([^\]]+)\]$/;
-	const timeRegex = /^\[((?:\d+:)*\d+(?:\.\d+)?)\](.*)$/;
-	const bgRegex = /^[(（](.+)[)）]$/;
-	const lines = lrc.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
-	const lyricLines = [];
-	for (let lineStr of lines) {
-		if (tagRegex.test(lineStr)) continue;
-		const timeStamps = [];
-		while (true) {
-			const match = lineStr.match(timeRegex);
-			if (!match) break;
-			const [, timeStr, text] = match;
-			const timeStamp = parseTime(timeStr);
-			if (Number.isNaN(timeStamp)) break;
-			timeStamps.push(timeStamp);
-			lineStr = text;
+function normalizeLine(line) {
+	return {
+		...line,
+		startTime: normalizeTimestamp(line.startTime),
+		endTime: normalizeTimestamp(line.endTime),
+		words: line.words.map((word) => ({
+			...word,
+			startTime: normalizeTimestamp(word.startTime),
+			endTime: normalizeTimestamp(word.endTime)
+		}))
+	};
+}
+/**
+* 将一组音节拼接为完整文本
+* @param words 音节数组
+* @returns 拼接后的文本
+*/
+function joinWords(words) {
+	return words.map((word) => word.word).join("");
+}
+/**
+* 判断一行歌词是否有文本内容
+* @param line 一行歌词
+* @returns 是否有文本内容
+*/
+function hasText(line) {
+	return joinWords(line.words).trim() !== "";
+}
+/**
+* 判断一组音节是否为逐字歌词
+*
+* 逐行歌词只有一个音节，且该音节与歌词同时开始，
+* 因此可以直接由音节推导出来，无需额外的标记
+* @param words 音节数组
+* @param startTime 歌词行的开始时间
+* @returns 是否为逐字歌词
+*/
+function isWordSyncLyric(words, startTime) {
+	if (words.length === 0) return false;
+	if (words.length > 1) return true;
+	return words[0].startTime !== startTime;
+}
+const BG_PAREN_BEGIN = /^[(（]/;
+const BG_PAREN_END = /[）)]$/;
+/**
+* 判断一段歌词文本是否为背景人声
+*
+* 只有整段文本都被圆括号包裹时才算数，半角与全角括号都接受。
+* 括号内没有内容的不算，避免把 `()` 这样的写法当作背景人声
+* @param text 一段歌词文本
+* @returns 是否为背景人声
+*/
+function isBackgroundVocalText(text) {
+	return text.length > 2 && BG_PAREN_BEGIN.test(text) && BG_PAREN_END.test(text);
+}
+/**
+* 去掉背景人声最外层的圆括号
+* @param words 音节数组，会被就地修改
+*/
+function trimBackgroundVocalParentheses(words) {
+	if (words.length === 0) return;
+	words[0].word = words[0].word.slice(1);
+	const lastWord = words[words.length - 1];
+	lastWord.word = lastWord.word.slice(0, -1);
+}
+//#endregion
+//#region src/formats/lrc/metadata.ts
+const LRC_METADATA_REGEX = /^\[\s*(?<key>[a-zA-Z]+)\s*:\s*(?<value>.*?)\s*\]$/;
+/**
+* 解析一行 LRC 元数据，如 `[ti:标题]`
+* @param line 已去除首尾空白的单行文本
+* @returns 元数据键值对，若不是元数据行则为 `null`
+*/
+function parseLrcMetadataLine(line) {
+	const match = line.match(LRC_METADATA_REGEX);
+	if (!match?.groups) return null;
+	const key = match.groups.key.toLowerCase();
+	const value = match.groups.value.trim();
+	if (!value) return null;
+	return [[key, [value]]];
+}
+/**
+* 将元数据合并进目标元数据表
+*
+* 同名键的取值会按顺序合并并去重
+* @param target 目标元数据表，会被就地修改
+* @param source 待合并的元数据表
+*/
+function mergeMetadata(target, source) {
+	for (const [key, values] of source) {
+		const existing = target.find(([targetKey]) => targetKey === key);
+		if (!existing) {
+			target.push([key, [...values]]);
+			continue;
 		}
-		if (timeStamps.length === 0) continue;
-		lineStr = lineStr.trim();
-		const backgroundMatch = lineStr.match(bgRegex);
-		const isBG = Boolean(backgroundMatch);
-		if (backgroundMatch) lineStr = backgroundMatch[1];
-		for (const t of timeStamps) lyricLines.push(createLine({
-			startTime: t,
-			endTime: MAX_LRC_TIMESTAMP,
-			words: [createWord({
-				word: lineStr,
-				startTime: t,
-				endTime: t
-			})],
-			isBG
-		}));
+		for (const value of values) if (!existing[1].includes(value)) existing[1].push(value);
 	}
-	lyricLines.sort((a, b) => a.startTime - b.startTime);
-	for (const [prev, curr] of pairwise(lyricLines)) prev.endTime = prev.words[0].endTime = curr.startTime;
-	return lyricLines.filter((line) => line.words[0].word);
 }
 /**
-* 将歌词数组转换为 LyRiC 格式的字符串
-* @param lines 歌词数组
-* @returns LyRiC 格式的字符串
+* 将元数据表生成为 LRC 元数据行
+* @param metadata 元数据表
+* @returns 元数据行数组，没有可输出的元数据时为空数组
 */
-function stringifyLrc(lines) {
-	return lines.map((line) => {
-		const text = line.words.map((w) => w.word).join("");
-		const printText = line.isBG ? `(${text})` : text;
-		return `[${formatTime(normalizeTimestamp(line.startTime))}]${printText}`;
-	}).join("\n");
+function generateLrcMetadataLines(metadata) {
+	const lines = [];
+	for (const [key, values] of metadata) {
+		const printableValues = values.filter((value) => value.trim() !== "");
+		if (!key.trim() || printableValues.length === 0) continue;
+		lines.push(`[${key}:${printableValues.join("/")}]`);
+	}
+	return lines;
 }
 //#endregion
-//#region src/formats/lrca2.ts
+//#region src/formats/lrc/types.ts
 /**
-* 解析 LRC A2 格式的歌词字符串
-* @param lrc 歌词字符串
-* @returns 成功解析出来的歌词
+* 各歌词模式的行为，由解析器与生成器共用
 */
-function parseLrcA2(lrc) {
-	const lines = lrc.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
-	const lyricLines = [];
-	const lineTimeStampRegex = /^\[((?:\d+:)*\d+(?:\.\d+)?)\]/;
-	const wordTimestampRegex = /<((?:\d+:)*\d+(?:\.\d+)?)>/;
-	const wordTimestampPrefixRegex = /^<((?:\d+:)*\d+(?:\.\d+)?)>/;
-	for (let lineStr of lines) {
-		if (lineStr.match(/^\[([a-z]):(.+)\]$/i)) continue;
-		const lineTimeStampmatch = lineStr.match(lineTimeStampRegex);
-		if (!lineTimeStampmatch) continue;
-		const [lineTimeStamp, lineTimeStr] = lineTimeStampmatch;
-		const lineStartTime = parseTime(lineTimeStr);
-		if (Number.isNaN(lineStartTime)) continue;
-		lineStr = lineStr.slice(lineTimeStamp.length).trim();
-		if (!lineStr) continue;
-		const lineItems = [];
-		while (lineStr.length) {
-			const prefixedTimeStampMatch = lineStr.match(wordTimestampPrefixRegex);
-			if (prefixedTimeStampMatch) {
-				const [wordTimeStamp, wordTimeStr] = prefixedTimeStampMatch;
-				const parsedWordTime = parseTime(wordTimeStr);
-				if (!Number.isNaN(parsedWordTime)) lineItems.push(parsedWordTime);
-				lineStr = lineStr.slice(wordTimeStamp.length);
+const LRC_MODE_FEATURES = {
+	plain: {
+		wordLevel: false,
+		inlineAuxiliary: true
+	},
+	enhanced: {
+		wordLevel: true,
+		inlineAuxiliary: false
+	},
+	spl: {
+		wordLevel: true,
+		inlineAuxiliary: false
+	}
+};
+//#endregion
+//#region src/formats/lrc/generator.ts
+/**
+* 展开单种辅助行的默认配置
+*/
+function resolveAuxiliaryLineOptions(options) {
+	return {
+		enabled: options?.enabled ?? true,
+		inline: options?.inline ?? false
+	};
+}
+var LrcGenerator = class {
+	options;
+	features;
+	constructor(options) {
+		this.options = {
+			mode: options?.mode ?? "plain",
+			inlineBracket: options?.inlineBracket ?? "angle",
+			auxiliaryLines: {
+				order: options?.auxiliaryLines?.order ?? "translation-first",
+				translation: resolveAuxiliaryLineOptions(options?.auxiliaryLines?.translation),
+				romanization: resolveAuxiliaryLineOptions(options?.auxiliaryLines?.romanization),
+				backgroundVocal: resolveAuxiliaryLineOptions(options?.auxiliaryLines?.backgroundVocal)
+			},
+			endTimestamp: {
+				mode: options?.endTimestamp?.mode ?? "none",
+				intervalGap: options?.endTimestamp?.intervalGap ?? 5e3
+			}
+		};
+		this.features = LRC_MODE_FEATURES[this.options.mode];
+	}
+	/**
+	* 行首时间戳是否改用首个音节的开始时间
+	*
+	* 生成方括号时间戳时，按常见实现省略行首时间戳，只在行首写入首个音节的开始时间，
+	* 生成尖括号时则写入行时间戳
+	*/
+	get usesFirstWordStartTime() {
+		return this.options.inlineBracket === "square";
+	}
+	/**
+	* 生成 LRC 家族歌词
+	* @param input 歌词行，或带元数据的解析结果
+	* @returns 歌词文本
+	*/
+	generate(input) {
+		const metadata = Array.isArray(input) ? [] : input.metadata;
+		const sourceLines = Array.isArray(input) ? input : input.lines;
+		const outputLines = [];
+		const metaLines = generateLrcMetadataLines(metadata);
+		if (metaLines.length > 0) outputLines.push(...metaLines);
+		const lines = sourceLines.map(normalizeLine).filter(hasText);
+		const backgroundVocals = /* @__PURE__ */ new Set();
+		for (const [index, line] of lines.entries()) {
+			if (line.isBG) continue;
+			const nextLine = lines[index + 1];
+			const backgroundVocal = nextLine?.isBG ? nextLine : void 0;
+			if (backgroundVocal) backgroundVocals.add(backgroundVocal);
+		}
+		for (const [index, line] of lines.entries()) {
+			if (backgroundVocals.has(line)) continue;
+			const nextLine = lines[index + 1];
+			const backgroundVocal = !line.isBG && nextLine?.isBG ? nextLine : void 0;
+			let nextMainLine;
+			for (let nextIndex = index + 1; nextIndex < lines.length; nextIndex++) if (!lines[nextIndex].isBG) {
+				nextMainLine = lines[nextIndex];
+				break;
+			}
+			this.processSingleLine(line, backgroundVocal, nextMainLine, outputLines);
+		}
+		return outputLines.join("\n");
+	}
+	processSingleLine(line, backgroundVocal, nextLine, outputLines) {
+		const { auxiliaryLines: auxConfig } = this.options;
+		const { inlineAuxiliary } = this.features;
+		const transInline = inlineAuxiliary && auxConfig.translation.inline;
+		const romaInline = inlineAuxiliary && !transInline && auxConfig.romanization.inline;
+		const bgvInline = inlineAuxiliary && !transInline && !romaInline && auxConfig.backgroundVocal.inline;
+		const lineTimeTag = this.formatTimeTag(line.startTime, "square");
+		let transText = auxConfig.translation.enabled ? line.translatedLyric : "";
+		let romaText = auxConfig.romanization.enabled ? line.romanLyric : "";
+		let bgLine = auxConfig.backgroundVocal.enabled ? backgroundVocal : void 0;
+		let mainLineText = joinWords(line.words);
+		if (inlineAuxiliary) {
+			const applyInline = (text) => {
+				mainLineText += `${mainLineText ? " " : ""}(${text})`;
+			};
+			if (transInline && transText) {
+				applyInline(transText);
+				transText = "";
+			} else if (romaInline && romaText) {
+				applyInline(romaText);
+				romaText = "";
+			} else if (bgvInline && bgLine) {
+				mainLineText += `${mainLineText ? " " : ""}(${joinWords(bgLine.words)})`;
+				if (auxConfig.translation.enabled && bgLine.translatedLyric) transText = transText ? `${transText} (${bgLine.translatedLyric})` : `(${bgLine.translatedLyric})`;
+				if (auxConfig.romanization.enabled && bgLine.romanLyric) romaText = romaText ? `${romaText} (${bgLine.romanLyric})` : `(${bgLine.romanLyric})`;
+				bgLine = void 0;
+			}
+		}
+		outputLines.push(this.renderBaseItem(line, mainLineText, line.isBG));
+		if (bgLine) outputLines.push(this.renderBaseItem(bgLine, joinWords(bgLine.words), true));
+		const auxTexts = auxConfig.order === "translation-first" ? [transText, romaText] : [romaText, transText];
+		for (const auxText of auxTexts) if (auxText) outputLines.push(`${lineTimeTag}${auxText}`);
+		this.processEndTimestamp(line, nextLine, outputLines);
+	}
+	/**
+	* 渲染一行歌词，`lineText` 是已经处理过内联的整行文本
+	*/
+	renderBaseItem(item, lineText, isBgv) {
+		const { inlineBracket } = this.options;
+		const { wordLevel } = this.features;
+		if (wordLevel && isWordSyncLyric(item.words, item.startTime)) {
+			const words = item.words;
+			const leadingTimestamp = this.usesFirstWordStartTime ? words[0].startTime : item.startTime;
+			let output = this.formatTimeTag(leadingTimestamp, "square");
+			for (let i = 0; i < words.length; i++) {
+				const word = words[i];
+				if (i > 0 || !this.usesFirstWordStartTime) output += this.formatTimeTag(word.startTime, inlineBracket);
+				let wordText = word.word;
+				if (isBgv) {
+					if (i === 0) wordText = `(${wordText}`;
+					if (i === words.length - 1) wordText = `${wordText})`;
+				}
+				output += wordText;
+				if (i === words.length - 1) output += this.formatTimeTag(word.endTime, inlineBracket);
+			}
+			return output;
+		}
+		let output = `${this.formatTimeTag(item.startTime, "square")}${isBgv ? `(${lineText})` : lineText}`;
+		if (wordLevel) output += this.formatTimeTag(item.endTime, "square");
+		return output;
+	}
+	processEndTimestamp(line, nextLine, outputLines) {
+		const { mode: endTsMode, intervalGap: endTsGap } = this.options.endTimestamp;
+		if (this.features.wordLevel || endTsMode === "none") return;
+		const gap = nextLine ? nextLine.startTime - line.endTime : Infinity;
+		if (endTsMode === "always" || endTsMode === "interval" && gap >= endTsGap) outputLines.push(this.formatTimeTag(line.endTime, "square"));
+	}
+	/**
+	* 将毫秒渲染为时间戳
+	*
+	* 传入的时间都已由 {@link normalizeLine} 归一化过，这里再钳制到时间戳可表示的最大值，
+	* 保证写出来的时间戳都能被解析回来
+	*/
+	formatTimeTag(ms, bracket = "square") {
+		const content = formatTime(clampTimestamp(ms));
+		return bracket === "angle" ? `<${content}>` : `[${content}]`;
+	}
+};
+//#endregion
+//#region src/formats/lrc/parser.ts
+/**
+* 注释行的行首标记
+*
+* `#` 是 LRC 生态中常见的注释写法，`//` 则是 SPL 标准在示例里标注说明的写法，
+* 两者都没有被写进格式规范，这里一并按整行丢弃处理
+*/
+const COMMENT_PREFIXES = ["#", "//"];
+var LrcParser = class LrcParser {
+	mode;
+	/**
+	* 匹配行内所有的逐字时间戳
+	*
+	* 例如 `<05:21.22>` 或 `[05:23.22]`，`[00:13]` 这样省略毫秒段的写法同样算数，省略时视作 `0`。
+	* 秒与毫秒之间本应使用半角句号，这里也接受半角冒号，以兼容不规范的既有歌词文件
+	*/
+	static WORD_TIMESTAMP_REGEX = /(?:\[|<)(?<min>\d{1,3}):(?<sec>\d{1,2})(?:[:.](?<ms>\d{1,6}))?(?:\]|>)/g;
+	constructor(options) {
+		this.mode = options?.mode ?? "spl";
+	}
+	/**
+	* 解析 LRC 家族歌词
+	* @param text 歌词文本
+	* @returns 解析结果
+	*/
+	parse(text) {
+		const metadata = [];
+		const allParsedLines = [];
+		const state = {
+			lastMainLines: [],
+			mainLinesByStartTime: /* @__PURE__ */ new Map(),
+			translations: /* @__PURE__ */ new Map()
+		};
+		for (const rawLine of text.split(/\r?\n/)) {
+			const trimmedLine = rawLine.trim();
+			if (!trimmedLine) continue;
+			if (COMMENT_PREFIXES.some((prefix) => trimmedLine.startsWith(prefix))) continue;
+			const parsedMeta = parseLrcMetadataLine(trimmedLine);
+			if (parsedMeta) {
+				mergeMetadata(metadata, parsedMeta);
+				continue;
+			}
+			const tokens = this.tokenizeLine(trimmedLine);
+			if (tokens.every((t) => t.type === "text")) {
+				this.appendTranslation(trimmedLine, [], state);
 				continue;
 			}
-			const nextWordTimeStampIndex = lineStr.search(wordTimestampRegex);
-			const text = nextWordTimeStampIndex === -1 ? lineStr : lineStr.slice(0, nextWordTimeStampIndex);
-			lineItems.push(text);
-			lineStr = lineStr.slice(text.length);
+			const features = this.getLineFeatures(tokens);
+			if (features.text.trim() === "") {
+				this.appendExplicitEndTime(tokens, state.lastMainLines);
+				continue;
+			}
+			const newLines = features.isWordSync ? this.parseWordSyncLine(tokens, features, state) : this.parsePlainLines(tokens, features, state);
+			if (newLines.length > 0) {
+				this.applyBackgroundVocal(newLines, features.isBG);
+				allParsedLines.push(...newLines);
+				state.lastMainLines = newLines;
+				for (const line of newLines) if (!state.mainLinesByStartTime.has(line.startTime)) state.mainLinesByStartTime.set(line.startTime, line);
+			}
 		}
-		const words = [];
-		lineItems.forEach((item, index) => {
-			if (typeof item === "number") return;
-			const startTime = lineItems[index - 1] ?? lineStartTime;
-			const endTime = lineItems[index + 1] ?? startTime;
-			if (typeof startTime !== "number" || typeof endTime !== "number") return;
-			if (item.startsWith(" ") && words[words.length - 1]?.word.trim()) words.push(createWord({ word: " " }));
-			words.push(createWord({
-				word: item.trim(),
-				startTime,
-				endTime
-			}));
-			if (item.endsWith(" ")) words.push(createWord({ word: " " }));
+		return {
+			metadata,
+			lines: this.expandTranslations(this.finalizeLyricLines(allParsedLines), state.translations)
+		};
+	}
+	/**
+	* 语法分析器
+	*/
+	tokenizeLine(line) {
+		const tokens = [];
+		let lastIndex = 0;
+		for (const match of line.matchAll(LrcParser.WORD_TIMESTAMP_REGEX)) {
+			if (!match.groups) continue;
+			const matchIndex = match.index ?? 0;
+			const textBefore = line.substring(lastIndex, matchIndex);
+			if (textBefore) tokens.push({
+				type: "text",
+				val: textBefore
+			});
+			const time = parseTimestampParts(match.groups.min, match.groups.sec, match.groups.ms);
+			tokens.push({
+				type: "time",
+				val: time
+			});
+			lastIndex = matchIndex + match[0].length;
+		}
+		const textAfter = line.substring(lastIndex);
+		if (textAfter) tokens.push({
+			type: "text",
+			val: textAfter
 		});
-		const lineEndTime = words[words.length - 1]?.endTime ?? lineStartTime;
-		lyricLines.push(createLine({
-			startTime: lineStartTime,
-			endTime: lineEndTime,
-			words
+		return tokens;
+	}
+	getLineFeatures(tokens) {
+		const firstTextIndex = tokens.findIndex((t) => t.type === "text");
+		let isWordSync = false;
+		if (firstTextIndex > 0) {
+			for (let i = firstTextIndex + 1; i < tokens.length; i++) if (tokens[i].type === "time") {
+				isWordSync = true;
+				break;
+			}
+		}
+		const text = tokens.filter((t) => t.type === "text").map((t) => t.val).join("");
+		return {
+			firstTextIndex,
+			isWordSync,
+			isBG: isBackgroundVocalText(text),
+			text
+		};
+	}
+	/**
+	* 把整行被圆括号包裹的歌词行标记为背景人声，并去掉最外层的括号
+	*
+	* 与 YRC、QRC 的做法一致，只按整行是否被括号包裹判断。
+	* 多个背景人声行各自独立处理，不做归并或配对
+	* @param lines 已解析出来的歌词行
+	* @param isBG 该行是否为背景人声行
+	*/
+	applyBackgroundVocal(lines, isBG) {
+		if (!isBG) return;
+		for (const line of lines) {
+			line.isBG = true;
+			trimBackgroundVocalParentheses(line.words);
+		}
+	}
+	/**
+	* 尝试将一段文本记录为已出现过的某（组）歌词行的翻译
+	*
+	* 时间信息必须一致才会认为是翻译，否则视为独立的歌词行
+	* @returns 是否成功记录为翻译
+	*/
+	appendTranslation(text, baseTimes, state) {
+		if (text.trim() === "") return false;
+		const targets = baseTimes.length === 0 ? state.lastMainLines : this.matchLinesByTime(baseTimes, state.mainLinesByStartTime);
+		if (!targets || targets.length === 0) return false;
+		for (const line of targets) {
+			const texts = state.translations.get(line);
+			if (texts) texts.push(text);
+			else state.translations.set(line, [text]);
+		}
+		return true;
+	}
+	/**
+	* 按时间戳找出与之对应的歌词行
+	*
+	* 翻译行可以不紧挨着主歌词行，所以在全部已出现的主歌词行里按开始时间查找。
+	* 重复行写法的翻译需要每个时间戳都能找到宿主，只要有一个落空就不算翻译
+	* @returns 对应的歌词行，时间信息不一致时为 `null`
+	*/
+	matchLinesByTime(baseTimes, mainLinesByStartTime) {
+		const targets = [];
+		for (const baseTime of baseTimes) {
+			const line = mainLinesByStartTime.get(baseTime);
+			if (!line) return null;
+			targets.push(line);
+		}
+		return targets;
+	}
+	/**
+	* 将一行只有时间戳的歌词行作为上一（组）歌词行的显式结束时间
+	*
+	* 与行内写法 `文本[结束时间]` 一致，取该行最后一个时间戳作为结束时间。
+	* 上一（组）歌词行不存在、已经有结束时间，或该时间戳不晚于其开始时间时，整行被忽略
+	*
+	* 重复行写法（`[t1][t2]文本`）会产生多条内容相同的歌词行，
+	* 此时这个结束时间应该归属哪一条存在语义模糊：
+	* 给最早的一条会让组内各行的结束时间不一致，给所有行又会造成时间区间相互重叠，
+	* 格式本身没有说明哪种解读正确。这里选择只标记最后一条（即时间上最近一次出现）的行，
+	* 组内其余行仍交给后续的推导逻辑决定结束时间
+	*/
+	appendExplicitEndTime(tokens, lastMainLines) {
+		const lastTimeToken = tokens.findLast((token) => token.type === "time");
+		const lastLine = lastMainLines[lastMainLines.length - 1];
+		if (!lastTimeToken || !lastLine) return;
+		const endTime = lastTimeToken.val;
+		if (lastLine.endTime !== -1 || endTime <= lastLine.startTime) return;
+		lastLine.endTime = endTime;
+	}
+	parsePlainLines(tokens, features, state) {
+		const baseTimes = [];
+		const endIndex = features.firstTextIndex !== -1 ? features.firstTextIndex : tokens.length;
+		for (let i = 0; i < endIndex; i++) {
+			const token = tokens[i];
+			if (token.type === "time" && !baseTimes.includes(token.val)) baseTimes.push(token.val);
+		}
+		if (!features.isBG && this.appendTranslation(features.text, baseTimes, state)) return [];
+		return baseTimes.map((baseTime) => createLine({
+			startTime: baseTime,
+			endTime: -1,
+			words: [createWord({
+				word: features.text,
+				startTime: baseTime,
+				endTime: -1
+			})]
 		}));
 	}
-	return lyricLines;
+	parseWordSyncLine(tokens, features, state) {
+		const firstToken = tokens[0];
+		const delayToken = tokens[features.firstTextIndex - 1];
+		if (firstToken?.type !== "time" || delayToken?.type !== "time") return [];
+		const baseTime = firstToken.val;
+		if (!features.isBG && this.appendTranslation(features.text, [baseTime], state)) return [];
+		const syllableStartTimeInitial = delayToken.val;
+		let explicitEnd;
+		const syllables = [];
+		let currentText = "";
+		let syllableStartTime = syllableStartTimeInitial;
+		const pushSyllable = (text, start, end) => {
+			syllables.push(createWord({
+				word: text,
+				startTime: start,
+				endTime: end
+			}));
+		};
+		for (let i = features.firstTextIndex; i < tokens.length; i++) {
+			const tok = tokens[i];
+			if (tok.type === "text") currentText += tok.val;
+			else if (tok.type === "time") {
+				const nextTime = tok.val;
+				if (currentText !== "") {
+					pushSyllable(currentText, syllableStartTime, nextTime);
+					currentText = "";
+				}
+				syllableStartTime = nextTime;
+				if (i === tokens.length - 1) explicitEnd = nextTime;
+			}
+		}
+		if (currentText !== "") pushSyllable(currentText, syllableStartTime, -1);
+		return [createLine({
+			startTime: baseTime,
+			endTime: explicitEnd ?? -1,
+			words: isWordSyncLyric(syllables, baseTime) ? syllables : [createWord({
+				word: features.text,
+				startTime: baseTime,
+				endTime: -1
+			})]
+		})];
+	}
+	finalizeLyricLines(allParsedLines) {
+		allParsedLines.sort((a, b) => a.startTime - b.startTime);
+		this.resolveEndTimes(allParsedLines);
+		if (!LRC_MODE_FEATURES[this.mode].wordLevel) this.stripWordTimings(allParsedLines);
+		return allParsedLines;
+	}
+	/**
+	* 决定所有尚未推导的时间，逐行歌词取下一行的开始时间，逐字歌词还会收尾最后一个音节
+	*/
+	resolveEndTimes(allParsedLines) {
+		for (let i = 0; i < allParsedLines.length; i++) {
+			const line = allParsedLines[i];
+			const isLastLine = i === allParsedLines.length - 1;
+			if (line.endTime === -1) {
+				if (isLastLine && !isWordSyncLyric(line.words, line.startTime)) line.endTime = MAX_LRC_TIMESTAMP;
+				else if (!isLastLine) line.endTime = allParsedLines[i + 1].startTime;
+			}
+			const words = line.words;
+			if (words.length > 0) for (let j = 0; j < words.length; j++) {
+				const word = words[j];
+				if (word.endTime !== -1) continue;
+				if (j + 1 < words.length) word.endTime = words[j + 1].startTime;
+				else if (isLastLine && line.endTime === -1) {
+					word.endTime = word.startTime + 1e3;
+					line.endTime = word.endTime;
+				} else word.endTime = line.endTime;
+			}
+		}
+	}
+	/**
+	* 普通 LRC 模式丢弃逐字时间戳，只留下覆盖整行的单个音节
+	*/
+	stripWordTimings(allParsedLines) {
+		for (const line of allParsedLines) {
+			if (line.words.length <= 1) continue;
+			line.words = [createWord({
+				word: joinWords(line.words),
+				startTime: line.startTime,
+				endTime: line.endTime
+			})];
+		}
+	}
+	/**
+	* 将翻译展开成与主歌词行同时开始、同时结束的独立歌词行
+	*/
+	expandTranslations(lines, translations) {
+		if (translations.size === 0) return lines;
+		const result = [];
+		for (const line of lines) {
+			result.push(line);
+			for (const text of translations.get(line) ?? []) result.push(createLine({
+				startTime: line.startTime,
+				endTime: line.endTime,
+				words: [createWord({
+					word: text,
+					startTime: line.startTime,
+					endTime: line.endTime
+				})]
+			}));
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/formats/lrc/index.ts
+/**
+* 解析任意 LRC 家族歌词，包括普通 LRC、增强型 LRC、ESLyric 逐词歌词与 Salt Player Lyrics
+*
+* 因为 Salt Player Lyrics 是其余格式的超集，所以一个接口即可解析全部种类
+*
+* 同一时间可能出现多条歌词行（例如翻译与音译），
+* 本接口不做多语言适配，由使用者自行决定如何使用这些时间相同的歌词行
+*
+* @param text 歌词文本
+* @param options 解析选项
+* @returns 解析出来的歌词与元数据
+*/
+function parseLrcLike(text, options) {
+	return new LrcParser(options).parse(text);
+}
+/**
+* 生成 LRC 家族歌词
+* @param input 歌词行，或带元数据的解析结果
+* @param options 生成选项
+* @returns 歌词文本
+*/
+function stringifyLrcLike(input, options) {
+	return new LrcGenerator(options).generate(input);
 }
 /**
-* 将歌词数组转换为 LRC A2 格式的字符串
+* 解析 LyRiC 格式的歌词字符串
+* @param lrc 歌词字符串
+* @returns 成功解析出来的歌词
+*/
+function parseLrc(lrc) {
+	return parseLrcLike(lrc).lines;
+}
+/**
+* 解析 ESLyric 逐词歌词格式的歌词字符串
+* @param eslrc 歌词字符串
+* @returns 成功解析出来的歌词
+*/
+function parseEslrc(eslrc) {
+	return parseLrcLike(eslrc).lines;
+}
+/**
+* 解析 LRC A2（增强 LRC）格式的歌词字符串
+* @param lrc 歌词字符串
+* @returns 成功解析出来的歌词
+*/
+function parseLrcA2(lrc) {
+	return parseLrcLike(lrc).lines;
+}
+/**
+* 解析 SPL（Salt Player Lyrics）格式的歌词字符串
+*
+* 上述几种格式都语出同源，本接口只是以 SPL 之名调用同一套解析算法
+* @param spl 歌词字符串
+* @returns 成功解析出来的歌词
+*/
+function parseSPL(spl) {
+	return parseLrcLike(spl).lines;
+}
+/**
+* 将歌词数组转换为 LyRiC 格式的字符串
+* @param lines 歌词数组
+* @returns LyRiC 格式的字符串
+*/
+function stringifyLrc(lines) {
+	return stringifyLrcLike(lines, { mode: "plain" });
+}
+/**
+* 将歌词数组转换为 ESLyric 逐词歌词格式的字符串
+*
+* ESLyric 的逐词语法为「文本后跟该词的结束时间」，行首时间戳即首个词的开始时间，
+* 因此不写行自身的时间戳，行首时间戳直接取首个词的开始时间
+* @param lines 歌词数组
+* @returns ESLyric 逐词歌词格式的字符串
+*/
+function stringifyEslrc(lines) {
+	return stringifyLrcLike(lines, {
+		mode: "spl",
+		inlineBracket: "square"
+	});
+}
+/**
+* 将歌词数组转换为 LRC A2（增强 LRC）格式的字符串
 * @param lines 歌词数组
 * @returns LRC A2 格式的字符串
 */
 function stringifyLrcA2(lines) {
-	return lines.map((line) => {
-		const normalizedLineStartTime = normalizeTimestamp(line.startTime);
-		if (line.words.length === 0) return `[${formatTime(normalizedLineStartTime)}]`;
-		const normalizedWords = [];
-		line.words.forEach((w) => {
-			if (!w.word.trim() && normalizedWords.length) {
-				normalizedWords[normalizedWords.length - 1].word += w.word;
-				return;
-			}
-			normalizedWords.push({
-				word: w.word,
-				startTime: normalizeTimestamp(w.startTime),
-				endTime: normalizeTimestamp(w.endTime)
-			});
-		});
-		const lineItems = normalizedWords.flatMap((w) => [w.startTime, w.word]);
-		lineItems.push(normalizedWords[normalizedWords.length - 1].endTime);
-		return `[${formatTime(normalizedLineStartTime)}]` + lineItems.map((item) => typeof item === "number" ? `<${formatTime(item)}>` : item).join("");
-	}).join("\n");
+	return stringifyLrcLike(lines, {
+		mode: "spl",
+		inlineBracket: "angle"
+	});
+}
+/**
+* 生成 SPL（Salt Player Lyrics）格式的歌词字符串
+*
+* SPL 与增强型 LRC 的生成行为一致，逐字时间戳同样使用尖括号，
+* 因此本接口与 {@link stringifyLrcA2} 的输出完全相同
+* @param input 歌词行，或带元数据的解析结果
+* @returns SPL 格式的字符串
+*/
+function stringifySPL(input) {
+	return stringifyLrcLike(input, {
+		mode: "spl",
+		inlineBracket: "angle"
+	});
 }
 //#endregion
 //#region src/formats/lyl.ts
@@ -1833,7 +2324,8 @@ function parseQrc(qrc) {
 function stringifyQrc(lines) {
 	return lines.map((line) => {
 		const lineStart = normalizeTimestamp(line.startTime);
-		const lineDuration = normalizeDuration(normalizeTimestamp(line.endTime) - lineStart);
+		const lineEnd = normalizeTimestamp(line.endTime);
+		const lineDuration = normalizeDuration(lineEnd - lineStart);
 		const lineWords = [];
 		for (const [index, { word, startTime, endTime }] of line.words.entries()) {
 			if (!word.trim() && lineWords.length) {
@@ -1846,7 +2338,8 @@ function stringifyQrc(lines) {
 				if (index === line.words.length - 1) printedWord += "）";
 			}
 			const normalizedWordStart = normalizeTimestamp(startTime);
-			const wordDuration = normalizeDuration(normalizeTimestamp(endTime) - normalizedWordStart);
+			const normalizedWordEnd = normalizeTimestamp(endTime);
+			const wordDuration = normalizeDuration(normalizedWordEnd - normalizedWordStart);
 			lineWords.push(`${printedWord}(${normalizedWordStart},${wordDuration})`);
 		}
 		return `[${lineStart},${lineDuration}]${lineWords.join("")}`;
@@ -1939,7 +2432,8 @@ function makeParenthesesFull(text) {
 function stringifyYrc(lines) {
 	return lines.map((line) => {
 		const lineStart = normalizeTimestamp(line.startTime);
-		const lineDuration = normalizeDuration(normalizeTimestamp(line.endTime) - lineStart);
+		const lineEnd = normalizeTimestamp(line.endTime);
+		const lineDuration = normalizeDuration(lineEnd - lineStart);
 		const lineWords = [];
 		for (const [index, { word, startTime, endTime }] of line.words.entries()) {
 			if (!word.trim() && lineWords.length) {
@@ -1952,7 +2446,8 @@ function stringifyYrc(lines) {
 				if (index === line.words.length - 1) printedWord += "）";
 			}
 			const normalizedWordStart = normalizeTimestamp(startTime);
-			const wordDuration = normalizeDuration(normalizeTimestamp(endTime) - normalizedWordStart);
+			const normalizedWordEnd = normalizeTimestamp(endTime);
+			const wordDuration = normalizeDuration(normalizedWordEnd - normalizedWordStart);
 			lineWords.push(`(${normalizedWordStart},${wordDuration},0)${printedWord}`);
 		}
 		return `[${lineStart},${lineDuration}]${lineWords.join("")}`;
@@ -1975,9 +2470,11 @@ exports.parseEslrc = parseEslrc;
 exports.parseLqe = parseLqe;
 exports.parseLrc = parseLrc;
 exports.parseLrcA2 = parseLrcA2;
+exports.parseLrcLike = parseLrcLike;
 exports.parseLyl = parseLyl;
 exports.parseLys = parseLys;
 exports.parseQrc = parseQrc;
+exports.parseSPL = parseSPL;
 exports.parseTTML = parseTTML;
 exports.parseYrc = parseYrc;
 exports.stringifyAss = stringifyAss;
@@ -1985,9 +2482,11 @@ exports.stringifyEslrc = stringifyEslrc;
 exports.stringifyLqe = stringifyLqe;
 exports.stringifyLrc = stringifyLrc;
 exports.stringifyLrcA2 = stringifyLrcA2;
+exports.stringifyLrcLike = stringifyLrcLike;
 exports.stringifyLyl = stringifyLyl;
 exports.stringifyLys = stringifyLys;
 exports.stringifyQrc = stringifyQrc;
+exports.stringifySPL = stringifySPL;
 exports.stringifyTTML = stringifyTTML;
 exports.stringifyYrc = stringifyYrc;
 exports.stringifylrcA2 = stringifylrcA2;