@gondola-lyrics/kit 0.5.0 → 0.6.0

package/dist/formats.js

@@ -1,5 +1,55 @@
-import { i as mapShared, n as lowerTag, r as lowerBound } from "./language.js";
+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;
+/**
+* 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 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 };
+};
+//#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
+/**
+* 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, "うくぐつふゔ"],
@@ -31,7 +81,7 @@ var combinesKana = (first, second) => {
 };
 //#endregion
 //#region src/utils/annotation.ts
-var readText$2 = (line) => {
+var readText$3 = (line) => {
 	return getContentText(line.content).trim();
 };
 /**
@@ -267,7 +317,7 @@ var readSources = (lines, options) => {
 	const preserve = options.preservePlaceholders;
 	for (const [index, line] of lines.entries()) {
 		const start = line.time?.start;
-		const text = readText$2(line);
+		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({
@@ -289,7 +339,7 @@ var createTimeIndex = (lines, options) => {
 		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$2(line)) lyricRows.push(index);
+		if (options.matchByOrder && line.type === LineType.NORMAL && readText$3(line)) lyricRows.push(index);
 		if (!valid) continue;
 		const queue = targets.get(start) ?? [];
 		queue.push(index);
@@ -516,6 +566,26 @@ 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/encoding.ts
+/**
+* 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.
+*
+* @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$1 = /^(?:(?:(\d+):)?(\d+):)?(\d+)(?:\.(\d+))?$/;
 var OFFSET_PATTERN = /^(\d+(?:\.\d+)?)(ms|h|m|s)$/iu;
@@ -1233,6 +1303,77 @@ var serializeXml = (root, options = {}) => {
 	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.
@@ -1254,7 +1395,7 @@ var WORD_OFFSET_PATTERN = /^(\d+)(?:,(\d+))?$/;
 var WORD_CLOCK_DURATION_PATTERN = /^([^,]+),(\d+)$/;
 var WORD_TAG_PATTERN = /<([^>]*)>/g;
 var TAG_PATTERN = /\[([^\]]*)\]/g;
-var META_PATTERN$1 = /^([A-Za-z0-9_-]+)\s*:\s*([\s\S]*)$/;
+var META_PATTERN = /^([A-Za-z0-9_-]+)\s*:\s*([\s\S]*)$/;
 /**
 * Integer tags use `offset[,duration]` in milliseconds relative to the line start.
 * Clock tags are absolute and may append a duration in milliseconds, as in `<00:01.50,500>`.
@@ -1288,36 +1429,42 @@ var parseWordTime = (body, lineStart) => {
 	}
 };
 /**
-* Untagged leading text is preserved; empty timed pieces retain explicit segment boundaries.
-* Only recognized time tags split content; other angle-bracket text remains literal.
+* 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)) {
+	for (const match of content.matchAll(pattern)) {
 		const nextTag = match[1] ?? "";
-		if (!parseWordTime(nextTag, 0)) continue;
-		const at = match.index;
-		const before = content.slice(cursor, at);
-		if (before || tag) pieces.push({
+		if (accepts && !accepts(nextTag)) continue;
+		const before = content.slice(cursor, match.index);
+		if (before || tag !== void 0) pieces.push({
 			text: before,
 			tag
 		});
 		tag = nextTag;
-		cursor = at + match[0].length;
+		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) 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
 /**
@@ -1465,57 +1612,47 @@ var generateLrc = (lyric, options = {}) => {
 	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/reader.ts
+//#region src/formats/lrc/parser.ts
 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$1 = (body) => {
-	const match = META_PATTERN$1.exec(body);
+	const match = META_PATTERN.exec(body);
 	if (!match) return;
 	return {
 		key: (match[1] ?? "").toLowerCase(),
 		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,
-				tag
+				tag,
+				row
 			});
 			continue;
 		}
 		const pair = readMeta$1(tag);
-		if (pair) meta.push(pair);
+		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)];
@@ -1526,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,
@@ -1592,7 +1729,7 @@ var readWords$2 = (pieces, lineStart) => {
 * 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({
@@ -1639,15 +1776,14 @@ var readLines$1 = (timed, options) => {
 	const lines = [];
 	for (const [index, item] of timed.entries()) {
 		const next = timed[index + 1]?.start;
-		const line = 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));
+		options.onLine?.(line, readLineTiming(item.tag), item.row);
 	}
 	return lines;
 };
 /**
-* Reads one LRC track before normalization so consumers retain source order and timing slots.
-* The caller owns metadata mapping, annotation attachment, and final normalization.
+* 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.
@@ -1655,22 +1791,23 @@ var readLines$1 = (timed, options) => {
 * @returns Model lines in input order and metadata tags with lowercase keys and trimmed values.
 */
 var readLrc = (text, options = {}) => {
-	const { timed, meta } = readTimedLines(text);
+	const { timed, meta } = readTimedLines(text, options);
 	return {
 		lines: readLines$1(timed, options),
 		metaTags: meta
 	};
 };
