@gondola-lyrics/kit 0.4.0 → 0.6.0

package/dist/formats.js

@@ -1,109 +1,593 @@
-import { AgentType, CreditRole, LineType, LyricStatus, Timing, WordType, canonicalizeLyric, deriveLanguageUsages, getWordsText, makeAgent, makeLineAnnotation, makeLineAnnotationRoman, makeLineAnnotationTranslation, makeLineBackground, makeLineContentText, makeLineContentWords, makeLineInstrumental, makeLineNormal, makeLyric, makeMeta, makeMetaCredit, makeText, makeTimeRange, makeUnknownEntry, makeWordAnnotation, makeWordAnnotationRuby, makeWordAnnotationToken, makeWordNormal, makeWordSpace, removeOffset, resolveAnnotationItemTime, resolveAnnotationTokenTime, validateLyric } from "@gondola-lyrics/model/runtime";
-//#region src/utils/annotation.ts
+import { a as lowerBound, i as lowerTag, o as mapShared, r as trimRuleWhitespace } from "./rules.js";
+import { AgentType, CreditRole, LineType, LyricStatus, Timing, WordType, canonicalizeLyric, deriveLanguageUsages, deriveLineRomans, getAnnotationItemText, getContentText, getWordsText, isWordLevelLine, makeAgent, makeLineAnnotation, makeLineAnnotationRoman, makeLineAnnotationTranslation, makeLineBackground, makeLineContentText, makeLineContentWords, makeLineInstrumental, makeLineNormal, makeLyric, makeMeta, makeMetaCredit, makeText, makeTimeRange, makeUnknownEntry, makeWordAnnotation, makeWordAnnotationRoman, makeWordAnnotationRuby, makeWordAnnotationToken, makeWordNormal, makeWordSpace, removeOffset, resolveAnnotationItemTime, resolveAnnotationTokenTime, validateLyric } from "@gondola-lyrics/model/runtime";
+//#region src/formats/krc/common.ts
+var LINE_PATTERN$3 = /^\[(\d+),(\d+)\]/;
+var WORD_PATTERN$3 = /<(\d+,\d+,\d+)>/g;
 /**
-* An annotation line carries its text in either field, depending on whether the track used word tags.
+* Reads decrypted plaintext without unwrapping XML or accepting auxiliary tracks.
+*
+* @returns Original content, or null when the input cannot be read as plaintext KRC.
 */