-//#endregion
-//#region src/formats/lrc/parser.ts
 var isBareNumber = (value) => {
 	return /^\d+$/.test(value.trim());
 };
 /**
-* 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.
+* 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 readMetaTags = (tags) => {
+var readLrcMetaTags = (tags) => {
 	const meta = makeMeta();
 	for (const tag of tags) switch (tag.key) {
 		case "length":
@@ -1714,7 +1851,7 @@ var readMetaTags = (tags) => {
 };
 var parseLrcText = (text) => {
 	const { lines, metaTags } = readLrc(text);
-	const meta = readMetaTags(metaTags);
+	const meta = readLrcMetaTags(metaTags);
 	if (!lines.length) return makeLyric({
 		format: "lrc",
 		status: LyricStatus.INVALID,
@@ -1759,88 +1896,22 @@ var parseLrc = (input, options = {}) => {
 	});
 };
 //#endregion
-//#region src/formats/qrc/common.ts
-var LINE_PATTERN = /^\[(\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$1 = (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$1(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/qrc/parser.ts
-var WORD_PATTERN = /\((\d+),(\d+)\)/g;
-var META_PATTERN = /^([A-Za-z0-9_-]+)\s*:\s*([\s\S]*)$/;
+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 = /^\p{White_Space}+$/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;
@@ -1965,13 +2036,16 @@ var matchRubies = (words, sources) => {
 /**
 * Attaches whole-word ruby without changing the source text, segmentation, or timing.
 *
-* @param lines Original QRC rows before filtering or sorting.
+* @param lines Original timed rows before filtering or sorting.
 * @param sources Readings with source coverage lengths and optional token times.
 *
-* @returns Annotated rows, reusing arrays and nodes when they are unchanged.
+* @returns Annotated rows and matched source indices, preserving unchanged nodes.
 */
 var attachRubies = (lines, sources) => {
-	if (!sources.length) return lines;
+	if (!sources.length) return {
+		lines,
+		matched: /* @__PURE__ */ new Set()
+	};
 	const words = [];
 	for (const line of lines) {
 		if (line.type !== LineType.NORMAL) continue;
@@ -1986,33 +2060,39 @@ var attachRubies = (lines, sources) => {
 		});
 	}
 	const matched = matchRubies(words, sources);
-	if (!matched.size) return lines;
+	if (!matched.size) return {
+		lines,
+		matched: /* @__PURE__ */ new Set()
+	};
 	const annotations = new Map([...matched].map(([source, target]) => [words[target].word, sources[source].ruby]));
-	return 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 {
+		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
+				}
 			};
-		});
-		return words === content.words ? line : {
-			...line,
-			content: {
-				...content,
-				words
-			}
-		};
-	});
+		}),
+		matched: new Set(matched.keys())
+	};
 };
 var readMeta = (body, meta) => {
-	const match = META_PATTERN.exec(body);
+	const match = META_PATTERN$1.exec(body);
 	if (!match) return;
 	const key = match[1].toLowerCase();
 	const value = match[2].trim();
@@ -2062,10 +2142,10 @@ var readTimeRange = (startText, durationText) => {
 		end: start + Number(durationText)
 	});
 };
-var appendWords = (words, text, time) => {
+var appendWords$2 = (words, text, time) => {
 	for (const fragment of text.split(/(\p{White_Space}+)/u)) {
 		if (!fragment) continue;
-		if (SEPARATORS.test(fragment)) words.push(makeWordSpace({ text: fragment }));
+		if (SEPARATORS$3.test(fragment)) words.push(makeWordSpace({ text: fragment }));
 		else words.push(makeWordNormal({
 			text: fragment,
 			time
@@ -2076,28 +2156,36 @@ var readWords$1 = (text) => {
 	const words = [];
 	let cursor = 0;
 	let tagged = false;
-	for (const match of text.matchAll(WORD_PATTERN)) {
+	for (const match of text.matchAll(WORD_PATTERN$2)) {
 		tagged = true;
-		appendWords(words, text.slice(cursor, match.index), readTimeRange(match[1], match[2]));
+		appendWords$2(words, text.slice(cursor, match.index), readTimeRange(match[1], match[2]));
 		cursor = match.index + match[0].length;
 	}
 	if (!tagged) return;
-	appendWords(words, text.slice(cursor));
+	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.exec(line);
+		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 = contentText === "//";
+			const placeholder = isPlaceholderText(contentText);
 			if (placeholder) placeholders.add(lines.length);
 			if (!contentText || placeholder) lines.push(makeLineInstrumental({ time }));
 			else {
@@ -2122,7 +2210,7 @@ var readLines = (text) => {
 		placeholders
 	};
 };
-var readAnnotations = (text, timings) => {
+var readAnnotations$1 = (text, timings) => {
 	if (!text) return [];
 	const { lines } = readLines(text);
 	if (lines.length) {
@@ -2130,7 +2218,7 @@ var readAnnotations = (text, timings) => {
 		return lines;
 	}
 	readLrc(text, { onLine: (line, timing) => {
-		const annotation = getContentText(line.content).trim() === "//" ? makeLineInstrumental({ time: line.time }) : line;
+		const annotation = isPlaceholderText(getContentText(line.content)) ? makeLineInstrumental({ time: line.time }) : line;
 		timings.set(annotation, timing);
 		lines.push(annotation);
 	} });
@@ -2160,11 +2248,11 @@ var parseQrc = (input, options = {}) => {
 		meta
 	}));
 	const timings = /* @__PURE__ */ new WeakMap();
-	const translationLines = readAnnotations(source.translations && readText$1(source.translations), timings);
-	const romanLines = readAnnotations(source.romans && readText$1(source.romans), timings);
+	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), {
+	const annotated = attachAnnotations(!rubies ? parsed.lines : attachRubies(parsed.lines, rubies).lines, {
 		translations: translationLines,
 		romans: romanLines
 	}, {
@@ -2186,6 +2274,441 @@ var parseQrc = (input, options = {}) => {
 	}));
 };
 //#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;
@@ -2896,7 +3419,7 @@ 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);
@@ -3177,7 +3700,7 @@ var parseTtml = (input, options = {}) => {
 	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);
@@ -3208,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.
@@ -3215,7 +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";
 };
@@ -3227,9 +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 = {
@@ -3247,6 +4030,6 @@ var generate = (lyric, target, options = {}) => {
 	return GENERATORS[target](lyric, options);
 };
 //#endregion
-export { detectFormat, detectLrc, detectQrc, detectTtml, generate, generateLrc, generateTtml, parse, parseLrc, parseQrc, parseTtml, readLrc };
+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