-var readText$1 = (line) => {
-	return (line.content?.text ?? getWordsText(line.content?.words ?? [])).trim();
+var readKrcContent = (input) => {
+	const source = typeof input === "string" ? { original: input } : input;
+	if (!source || typeof source !== "object" || Array.isArray(source)) return null;
+	const original = source.original;
+	if (typeof original !== "string" || /^\s*</.test(original)) return null;
+	return { original };
 };
-var isReadable = (line) => {
-	return line.time?.start !== void 0 && readText$1(line) !== "";
+//#endregion
+//#region src/formats/krc/detect.ts
+var LANGUAGE_PATTERN = /\[language:\s*ey[A-Za-z0-9+/=]*\]/;
+/**
+* Recognizes native KRC from a duration line carrying a complete three-field word tag, or from the Kugou language container.
+*
+* Both signals live in the original plaintext, so an auxiliary track still cannot decide the format.
+*
+* @returns Whether the original plaintext contains a strong KRC syntax signal.
+*/
+var detectKrc = (input) => {
+	const source = readKrcContent(input);
+	if (!source) return false;
+	if (LANGUAGE_PATTERN.test(source.original)) return true;
+	return source.original.split(/\r\n?|\n/).some((raw) => {
+		const line = raw.trimStart();
+		const header = LINE_PATTERN$3.exec(line);
+		return !!header && /<\d+,\d+,\d+>/.test(line.slice(header[0].length));
+	});
 };
+//#endregion
+//#region src/formats/result.ts
 /**
-* Assigns each annotation line to a lyric line index.
+* Canonicalizes and validates one parser's output, so every format hands back the same shape.
+*
+* Canonicalization runs first because validation reports paths against the canonical tree.
+*/
+var finalizeLyric = (input) => {
+	const lyric = canonicalizeLyric(input);
+	return {
+		lyric,
+		diagnostics: validateLyric(lyric)
+	};
+};
+//#endregion
+//#region src/utils/kana.ts
+var KANA_COMBINATIONS = /* @__PURE__ */ new Map([
+	[12353, "うくぐつふゔ"],
+	[12355, "うくぐすずつてでふゔ"],
+	[12357, "とど"],
+	[12359, "いうくぐしじちぢつにひびぴみりふゔ"],
+	[12361, "うくぐつふゔ"],
+	[12419, "きぎしじちぢにひびぴみり"],
+	[12421, "きぎしじちぢにひびぴみりてでふゔ"],
+	[12423, "きぎしじちぢにひびぴみり"],
+	[12430, "くぐ"]
+]);
+var readKana = (text) => {
+	const kana = text.normalize("NFKC");
+	if (kana.length !== 1) return "";
+	const code = kana.charCodeAt(0);
+	return code >= 12449 && code <= 12534 ? String.fromCharCode(code - 96) : kana;
+};
+/**
+* Reports whether the second kana joins the first into one mora, so a single roman fragment may cover both.
 *
-* Exact matches claim their lines first, so a fuzzy match never takes a line an exact one needed.
-* The remaining annotations take the nearest unclaimed line within the tolerance, and ties keep the earlier line.
+* Katakana and compatibility forms normalize to hiragana first.
+* Doubled consonants, long-vowel marks and three-kana runs are not combinations.
 */
-var matchEntries = (lines, annotations, tolerance) => {
+var combinesKana = (first, second) => {
+	const base = readKana(first);
+	const small = readKana(second);
+	return !!base && !!small && !!KANA_COMBINATIONS.get(small.charCodeAt(0))?.includes(base);
+};
+//#endregion
+//#region src/utils/annotation.ts
+var readText$3 = (line) => {
+	return getContentText(line.content).trim();
+};
+/**
+* Combines explicit roman tracks with display-only word aggregations, preferring explicit entries for the same language.
+*
+* Derived entries must not be stored back on the line.
+*/
+var getLineRomans = (line) => {
+	const explicit = line.annotation?.romans ?? [];
+	const languages = new Set(explicit.map((item) => lowerTag(item.language)));
+	const derived = deriveLineRomans(line.content).filter((item) => !languages.has(lowerTag(item.language)));
+	return derived.length ? [...explicit, ...derived] : explicit;
+};
+var readWordRange = (word) => {
+	const time = word.time;
+	if (!time || !Number.isSafeInteger(time.start) || time.start < 0 || time.end !== void 0 && (!Number.isSafeInteger(time.end) || time.end < time.start)) return;
+	return time;
+};
+var containsRomanTime = (source, target, tolerance) => {
+	const end = target.end ?? Number.POSITIVE_INFINITY;
+	if (source.start < target.start - tolerance || source.end !== void 0 && source.end > end + tolerance) return false;
+	if (source.end === void 0 || source.start === source.end) return target.start === target.end ? source.start <= end + tolerance : source.start < end + tolerance;
+	return true;
+};
+var matchRomanTarget = (time, targets, tolerance) => {
+	let matched;
+	let priority = -1;
+	for (const target of targets) {
+		if (!containsRomanTime(time, target.time, tolerance)) continue;
+		const exact = time.end !== void 0 && time.start === target.time.start && time.end === target.time.end;
+		const point = time.start === time.end && target.time.start === target.time.end;
+		const rank = exact ? 3 : point ? 2 : containsRomanTime(time, target.time, 0) ? 1 : 0;
+		if (rank > priority) {
+			matched = target;
+			priority = rank;
+		} else if (rank === priority) matched = void 0;
+	}
+	return matched ?? (priority === -1 ? void 0 : null);
+};
+var overlapLength = (time, target) => {
+	const finish = time.end ?? time.start;
+	return Math.min(finish, target.time.end ?? Number.POSITIVE_INFINITY) - Math.max(time.start, target.time.start);
+};
+var sharesLanguage = (targets) => {
+	return new Set(targets.flatMap((target) => target ? [lowerTag(target.word.language)] : []).filter(Boolean)).size <= 1;
+};
+var isOrderedByTime = (targets) => {
+	return targets.every((target, index) => {
+		return target.time.start >= (targets[index - 1]?.time.start ?? 0);
+	});
+};
+var canExtendToFollowing = (target, following) => {
+	const first = lowerTag(target.word.language);
+	const second = lowerTag(following.word.language);
+	return (!first || !second || first === second) && combinesKana(target.word.text, following.word.text);
+};
+var recoverRomanTargets = (sources, targets, tolerance, rounding, language) => {
+	const slack = Math.max(tolerance, rounding);
+	const used = new Set(sources.flatMap((source) => source.target ? [source.target] : []));
+	const reserved = /* @__PURE__ */ new Set();
+	const conflict = (target) => {
+		return target.word.annotation?.romans.some((item) => lowerTag(item.language) === language);
+	};
+	for (const [index, source] of sources.entries()) {
+		const time = source.time;
+		if (source.target || !time || time.end === void 0) continue;
+		const exact = targets.filter((target) => target.time.start === time.start);
+		const candidates = exact.length ? exact : targets.filter((target) => Math.abs(target.time.start - time.start) <= rounding);
+		if (candidates.length !== 1) continue;
+		const target = candidates[0];
+		const following = targets[targets.indexOf(target) + 1];
+		if (!following || following.index !== target.index + 1 || !canExtendToFollowing(target, following)) continue;
+		if (used.has(target) || used.has(following) || reserved.has(target) || reserved.has(following)) continue;
+		if (conflict(target) || following.word.annotation?.romans.length) continue;
+		const previous = sources.slice(0, index).findLast((item) => item.target)?.target;
+		const next = sources.slice(index + 1).find((item) => item.target)?.target;
+		if (target.index <= (previous?.index ?? -1) || following.index >= (next?.index ?? Number.POSITIVE_INFINITY)) continue;
+		if (target.time.start < (previous?.time.start ?? 0) || following.time.start > (next?.time.start ?? Number.POSITIVE_INFINITY)) continue;
+		if (!sharesLanguage([
+			previous,
+			target,
+			following,
+			next
+		])) continue;
+		if (target.time.end === void 0 || following.time.end === void 0 || Math.abs(following.time.start - target.time.end) > rounding) continue;
+		if (time.end <= target.time.end || time.end > following.time.end + slack) continue;
+		if (targets.some((candidate) => candidate !== target && candidate !== following && overlapLength(time, candidate) > slack)) continue;
+		source.target = target;
+		used.add(target);
+		reserved.add(following);
+	}
+	for (let start = 0; start < sources.length; start += 1) {
+		if (sources[start].target) continue;
+		let end = start + 1;
+		while (end < sources.length && !sources[end].target) end += 1;
+		const previous = sources[start - 1]?.target;
+		const next = sources[end]?.target;
+		const pending = targets.filter((target) => {
+			return target.index > (previous?.index ?? -1) && target.index < (next?.index ?? Number.POSITIVE_INFINITY) && !reserved.has(target);
+		});
+		if (pending.length !== end - start) return false;
+		if (sources.slice(start, end).some((source) => !source.time) && pending.length > 1 && (!previous || !next)) return false;
+		const boundaries = [
+			previous,
+			...pending,
+			next
+		].filter((target) => target !== void 0);
+		if (!sharesLanguage(boundaries) || !isOrderedByTime(boundaries)) return false;
+		for (const [offset, target] of pending.entries()) {
+			const source = sources[start + offset];
+			if (used.has(target) || conflict(target)) return false;
+			const time = source.time;
+			if (time && (overlapLength(time, target) <= 0 || targets.some((candidate) => candidate !== target && overlapLength(time, candidate) > slack))) return false;
+			source.target = target;
+			used.add(target);
+		}
+		start = end - 1;
+	}
+	return true;
+};
+var readRomanLanguage = (source) => {
+	const languages = new Set(source.languages.map(lowerTag).filter(Boolean));
+	for (const word of source.content?.words ?? []) {
+		const language = word.type === WordType.NORMAL ? lowerTag(word.language) : void 0;
+		if (language) languages.add(language);
+	}
+	return {
+		language: languages.size === 1 ? languages.values().next().value : lowerTag(source.languages[0]),
+		consistent: languages.size <= 1
+	};
+};
+var attachWordRomans = (line, source, tolerance, language, fallback) => {
+	const content = line.content;
+	const sourceContent = source.line.content;
+	if (!content?.words.length || content.text !== void 0 || !sourceContent?.words.length || sourceContent.text !== void 0) return;
+	const targets = [];
+	let spaces = 0;
+	for (const [index, word] of content.words.entries()) {
+		if (word.type === WordType.SPACE) {
+			spaces += 1;
+			continue;
+		}
+		const time = readWordRange(word);
+		if (word.type !== WordType.NORMAL || !time) return;
+		targets.push({
+			word,
+			index,
+			time,
+			spaces,
+			tokens: []
+		});
+	}
+	const sources = [];
+	let separator = "";
+	for (const word of sourceContent.words) {
+		if (word.type === WordType.SPACE) {
+			separator += word.text;
+			continue;
+		}
+		const time = readWordRange(word);
+		if (word.type !== WordType.NORMAL || !word.text.trim() || word.time && !time || !time && !fallback) return;
+		const target = time ? matchRomanTarget(time, targets, tolerance) : void 0;
+		if (target === null || !target && !fallback) return;
+		sources.push({
+			word,
+			time,
+			separator,
+			target
+		});
+		separator = "";
+	}
+	const anchors = sources.flatMap((source) => source.target ? [source.target] : []);
+	if (anchors.some((target, index) => target.index < (anchors[index - 1]?.index ?? -1))) return;
+	const recovered = fallback && sources.some((item) => !item.target);
+	if (recovered && !recoverRomanTargets(sources, targets, tolerance, source.rounding, language)) return;
+	let previous;
+	let previousStart = 0;
+	for (const { word, time, separator, target } of sources) {
+		if (!target || target.index < (previous?.index ?? -1) || target.word.annotation?.romans.some((item) => lowerTag(item.language) === language)) return;
+		const bound = target.time.end ?? Number.POSITIVE_INFINITY;
+		const start = time ? Math.min(bound, Math.max(target.time.start, time.start)) : target.time.start;
+		const end = time?.end === void 0 ? target.time.end : Math.min(bound, Math.max(target.time.start, time.end));
+		if (recovered && start < previousStart) return;
+		previousStart = start;
+		const token = makeWordAnnotationToken({
+			text: previous ? word.text : word.text.trimStart(),
+			time: {
+				start,
+				end
+			}
+		});
+		if (previous) {
+			const last = previous.tokens.at(-1);
+			if (target.spaces > previous.spaces) {
+				const space = separator.indexOf(" ");
+				if (space === -1) return;
+				last.text += separator.slice(0, space);
+				token.text = separator.slice(space + 1) + token.text;
+			} else last.text += separator;
+		}
+		target.tokens.push(token);
+		previous = target;
+	}
+	if (!previous) return;
+	const last = previous.tokens.at(-1);
+	last.text = last.text.trimEnd();
+	const words = content.words.slice();
+	for (const { word, index, tokens } of targets) {
+		if (!tokens.length) continue;
+		const roman = makeWordAnnotationRoman({
+			language,
+			tokens
+		});
+		words[index] = {
+			...word,
+			annotation: makeWordAnnotation({
+				...word.annotation,
+				romans: [...word.annotation?.romans ?? [], roman]
+			})
+		};
+	}
+	const result = {
+		...line,
+		content: {
+			...content,
+			words
+		}
+	};
+	return deriveLineRomans(result.content).find((item) => lowerTag(item.language) === language)?.text === source.text ? result : void 0;
+};
+var readSources = (lines, options) => {
+	const result = [];
+	const preserve = options.preservePlaceholders;
+	for (const [index, line] of lines.entries()) {
+		const start = line.time?.start;
+		const text = readText$3(line);
+		const timing = options.getTiming?.(line);
+		const precision = timing?.precision;
+		if (start !== void 0 && (preserve || text) || options.matchByOrder && text) result.push({
+			line,
+			index,
+			text,
+			start,
+			precision: precision && Number.isFinite(precision) && precision > 0 ? precision : 1,
+			rounding: timing?.rounding === 1 ? 1 : 0
+		});
+	}
+	return result;
+};
+var createTimeIndex = (lines, options) => {
+	const starts = [];
+	const lyricRows = [];
+	const targets = /* @__PURE__ */ new Map();
+	for (const [index, line] of lines.entries()) {
+		const start = line.time?.start;
+		const valid = start !== void 0 && (!options.preservePlaceholders || Number.isFinite(start));
+		starts.push(valid ? start : void 0);
+		if (options.matchByOrder && line.type === LineType.NORMAL && readText$3(line)) lyricRows.push(index);
+		if (!valid) continue;
+		const queue = targets.get(start) ?? [];
+		queue.push(index);
+		targets.set(start, queue);
+	}
+	return {
+		starts,
+		lyricRows,
+		targets,
+		buckets: /* @__PURE__ */ new Map()
+	};
+};
+var getTimeBuckets = (index, precision) => {
+	const cached = index.buckets.get(precision);
+	if (cached) return cached;
+	const buckets = /* @__PURE__ */ new Map();
+	for (const [target, start] of index.starts.entries()) {
+		if (start === void 0 || !Number.isFinite(start)) continue;
+		const key = Math.floor(start / precision);
+		let bucket = buckets.get(key);
+		if (!bucket) {
+			bucket = {
+				start,
+				indices: [],
+				mixed: false
+			};
+			buckets.set(key, bucket);
+		}
+		bucket.indices.push(target);
+		bucket.mixed ||= bucket.start !== start;
+	}
+	index.buckets.set(precision, buckets);
+	return buckets;
+};
+var matchDuplicates = (start, count, index, groups) => {
+	const result = [];
+	const collect = (precision, key, roundingOnly) => {
+		const queue = groups.get(precision)?.get(key);
+		if (!queue) return true;
+		const bucket = getTimeBuckets(index, precision).get(key);
+		if (bucket && (bucket.mixed || bucket.start !== start)) return roundingOnly && queue.every((source) => source.rounding !== 1);
+		for (const source of queue) {
+			const sourceStart = source.start;
+			const rounded = source.rounding === 1;
+			if (roundingOnly && !rounded) continue;
+			if (rounded && (sourceStart - 1 !== start && index.targets.has(sourceStart - 1) || sourceStart + 1 !== start && index.targets.has(sourceStart + 1))) return false;
+			result.push(source);
+			if (result.length > count) return false;
+		}
+		return true;
+	};
+	for (const precision of groups.keys()) if (!collect(precision, Math.floor(start / precision), false)) return;
+	for (const neighbor of [start - 1, start + 1]) if (neighbor !== start && !collect(1, Math.floor(neighbor), true)) return;
+	return result;
+};
+var matchAnnotations = (index, sources, options) => {
 	const matched = /* @__PURE__ */ new Map();
-	if (annotations.length === 0) return matched;
-	const starts = lines.map((line) => line.time?.start);
-	const queues = /* @__PURE__ */ new Map();
-	for (const [index, start] of starts.entries()) {
-		if (start === void 0) continue;
-		const queue = queues.get(start);
-		if (queue) queue.push(index);
-		else queues.set(start, [index]);
+	if (!sources.length) return matched;
+	const preserve = options.preservePlaceholders;
+	const byStart = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const start = source.start;
+		if (start === void 0 || preserve && !Number.isFinite(start)) continue;
+		const queue = byStart.get(start) ?? [];
+		queue.push(source);
+		byStart.set(start, queue);
 	}
-	const used = /* @__PURE__ */ new Set();
-	const pending = [];
-	for (const annotation of annotations) {
-		const start = annotation.time?.start;
-		if (start === void 0) continue;
-		const index = queues.get(start)?.shift();
-		if (index === void 0) {
-			pending.push(annotation);
+	const usedSources = /* @__PURE__ */ new Set();
+	const ambiguous = /* @__PURE__ */ new Set();
+	const assign = (target, source) => {
+		matched.set(target, source);
+		usedSources.add(source);
+	};
+	for (const [start, queue] of index.targets) {
+		const candidates = byStart.get(start);
+		if (!candidates) continue;
+		if (queue.length > 1) {
+			if (!preserve || candidates.length === queue.length) {
+				const count = Math.min(queue.length, candidates.length);
+				for (let position = 0; position < count; position += 1) assign(queue[position], candidates[position]);
+			}
 			continue;
 		}
-		matched.set(index, annotation);
-		used.add(index);
+		let source = candidates[0];
+		for (const candidate of candidates) if (candidate.precision < source.precision) source = candidate;
+		assign(queue[0], source);
 	}
-	if (tolerance <= 0) return matched;
-	for (const annotation of pending) {
-		const start = annotation.time?.start;
-		if (start === void 0) continue;
+	if (usedSources.size === sources.length) return matched;
+	const readable = options.matchByOrder ? sources.filter((source) => source.text) : [];
+	if (readable.length && readable.length === index.lyricRows.length) {
+		if (readable.every((source, position) => {
+			const target = index.lyricRows[position];
+			return !matched.has(target) && !usedSources.has(source) || matched.get(target) === source;
+		})) {
+			for (const [position, source] of readable.entries()) if (!usedSources.has(source)) assign(index.lyricRows[position], source);
+			return matched;
+		}
+	}
+	if (preserve || options.getTiming) {
+		const groups = /* @__PURE__ */ new Map();
+		for (const source of sources) {
+			const start = source.start;
+			if (usedSources.has(source) || start === void 0 || !Number.isFinite(start)) continue;
+			const precision = source.precision;
+			let group = groups.get(precision);
+			if (!group) {
+				group = /* @__PURE__ */ new Map();
+				groups.set(precision, group);
+			}
+			const key = Math.floor(start / precision);
+			const queue = group.get(key) ?? [];
+			queue.push(source);
+			group.set(key, queue);
+		}
+		for (const [start, queue] of index.targets) {
+			if (queue.length < 2 || matched.has(queue[0])) continue;
+			const candidates = matchDuplicates(start, queue.length, index, groups);
+			if (!candidates || candidates.length !== queue.length) continue;
+			candidates.sort((first, second) => first.index - second.index);
+			for (const [position, source] of candidates.entries()) assign(queue[position], source);
+		}
+		for (const precision of [...groups.keys()].sort((first, second) => first - second)) {
+			const candidates = getTimeBuckets(index, precision);
+			for (const [key, entries] of groups.get(precision)) {
+				const bucket = candidates.get(key);
+				if (!bucket) continue;
+				const sourceQueue = entries.filter((source) => !usedSources.has(source));
+				const targetQueue = bucket.indices.filter((target) => !matched.has(target));
+				if (!sourceQueue.length || !targetQueue.length) continue;
+				if ((precision > 1 || targetQueue.length > 1) && sourceQueue.length !== targetQueue.length) {
+					for (const source of sourceQueue) ambiguous.add(source);
+					continue;
+				}
+				const count = Math.min(sourceQueue.length, targetQueue.length);
+				for (let position = 0; position < count; position += 1) assign(targetQueue[position], sourceQueue[position]);
+			}
+		}
+		const rounding = /* @__PURE__ */ new Map();
+		const claims = /* @__PURE__ */ new Map();
+		for (const source of sources) {
+			const start = source.start;
+			if (source.rounding !== 1 || usedSources.has(source) || ambiguous.has(source) || start === void 0 || !Number.isFinite(start)) continue;
+			let target = -1;
+			let count = 0;
+			for (const neighbor of [start - 1, start + 1]) for (const candidate of index.targets.get(neighbor) ?? []) {
+				if (matched.has(candidate)) continue;
+				target = candidate;
+				count += 1;
+				claims.set(candidate, (claims.get(candidate) ?? 0) + 1);
+			}
+			if (count === 1) rounding.set(source, target);
+			else if (count > 1) ambiguous.add(source);
+		}
+		for (const [source, target] of rounding) if (claims.get(target) === 1) assign(target, source);
+		else ambiguous.add(source);
+	}
+	const tolerance = options.tolerance ?? 0;
+	if (!Number.isFinite(tolerance) || tolerance <= 0) return matched;
+	const ordered = index.ordered ??= [...index.targets.keys()].filter(Number.isFinite).sort((first, second) => first - second);
+	const cursors = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const start = source.start;
+		if (usedSources.has(source) || ambiguous.has(source) || start === void 0 || !Number.isFinite(start)) continue;
 		let target = -1;
 		let distance = Number.POSITIVE_INFINITY;
-		for (const [index, lineStart] of starts.entries()) {
-			if (lineStart === void 0 || used.has(index)) continue;
-			const current = Math.abs(lineStart - start);
-			if (current <= tolerance && current < distance) {
-				target = index;
+		const end = start + tolerance;
+		for (let position = lowerBound(ordered, start - tolerance); position < ordered.length && ordered[position] <= end; position += 1) {
+			const targetStart = ordered[position];
+			const current = Math.abs(targetStart - start);
+			if (current > tolerance || current > distance) continue;
+			const queue = index.targets.get(targetStart);
+			let cursor = cursors.get(targetStart) ?? 0;
+			while (cursor < queue.length && matched.has(queue[cursor])) cursor += 1;
+			cursors.set(targetStart, cursor);
+			const candidate = queue[cursor];
+			if (candidate !== void 0 && (current < distance || current === distance && candidate < target)) {
+				target = candidate;
 				distance = current;
 			}
 		}
-		if (target !== -1) {
-			matched.set(target, annotation);
-			used.add(target);
-		}
+		if (target !== -1) assign(target, source);
 	}
 	return matched;
 };
+var attachTracks = (lines, sources, options, wordTolerance) => {
+	if (!lines.length || !sources.translations?.length && !sources.romans?.length) return lines;
+	const index = createTimeIndex(lines, options);
+	let result = lines;
+	for (const kind of ["translations", "romans"]) {
+		const matches = matchAnnotations(index, readSources(sources[kind] ?? [], options), options);
+		for (const [target, source] of matches) {
+			const line = result[target];
+			if (line.type === LineType.INSTRUMENTAL || !source.text) continue;
+			const romanLanguage = kind === "romans" && wordTolerance !== void 0 ? readRomanLanguage(source.line) : void 0;
+			let annotated = romanLanguage?.consistent && wordTolerance !== void 0 ? attachWordRomans(line, source, wordTolerance, romanLanguage.language, options.wordFallback === true) : void 0;
+			if (!annotated) {
+				const language = romanLanguage ? romanLanguage.language : source.line.languages[0];
+				const create = kind === "romans" ? makeLineAnnotationRoman : makeLineAnnotationTranslation;
+				const annotation = makeLineAnnotation({
+					...line.annotation,
+					[kind]: [...line.annotation?.[kind] ?? [], create({
+						text: source.text,
+						language
+					})]
+				});
+				annotated = {
+					...line,
+					annotation
+				};
+			}
+			if (result === lines) result = lines.slice();
+			result[target] = annotated;
+		}
+	}
+	return result;
+};
 /**
-* Attaches annotation tracks to parsed lines by start time.
+* Attaches complete roman tracks to words using timing and optional local recovery, retaining the source line when matching is incomplete.
+* Translations remain line-level, and successful word tracks are not duplicated on the line.
 *
-* Annotations that match nothing are dropped, and an instrumental line consumes its annotation without carrying one.
-* Any annotation already on a line is kept, with the matched track appended to its layer.
-*/
-var attachLineAnnotations = (lines, sources, options = {}) => {
-	const tolerance = Number.isFinite(options.tolerance) ? Math.max(0, options.tolerance ?? 0) : 0;
-	const translations = matchEntries(lines, (sources.translations ?? []).filter(isReadable), tolerance);
-	const romans = matchEntries(lines, (sources.romans ?? []).filter(isReadable), tolerance);
-	if (translations.size === 0 && romans.size === 0) return lines;
-	return lines.map((line, index) => {
-		const translation = translations.get(index);
-		const roman = romans.get(index);
-		if (line.type === LineType.INSTRUMENTAL || translation === void 0 && roman === void 0) return line;
-		return {
-			...line,
-			annotation: makeLineAnnotation({
-				romans: [...line.annotation?.romans ?? [], ...roman === void 0 ? [] : [makeLineAnnotationRoman({
-					text: readText$1(roman),
-					language: roman.languages[0]
-				})]],
-				translations: [...line.annotation?.translations ?? [], ...translation === void 0 ? [] : [makeLineAnnotationTranslation({
-					text: readText$1(translation),
-					language: translation.languages[0]
-				})]]
-			})
-		};
-	});
+* Match before final normalization; original text and word timing are preserved.
+*/
+var attachAnnotations = (lines, sources, options = {}) => {
+	return attachTracks(lines, sources, options, Number.isFinite(options.wordTolerance) ? Math.max(0, options.wordTolerance ?? 0) : 0);
 };
 //#endregion
-//#region src/utils/language.ts
+//#region src/utils/encoding.ts
 /**
-* Returns a language tag in the canonical form the model stores, which is lower case.
+* Decodes canonical standard base64 into bytes, identically in browsers and Node.
+* atob decides what is decodable; the round-trip re-encode keeps the result canonical, so slacker forms stay undecoded.
 *
-* This mirrors the model's own helper, which it does not export.
-* Comparing tags stays with the consumer, since BCP 47 matches by subtag prefix rather than by string equality.
-*/
-var lowerTag = (tag) => {
-	return tag ? tag.toLowerCase() : void 0;
+* @param value Base64 text; whitespace, URL-safe alphabets, and misplaced padding are rejected.
+*
+* @returns The decoded bytes, or null when the input is not canonical base64.
+*/
+var decodeBase64 = (value) => {
+	if (!value) return null;
+	try {
+		const binary = atob(value);
+		if (btoa(binary).replace(/=+$/, "") !== value.replace(/=+$/, "")) return null;
+		return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+	} catch {
+		return null;
+	}
 };
 //#endregion
 //#region src/utils/time.ts
-var CLOCK_PATTERN = /^(?:(?:(\d+):)?(\d+):)?(\d+)(?:\.(\d+))?$/;
+var CLOCK_PATTERN$1 = /^(?:(?:(\d+):)?(\d+):)?(\d+)(?:\.(\d+))?$/;
 var OFFSET_PATTERN = /^(\d+(?:\.\d+)?)(ms|h|m|s)$/iu;
 /**
 * Reads a clock value, where the fraction is padded or truncated to millisecond precision.
@@ -112,7 +596,7 @@ var OFFSET_PATTERN = /^(\d+(?:\.\d+)?)(ms|h|m|s)$/iu;
 */
 var parseClock = (value) => {
 	if (!value.includes(":") && !value.includes(".")) return;
-	const match = CLOCK_PATTERN.exec(value);
+	const match = CLOCK_PATTERN$1.exec(value);
 	if (!match) return;
 	const hour = Number(match[1] ?? 0);
 	const minute = Number(match[2] ?? 0);
@@ -194,7 +678,7 @@ var prefixedNames = /* @__PURE__ */ new Map();
 */
 var splitXmlName = (name) => {
 	const cached = prefixedNames.get(name);
-	if (cached !== void 0) return cached;
+	if (cached) return cached;
 	const colon = name.indexOf(":");
 	const split = colon === -1 ? {
 		namespacePrefix: "",
@@ -203,7 +687,7 @@ var splitXmlName = (name) => {
 		namespacePrefix: name.slice(0, colon),
 		localName: name.slice(colon + 1)
 	};
-	if (split.namespacePrefix !== "" && prefixedNames.size < 1024) prefixedNames.set(name, split);
+	if (split.namespacePrefix && prefixedNames.size < 1024) prefixedNames.set(name, split);
 	return split;
 };
 /**
@@ -265,7 +749,7 @@ var getXmlAttribute = (element, localName) => {
 	const attributes = element.attributes;
 	for (let index = 0; index < attributes.length; index += 1) {
 		const attribute = attributes[index];
-		if (attribute !== void 0 && attribute.localName === localName) return attribute.value;
+		if (attribute && attribute.localName === localName) return attribute.value;
 	}
 };
 /**
@@ -275,7 +759,7 @@ var getXmlQualifiedAttribute = (element, qualifiedName) => {
 	const attributes = element.attributes;
 	for (let index = 0; index < attributes.length; index += 1) {
 		const attribute = attributes[index];
-		if (attribute !== void 0 && attribute.qualifiedName === qualifiedName) return attribute.value;
+		if (attribute && attribute.qualifiedName === qualifiedName) return attribute.value;
 	}
 };
 /**
@@ -286,7 +770,7 @@ var getXmlChildElements = (element, localName) => {
 	const children = element.children;
 	for (let index = 0; index < children.length; index += 1) {
 		const child = children[index];
-		if (child !== void 0 && child.nodeType === XmlNodeType.element && child.localName === localName) result.push(child);
+		if (child && child.nodeType === XmlNodeType.element && child.localName === localName) result.push(child);
 	}
 	return result;
 };
@@ -297,7 +781,7 @@ var hasXmlChildElement = (element, localName) => {
 	const children = element.children;
 	for (let index = 0; index < children.length; index += 1) {
 		const child = children[index];
-		if (child !== void 0 && child.nodeType === XmlNodeType.element && child.localName === localName) return true;
+		if (child && child.nodeType === XmlNodeType.element && child.localName === localName) return true;
 	}
 	return false;
 };
@@ -306,13 +790,13 @@ var hasXmlChildElement = (element, localName) => {
 */
 var findXmlElement = (element, localName) => {
 	const stack = [element];
-	while (stack.length > 0) {
+	while (stack.length) {
 		const node = stack.pop();
-		if (node === void 0 || node.nodeType !== XmlNodeType.element) continue;
+		if (!node || node.nodeType !== XmlNodeType.element) continue;
 		if (node.localName === localName) return node;
 		for (let index = node.children.length - 1; index >= 0; index -= 1) {
 			const child = node.children[index];
-			if (child !== void 0) stack.push(child);
+			if (child) stack.push(child);
 		}
 	}
 };
@@ -321,18 +805,18 @@ var findXmlElement = (element, localName) => {
 */
 var getXmlTextContent = (node) => {
 	if (node.nodeType !== XmlNodeType.element) return node.text;
-	if (node.children.length === 0) return "";
+	if (!node.children.length) return "";
 	const child = node.children[0];
-	if (node.children.length === 1 && child !== void 0 && child.nodeType !== XmlNodeType.element) return child.text;
+	if (node.children.length === 1 && child && child.nodeType !== XmlNodeType.element) return child.text;
 	const parts = [];
 	const stack = [node];
-	while (stack.length > 0) {
+	while (stack.length) {
 		const current = stack.pop();
-		if (current === void 0) continue;
+		if (!current) continue;
 		if (current.nodeType === XmlNodeType.element) {
 			for (let index = current.children.length - 1; index >= 0; index -= 1) {
 				const child = current.children[index];
-				if (child !== void 0) stack.push(child);
+				if (child) stack.push(child);
 			}
 			continue;
 		}
@@ -400,7 +884,7 @@ var decodeText = (text) => {
 		cursor = end + 1;
 		start = cursor;
 	}
-	if (parts.length === 0) return text;
+	if (!parts.length) return text;
 	parts.push(text.slice(start));
 	return parts.join("");
 };
@@ -409,7 +893,7 @@ var decodeText = (text) => {
 */
 var parseXml = (source) => {
 	const length = source.length;
-	let position = length > 0 && source.charCodeAt(0) === BYTE_ORDER_MARK ? 1 : 0;
+	let position = length && source.charCodeAt(0) === BYTE_ORDER_MARK ? 1 : 0;
 	let valid = true;
 	const stack = [];
 	const root = {
@@ -429,7 +913,7 @@ var parseXml = (source) => {
 		position = end;
 		if (start === end) return;
 		const parent = stack[stack.length - 1];
-		if (parent === void 0) {
+		if (!parent) {
 			valid = false;
 			return;
 		}
@@ -544,7 +1028,7 @@ var parseXml = (source) => {
 		}
 		position = cursor;
 		const parent = stack[stack.length - 1];
-		if (parent === void 0) {
+		if (!parent) {
 			valid = false;
 			return;
 		}
@@ -574,7 +1058,7 @@ var parseXml = (source) => {
 			return;
 		}
 		const top = stack[stack.length - 1];
-		if (top === void 0 || top.qualifiedName !== name) {
+		if (!top || top.qualifiedName !== name) {
 			valid = false;
 			return;
 		}
@@ -601,7 +1085,7 @@ var parseXml = (source) => {
 				return;
 			}
 			const parent = stack[stack.length - 1];
-			if (parent === void 0) {
+			if (!parent) {
 				valid = false;
 				return;
 			}
@@ -706,7 +1190,7 @@ var escapeXmlText = (text, chunks) => {
 			}
 		} else if (code >= 56320 && code <= 57343) escaped = REPLACEMENT_CHARACTER;
 		else if (!isAllowedCodePoint(code)) escaped = REPLACEMENT_CHARACTER;
-		if (escaped === "") continue;
+		if (!escaped) continue;
 		if (start < index) chunks.push(text.slice(start, index));
 		chunks.push(escaped);
 		start = index + 1;
@@ -742,7 +1226,7 @@ var escapeXmlAttribute = (value, chunks) => {
 			}
 		} else if (code >= 56320 && code <= 57343) escaped = REPLACEMENT_CHARACTER;
 		else if (!isAllowedCodePoint(code)) escaped = REPLACEMENT_CHARACTER;
-		if (escaped === "") continue;
+		if (!escaped) continue;
 		if (start < index) chunks.push(value.slice(start, index));
 		chunks.push(escaped);
 		start = index + 1;
@@ -762,7 +1246,7 @@ var hasOnlyElements = (element) => {
 	const children = element.children;
 	for (let index = 0; index < children.length; index += 1) {
 		const child = children[index];
-		if (child !== void 0 && child.nodeType !== XmlNodeType.element) return false;
+		if (child && child.nodeType !== XmlNodeType.element) return false;
 	}
 	return true;
 };
@@ -782,13 +1266,13 @@ var writeXmlNode = (node, chunks, depth, indent) => {
 	chunks.push("<", node.qualifiedName);
 	for (let index = 0; index < node.attributes.length; index += 1) {
 		const attribute = node.attributes[index];
-		if (attribute === void 0) continue;
+		if (!attribute) continue;
 		chunks.push(" ", attribute.qualifiedName, "=\"");
 		escapeXmlAttribute(attribute.value, chunks);
 		chunks.push("\"");
 	}
 	const children = node.children;
-	if (children.length === 0) {
+	if (!children.length) {
 		chunks.push("/>");
 		return;
 	}
@@ -796,7 +1280,7 @@ var writeXmlNode = (node, chunks, depth, indent) => {
 	const childIndent = indent !== void 0 && hasOnlyElements(node) ? indent : void 0;
 	for (let index = 0; index < children.length; index += 1) {
 		const child = children[index];
-		if (child !== void 0) writeXmlNode(child, chunks, depth + 1, childIndent);
+		if (child) writeXmlNode(child, chunks, depth + 1, childIndent);
 	}
 	if (childIndent !== void 0) chunks.push("\n", childIndent.repeat(depth));
 	chunks.push("</", node.qualifiedName, ">");
@@ -809,20 +1293,94 @@ var writeXmlNode = (node, chunks, depth, indent) => {
 var serializeXml = (root, options = {}) => {
 	const chunks = [];
 	if (options.declaration ?? true) chunks.push(XML_DECLARATION);
-	const indent = options.indent === true ? options.indentText ?? DEFAULT_INDENT : void 0;
+	const indent = options.indent ? options.indentText ?? DEFAULT_INDENT : void 0;
 	if (indent !== void 0) chunks.push("\n");
 	if (root.qualifiedName === ROOT_NAME) for (let index = 0; index < root.children.length; index += 1) {
 		const child = root.children[index];
-		if (child !== void 0) writeXmlNode(child, chunks, 0, indent);
+		if (child) writeXmlNode(child, chunks, 0, indent);
 	}
 	else writeXmlNode(root, chunks, 0, indent);
 	return chunks.join("");
 };
 //#endregion
+//#region src/formats/qrc/common.ts
+var LINE_PATTERN$2 = /^\[(\d+),(\d+)\]/;
+var XML_ROOT_NAMES = [
+	"QrcInfos",
+	"LyricInfo",
+	"Lyric_1"
+];
+var XML_PATTERN = /^\s*</;
+var TIMED_LINE_PATTERN = /(?:^|[\r\n])[^\S\r\n]*\[\d+,\d+\]/;
+/**
+* Unwraps supported QRC XML while keeping plaintext literal.
+*
+* XML entities are decoded once by the XML reader.
+*
+* @returns The payload, or null when XML is malformed or has no supported lyric content.
+*/
+var readText$2 = (source) => {
+	if (!XML_PATTERN.test(source)) return source;
+	if (!XML_ROOT_NAMES.some((name) => source.includes(name))) return null;
+	const document = parseXml(source);
+	if (!document) return null;
+	const root = document.children.find((node) => node.nodeType === XmlNodeType.element);
+	if (!root || !XML_ROOT_NAMES.includes(root.localName)) return null;
+	const pending = [root];
+	while (pending.length) {
+		const element = pending.pop();
+		const content = getXmlAttribute(element, "LyricContent");
+		if (content !== void 0) return content;
+		for (let index = element.children.length - 1; index >= 0; index -= 1) {
+			const child = element.children[index];
+			if (child.nodeType === XmlNodeType.element) pending.push(child);
+		}
+	}
+	return null;
+};
+/**
+* Validates the original payload and keeps auxiliary tracks separate so each can use its own format.
+*
+* @returns Normalized input, or null when the original content cannot be read.
+*/
+var readContent = (input) => {
+	const value = typeof input === "string" ? { original: input } : input;
+	if (!value || typeof value !== "object") return null;
+	const source = value;
+	if (typeof source.original !== "string") return null;
+	const original = readText$2(source.original);
+	if (original === null) return null;
+	return {
+		original,
+		translations: typeof source.translations === "string" ? source.translations : void 0,
+		romans: typeof source.romans === "string" ? source.romans : void 0
+	};
+};
+/**
+* Requires a timed QRC row so metadata alone cannot select the format.
+*/
+var hasTimedLines = (text) => {
+	return TIMED_LINE_PATTERN.test(text);
+};
+//#endregion
+//#region src/formats/qrc/detect.ts
+/**
+* Detects QRC from the original track so annotations cannot change format selection.
+*
+* @returns Whether plaintext or a supported XML payload contains a timed QRC row.
+*/
+var detectQrc = (input) => {
+	const content = readContent(input);
+	return !!content && hasTimedLines(content.original);
+};
+//#endregion
 //#region src/formats/lrc/common.ts
+/**
+* Accepts plain lyrics or separate tracks while rejecting an unreadable original payload.
+*/
 var readLrcContent = (input) => {
 	if (typeof input === "string") return { original: input };
-	if (typeof input !== "object" || input === null) return null;
+	if (!input || typeof input !== "object") return null;
 	const source = input;
 	if (typeof source.original !== "string") return null;
 	return {
@@ -871,34 +1429,42 @@ var parseWordTime = (body, lineStart) => {
 	}
 };
 /**
-* Untagged leading text is preserved; tags without following text produce no piece.
-* A trailing tag still yields an empty piece so it can close the preceding word.
+* Splits recognized tags from their following text while preserving literal content and empty tagged segments.
+*
+* @param pattern A global pattern whose first capture is the tag body.
+* @param accepts Optional format-specific tag validation.
+*
+* @returns Source pieces in their original order, including an untagged prefix when present.
 */
-var splitWordTags = (content) => {
+var scanWordTags = (content, pattern, accepts) => {
 	const pieces = [];
 	let tag;
 	let cursor = 0;
-	for (const match of content.matchAll(WORD_TAG_PATTERN)) {
-		const at = match.index;
-		const before = content.slice(cursor, at);
-		if (before) pieces.push({
+	for (const match of content.matchAll(pattern)) {
+		const nextTag = match[1] ?? "";
+		if (accepts && !accepts(nextTag)) continue;
+		const before = content.slice(cursor, match.index);
+		if (before || tag !== void 0) pieces.push({
 			text: before,
 			tag
 		});
-		tag = match[1] ?? "";
-		cursor = at + match[0].length;
+		tag = nextTag;
+		cursor = match.index + match[0].length;
 	}
 	const tail = content.slice(cursor);
-	if (tail) pieces.push({
+	if (tail || tag !== void 0) pieces.push({
 		text: tail,
 		tag
 	});
-	else if (tag !== void 0) pieces.push({
-		text: "",
-		tag
-	});
 	return pieces;
 };
+/**
+* Untagged leading text is preserved; empty timed pieces retain explicit segment boundaries.
+* Only recognized time tags split content; other angle-bracket text remains literal.
+*/
+var splitWordTags = (content) => {
+	return scanWordTags(content, WORD_TAG_PATTERN, (tag) => !!parseWordTime(tag, 0));
+};
 //#endregion
 //#region src/formats/lrc/detect.ts
 /**
@@ -932,25 +1498,48 @@ var renderWordTag = (start, end, options) => {
 	return `${open}${formatTime(start, options.timeFormat)}${duration}${close}`;
 };
 /**
-* Plain text joins words as written, including the separators stored as space words.
-*/
-var renderPlainText = (line) => {
-	const content = line.content;
-	if (!content) return "";
-	if (content.text !== void 0) return content.text;
-	return content.words.map((word) => word.text).join("");
-};
-/**
 * Word-level lines interleave tags with their text; untimed words stay untagged.
 */
 var renderSyllableText = (line, options) => {
 	const content = line.content;
-	if (!content?.words.length) return renderPlainText(line);
+	if (!content?.words.length) return getContentText(content);
 	return content.words.map((word) => {
 		if (word.type === WordType.SPACE) return word.text;
 		const start = word.time?.start;
 		if (start === void 0) return word.text;
-		return `${renderWordTag(start, word.time?.end, options)}${word.text}`;
+		const end = word.time?.end;
+		const closing = options.wordTiming === "angle" && options.includeWordEnd && end === start ? renderWordTag(end, void 0, options) : "";
+		return `${renderWordTag(start, end, options)}${word.text}${closing}`;
+	}).join("");
+};
+var renderWordRomans = (line, language, options) => {
+	const pieces = [];
+	let spaced = false;
+	for (const word of line.content?.words ?? []) {
+		if (word.type === WordType.SPACE) {
+			spaced = true;
+			continue;
+		}
+		const roman = word.annotation?.romans.find((item) => lowerTag(item.language) === language);
+		if (!roman || !getAnnotationItemText(roman)) continue;
+		let prefix = pieces.length && spaced ? " " : "";
+		spaced = false;
+		for (const token of roman.tokens) {
+			if (!token.text) continue;
+			pieces.push({
+				text: prefix + token.text,
+				time: resolveAnnotationTokenTime(token, roman, word)
+			});
+			prefix = "";
+		}
+	}
+	return pieces.map((piece, index) => {
+		const start = piece.time?.start;
+		if (start === void 0) return piece.text;
+		const end = piece.time?.end;
+		const nextStart = pieces[index + 1]?.time?.start;
+		const closing = end !== void 0 && end !== nextStart && (!options.includeWordEnd || end === start) ? renderWordTag(end, void 0, options) : "";
+		return `${renderWordTag(start, end, options)}${piece.text}${closing}`;
 	}).join("");
 };
 var renderMetaRows = (meta, options) => {
@@ -972,7 +1561,7 @@ var renderLineRow = (line, options, wordLevel) => {
 	if (line.type === LineType.INSTRUMENTAL && !options.includeInstrumental) return;
 	const time = renderTimeTag(line.time?.start ?? 0, options);
 	if (line.type === LineType.INSTRUMENTAL) return time;
-	return `${time}${wordLevel && line.content?.words.length ? renderSyllableText(line, options) : renderPlainText(line)}`;
+	return `${time}${wordLevel && line.content?.words.length ? renderSyllableText(line, options) : getContentText(line.content)}`;
 };
 var renderAnnotationRows = (lines, options, pick) => {
 	const rows = [];
@@ -983,6 +1572,20 @@ var renderAnnotationRows = (lines, options, pick) => {
 	}
 	return rows;
 };
+var renderRomanRows = (lines, options) => {
+	const rows = [];
+	for (const line of lines) {
+		const start = line.time?.start;
+		if (start === void 0) continue;
+		const explicit = new Set((line.annotation?.romans ?? []).map((item) => lowerTag(item.language)));
+		for (const item of getLineRomans(line)) {
+			const language = lowerTag(item.language);
+			const text = options.wordTiming === "none" || explicit.has(language) ? item.text : renderWordRomans(line, language, options);
+			rows.push(`${renderTimeTag(start, options)}${text}`);
+		}
+	}
+	return rows;
+};
 var joinBlocks = (header, body) => {
 	const blocks = [];
 	if (header.length) blocks.push(header.join("\n"));
@@ -993,47 +1596,29 @@ var joinBlocks = (header, body) => {
 * Generates the LRC text plus the annotations a single file cannot hold.
 *
 * Word tags appear only for a word-timed lyric when `wordTiming` is not `none`; otherwise every line stays whole.
+* Word romanizations retain token boundaries; explicit line romanizations take precedence for the same language.
 */
 var generateLrc = (lyric, options = {}) => {
 	const resolved = resolveOptions$1(options);
 	const header = resolved.includeMeta && lyric.meta ? renderMetaRows(lyric.meta, resolved) : [];
-	const wordLevel = lyric.lines.some((line) => (line.content?.words.length ?? 0) > 0) && resolved.wordTiming !== "none";
+	const wordLevel = lyric.lines.some((line) => !!line.content?.words.length) && resolved.wordTiming !== "none";
 	const result = { original: joinBlocks(header, lyric.lines.map((line) => {
 		return renderLineRow(line, resolved, wordLevel);
 	}).filter((row) => row !== void 0)) };
 	const translations = renderAnnotationRows(lyric.lines, resolved, (line) => line.annotation?.translations ?? []);
 	if (translations.length) result.translations = joinBlocks(header, translations);
-	const romans = renderAnnotationRows(lyric.lines, resolved, (line) => line.annotation?.romans ?? []);
+	const romans = renderRomanRows(lyric.lines, resolved);
 	if (romans.length) result.romans = joinBlocks(header, romans);
 	return result;
 };
 //#endregion
-//#region src/formats/result.ts
-/**
-* Canonicalizes and validates one parser's output, so every format hands back the same shape.
-*
-* Canonicalization runs first because validation reports paths against the canonical tree.
-*/
-var finalizeLyric = (input) => {
-	const lyric = canonicalizeLyric(input);
-	return {
-		lyric,
-		diagnostics: validateLyric(lyric)
-	};
-};
-//#endregion
 //#region src/formats/lrc/parser.ts
-var isBareNumber = (value) => {
-	return /^\d+$/.test(value.trim());
-};
-/**
-* A trailing tag alone still makes the line word-level, so it can close the last word.
-* Unreadable angle-bracket text stays plain lyric content.
-*/
-var isWordTimed = (text) => {
-	return splitWordTags(text).some((piece) => piece.tag !== void 0 && parseWordTime(piece.tag, 0) !== void 0);
+var CLOCK_PATTERN = /^(?:\d+:){0,2}\d+(?:\.(\d+))?$/;
+var readLineTiming = (tag) => {
+	const clock = CLOCK_PATTERN.exec(tag.trim());
+	return { precision: clock ? 10 ** Math.max(0, 3 - (clock[1]?.length ?? 0)) : 1 };
 };
-var readMeta = (body) => {
+var readMeta$1 = (body) => {
 	const match = META_PATTERN.exec(body);
 	if (!match) return;
 	return {
@@ -1041,28 +1626,33 @@ var readMeta = (body) => {
 		value: (match[2] ?? "").trim()
 	};
 };
-var readGroup = (tags, text, timed, meta) => {
+var readGroup = (tags, text, row, timed, meta, options) => {
 	for (const tag of tags) {
 		const start = isTime(tag) ? parseTime(tag) : void 0;
 		if (start !== void 0) {
 			timed.push({
 				text,
-				start
+				start,
+				tag,
+				row
 			});
 			continue;
 		}
-		const pair = readMeta(tag);
-		if (pair) meta.push(pair);
+		const pair = readMeta$1(tag);
+		if (pair) {
+			meta.push(pair);
+			options.onMeta?.(pair, row);
+		}
 	}
 };
 /**
 * Stacked timestamps share the following text, as in `[00:10][00:20]twice`.
 * Text before the first tag is discarded because it has no timing association.
 */
-var readTimedLines = (text) => {
+var readTimedLines = (text, options) => {
 	const timed = [];
 	const meta = [];
-	for (const raw of text.replace(/\r\n?/g, "\n").split("\n")) {
+	for (const [row, raw] of text.replace(/\r\n?/g, "\n").split("\n").entries()) {
 		const line = raw.trim();
 		if (!line) continue;
 		const matches = [...line.matchAll(TAG_PATTERN)];
@@ -1073,10 +1663,10 @@ var readTimedLines = (text) => {
 			const shared = line.slice(at, next);
 			group.push(match[1] ?? "");
 			if (!shared.trim()) continue;
-			readGroup(group, shared, timed, meta);
+			readGroup(group, shared, row, timed, meta, options);
 			group = [];
 		}
-		readGroup(group, "", timed, meta);
+		readGroup(group, "", row, timed, meta, options);
 	}
 	return {
 		timed,
@@ -1084,57 +1674,11 @@ var readTimedLines = (text) => {
 	};
 };
 /**
-* Unmapped tags and unparseable durations remain in `unknowns` to avoid discarding metadata.
-* Keys are lowercased and values trimmed, so original tag spelling is not preserved.
-*/
-var readMetaTags = (tags) => {
-	const meta = makeMeta();
-	for (const tag of tags) switch (tag.key) {
-		case "length":
-		case "duration": {
-			const duration = parseTime(tag.value) ?? (isBareNumber(tag.value) ? Number(tag.value) : NaN);
-			if (Number.isFinite(duration)) meta.duration = Math.trunc(duration);
-			else meta.unknowns.push(makeUnknownEntry({
-				key: tag.key,
-				value: tag.value
-			}));
-			break;
-		}
-		case "offset":
-			meta.offset = Math.trunc(Number(tag.value)) || 0;
-			break;
-		case "ti":
-		case "title":
-			meta.titles.push(makeText({ text: tag.value }));
-			break;
-		case "ar":
-		case "artist":
-			meta.artists.push(makeText({ text: tag.value }));
-			break;
-		case "al":
-		case "album":
-			meta.albums.push(makeText({ text: tag.value }));
-			break;
-		case "by":
-		case "author":
-			meta.authors.push(makeText({ text: tag.value }));
-			break;
-		case "isrc":
-			meta.isrcs.push(tag.value);
-			break;
-		default: meta.unknowns.push(makeUnknownEntry({
-			key: tag.key,
-			value: tag.value
-		}));
-	}
-	return meta;
-};
-/**
 * Whitespace becomes a space word preserving the source run, as in `lo      World`.
 * A tag opens a segment; untagged words continue from the previous end so the timeline has no holes.
 * Explicit word ends are kept as written, so duration tags survive unchanged.
 */
-var readWords$1 = (text, lineStart) => {
+var readWords$2 = (pieces, lineStart) => {
 	const drafts = [];
 	const open = /* @__PURE__ */ new Set();
 	const closeSegment = (boundary) => {
@@ -1144,9 +1688,9 @@ var readWords$1 = (text, lineStart) => {
 	};
 	let segmentStart = lineStart;
 	let cursor = lineStart;
-	for (const piece of splitWordTags(text)) {
-		const time = piece.tag === void 0 ? void 0 : parseWordTime(piece.tag, lineStart);
-		if (time?.start !== void 0) {
+	for (const piece of pieces) {
+		const time = piece.tag ? parseWordTime(piece.tag, lineStart) : void 0;
+		if (time) {
 			closeSegment(time.start);
 			segmentStart = time.start;
 			cursor = time.start;
@@ -1162,7 +1706,7 @@ var readWords$1 = (text, lineStart) => {
 				});
 				continue;
 			}
-			const tagged = !applied && time?.start !== void 0;
+			const tagged = !applied && !!time;
 			applied = true;
 			const start = tagged ? segmentStart : cursor;
 			const end = tagged ? time?.end : void 0;
@@ -1182,23 +1726,26 @@ var readWords$1 = (text, lineStart) => {
 	};
 };
 /**
-* A line ends at the next line's start; without one, it ends at its final word's end.
-* An open word is closed by the next timed word, or by the line end, so every sung word stays inside the line.
-* Empty timed rows represent instrumental time rather than sung content.
+* Explicit word ranges can extend past the next line's start, so the inferred end covers both.
+* A trailing open segment uses that end when it is known.
 */
-var readLine$1 = (text, start, nextStart) => {
+var readLine$4 = (text, start, nextStart) => {
 	const trimmed = text.trim();
 	let end = nextStart !== void 0 && nextStart >= start ? nextStart : void 0;
-	if (trimmed === "") return makeLineInstrumental({ time: makeTimeRange({
+	if (!trimmed) return makeLineInstrumental({ time: makeTimeRange({
 		start,
 		end
 	}) });
-	const wordTimed = isWordTimed(text);
-	const { drafts, closeSegment } = wordTimed ? readWords$1(text, start) : {
+	const pieces = splitWordTags(text);
+	const wordTimed = pieces.some((piece) => !!piece.tag);
+	const { drafts, closeSegment } = wordTimed ? readWords$2(pieces, start) : {
 		drafts: [],
 		closeSegment: () => {}
 	};
 	if (end === void 0) end = [...drafts].reverse().find((draft) => !draft.space && draft.start !== void 0)?.end;
+	if (end !== void 0) {
+		for (const draft of drafts) if (draft.end !== void 0) end = Math.max(end, draft.end);
+	}
 	closeSegment(end);
 	const words = drafts.map((draft) => {
 		if (draft.space) return makeWordSpace({ text: draft.text });
@@ -1225,29 +1772,97 @@ var readLine$1 = (text, start, nextStart) => {
 * Builds one line per timed row, so an annotation track reuses the original text's reading unchanged.
 * Empty timed rows become instrumental lines bounded by the next timestamp when one is usable.
 */
-var readLines = (timed) => {
+var readLines$1 = (timed, options) => {
 	const lines = [];
 	for (const [index, item] of timed.entries()) {
 		const next = timed[index + 1]?.start;
-		lines.push(readLine$1(item.text, item.start, next));
+		const line = readLine$4(item.text, item.start, next);
+		lines.push(line);
+		options.onLine?.(line, readLineTiming(item.tag), item.row);
 	}
 	return lines;
 };
-var parseLrcText = (text) => {
-	const { timed, meta } = readTimedLines(text);
-	const metaTags = readMetaTags(meta);
-	if (!timed.length) return makeLyric({
-		format: "lrc",
-		status: LyricStatus.INVALID,
-		meta: metaTags
-	});
-	const lines = readLines(timed);
+/**
+* Reads one LRC track in source order and performs no other operation: no metadata mapping, annotation attachment, sorting, or normalization.
+*
+* @param text Original lyrics or one auxiliary track in LRC syntax.
+* @param options Optional observer for source timestamp information.
+*
+* @returns Model lines in input order and metadata tags with lowercase keys and trimmed values.
+*/
+var readLrc = (text, options = {}) => {
+	const { timed, meta } = readTimedLines(text, options);
+	return {
+		lines: readLines$1(timed, options),
+		metaTags: meta
+	};
+};
+var isBareNumber = (value) => {
+	return /^\d+$/.test(value.trim());
+};
+/**
+* Maps standard lyric metadata while preserving unmapped tags and unparseable durations in unknowns.
+*
+* @param tags Reader tags with lowercase keys and trimmed values.
+*
+* @returns Model metadata without interpreting platform-specific embedded annotations.
+*/
+var readLrcMetaTags = (tags) => {
+	const meta = makeMeta();
+	for (const tag of tags) switch (tag.key) {
+		case "length":
+		case "duration": {
+			const duration = parseTime(tag.value) ?? (isBareNumber(tag.value) ? Number(tag.value) : NaN);
+			if (Number.isFinite(duration)) meta.duration = Math.trunc(duration);
+			else meta.unknowns.push(makeUnknownEntry({
+				key: tag.key,
+				value: tag.value
+			}));
+			break;
+		}
+		case "offset":
+			meta.offset = Math.trunc(Number(tag.value)) || 0;
+			break;
+		case "ti":
+		case "title":
+			meta.titles.push(makeText({ text: tag.value }));
+			break;
+		case "ar":
+		case "artist":
+			meta.artists.push(makeText({ text: tag.value }));
+			break;
+		case "al":
+		case "album":
+			meta.albums.push(makeText({ text: tag.value }));
+			break;
+		case "by":
+		case "author":
+			meta.authors.push(makeText({ text: tag.value }));
+			break;
+		case "isrc":
+			meta.isrcs.push(tag.value);
+			break;
+		default: meta.unknowns.push(makeUnknownEntry({
+			key: tag.key,
+			value: tag.value
+		}));
+	}
+	return meta;
+};
+var parseLrcText = (text) => {
+	const { lines, metaTags } = readLrc(text);
+	const meta = readLrcMetaTags(metaTags);
+	if (!lines.length) return makeLyric({
+		format: "lrc",
+		status: LyricStatus.INVALID,
+		meta
+	});
 	const wordTimed = lines.some((line) => (line.content?.words.length ?? 0) > 0);
 	return makeLyric({
 		format: "lrc",
 		status: LyricStatus.VALID,
 		timing: wordTimed ? Timing.WORD : Timing.LINE,
-		meta: metaTags,
+		meta,
 		languages: deriveLanguageUsages(lines),
 		lines
 	});
@@ -1256,6 +1871,7 @@ var parseLrcText = (text) => {
 * Empty timed rows become instrumental lines; source order and missing word times remain for model validation.
 *
 * Annotation tracks are read as lines too and attached by timestamp, and rows that match no line are dropped.
+* Complete roman tracks attach to words by timing and optional local recovery; other tracks retain their source line text.
 *
 * `INVALID` means no readable timed lines; the returned diagnostics carry whatever the canonical tree breaks.
 */
@@ -1263,19 +1879,836 @@ var parseLrc = (input, options = {}) => {
 	const source = readLrcContent(input) ?? { original: "" };
 	const lyric = parseLrcText(source.original);
 	if (lyric.status === LyricStatus.INVALID) return finalizeLyric(lyric);
-	const translations = source.translations === void 0 ? [] : readLines(readTimedLines(source.translations).timed);
-	const romans = source.romans === void 0 ? [] : readLines(readTimedLines(source.romans).timed);
-	if (translations.length === 0 && romans.length === 0) return finalizeLyric(lyric);
-	const lines = attachLineAnnotations(lyric.lines, {
+	const translations = source.translations ? readLrc(source.translations).lines : [];
+	const romans = source.romans ? readLrc(source.romans).lines : [];
+	if (!translations.length && !romans.length) return finalizeLyric(lyric);
+	const lines = attachAnnotations(lyric.lines, {
 		translations,
 		romans
-	}, { tolerance: options.annotationTolerance });
+	}, {
+		tolerance: options.annotationTolerance,
+		wordTolerance: options.wordAnnotationTolerance,
+		wordFallback: options.wordAnnotationFallback
+	});
 	return finalizeLyric({
 		...lyric,
 		lines
 	});
 };
 //#endregion
+//#region src/formats/qrc/parser.ts
+var WORD_PATTERN$2 = /\((\d+),(\d+)\)/g;
+var META_PATTERN$1 = /^([A-Za-z0-9_-]+)\s*:\s*([\s\S]*)$/;
+var META_TAG_PATTERN = /\[([^\]]*)\]/g;
+var RUBY_PATTERN = /\((\d+),(\d+)\)|(\d+)|([^0-9()]+)/gy;
+var RUBY_WORD_PATTERN = /[\p{Script=Han}\p{Number}]/u;
+var SEPARATORS$3 = /^\p{White_Space}+$/u;
+var NATIVE_ANNOTATION_TIMING = {
+	precision: 1,
+	rounding: 1
+};
+/**
+* Reads coverage markers and optional absolute token times without interpreting timing digits as coverage.
+*
+* @returns Complete ruby sources, or undefined when any source cannot be read.
+*/
+var readRubyEntries = (value) => {
+	const entries = [];
+	let length = 0;
+	let tokens = [];
+	let text = "";
+	let cursor = 0;
+	const finish = () => {
+		if (text.trim()) tokens.push(makeWordAnnotationToken({ text }));
+		if (!length || !tokens.length) return false;
+		entries.push({
+			length,
+			ruby: makeWordAnnotationRuby({ tokens })
+		});
+		tokens = [];
+		text = "";
+		return true;
+	};
+	for (const match of value.matchAll(RUBY_PATTERN)) {
+		cursor = match.index + match[0].length;
+		if (match[3]) {
+			if (length && !finish()) return;
+			length = Number(match[3]);
+			if (!Number.isSafeInteger(length) || length <= 0) return;
+		} else if (match[1]) {
+			const start = Number(match[1]);
+			const end = start + Number(match[2]);
+			if (!length || !text.trim() || !Number.isSafeInteger(start) || !Number.isSafeInteger(end)) return;
+			tokens.push(makeWordAnnotationToken({
+				text,
+				time: {
+					start,
+					end
+				}
+			}));
+			text = "";
+		} else {
+			if (!length) return;
+			text += match[4];
+		}
+	}
+	return cursor === value.length && finish() ? entries : void 0;
+};
+var readRubies = (meta) => {
+	let entries;
+	const unknowns = [];
+	for (const entry of meta.unknowns) if (entry.key === "kana") entries ??= readRubyEntries(entry.value);
+	else unknowns.push(entry);
+	meta.unknowns = unknowns;
+	return entries;
+};
+var matchRubies = (words, sources) => {
+	const starts = /* @__PURE__ */ new Map();
+	for (const [index, candidate] of words.entries()) {
+		const start = candidate?.word.time?.start;
+		if (start !== void 0 && Number.isSafeInteger(start) && start >= 0) {
+			const queue = starts.get(start) ?? [];
+			queue.push(index);
+			starts.set(start, queue);
+		}
+	}
+	const timed = /* @__PURE__ */ new Set();
+	const claims = /* @__PURE__ */ new Map();
+	for (const [index, source] of sources.entries()) {
+		const times = source.ruby.tokens.flatMap((token) => token.time ? [token.time] : []);
+		if (!times.length) continue;
+		timed.add(index);
+		const start = times[0].start;
+		const end = times.at(-1).end;
+		if (start === void 0) continue;
+		let candidates = (starts.get(start) ?? []).filter((target) => {
+			const candidate = words[target];
+			const finish = candidate.word.time?.end;
+			return candidate.length === source.length && finish !== void 0 && Number.isSafeInteger(finish) && times.every((time) => {
+				return time.start !== void 0 && time.end !== void 0 && time.start >= start && time.end >= time.start && time.end <= finish;
+			});
+		});
+		if (times.length === source.ruby.tokens.length) {
+			const exact = candidates.filter((target) => words[target].word.time.end === end);
+			if (exact.length) candidates = exact;
+		}
+		if (candidates.length !== 1) continue;
+		const target = candidates[0];
+		const queue = claims.get(target) ?? [];
+		queue.push(index);
+		claims.set(target, queue);
+	}
+	const matched = /* @__PURE__ */ new Map();
+	for (const [target, queue] of claims) if (queue.length === 1) matched.set(queue[0], target);
+	const anchors = [
+		[-1, -1],
+		...[...matched].sort((first, second) => first[0] - second[0]),
+		[sources.length, words.length]
+	];
+	for (let index = 1; index < anchors.length; index += 1) if (anchors[index][1] <= anchors[index - 1][1]) return matched;
+	for (let index = 1; index < anchors.length; index += 1) {
+		const [firstSource, firstWord] = anchors[index - 1];
+		const [lastSource, lastWord] = anchors[index];
+		const pending = [];
+		let compatible = true;
+		for (let source = firstSource + 1; source < lastSource; source += 1) {
+			if (timed.has(source)) {
+				compatible = false;
+				break;
+			}
+			pending.push(source);
+		}
+		if (!compatible || !pending.length) continue;
+		const candidates = [];
+		for (let target = firstWord + 1; target < lastWord; target += 1) {
+			const candidate = words[target];
+			if (!candidate) {
+				compatible = false;
+				break;
+			}
+			if (candidate.byOrder) candidates.push(target);
+		}
+		if (!compatible || candidates.length !== pending.length || pending.some((source, position) => sources[source].length !== words[candidates[position]].length)) continue;
+		for (const [position, source] of pending.entries()) matched.set(source, candidates[position]);
+	}
+	return matched;
+};
+/**
+* Attaches whole-word ruby without changing the source text, segmentation, or timing.
+*
+* @param lines Original timed rows before filtering or sorting.
+* @param sources Readings with source coverage lengths and optional token times.
+*
+* @returns Annotated rows and matched source indices, preserving unchanged nodes.
+*/
+var attachRubies = (lines, sources) => {
+	if (!sources.length) return {
+		lines,
+		matched: /* @__PURE__ */ new Set()
+	};
+	const words = [];
+	for (const line of lines) {
+		if (line.type !== LineType.NORMAL) continue;
+		if (line.content?.text && RUBY_WORD_PATTERN.test(line.content.text)) {
+			words.push(void 0);
+			continue;
+		}
+		for (const word of line.content?.words ?? []) if (word.type === WordType.NORMAL) words.push({
+			word,
+			length: [...word.text].length,
+			byOrder: RUBY_WORD_PATTERN.test(word.text)
+		});
+	}
+	const matched = matchRubies(words, sources);
+	if (!matched.size) return {
+		lines,
+		matched: /* @__PURE__ */ new Set()
+	};
+	const annotations = new Map([...matched].map(([source, target]) => [words[target].word, sources[source].ruby]));
+	return {
+		lines: mapShared(lines, (line) => {
+			const content = line.content;
+			if (!content) return line;
+			const words = mapShared(content.words, (word) => {
+				const ruby = annotations.get(word);
+				if (!ruby) return word;
+				return {
+					...word,
+					annotation: makeWordAnnotation({
+						...word.annotation,
+						rubies: [...word.annotation?.rubies ?? [], ruby]
+					})
+				};
+			});
+			return words === content.words ? line : {
+				...line,
+				content: {
+					...content,
+					words
+				}
+			};
+		}),
+		matched: new Set(matched.keys())
+	};
+};
+var readMeta = (body, meta) => {
+	const match = META_PATTERN$1.exec(body);
+	if (!match) return;
+	const key = match[1].toLowerCase();
+	const value = match[2].trim();
+	switch (key) {
+		case "length":
+		case "duration": {
+			const duration = parseTime(value) ?? (/^\d+$/.test(value) ? Number(value) : NaN);
+			if (Number.isFinite(duration)) meta.duration = Math.trunc(duration);
+			else meta.unknowns.push(makeUnknownEntry({
+				key,
+				value
+			}));
+			break;
+		}
+		case "offset":
+			meta.offset = Math.trunc(Number(value)) || 0;
+			break;
+		case "ti":
+		case "title":
+			meta.titles.push(makeText({ text: value }));
+			break;
+		case "ar":
+		case "artist":
+			meta.artists.push(makeText({ text: value }));
+			break;
+		case "al":
+		case "album":
+			meta.albums.push(makeText({ text: value }));
+			break;
+		case "by":
+		case "author":
+			meta.authors.push(makeText({ text: value }));
+			break;
+		case "isrc":
+			meta.isrcs.push(value);
+			break;
+		default: meta.unknowns.push(makeUnknownEntry({
+			key,
+			value
+		}));
+	}
+};
+var readTimeRange = (startText, durationText) => {
+	const start = Number(startText);
+	return makeTimeRange({
+		start,
+		end: start + Number(durationText)
+	});
+};
+var appendWords$2 = (words, text, time) => {
+	for (const fragment of text.split(/(\p{White_Space}+)/u)) {
+		if (!fragment) continue;
+		if (SEPARATORS$3.test(fragment)) words.push(makeWordSpace({ text: fragment }));
+		else words.push(makeWordNormal({
+			text: fragment,
+			time
+		}));
+	}
+};
+var readWords$1 = (text) => {
+	const words = [];
+	let cursor = 0;
+	let tagged = false;
+	for (const match of text.matchAll(WORD_PATTERN$2)) {
+		tagged = true;
+		appendWords$2(words, text.slice(cursor, match.index), readTimeRange(match[1], match[2]));
+		cursor = match.index + match[0].length;
+	}
+	if (!tagged) return;
+	appendWords$2(words, text.slice(cursor));
+	return words;
+};
+/**
+* Kugou writes `//` where it holds no translation, in QRC source rows and in its language payload alike.
+*
+* @returns Whether the trimmed text is that sentinel instead of real content.
+*/
+var isPlaceholderText = (text) => {
+	return text.trim() === "//";
+};
+var readLines = (text) => {
+	const lines = [];
+	const meta = makeMeta();
+	const placeholders = /* @__PURE__ */ new Set();
+	for (const raw of text.split(/\r\n?|\n/)) {
+		const line = raw.trimStart();
+		const match = LINE_PATTERN$2.exec(line);
+		if (match) {
+			const time = readTimeRange(match[1], match[2]);
+			const text = line.slice(match[0].length);
+			const words = readWords$1(text);
+			const contentText = (words ? getWordsText(words) : text).trim();
+			const placeholder = isPlaceholderText(contentText);
+			if (placeholder) placeholders.add(lines.length);
+			if (!contentText || placeholder) lines.push(makeLineInstrumental({ time }));
+			else {
+				const content = words ? makeLineContentWords(words) : makeLineContentText(text);
+				lines.push(makeLineNormal({
+					time,
+					content
+				}));
+			}
+			continue;
+		}
+		if (!line.startsWith("[")) continue;
+		for (const tag of line.matchAll(META_TAG_PATTERN)) {
+			const body = tag[1];
+			if (isTime(body)) continue;
+			readMeta(body, meta);
+		}
+	}
+	return {
+		lines,
+		meta,
+		placeholders
+	};
+};
+var readAnnotations$1 = (text, timings) => {
+	if (!text) return [];
+	const { lines } = readLines(text);
+	if (lines.length) {
+		for (const line of lines) timings.set(line, NATIVE_ANNOTATION_TIMING);
+		return lines;
+	}
+	readLrc(text, { onLine: (line, timing) => {
+		const annotation = isPlaceholderText(getContentText(line.content)) ? makeLineInstrumental({ time: line.time }) : line;
+		timings.set(annotation, timing);
+		lines.push(annotation);
+	} });
+	return lines;
+};
+/**
+* Parses plaintext or XML QRC, retaining explicit timing, word romanization, and ruby from kana metadata.
+* Original-track kana supplies ruby and is removed from the returned metadata.
+*
+* @param input Original lyrics with optional translation and romanization tracks.
+* @param options Independent line and word tolerances, with optional local roman recovery.
+*
+* @returns Canonical lyrics and source diagnostics; an empty result has INVALID status.
+*/
+var parseQrc = (input, options = {}) => {
+	const source = readContent(input);
+	if (!source) return finalizeLyric(makeLyric({
+		format: "qrc",
+		status: LyricStatus.INVALID
+	}));
+	const parsed = readLines(source.original);
+	const meta = parsed.meta;
+	const rubies = readRubies(meta);
+	if (!parsed.lines.length) return finalizeLyric(makeLyric({
+		format: "qrc",
+		status: LyricStatus.INVALID,
+		meta
+	}));
+	const timings = /* @__PURE__ */ new WeakMap();
+	const translationLines = readAnnotations$1(source.translations && readText$2(source.translations), timings);
+	const romanLines = readAnnotations$1(source.romans && readText$2(source.romans), timings);
+	const rounding = romanLines.some((line) => timings.get(line)?.rounding === 1) ? 1 : 0;
+	const wordTolerance = Number.isFinite(options.wordAnnotationTolerance) ? options.wordAnnotationTolerance ?? 0 : 0;
+	const annotated = attachAnnotations(!rubies ? parsed.lines : attachRubies(parsed.lines, rubies).lines, {
+		translations: translationLines,
+		romans: romanLines
+	}, {
+		matchByOrder: true,
+		preservePlaceholders: true,
+		tolerance: options.annotationTolerance,
+		wordTolerance: Math.max(wordTolerance, rounding),
+		wordFallback: options.wordAnnotationFallback,
+		getTiming: (line) => timings.get(line)
+	});
+	const lines = parsed.placeholders.size ? annotated.filter((_, index) => !parsed.placeholders.has(index)) : annotated;
+	return finalizeLyric(makeLyric({
+		format: "qrc",
+		status: lines.length ? LyricStatus.VALID : LyricStatus.INVALID,
+		timing: lines.some(isWordLevelLine) ? Timing.WORD : Timing.LINE,
+		meta,
+		lines,
+		languages: deriveLanguageUsages(lines)
+	}));
+};
+//#endregion
+//#region src/formats/krc/parser.ts
+var SEPARATORS$2 = /^\p{White_Space}+$/u;
+var appendWords$1 = (words, text, time) => {
+	for (const fragment of text.split(/(\p{White_Space}+)/u)) {
+		if (!fragment) continue;
+		words.push(SEPARATORS$2.test(fragment) ? makeWordSpace({ text: fragment }) : makeWordNormal({
+			text: fragment,
+			time
+		}));
+	}
+};
+var readLine$3 = (body, start, duration) => {
+	const time = makeTimeRange({
+		start,
+		end: start + duration
+	});
+	const pieces = scanWordTags(body, WORD_PATTERN$3);
+	if (!pieces.some((piece) => piece.tag !== void 0)) return body.trim() ? makeLineNormal({
+		time,
+		content: makeLineContentText(body)
+	}) : makeLineInstrumental({ time });
+	const words = [];
+	for (const piece of pieces) {
+		if (piece.tag === void 0) {
+			appendWords$1(words, piece.text);
+			continue;
+		}
+		const [offset, wordDuration] = piece.tag.split(",").map(Number);
+		const wordStart = start + offset;
+		appendWords$1(words, piece.text, makeTimeRange({
+			start: wordStart,
+			end: wordStart + wordDuration
+		}));
+	}
+	return getWordsText(words).trim() ? makeLineNormal({
+		time,
+		content: makeLineContentWords(words)
+	}) : makeLineInstrumental({ time });
+};
+/**
+* Reads native KRC rows in source order and performs no other operation: no metadata mapping, annotation attachment, sorting, or normalization.
+*
+* Explicit line and word durations survive unchanged; whitespace splitting never reallocates segment time.
+*
+* @returns Original-order model lines and metadata tags awaiting interpretation.
+*/
+var readKrc = (text) => {
+	const lines = [];
+	const metaTags = [];
+	for (const raw of text.replace(/^\uFEFF/, "").split(/\r\n?|\n/)) {
+		const line = raw.trimStart();
+		const header = LINE_PATTERN$3.exec(line);
+		if (header) {
+			lines.push(readLine$3(line.slice(header[0].length), Number(header[1]), Number(header[2])));
+			continue;
+		}
+		if (!line.startsWith("[")) continue;
+		for (const tag of line.matchAll(TAG_PATTERN)) {
+			const meta = META_PATTERN.exec(tag[1]);
+			if (meta) metaTags.push({
+				key: meta[1].toLowerCase(),
+				value: meta[2].trim()
+			});
+		}
+	}
+	return {
+		lines,
+		metaTags
+	};
+};
+var attachKana = (lines, meta) => {
+	for (const entry of meta.unknowns) {
+		if (entry.key !== "kana") continue;
+		const sources = readRubyEntries(entry.value);
+		if (!sources) continue;
+		const attached = attachRubies(lines, sources);
+		if (attached.matched.size === sources.length) meta.unknowns = meta.unknowns.filter((item) => item !== entry);
+		return attached.lines;
+	}
+	return lines;
+};
+var isObject$1 = (value) => {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+};
+var readPayload = (value) => {
+	const bytes = decodeBase64(value);
+	if (!bytes) return;
+	try {
+		const payload = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+		return isObject$1(payload) && payload.version === 1 && Array.isArray(payload.content) ? payload : void 0;
+	} catch {
+		return;
+	}
+};
+var readTrack$1 = (value) => {
+	if (!isObject$1(value) || value.type !== 0 && value.type !== 1 || typeof value.language !== "number" || !Number.isSafeInteger(value.language) || value.language < 0 || !Array.isArray(value.lyricContent) || !value.lyricContent.every((row) => Array.isArray(row) && row.every((cell) => typeof cell === "string"))) return;
+	return value;
+};
+var attachTrack = (lines, track) => {
+	let result = lines;
+	let complete = true;
+	for (const [index, cells] of track.lyricContent.entries()) {
+		const text = cells.join("");
+		if (cells.length > 1) complete = false;
+		if (!text.trim() || isPlaceholderText(text)) continue;
+		const line = result[index];
+		if (line.type === LineType.INSTRUMENTAL) {
+			complete = false;
+			continue;
+		}
+		const kind = track.type === 1 ? "translations" : "romans";
+		const existing = line.annotation?.[kind] ?? [];
+		const occupied = existing.find((item) => !item.language);
+		if (occupied) {
+			complete = complete && occupied.text === text;
+			continue;
+		}
+		const create = track.type === 1 ? makeLineAnnotationTranslation : makeLineAnnotationRoman;
+		const annotated = {
+			...line,
+			annotation: makeLineAnnotation({
+				...line.annotation,
+				[kind]: [...existing, create({ text })]
+			})
+		};
+		if (result === lines) result = lines.slice();
+		result[index] = annotated;
+	}
+	return {
+		lines: result,
+		complete
+	};
+};
+/**
+* Attaches strictly recognized Kugou language tracks by original timed slot before sorting or filtering.
+*
+* Existing annotations take precedence; incomplete or ambiguous payloads remain in metadata.
+* Numeric language codes other than the verified default are retained without inventing BCP 47 tags.
+*
+* @returns Annotated lines, reusing the original array when no visible content changes.
+*/
+var attachKugouLanguage = (lines, meta) => {
+	if (!lines.length) return lines;
+	let result = lines;
+	const unknowns = [];
+	const selected = /* @__PURE__ */ new Map();
+	for (const entry of meta.unknowns) {
+		const payload = entry.key === "language" ? readPayload(entry.value) : void 0;
+		if (!payload) {
+			unknowns.push(entry);
+			continue;
+		}
+		let complete = Object.keys(payload).every((key) => key === "version" || key === "content" || key === "contentV2");
+		if ("contentV2" in payload && (!Array.isArray(payload.contentV2) || payload.contentV2.length !== 0)) complete = false;
+		for (const value of payload.content) {
+			const track = readTrack$1(value);
+			if (!track || track.language !== 0 || track.lyricContent.length !== lines.length) {
+				complete = false;
+				continue;
+			}
+			if (Object.keys(value).some((key) => key !== "type" && key !== "language" && key !== "lyricContent")) complete = false;
+			const previous = selected.get(track.type);
+			if (previous) {
+				complete = complete && JSON.stringify(previous) === JSON.stringify(track.lyricContent);
+				continue;
+			}
+			selected.set(track.type, track.lyricContent);
+			const attached = attachTrack(result, track);
+			result = attached.lines;
+			complete = complete && attached.complete;
+		}
+		if (!complete) unknowns.push(entry);
+	}
+	meta.unknowns = unknowns;
+	return result;
+};
+/**
+* Parses decrypted Kugou lyrics, retaining explicit durations and attaching embedded annotations by source slot.
+*
+* A source carrying no KRC row is read as LRC, so a platform fallback keeps its container annotations.
+* Placeholder slots carry no annotation, so they never keep a credit line in the stream.
+* Kana supplies whole-word ruby; type 0 language tracks retain complete line romanization.
+* Incomplete metadata remains available in unknowns, and source timing violations remain visible in diagnostics.
+*
+* @param input Decrypted plaintext or an object containing its original text.
+*
+* @returns Canonical lyrics and model diagnostics; no readable timed rows yields INVALID status.
+*/
+var parseKrc = (input) => {
+	const source = readKrcContent(input);
+	if (!source) return finalizeLyric(makeLyric({
+		format: "krc",
+		status: LyricStatus.INVALID
+	}));
+	const native = readKrc(source.original);
+	const parsed = native.lines.length ? native : readLrc(source.original);
+	const meta = readLrcMetaTags(parsed.metaTags);
+	const lines = attachKugouLanguage(attachKana(parsed.lines, meta), meta);
+	return finalizeLyric(makeLyric({
+		format: "krc",
+		status: lines.length ? LyricStatus.VALID : LyricStatus.INVALID,
+		timing: lines.some(isWordLevelLine) ? Timing.WORD : Timing.LINE,
+		meta,
+		lines,
+		languages: deriveLanguageUsages(lines)
+	}));
+};
+//#endregion
+//#region src/formats/kwrc/common.ts
+var FORMAT$1 = "kwrc";
+var LINE_PATTERN$1 = /^\[([^\]]*)\]/;
+var WORD_PATTERN$1 = /<(-?\d+,-?\d+(?:,-?\d+)?)>/g;
+var VISIBLE_TEXT = /[^\p{White_Space}]/u;
+/**
+* Removes only complete encoded tags so literal angle-bracket text survives.
+*/
+var readText$1 = (text) => {
+	return text.replace(WORD_PATTERN$1, "");
+};
+/**
+* Accepts decoded plaintext without unwrapping XML or auxiliary tracks.
+*/
+var readKwrcContent = (input) => {
+	const source = typeof input === "string" ? { original: input } : input;
+	if (!source || typeof source !== "object" || Array.isArray(source)) return null;
+	const original = source.original;
+	if (typeof original !== "string" || /^\s*</.test(original)) return null;
+	return { original };
+};
+/**
+* Retains source slots and literal bodies before word timing or bilingual boundaries are interpreted.
+*/
+var readKwrcSource = (text) => {
+	const lines = [];
+	const metaTags = [];
+	const rows = text.replace(/^\uFEFF/, "").split(/\r\n?|\n/);
+	for (const [row, raw] of rows.entries()) {
+		const times = [];
+		let body = raw.trimStart();
+		let header;
+		while (header = LINE_PATTERN$1.exec(body)) {
+			const tag = header[1].trim();
+			const start = parseTime(tag);
+			if (start !== void 0) times.push({
+				start,
+				clock: /^[\d:.]+$/.test(tag)
+			});
+			else {
+				const meta = META_PATTERN.exec(tag);
+				if (!meta || times.length) break;
+				metaTags.push({
+					key: meta[1].toLowerCase(),
+					value: meta[2].trim()
+				});
+			}
+			body = body.slice(header[0].length);
+			if (!times.length) body = body.trimStart();
+		}
+		for (const time of times) lines.push({
+			row,
+			...time,
+			text: body
+		});
+	}
+	return {
+		lines,
+		metaTags
+	};
+};
+/**
+* Requires complete octal values and agreement across all parameter tags, without selecting a default scale.
+*/
+var readKwrcScales = (tags) => {
+	let value;
+	for (const tag of tags) {
+		if (tag.key !== "kuwo") continue;
+		if (!/^[0-7]+$/.test(tag.value)) return;
+		const next = Number.parseInt(tag.value, 8);
+		if (!Number.isSafeInteger(next) || value !== void 0 && value !== next) return;
+		value = next;
+	}
+	if (value === void 0) return;
+	const start = Math.trunc(value / 10);
+	const duration = value % 10;
+	return start > 0 && duration > 0 ? {
+		start,
+		duration
+	} : void 0;
+};
+/**
+* A repeated timestamp opens the previous original's translation slot before the next original.
+* The entire sequence must agree so one missing slot cannot shift all later translations.
+*/
+var hasKwrcTranslations = ({ lines, metaTags }) => {
+	const markers = metaTags.filter((tag) => tag.key === "ml");
+	if (!markers.length || markers.some((tag) => tag.value !== "1.0") || lines.length < 3 || lines.length % 2 !== 1) return false;
+	if (!lines.every((line, index) => {
+		return line.clock && Number.isSafeInteger(line.start) && line.row !== lines[index - 1]?.row;
+	})) return false;
+	let previous = lines[0];
+	for (let index = 1; index < lines.length; index += 2) {
+		const translation = lines[index];
+		const original = lines[index + 1];
+		if (translation.start <= previous.start || translation.start !== original.start) return false;
+		if (!VISIBLE_TEXT.test(readText$1(previous.text)) && VISIBLE_TEXT.test(readText$1(translation.text))) return false;
+		previous = original;
+	}
+	return true;
+};
+//#endregion
+//#region src/formats/kwrc/detect.ts
+/**
+* Recognizes octal parameters with encoded clock rows, or a complete marked bilingual sequence.
+*/
+var detectKwrc = (input) => {
+	const source = readKwrcContent(input);
+	if (!source) return false;
+	const track = readKwrcSource(source.original);
+	if (readKwrcScales(track.metaTags)) {
+		for (const line of track.lines) if (line.clock && Number.isSafeInteger(line.start) && line.text.search(WORD_PATTERN$1) !== -1) return true;
+	}
+	return hasKwrcTranslations(track);
+};
+//#endregion
+//#region src/formats/kwrc/parser.ts
+var SEPARATORS$1 = /^\p{White_Space}+$/u;
+var readWordTime = (tag, lineStart, scales) => {
+	const values = tag.split(",").map(Number);
+	if (!Number.isSafeInteger(lineStart) || !values.every(Number.isSafeInteger)) return;
+	const [x, y] = values;
+	const sum = x + y;
+	const difference = x - y;
+	if (!Number.isSafeInteger(sum) || !Number.isSafeInteger(difference) || sum % (2 * scales.start) !== 0 || difference % (2 * scales.duration) !== 0) return;
+	const relativeStart = Math.abs(sum / (2 * scales.start));
+	const duration = Math.abs(difference / (2 * scales.duration));
+	const start = lineStart + relativeStart;
+	const end = start + duration;
+	if (![
+		relativeStart,
+		duration,
+		start,
+		end
+	].every(Number.isSafeInteger)) return;
+	return makeTimeRange({
+		start,
+		end
+	});
+};
+var readLine$2 = ({ text, start }, nextStart, scales) => {
+	const boundary = nextStart !== void 0 && nextStart >= start ? nextStart : void 0;
+	let end = boundary;
+	const pieces = scanWordTags(text, WORD_PATTERN$1);
+	if (!pieces.some((piece) => piece.tag !== void 0)) {
+		if (Number.isSafeInteger(start) && splitWordTags(text).some((piece) => piece.tag !== void 0)) return readLrc(`[${start}ms]${text}${end === void 0 ? "" : `\n[${end}ms]`}`).lines[0];
+		const time = makeTimeRange({
+			start,
+			end
+		});
+		return VISIBLE_TEXT.test(text) ? makeLineNormal({
+			time,
+			content: makeLineContentText(text)
+		}) : makeLineInstrumental({ time });
+	}
+	const words = [];
+	for (const piece of pieces) {
+		const time = piece.tag !== void 0 && scales ? readWordTime(piece.tag, start, scales) : void 0;
+		if (piece.tag !== void 0 && !time) return makeLineNormal({
+			time: makeTimeRange({
+				start,
+				end: boundary
+			}),
+			content: makeLineContentText(text)
+		});
+		if (time?.end !== void 0) end = Math.max(end ?? start, time.end);
+		for (const fragment of piece.text.split(/(\p{White_Space}+)/u)) if (fragment) words.push(SEPARATORS$1.test(fragment) ? makeWordSpace({ text: fragment }) : makeWordNormal({
+			text: fragment,
+			time
+		}));
+	}
+	const time = makeTimeRange({
+		start,
+		end
+	});
+	return VISIBLE_TEXT.test(readText$1(text)) ? makeLineNormal({
+		time,
+		content: makeLineContentWords(words)
+	}) : makeLineInstrumental({ time });
+};
+/**
+* Parses decoded KWRC with explicit word durations and structurally verified embedded translations.
+*
+* Missing or conflicting parameters and unsafe word calculations retain the complete row as line-level text.
+* Plain LRC remains readable; offset is stored as metadata without changing source timestamps.
+*
+* @param input Decoded plaintext or an object containing its original text.
+*
+* @returns Canonical lyrics and model diagnostics; no readable timed rows yields INVALID status.
+*/
+var parseKwrc = (input) => {
+	const source = readKwrcContent(input);
+	if (!source) return finalizeLyric(makeLyric({
+		format: FORMAT$1,
+		status: LyricStatus.INVALID
+	}));
+	const track = readKwrcSource(source.original);
+	const bilingual = hasKwrcTranslations(track);
+	const encoded = track.lines.some((line) => !!line.text.match(WORD_PATTERN$1));
+	let lines;
+	let tags = track.metaTags;
+	if (!encoded && !bilingual) {
+		const fallback = readLrc(source.original);
+		lines = fallback.lines;
+		tags = fallback.metaTags;
+	} else {
+		const scales = readKwrcScales(tags);
+		const originals = bilingual ? track.lines.filter((_, index) => index % 2 === 0) : track.lines;
+		lines = originals.map((original, index) => {
+			const line = readLine$2(original, originals[index + 1]?.start, scales);
+			const translation = bilingual ? readText$1(track.lines[index * 2 + 1]?.text ?? "") : "";
+			if (VISIBLE_TEXT.test(translation)) line.annotation = makeLineAnnotation({ translations: [makeLineAnnotationTranslation({ text: translation })] });
+			return line;
+		});
+	}
+	const last = lines.at(-1);
+	if (last?.type === LineType.INSTRUMENTAL && (last.time?.end === void 0 || last.time.end === last.time.start)) lines.pop();
+	return finalizeLyric(makeLyric({
+		format: FORMAT$1,
+		status: lines.length ? LyricStatus.VALID : LyricStatus.INVALID,
+		timing: lines.some(isWordLevelLine) ? Timing.WORD : Timing.LINE,
+		meta: readLrcMetaTags(tags),
+		lines,
+		languages: deriveLanguageUsages(lines)
+	}));
+};
+//#endregion
 //#region src/formats/ttml/common.ts
 var FORMAT = "ttml";
 var AMLL_HINT_PATTERN = /xmlns:amll|amll:meta/iu;
@@ -1404,7 +2837,7 @@ var renderTime = (time, offset) => {
 * Writes known bounds without inventing an end.
 */
 var renderTimeAttributes = (time, offset) => {
-	if (time === void 0) throw new Error("TTML sung lines, words, and ruby tokens require a time range");
+	if (!time) throw new Error("TTML sung lines, words, and ruby tokens require a time range");
 	const attributes = [["begin", renderTime(time.start, offset)]];
 	if (time.end !== void 0) attributes.push(["end", renderTime(time.end, offset)]);
 	return attributes;
@@ -1426,7 +2859,7 @@ var renderWord = (word, context, language) => {
 	if (word.type === WordType.SPACE) return createXmlText(word.text);
 	const attributes = [...renderTimeAttributes(word.time, context.offset), ...renderLanguage(word.language, language)];
 	const ruby = context.profile === "amll" ? word.annotation?.rubies[0] : void 0;
-	if (ruby === void 0) return createXmlElement("span", attributes, [createXmlText(word.text)]);
+	if (!ruby) return createXmlElement("span", attributes, [createXmlText(word.text)]);
 	const tokens = ruby.tokens.map((token) => {
 		return createXmlElement("span", [["tts:ruby", RUBY_TEXT], ...renderTimeAttributes(resolveAnnotationTokenTime(token, ruby, word), context.offset)], [createXmlText(token.text)]);
 	});
@@ -1441,7 +2874,7 @@ var renderWord = (word, context, language) => {
 */
 var renderContent = (line, context) => {
 	const content = line.content;
-	if (content === void 0) throw new Error("TTML sung lines require content");
+	if (!content) throw new Error("TTML sung lines require content");
 	if (content.text !== void 0) return [createXmlText(content.text)];
 	return content.words.map((word) => {
 		return renderWord(word, context, getLineLanguage(line));
@@ -1450,10 +2883,10 @@ var renderContent = (line, context) => {
 /**
 * Keeps annotations outside the sung word stream.
 */
-var renderInlineAnnotations = (annotation, language) => {
+var renderInlineAnnotations = (line, language) => {
 	const nodes = [];
-	for (const item of annotation?.translations ?? []) nodes.push(createXmlElement("span", [["ttm:role", ROLE_TRANSLATION], ...renderLanguage(item.language, language)], [createXmlText(item.text)]));
-	for (const item of annotation?.romans ?? []) nodes.push(createXmlElement("span", [["ttm:role", ROLE_ROMAN], ...renderLanguage(item.language, language)], [createXmlText(item.text)]));
+	for (const item of line.annotation?.translations ?? []) nodes.push(createXmlElement("span", [["ttm:role", ROLE_TRANSLATION], ...renderLanguage(item.language, language)], [createXmlText(item.text)]));
+	for (const item of getLineRomans(line)) nodes.push(createXmlElement("span", [["ttm:role", ROLE_ROMAN], ...renderLanguage(item.language, language)], [createXmlText(item.text)]));
 	return nodes;
 };
 /**
@@ -1469,7 +2902,7 @@ var renderLineAttributes = (line, context) => {
 	const lead = line.agents[0];
 	if (lead !== void 0) {
 		const id = context.agents.get(lead);
-		if (id === void 0) throw new Error("TTML performing agents must have a declaration");
+		if (!id) throw new Error("TTML performing agents must have a declaration");
 		attributes.push(["ttm:agent", id]);
 	}
 	return attributes;
@@ -1482,7 +2915,7 @@ var createLyricElement = (name, attributes, children) => {
 };
 var renderBackground = (line, context) => {
 	const children = renderContent(line, context);
-	if (context.profile === "amll") children.push(...renderInlineAnnotations(line.annotation, getLineLanguage(line)));
+	if (context.profile === "amll") children.push(...renderInlineAnnotations(line, getLineLanguage(line)));
 	return createXmlElement("span", [["ttm:role", ROLE_BACKGROUND], ...renderLineAttributes(line, context)], children);
 };
 var renderLine = (line, context) => {
@@ -1490,7 +2923,7 @@ var renderLine = (line, context) => {
 	const after = [];
 	for (const background of line.backgrounds) {
 		const node = renderBackground(background, context);
-		if (background.time !== void 0 && line.time !== void 0 && background.time.start < line.time.start) before.push(node);
+		if (background.time && line.time && background.time.start < line.time.start) before.push(node);
 		else after.push(node);
 	}
 	const children = [
@@ -1498,7 +2931,7 @@ var renderLine = (line, context) => {
 		...renderContent(line, context),
 		...after
 	];
-	if (context.profile === "amll") children.push(...renderInlineAnnotations(line.annotation, getLineLanguage(line)));
+	if (context.profile === "amll") children.push(...renderInlineAnnotations(line, getLineLanguage(line)));
 	return createLyricElement("p", renderLineAttributes(line, context), children);
 };
 var renderAgents = (lyric, context) => {
@@ -1533,10 +2966,10 @@ var renderSongwriters = (meta) => {
 		if (credit.role !== CreditRole.LYRICIST) continue;
 		for (const name of credit.names) names.push(createXmlElement("songwriter", renderLanguage(name.language), [createXmlText(name.text)]));
 	}
-	return names.length === 0 ? [] : [createXmlElement("songwriters", [], names)];
+	return names.length ? [createXmlElement("songwriters", [], names)] : [];
 };
 var renderAnnotationTracks = (tracks, kind, context) => {
-	if (tracks.size === 0) return [];
+	if (!tracks.size) return [];
 	const translated = kind === "translations";
 	const blocks = Array.from(tracks, ([language, track]) => {
 		const attributes = translated ? [["type", "subtitle"]] : [];
@@ -1556,26 +2989,29 @@ var renderHeadAnnotations = (lines, context) => {
 		translations: /* @__PURE__ */ new Map(),
 		romans: /* @__PURE__ */ new Map()
 	};
-	const append = (annotation, line, background) => {
-		if (annotation === void 0) return;
+	const append = (source, line, background) => {
+		const annotation = {
+			translations: source.annotation?.translations ?? [],
+			romans: getLineRomans(source)
+		};
 		for (const kind of ANNOTATION_KINDS) for (const item of annotation[kind]) {
 			const language = item.language?.toLowerCase();
 			let track = tracks[kind].get(language);
-			if (track === void 0) {
+			if (!track) {
 				track = /* @__PURE__ */ new Map();
 				tracks[kind].set(language, track);
 			}
 			let nodes = track.get(line);
-			if (nodes === void 0) {
+			if (!nodes) {
 				nodes = [];
 				track.set(line, nodes);
 			}
-			nodes.push(background === void 0 ? createXmlText(item.text) : createXmlElement("span", [["ttm:role", ROLE_BACKGROUND], ["for", context.keys.get(background)]], [createXmlText(item.text)]));
+			nodes.push(!background ? createXmlText(item.text) : createXmlElement("span", [["ttm:role", ROLE_BACKGROUND], ["for", context.keys.get(background)]], [createXmlText(item.text)]));
 		}
 	};
 	for (const line of lines) {
-		append(line.annotation, line);
-		for (const background of line.backgrounds) append(background.annotation, line, background);
+		append(line, line);
+		for (const background of line.backgrounds) append(background, line, background);
 	}
 	return ANNOTATION_KINDS.flatMap((kind) => {
 		return renderAnnotationTracks(tracks[kind], kind, context);
@@ -1584,12 +3020,12 @@ var renderHeadAnnotations = (lines, context) => {
 var renderMetadata = (lyric, lines, context, includeMeta) => {
 	const metadata = renderAgents(lyric, context);
 	const itunes = [];
-	if (includeMeta && lyric.meta !== void 0) {
+	if (includeMeta && lyric.meta) {
 		if (context.profile === "amll") metadata.push(...renderAmllMeta(lyric.meta));
 		itunes.push(...renderSongwriters(lyric.meta));
 	}
 	if (context.profile === "itunes") itunes.push(...renderHeadAnnotations(lines, context));
-	if (itunes.length > 0) metadata.push(createXmlElement("iTunesMetadata", [["xmlns", NAMESPACE_ITUNES_METADATA]], itunes));
+	if (itunes.length) metadata.push(createXmlElement("iTunesMetadata", [["xmlns", NAMESPACE_ITUNES_METADATA]], itunes));
 	return createXmlElement("metadata", renderLanguage(void 0, lyric.meta?.language), metadata);
 };
 var renderRootAttributes = (lyric, profile) => {
@@ -1608,6 +3044,7 @@ var renderRootAttributes = (lyric, profile) => {
 *
 * Offsets are baked into timestamps; a negative result or a missing required time throws.
 * Profile mappings retain the lead agent and first AMLL ruby, omitting unsupported fields and instrumental nodes.
+* Word romanizations are emitted as line text without their token timing.
 */
 var generateTtml = (lyric, options = {}) => {
 	if (lyric.timing !== Timing.LINE && lyric.timing !== Timing.WORD) throw new Error("TTML generation requires line or word timing");
@@ -1691,7 +3128,7 @@ var readText = (element, inherited) => {
 * Preserves the parser's whitespace segmentation when turning text into word drafts.
 */
 var splitWords = (text, language) => {
-	if (text === "") return [];
+	if (!text) return [];
 	if (!WORD_SEPARATOR_PATTERN.test(text)) return [{
 		text,
 		space: false,
@@ -1699,7 +3136,7 @@ var splitWords = (text, language) => {
 		rubies: []
 	}];
 	const words = [];
-	for (const run of text.split(/(\p{White_Space}+)/u)) if (run !== "") {
+	for (const run of text.split(/(\p{White_Space}+)/u)) if (run) {
 		const space = /^\p{White_Space}+$/u.test(run);
 		words.push({
 			text: run,
@@ -1714,7 +3151,7 @@ var splitWords = (text, language) => {
 * Distinguishes indentation runs from separators using the parser's existing rule.
 */
 var isFormattingWhitespace = (text) => {
-	return text.trim() === "" && text.includes("\n");
+	return !text.trim() && text.includes("\n");
 };
 /**
 * Builds words from source drafts without deriving missing timestamps.
@@ -1730,7 +3167,7 @@ var buildWords = (draft) => {
 			start: word.start,
 			end: word.end
 		});
-		if (word.rubies.length === 0) {
+		if (!word.rubies.length) {
 			words.push(makeWordNormal({
 				text: word.text,
 				time,
@@ -1769,7 +3206,7 @@ var buildWords = (draft) => {
 * Builds only annotations explicitly present in the source drafts.
 */
 var buildLineAnnotation = (draft) => {
-	if (draft.translations.length === 0 && draft.romans.length === 0) return;
+	if (!draft.translations.length && !draft.romans.length) return;
 	return makeLineAnnotation({
 		translations: draft.translations.map((item) => {
 			return makeLineAnnotationTranslation({
@@ -1820,9 +3257,9 @@ var groupElements = (root, names, preserveSpace, stopAtMatch = false, language)
 		preserveSpace,
 		language
 	}];
-	while (stack.length > 0) {
+	while (stack.length) {
 		const entry = stack.pop();
-		if (entry === void 0) continue;
+		if (!entry) continue;
 		const element = entry.element;
 		const currentSpace = readPreserveSpace(element, entry.preserveSpace);
 		const currentLanguage = readLanguage(element, entry.language);
@@ -1833,7 +3270,7 @@ var groupElements = (root, names, preserveSpace, stopAtMatch = false, language)
 				preserveSpace: currentSpace,
 				language: currentLanguage
 			};
-			if (group === void 0) result.set(element.localName, [context]);
+			if (!group) result.set(element.localName, [context]);
 			else group.push(context);
 			if (stopAtMatch) continue;
 		}
@@ -1893,22 +3330,22 @@ var readRuby = (container, preserveSpace, language) => {
 	const last = tokens.findLast((token) => {
 		return token.start !== void 0;
 	});
-	const time = readSpanTime(container) ?? rubyTime ?? (first === void 0 ? void 0 : {
+	const time = readSpanTime(container) ?? rubyTime ?? (first ? {
 		start: first.start,
 		end: last?.end
-	});
+	} : void 0);
 	return {
 		text: base,
 		space: false,
 		start: time?.start,
 		end: time?.end,
 		language: baseLanguage,
-		rubies: tokens.length === 0 ? [] : [{
+		rubies: tokens.length ? [{
 			start: rubyTime?.start,
 			end: rubyTime?.end,
 			language: rubyLanguage,
 			tokens
-		}]
+		}] : []
 	};
 };
 /**
@@ -1932,7 +3369,7 @@ var readWords = (element, preserveSpace, language) => {
 		if (getXmlAttribute(child, "role") !== void 0) continue;
 		if (getXmlAttribute(child, "ruby") === "container") {
 			const ruby = readRuby(child, preserveSpace, language);
-			if (ruby !== void 0) {
+			if (ruby) {
 				for (const part of splitWords(ruby.text)) words.push(part.space ? part : {
 					...ruby,
 					text: part.text
@@ -1946,7 +3383,7 @@ var readWords = (element, preserveSpace, language) => {
 		if (!text || !childSpace && isFormattingWhitespace(text)) continue;
 		const time = readSpanTime(child);
 		for (const part of splitWords(text, readLanguage(child, language))) {
-			if (!part.space && time !== void 0) {
+			if (!part.space && time) {
 				part.start = time.start;
 				part.end = time.end;
 				wordLevel = true;
@@ -1982,11 +3419,11 @@ var readInlineAnnotations = (element, preserveSpace, language) => {
 /**
 * Reads one paragraph, pulling its inline annotations and background lines out of the word stream.
 */
-var readLine = (element, preserveSpace, language) => {
+var readLine$1 = (element, preserveSpace, language) => {
 	preserveSpace = readPreserveSpace(element, preserveSpace);
 	language = readLanguage(element, language);
 	const time = readLineTime(element);
-	if (time === void 0) return;
+	if (!time) return;
 	const draft = {
 		start: time.start,
 		end: time.end,
@@ -2027,7 +3464,7 @@ var readBackground = (element, preserveSpace, language) => {
 	preserveSpace = readPreserveSpace(element, preserveSpace);
 	language = readLanguage(element, language);
 	const read = readWords(element, preserveSpace, language);
-	if (read.words.length === 0) return;
+	if (!read.words.length) return;
 	const begin = getXmlAttribute(element, "begin");
 	const end = getXmlAttribute(element, "end");
 	const first = read.words.find((word) => {
@@ -2069,7 +3506,7 @@ var buildBackground = (draft) => {
 			end: draft.end
 		}),
 		agents: draft.agentId === void 0 ? [] : [draft.agentId],
-		languages: draft.language === void 0 ? [] : [draft.language],
+		languages: draft.language ? [draft.language] : [],
 		content: buildContent(draft),
 		annotation: buildLineAnnotation(draft)
 	});
@@ -2085,7 +3522,7 @@ var buildLine = (draft) => {
 			end: draft.end
 		}),
 		agents: draft.agentId === void 0 ? [] : [draft.agentId],
-		languages: draft.language === void 0 ? [] : [draft.language],
+		languages: draft.language ? [draft.language] : [],
 		content: buildContent(draft),
 		annotation: buildLineAnnotation(draft),
 		backgrounds: draft.backgrounds.map(buildBackground)
@@ -2105,7 +3542,7 @@ var readAgents = (elements) => {
 				language: readLanguage(name, language)
 			});
 		}).filter((name) => {
-			return name.text !== "";
+			return !!name.text;
 		});
 		const kind = readAgentType(getXmlAttribute(element, "type"));
 		agents.push(makeAgent({
@@ -2129,9 +3566,9 @@ var readCredits = (elements, meta) => {
 			language
 		});
 	}).filter((name) => {
-		return name.text !== "";
+		return !!name.text;
 	});
-	if (names.length === 0) return;
+	if (!names.length) return;
 	meta.credits.push(makeMetaCredit({
 		role: CreditRole.LYRICIST,
 		names
@@ -2185,7 +3622,7 @@ var applyAmllMeta = (meta, element, language) => {
 * A replacement translation rewrites the line's text, which is how a source swaps one script for another.
 */
 var attachHeadAnnotations = (metadata, lineMap, backgroundMap) => {
-	if (lineMap.size === 0) return;
+	if (!lineMap.size) return;
 	const attach = (blocks, kind) => {
 		for (const { element: block, preserveSpace, language } of blocks) {
 			const type = getXmlQualifiedAttribute(block, "type") ?? getXmlAttribute(block, "type");
@@ -2254,23 +3691,23 @@ var parseTtml = (input, options = {}) => {
 	const language = readLanguage(root, lowerTag(options.language));
 	const body = findElements(root, "body", false, true, language)[0];
 	const metadata = findElements(root, "metadata", false, true, language)[0];
-	const metadataElements = metadata === void 0 ? /* @__PURE__ */ new Map() : groupElements(metadata.element, METADATA_NAMES, metadata.preserveSpace, false, metadata.language);
+	const metadataElements = metadata ? groupElements(metadata.element, METADATA_NAMES, metadata.preserveSpace, false, metadata.language) : /* @__PURE__ */ new Map();
 	const meta = makeMeta();
-	if (language !== void 0) meta.language = language;
+	if (language) meta.language = language;
 	readCredits(metadataElements.get("songwriter") ?? [], meta);
 	for (const { element, language: itemLanguage } of metadataElements.get("meta") ?? []) applyAmllMeta(meta, element, itemLanguage);
 	const drafts = [];
 	const lineMap = /* @__PURE__ */ new Map();
 	const backgroundMap = /* @__PURE__ */ new Map();
 	for (const { element, preserveSpace, language: lineLanguage } of body ? findElements(body.element, "p", body.preserveSpace, true, body.language) : []) {
-		const draft = readLine(element, preserveSpace, lineLanguage);
+		const draft = readLine$1(element, preserveSpace, lineLanguage);
 		if (!draft) continue;
 		drafts.push(draft);
 		if (draft.key) lineMap.set(draft.key, draft);
 		for (const background of draft.backgrounds) if (background.key) backgroundMap.set(background.key, background);
 	}
 	attachHeadAnnotations(metadataElements, lineMap, backgroundMap);
-	if (drafts.length === 0) return finalizeLyric(makeLyric({
+	if (!drafts.length) return finalizeLyric(makeLyric({
 		format: FORMAT,
 		status: LyricStatus.INVALID,
 		meta,
@@ -2294,6 +3731,260 @@ var parseTtml = (input, options = {}) => {
 	}));
 };
 //#endregion
+//#region src/formats/yrc/common.ts
+var LINE_PATTERN = /^\[(\d+),(\d+)\]/;
+var WORD_PATTERN = /\((\d+,\d+,\d+)\)/g;
+/**
+* Accepts plaintext tracks on one timeline without interpreting an API response or an XML container.
+*
+* @returns Original and optional auxiliary text, or null when the original payload is unreadable.
+*/
+var readYrcContent = (input) => {
+	const value = typeof input === "string" ? { original: input } : input;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const source = value;
+	if (typeof source.original !== "string" || /^\s*</.test(source.original)) return null;
+	return {
+		original: source.original,
+		translations: typeof source.translations === "string" ? source.translations : void 0,
+		romans: typeof source.romans === "string" ? source.romans : void 0
+	};
+};
+//#endregion
+//#region src/formats/yrc/parser.ts
+var SEPARATORS = /^\p{White_Space}+$/u;
+var CREDIT_LABEL_PATTERN = /[:：]$/u;
+var isObject = (value) => {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+};
+var readCredit = (fragments) => {
+	const label = trimRuleWhitespace(fragments[0] ?? "");
+	const raw = trimRuleWhitespace(label.replace(CREDIT_LABEL_PATTERN, ""));
+	if (!raw) return;
+	const names = fragments.slice(1).join("").split("/").map(trimRuleWhitespace).filter(Boolean);
+	return names.length ? {
+		raw,
+		names
+	} : void 0;
+};
+/**
+* Reads JSON display text and splits the joined credit content at slash separators.
+*
+* @returns A readable display line and whether all source fields are represented, or null for other JSON.
+*/
+var readJsonLine = (text) => {
+	try {
+		const value = JSON.parse(text);
+		if (!isObject(value) || typeof value.t !== "number" || !Number.isSafeInteger(value.t) || value.t < 0 || !Array.isArray(value.c)) return null;
+		const fragments = [];
+		let complete = Object.keys(value).every((key) => key === "t" || key === "c");
+		for (const fragment of value.c) {
+			if (!isObject(fragment) || typeof fragment.tx !== "string") return null;
+			fragments.push(fragment.tx);
+			complete = complete && Object.keys(fragment).every((key) => key === "tx");
+		}
+		const content = fragments.join("");
+		return /[^\p{White_Space}]/u.test(content) ? {
+			start: value.t,
+			text: content,
+			complete,
+			credit: readCredit(fragments)
+		} : null;
+	} catch {
+		return null;
+	}
+};
+var appendWords = (words, text, time) => {
+	for (const fragment of text.split(/(\p{White_Space}+)/u)) if (fragment) words.push(SEPARATORS.test(fragment) ? makeWordSpace({ text: fragment }) : makeWordNormal({
+		text: fragment,
+		time
+	}));
+};
+var readLine = (body, start, duration) => {
+	const time = makeTimeRange({
+		start,
+		end: start + duration
+	});
+	const pieces = scanWordTags(body, WORD_PATTERN);
+	if (!pieces.some((piece) => piece.tag !== void 0)) return /[^\p{White_Space}]/u.test(body) ? makeLineNormal({
+		time,
+		content: makeLineContentText(body)
+	}) : makeLineInstrumental({ time });
+	const words = [];
+	for (const piece of pieces) {
+		if (piece.tag === void 0) {
+			appendWords(words, piece.text);
+			continue;
+		}
+		const [wordStart, wordDuration] = piece.tag.split(",").map(Number);
+		appendWords(words, piece.text, makeTimeRange({
+			start: wordStart,
+			end: wordStart + wordDuration
+		}));
+	}
+	return words.some((word) => word.type === WordType.NORMAL) ? makeLineNormal({
+		time,
+		content: makeLineContentWords(words)
+	}) : makeLineInstrumental({ time });
+};
+var readTrack = (text, timings) => {
+	const tags = [];
+	const native = [];
+	const fallback = [];
+	const displays = [];
+	const rows = /^\s*</.test(text) ? [] : text.replace(/^\uFEFF/, "").split(/\r\n?|\n/);
+	for (const [row, raw] of rows.entries()) {
+		const line = raw.trimStart();
+		const header = LINE_PATTERN.exec(line);
+		if (header) {
+			native.push({
+				row,
+				line: readLine(line.slice(header[0].length), Number(header[1]), Number(header[2]))
+			});
+			fallback.push("");
+		} else if (line.startsWith("{")) {
+			const display = readJsonLine(line);
+			if (display) {
+				displays.push({
+					row,
+					display: true,
+					credit: !!display.credit,
+					line: makeLineNormal({
+						time: makeTimeRange({ start: display.start }),
+						content: makeLineContentText(display.text)
+					})
+				});
+				if (display.credit) {
+					const { raw, names } = display.credit;
+					for (const value of names) tags.push({
+						row,
+						unknown: true,
+						tag: {
+							key: raw,
+							value
+						}
+					});
+				}
+			}
+			if (!display?.complete) tags.push({
+				row,
+				unknown: true,
+				tag: {
+					key: "yrc:json",
+					value: raw
+				}
+			});
+			fallback.push(display ? `[${display.start}ms]` : "");
+		} else fallback.push(raw);
+	}
+	const clock = [];
+	const displayRows = new Set(displays.map((entry) => entry.row));
+	readLrc(fallback.join("\n"), {
+		onLine: (line, timing, row) => {
+			if (displayRows.has(row)) return;
+			clock.push({
+				row,
+				line
+			});
+			timings?.set(line, timing);
+		},
+		onMeta: (tag, row) => {
+			tags.push({
+				row,
+				tag
+			});
+		}
+	});
+	const entries = [...displays, ...native.length ? native : clock].sort((first, second) => first.row - second.row);
+	for (const [index, entry] of entries.entries()) {
+		if (!entry.display) continue;
+		const next = entries[index + 1]?.line.time?.start;
+		if (next !== void 0 && next >= entry.line.time.start) entry.line.time.end = next;
+	}
+	const metaTags = tags.sort((first, second) => first.row - second.row);
+	return {
+		entries: entries.filter((entry) => !entry.credit),
+		metaTags
+	};
+};
+var readAnnotations = (text, timings) => {
+	return text ? readTrack(text, timings).entries.filter((entry) => !entry.display).map((entry) => entry.line) : [];
+};
+/**
+* Parses native YRC or LRC fallback, keeping JSON display rows separate from annotation matching.
+* Explicit line and word durations remain unchanged, including zero durations and source timing violations.
+* JSON credit content becomes separate plain-text unknown entries sharing the source label and is omitted from lyric lines.
+*
+* @param input Plaintext tracks on the same timeline: yrc with ytlrc/yromalrc, or lrc with tlyric/romalrc.
+* @param options Independent line and word tolerances, with optional local roman recovery.
+*
+* @returns Canonical lyrics and model diagnostics; no readable timed rows yields INVALID status.
+*/
+var parseYrc = (input, options = {}) => {
+	const source = readYrcContent(input);
+	if (!source) return finalizeLyric(makeLyric({
+		format: "yrc",
+		status: LyricStatus.INVALID
+	}));
+	const parsed = readTrack(source.original);
+	const meta = readLrcMetaTags(parsed.metaTags.filter((entry) => !entry.unknown).map((entry) => entry.tag));
+	let unknownIndex = 0;
+	meta.unknowns = parsed.metaTags.flatMap(({ tag, unknown }) => {
+		if (unknown) return [makeUnknownEntry(tag)];
+		const entry = meta.unknowns[unknownIndex];
+		if (entry?.key === tag.key && entry.value === tag.value) {
+			unknownIndex += 1;
+			return [entry];
+		}
+		return [];
+	});
+	const body = parsed.entries.filter((entry) => !entry.display).map((entry) => entry.line);
+	const timings = /* @__PURE__ */ new WeakMap();
+	const annotated = attachAnnotations(body, {
+		translations: readAnnotations(source.translations, timings),
+		romans: readAnnotations(source.romans, timings)
+	}, {
+		preservePlaceholders: true,
+		tolerance: options.annotationTolerance,
+		wordTolerance: options.wordAnnotationTolerance,
+		wordFallback: options.wordAnnotationFallback,
+		getTiming: (line) => timings.get(line)
+	});
+	let index = 0;
+	const lines = parsed.entries.map((entry) => {
+		return entry.display ? entry.line : annotated[index++];
+	});
+	return finalizeLyric(makeLyric({
+		format: "yrc",
+		status: lines.length ? LyricStatus.VALID : LyricStatus.INVALID,
+		timing: lines.some(isWordLevelLine) ? Timing.WORD : Timing.LINE,
+		meta,
+		lines,
+		languages: deriveLanguageUsages(lines)
+	}));
+};
+//#endregion
+//#region src/formats/yrc/detect.ts
+/**
+* Recognizes native word tags or a JSON display line accompanied by LRC content in the original track.
+*
+* @returns Whether the original plaintext carries a YRC signal stronger than its shared QRC line header.
+*/
+var detectYrc = (input) => {
+	const source = readYrcContent(input);
+	if (!source) return false;
+	let display = false;
+	const fallback = [];
+	for (const raw of source.original.split(/\r\n?|\n/)) {
+		const line = raw.trimStart();
+		const header = LINE_PATTERN.exec(line);
+		if (header && line.slice(header[0].length).match(WORD_PATTERN)) return true;
+		if (line.startsWith("{")) display = display || !!readJsonLine(line);
+		else fallback.push(raw);
+	}
+	return display && detectLrc(fallback.join("\n"));
+};
+//#endregion
 //#region src/formats/index.ts
 /**
 * Recognition reads only the original text; the annotation tracks never decide the format.
@@ -2301,6 +3992,10 @@ var parseTtml = (input, options = {}) => {
 * Unrecognized text returns `undefined`.
 */
 var detectFormat = (input) => {
+	if (detectKrc(input)) return "krc";
+	if (detectYrc(input)) return "yrc";
+	if (detectQrc(input)) return "qrc";
+	if (detectKwrc(input)) return "kwrc";
 	if (detectLrc(input)) return "lrc";
 	if (detectTtml(input)) return "ttml";
 };
@@ -2312,8 +4007,12 @@ var parse = (input, options = {}) => {
 	const format = detectFormat(input);
 	if (!format) return null;
 	switch (format) {
+		case "krc": return parseKrc(input);
+		case "kwrc": return parseKwrc(input);
 		case "lrc": return parseLrc(input, options);
+		case "qrc": return parseQrc(input, options);
 		case "ttml": return parseTtml(input, options);
+		case "yrc": return parseYrc(input, options);
 	}
 };
 var GENERATORS = {
@@ -2323,7 +4022,7 @@ var GENERATORS = {
 /**
 * Generates text in the requested format, which need not match `lyric.format`.
 *
-* The writer map pairs each format's options with its result and requires a writer for every supported format.
+* The writer map pairs options with results only for formats that have an implemented writer.
 * An unknown target returns `null`.
 */
 var generate = (lyric, target, options = {}) => {
@@ -2331,6 +4030,6 @@ var generate = (lyric, target, options = {}) => {
 	return GENERATORS[target](lyric, options);
 };
 //#endregion
-export { detectFormat, detectLrc, detectTtml, generate, generateLrc, generateTtml, parse, parseLrc, parseTtml };
+export { META_PATTERN, TAG_PATTERN, attachRubies, detectFormat, detectKrc, detectKwrc, detectLrc, detectQrc, detectTtml, detectYrc, generate, generateLrc, generateTtml, isPlaceholderText, parse, parseKrc, parseKwrc, parseLrc, parseQrc, parseTtml, parseWordTime, parseYrc, readJsonLine, readKrc, readLrc, readLrcMetaTags, readRubyEntries, scanWordTags, splitWordTags };
 
 //# sourceMappingURL=formats.js.map