@gondola-lyrics/kit 0.3.0 → 0.5.0

package/dist/transforms.js

@@ -0,0 +1,3307 @@
+import { i as mapShared, t as findScriptRunEnd } from "./language.js";
+import { AgentType, CreditRole, LineType, Timing, WordType, deriveLanguageUsages, getContentText, isWordLevelLine, makeAgent, makeLineAnnotation, makeLineAnnotationRoman, makeLineAnnotationTranslation, makeLineBackground, makeLineContentText, makeLineContentWords, makeLineInstrumental, makeMeta, makeMetaCredit, makeText, makeTimeRange, makeWordEmphasis, makeWordSpace, validateTimeRange } from "@gondola-lyrics/model/runtime";
+//#region src/utils/rules.ts
+var RULE_WHITESPACE = /[\u0009-\u000D\u0020\u0085\u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]/g;
+var RULE_EDGE_WHITESPACE = /^[\u0009-\u000D\u0020\u0085\u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+|[\u0009-\u000D\u0020\u0085\u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+$/g;
+/**
+* Uses the shared whitespace set and ASCII case folding to keep matching consistent across language kits.
+*/
+var toRuleMatchKey = (text) => {
+	return text.replace(RULE_WHITESPACE, "").replace(/[A-Z]+/g, (run) => run.toLowerCase());
+};
+var RULE_WHITESPACE_CHARACTER = new RegExp(RULE_WHITESPACE.source);
+/**
+* Finds the offsets in toRuleMatchKey(text) where the source allows a cut.
+* A cut sits before the first kept character of a script run and after configured whitespace, so neutral punctuation never splits aliases such as A&R or Co-Producer.
+*
+* @param text A source label with its original spelling.
+*
+* @returns Ascending offsets from 0 to the key length, or undefined when the source has no inner cut.
+*/
+var findRuleMatchCuts = (text) => {
+	if (!RULE_WHITESPACE_CHARACTER.test(text) && findScriptRunEnd(text) === text.length) return;
+	const cuts = [0];
+	let length = 0;
+	let pendingCut = false;
+	let runStart = 0;
+	while (runStart < text.length) {
+		const runEnd = findScriptRunEnd(text, runStart);
+		if (runStart > 0) pendingCut = true;
+		for (const character of text.slice(runStart, runEnd)) {
+			if (RULE_WHITESPACE_CHARACTER.test(character)) {
+				pendingCut = true;
+				continue;
+			}
+			if (pendingCut) {
+				if (length > 0) cuts.push(length);
+				pendingCut = false;
+			}
+			length += character.length;
+		}
+		runStart = runEnd;
+	}
+	if (cuts.length === 1) return;
+	cuts.push(length);
+	return cuts;
+};
+/**
+* Preserves internal whitespace so source labels and credited names retain their spelling.
+*/
+var trimRuleWhitespace = (text) => text.replace(RULE_EDGE_WHITESPACE, "");
+//#endregion
+//#region src/transforms/agent/extract.ts
+var hashName = (name) => {
+	let hash = 0;
+	for (let index = 0; index < name.length; index += 1) hash = (hash << 5) - hash + name.charCodeAt(index) | 0;
+	return (hash >>> 0).toString(16).padStart(8, "0").toUpperCase();
+};
+var haveSameAgents = (first, second) => {
+	return first.length === second.length && first.every((id, index) => id === second[index]);
+};
+var prepareBindings = (bindings, agents) => {
+	if (!bindings) return;
+	const knownIds = new Set(agents.map((agent) => agent.id));
+	return new Map(Object.entries(bindings).map(([prefix, target]) => {
+		const ids = [...new Set(typeof target === "string" ? [target] : target)];
+		const missingId = ids.find((id) => !knownIds.has(id));
+		if (missingId !== void 0) throw new TypeError(`binding for ${JSON.stringify(prefix)} references unknown agent id ${JSON.stringify(missingId)}`);
+		return [prefix.trim(), ids];
+	}));
+};
+/**
+* Retains the legacy clock exclusion, including its accepted hour and minute bounds.
+*/
+var isClockTimeColon = (before, after) => {
+	const hour = /(\d+)$/.exec(before)?.[1];
+	const minute = /^(\d+)/.exec(after)?.[1];
+	if (!hour || !minute) return false;
+	return hour.length <= 2 && Number(hour) <= 24 && minute.length <= 2 && Number(minute) <= 60;
+};
+/**
+* Cuts only source text, so retained word ranges and annotations do not need fabricated character timings.
+*/
+var removePrefix = (content, length) => {
+	if (!content) return;
+	if (content.text !== void 0) {
+		const text = content.text.slice(length).trim();
+		return text ? makeLineContentText(text) : void 0;
+	}
+	const words = [];
+	let remaining = length;
+	for (const word of content.words) {
+		if (remaining >= word.text.length) {
+			remaining -= word.text.length;
+			continue;
+		}
+		if (remaining > 0) {
+			const text = word.text.slice(remaining).trim();
+			remaining = 0;
+			if (text) words.push({
+				...word,
+				text
+			});
+		} else words.push(word);
+	}
+	return words.some((word) => !!word.text.trim()) ? makeLineContentWords(words) : void 0;
+};
+/**
+* Extracts colon-prefixed performers and carries them across nonempty normal lines, replacing their existing agent lists.
+* Missing bindings enables legacy name inference; supplied bindings accept exact prefixes and reset propagation on unmatched prefixes.
+* Removing prefixes preserves retained line and word times, but drops prefix-only lines with their attached content.
+*
+* @returns The input when unchanged, or a new lyric sharing all unchanged nodes.
+*
+* @throws {TypeError} If bindings reference an agent id absent from lyric.agents.
+*/
+var extractAgents = (lyric, options = {}) => {
+	const bindings = prepareBindings(options.bindings, lyric.agents);
+	if (bindings?.size === 0 || !lyric.lines.length) return lyric;
+	const removePrefixes = options.removePrefixes ?? true;
+	const usedIds = new Set(lyric.agents.map((agent) => agent.id));
+	const names = /* @__PURE__ */ new Map();
+	for (const agent of lyric.agents) {
+		if (!agent.id) continue;
+		for (const item of agent.names) {
+			const name = item.text.trim();
+			if (!name) continue;
+			if (!names.has(name)) names.set(name, agent.id);
+			else if (names.get(name) !== agent.id) names.set(name, null);
+		}
+	}
+	let agents = lyric.agents;
+	const resolveName = (name) => {
+		const existing = names.get(name);
+		if (existing) return [existing];
+		const base = hashName(name);
+		let id = base;
+		for (let suffix = 1; usedIds.has(id); suffix += 1) id = `${base}-${suffix}`;
+		const agent = makeAgent({
+			id,
+			type: AgentType.PERSON,
+			names: [makeText({ text: name })]
+		});
+		if (agents === lyric.agents) agents = [...agents];
+		agents.push(agent);
+		usedIds.add(id);
+		names.set(name, id);
+		return [id];
+	};
+	const originalLines = lyric.lines;
+	let lines;
+	let current;
+	let contentChanged = false;
+	for (const [index, line] of originalLines.entries()) {
+		const text = line.type === LineType.NORMAL ? getContentText(line.content) : "";
+		if (line.type !== LineType.NORMAL || !text.trim()) {
+			current = void 0;
+			lines?.push(line);
+			continue;
+		}
+		const colon = text.search(/[:：]/u);
+		let matched = false;
+		if (colon !== -1) {
+			const name = text.slice(0, colon).trim();
+			if (bindings) {
+				const target = bindings.get(name);
+				if (!target) {
+					current = void 0;
+					lines?.push(line);
+					continue;
+				}
+				current = target;
+				matched = true;
+			} else if (!isClockTimeColon(text.slice(0, colon), text.slice(colon + 1))) {
+				if (!name) {
+					current = void 0;
+					lines?.push(line);
+					continue;
+				}
+				current = resolveName(name);
+				matched = true;
+			}
+		}
+		let content = line.content;
+		if (matched && removePrefixes) {
+			content = removePrefix(content, colon + 1);
+			contentChanged = true;
+			if (!content) {
+				lines ??= originalLines.slice(0, index);
+				continue;
+			}
+		}
+		const nextAgents = current && !haveSameAgents(line.agents, current) ? [...current] : line.agents;
+		if (content !== line.content || nextAgents !== line.agents) {
+			lines ??= originalLines.slice(0, index);
+			lines.push({
+				...line,
+				content,
+				agents: nextAgents
+			});
+		} else lines?.push(line);
+	}
+	if (!lines && agents === lyric.agents) return lyric;
+	const remainingLines = lines ?? originalLines;
+	let timing = lyric.timing;
+	if (contentChanged && timing === Timing.WORD) {
+		if (!remainingLines.some((line) => {
+			return isWordLevelLine(line) || line.backgrounds.some(isWordLevelLine);
+		})) timing = Timing.LINE;
+	}
+	return {
+		...lyric,
+		agents,
+		lines: remainingLines,
+		timing,
+		languages: contentChanged ? deriveLanguageUsages(remainingLines) : lyric.languages
+	};
+};
+//#endregion
+//#region src/transforms/background/utils.ts
+var OPEN_BRACKETS = /* @__PURE__ */ new Set(["(", "（"]);
+var CLOSE_BRACKETS = /* @__PURE__ */ new Set([")", "）"]);
+var isOpenBracket = (char) => {
+	return OPEN_BRACKETS.has(char);
+};
+var isCloseBracket = (char) => {
+	return CLOSE_BRACKETS.has(char);
+};
+var isNormalWord = (word) => {
+	return word.type === WordType.NORMAL;
+};
+/**
+* Content carries plain text or words, never both, so exactly one of the two is read.
+*/
+var readLineText = (line) => {
+	return line.content?.text ?? (line.content?.words ?? []).map((word) => word.text).join("");
+};
+var readTimeRange = (line) => {
+	return line.time ? makeTimeRange({
+		start: line.time.start,
+		end: line.time.end
+	}) : void 0;
+};
+//#endregion
+//#region src/transforms/background/brackets.ts
+/**
+* Removes one leading bracket from the first sung word and one trailing bracket from the last, so an inner pair stays as written.
+*
+* Space words at the same edge go with the bracket, and a word left with no text goes too, since a sung word must carry something.
+*/
+var stripWordEdges = (words) => {
+	const firstIndex = words.findIndex(isNormalWord);
+	const first = words[firstIndex];
+	const last = words[words.findLastIndex(isNormalWord)];
+	const stripStart = first ? isOpenBracket(first.text.charAt(0)) : false;
+	const stripEnd = last ? isCloseBracket(last.text.charAt(last.text.length - 1)) : false;
+	if (!stripStart && !stripEnd) return words;
+	const result = [...words];
+	if (stripStart && first) {
+		const text = first.text.slice(1);
+		if (text) result[firstIndex] = {
+			...first,
+			text
+		};
+		else result.splice(firstIndex, 1);
+		while (result[0]?.type === WordType.SPACE) result.shift();
+	}
+	const endIndex = result.findLastIndex(isNormalWord);
+	const end = result[endIndex];
+	if (stripEnd && end) {
+		const text = end.text.slice(0, -1);
+		if (text) result[endIndex] = {
+			...end,
+			text
+		};
+		else result.splice(endIndex, 1);
+		while (result.at(-1)?.type === WordType.SPACE) result.pop();
+	}
+	return result;
+};
+/**
+* Plain text is read literally, so a source that padded it with spaces keeps them; only word content
+* treats space words as the structural separators they are.
+*/
+var stripContentBrackets = (content) => {
+	if (!content) return content;
+	if (!content.words.length) {
+		const text = content.text;
+		if (!text) return content;
+		const start = isOpenBracket(text.charAt(0)) ? 1 : 0;
+		const end = isCloseBracket(text.charAt(text.length - 1)) ? -1 : 0;
+		if (!start && !end) return content;
+		const stripped = text.slice(start, end === 0 ? void 0 : end);
+		return stripped ? makeLineContentText(stripped) : void 0;
+	}
+	const words = stripWordEdges(content.words);
+	if (words === content.words) return content;
+	return words.length ? makeLineContentWords(words) : void 0;
+};
+var stripLineBackgrounds = (line) => {
+	if (!line.backgrounds.length) return line;
+	let changed = false;
+	const kept = [];
+	for (const background of line.backgrounds) {
+		const content = stripContentBrackets(background.content);
+		if (content === background.content) {
+			kept.push(background);
+			continue;
+		}
+		changed = true;
+		if (content) kept.push({
+			...background,
+			content
+		});
+	}
+	return changed ? {
+		...line,
+		backgrounds: kept
+	} : line;
+};
+/**
+* Removes the brackets some sources wrap around background vocals.
+*
+* One layer is removed from each edge of every background line, leaving a nested pair as `(x)`.
+* A line left with no content is dropped, since a background line must carry something.
+*
+* @returns The input when unchanged, or a new lyric sharing all unchanged nodes.
+*/
+var stripBackgroundBrackets = (lyric) => {
+	const lines = mapShared(lyric.lines, stripLineBackgrounds);
+	return lines === lyric.lines ? lyric : {
+		...lyric,
+		lines
+	};
+};
+//#endregion
+//#region src/transforms/background/extract.ts
+/**
+* An unclosed bracket never became a run, so its text returns to the line it came from.
+* An empty pair yields no run, since a background line must carry text.
+*/
+var splitText = (text) => {
+	const chars = [...text];
+	let main = "";
+	let current = "";
+	let opened = "";
+	let openedAt = 0;
+	let depth = 0;
+	const runs = [];
+	for (const [index, char] of chars.entries()) if (isOpenBracket(char)) {
+		if (depth) current += char;
+		else {
+			opened = char;
+			openedAt = index;
+		}
+		depth += 1;
+	} else if (isCloseBracket(char)) {
+		if (depth === 0) {
+			main += char;
+			continue;
+		}
+		depth -= 1;
+		if (depth) current += char;
+		else {
+			runs.push({
+				text: current,
+				start: openedAt + 1,
+				end: index
+			});
+			current = "";
+		}
+	} else if (depth) current += char;
+	else main += char;
+	if (depth) main += opened + current;
+	return {
+		main: main.trim().replaceAll(/\s{2,}/gu, " "),
+		runs: runs.filter((run) => {
+			return !!run.text.trim();
+		}),
+		length: chars.length
+	};
+};
+/**
+* A word straddling a bracket is cut into pieces sharing its time, since the source gave no finer boundary.
+* An unclosed bracket never became a run, so its text returns to the line it came from.
+* An empty pair yields no run, since a background line must carry text.
+*/
+var splitWords = (words) => {
+	const main = [];
+	const runs = [];
+	let current = [];
+	let opened;
+	let depth = 0;
+	for (const word of words) {
+		if (!isNormalWord(word)) {
+			(depth ? current : main).push(word);
+			continue;
+		}
+		let buffer = "";
+		for (const char of word.text) if (isOpenBracket(char)) {
+			if (depth) buffer += char;
+			else {
+				if (buffer) {
+					main.push({
+						...word,
+						text: buffer
+					});
+					buffer = "";
+				}
+				opened = {
+					...word,
+					text: char
+				};
+			}
+			depth += 1;
+		} else if (isCloseBracket(char)) {
+			if (depth === 0) {
+				buffer += char;
+				continue;
+			}
+			depth -= 1;
+			if (depth) buffer += char;
+			else {
+				if (buffer) {
+					current.push({
+						...word,
+						text: buffer
+					});
+					buffer = "";
+				}
+				if (current.length) {
+					runs.push(current);
+					current = [];
+				}
+			}
+		} else buffer += char;
+		if (buffer) (depth ? current : main).push({
+			...word,
+			text: buffer
+		});
+	}
+	if (depth) {
+		if (opened) main.push(opened);
+		main.push(...current);
+	}
+	return {
+		main,
+		runs: runs.filter((run) => {
+			return run.some((word) => {
+				return !!word.text.trim();
+			});
+		})
+	};
+};
+var mapSpan = (range, length, run) => {
+	if (range.end === void 0 || !length) return makeTimeRange({
+		start: range.start,
+		end: range.end
+	});
+	const span = range.end - range.start;
+	const start = range.start + Math.round(span * run.start / length);
+	const end = range.start + Math.round(span * run.end / length);
+	return makeTimeRange({
+		start,
+		end: Math.max(start, end)
+	});
+};
+/**
+* Falls back to the line's own range when no word carries a time, so a run still gets a range.
+*/
+var readWordRange = (words, fallback) => {
+	const timed = words.filter((word) => {
+		return isNormalWord(word) && !!word.time;
+	});
+	const first = timed[0]?.time;
+	const last = timed.at(-1)?.time;
+	if (!first || !last) return fallback;
+	return makeTimeRange({
+		start: first.start,
+		end: last.end
+	});
+};
+/**
+* A background may start before its line but not finish after it, so the line grows to the furthest stated end.
+*/
+var attach = (line, backgrounds) => {
+	const merged = [...line.backgrounds, ...backgrounds];
+	merged.sort((left, right) => {
+		const leftStart = left.time?.start ?? 0;
+		const rightStart = right.time?.start ?? 0;
+		return leftStart === rightStart ? (left.time?.end ?? 0) - (right.time?.end ?? 0) : leftStart - rightStart;
+	});
+	let end = line.time?.end;
+	for (const background of merged) {
+		const backgroundEnd = background.time?.end;
+		if (backgroundEnd !== void 0 && (end === void 0 || backgroundEnd > end)) end = backgroundEnd;
+	}
+	if (!line.time || end === line.time.end) return {
+		...line,
+		backgrounds: merged
+	};
+	return {
+		...line,
+		time: makeTimeRange({
+			start: line.time.start,
+			end
+		}),
+		backgrounds: merged
+	};
+};
+/**
+* A closed line cannot hold an open background, so it stops where the line does.
+* On the last line the timeline itself ends unknown, so an open background leaves the line open too.
+*/
+var boundOpenBackgrounds = (lines) => {
+	const last = lines.length - 1;
+	return lines.map((line, index) => {
+		if (!line.backgrounds.filter((background) => {
+			return !!background.time && background.time.end === void 0;
+		}).length) return line;
+		if (index === last) return line.time ? {
+			...line,
+			time: makeTimeRange({ start: line.time.start })
+		} : line;
+		if (!line.time || line.time.end === void 0) return line;
+		const end = line.time.end;
+		return {
+			...line,
+			backgrounds: line.backgrounds.map((background) => {
+				const time = background.time;
+				if (!time || time.end !== void 0) return background;
+				return {
+					...background,
+					time: makeTimeRange({
+						start: time.start,
+						end: Math.max(time.start, end)
+					})
+				};
+			})
+		};
+	});
+};
+/**
+* Words are kept only where the caller says the lyric is word-timed, since the other timings forbid them.
+*/
+var makeBackground = (line, words, text, time, wordLevel) => {
+	return makeLineBackground({
+		time,
+		agents: [...line.agents],
+		languages: [...line.languages],
+		content: wordLevel && words.length ? makeLineContentWords(words) : makeLineContentText(text)
+	});
+};
+var readBackgrounds = (line, wordLevel) => {
+	const content = line.content;
+	if (!content) return [];
+	const range = line.time;
+	if (wordLevel && content.words.length) return splitWords(content.words).runs.map((words) => {
+		const time = range ? readWordRange(words, range) : void 0;
+		return makeBackground(line, words, words.map((word) => word.text).join(""), time, wordLevel);
+	});
+	const text = content.text ?? content.words.map((word) => word.text).join("");
+	if (!text) return [];
+	const { runs, length } = splitText(text);
+	return runs.map((run) => {
+		return makeBackground(line, [], run.text, range ? mapSpan(range, length, run) : void 0, false);
+	});
+};
+/**
+* An entry without brackets stays on the line, since only the bracketed part describes a background.
+* The line's annotation is rebuilt rather than edited, so the input lyric stays untouched.
+*/
+var splitAnnotation = (annotation, backgrounds) => {
+	if (!annotation || !backgrounds.length) return annotation;
+	const move = (items, rebuild, push) => {
+		return items.map((item) => {
+			const { main, runs } = splitText(item.text);
+			if (!runs.length) return item;
+			for (const [index, run] of runs.entries()) {
+				const background = backgrounds[index];
+				if (background) push(background, run.text, item.language);
+			}
+			return rebuild(item, main);
+		});
+	};
+	const romans = move(annotation.romans, (item, text) => makeLineAnnotationRoman({
+		...item,
+		text
+	}), (background, text, language) => {
+		background.annotation ??= makeLineAnnotation();
+		background.annotation.romans.push(makeLineAnnotationRoman({
+			text,
+			language
+		}));
+	});
+	const translations = move(annotation.translations, (item, text) => makeLineAnnotationTranslation({
+		...item,
+		text
+	}), (background, text, language) => {
+		background.annotation ??= makeLineAnnotation();
+		background.annotation.translations.push(makeLineAnnotationTranslation({
+			text,
+			language
+		}));
+	});
+	return makeLineAnnotation({
+		...annotation,
+		romans,
+		translations
+	});
+};
+/**
+* Words survive only where the lyric is word-timed, since the other timings forbid them.
+*/
+var toBackground = (line, time, wordLevel) => {
+	const content = line.content;
+	if (!content) return;
+	const text = content.text ?? content.words.map((word) => word.text).join("");
+	if (!text) return;
+	return makeLineBackground({
+		time,
+		agents: [...line.agents],
+		languages: [...line.languages],
+		content: wordLevel && content.words.length ? content : makeLineContentText(text),
+		annotation: line.annotation
+	});
+};
+var isBracketOnlyLine = (line) => {
+	if (!line || line.type !== LineType.NORMAL) return false;
+	const { main, runs } = splitText(readLineText(line));
+	return !!runs.length && !main;
+};
+/**
+* A line that held nothing but brackets has no text of its own to sing, so it cannot be the one a background accompanies.
+*/
+var findParentIndex = (lines) => {
+	for (let index = lines.length - 1; index >= 0; index--) {
+		const line = lines[index];
+		if (line?.type === LineType.NORMAL && !isBracketOnlyLine(line)) return index;
+	}
+	return -1;
+};
+/**
+* Both source lines go, since neither holds anything left to sing, and the joined range spans both.
+*/
+var joinCrossLine = (lines, wordLevel) => {
+	const result = [];
+	let changed = false;
+	let skip = false;
+	for (const [index, line] of lines.entries()) {
+		if (skip) {
+			skip = false;
+			continue;
+		}
+		const next = lines[index + 1];
+		const parentIndex = findParentIndex(result);
+		if (line.type === LineType.NORMAL && next?.type === LineType.NORMAL && parentIndex !== -1) {
+			const opened = splitText(readLineText(line));
+			const closed = splitText(readLineText(next));
+			const opens = !opened.runs.length && isOpenBracket(opened.main.charAt(0));
+			const closes = !closed.runs.length && isCloseBracket(closed.main.charAt(closed.main.length - 1));
+			if (opens && closes) {
+				const start = line.time?.start;
+				const end = next.time?.end ?? next.time?.start;
+				const background = toBackground({
+					...line,
+					content: makeLineContentText(opened.main.slice(1) + closed.main.slice(0, -1))
+				}, start === void 0 ? void 0 : makeTimeRange({
+					start,
+					end
+				}), wordLevel);
+				if (background) {
+					result[parentIndex] = attach(result[parentIndex], [background]);
+					changed = true;
+					skip = true;
+					continue;
+				}
+			}
+		}
+		result.push(line);
+	}
+	return {
+		lines: result,
+		changed
+	};
+};
+var stripRuns = (content) => {
+	if (content.words.length) {
+		const { main } = splitWords(content.words);
+		return main.length ? makeLineContentWords(main) : void 0;
+	}
+	const { main } = splitText(content.text ?? "");
+	return main ? makeLineContentText(main) : void 0;
+};
+/**
+* Pulls bracketed background vocals out of the sung lines and attaches them to the line they accompany.
+*
+* A line holding nothing but brackets becomes a background of the line before it and is removed.
+* A bracket opened on one line and closed on a later one joins the line before the opening, and both source lines go.
+* Text outside brackets stays on its line, and a line left with none keeps its place.
+*
+* @returns The input when unchanged, or a new lyric sharing all unchanged nodes.
+*/
+var extractBackgroundLines = (lyric, options = {}) => {
+	const fullLine = options.fullLine ?? true;
+	const inLine = options.inLine ?? true;
+	const crossLine = options.crossLine ?? true;
+	if (!lyric.lines.length) return lyric;
+	const wordLevel = lyric.timing === Timing.WORD;
+	const joined = crossLine ? joinCrossLine(lyric.lines, wordLevel) : {
+		lines: lyric.lines,
+		changed: false
+	};
+	const result = [];
+	let changed = joined.changed;
+	for (const line of joined.lines) {
+		if (line.type !== LineType.NORMAL || !line.content) {
+			result.push(line);
+			continue;
+		}
+		const parentIndex = findParentIndex(result);
+		if (fullLine && parentIndex !== -1) {
+			const { main, runs } = splitText(readLineText(line));
+			if (runs.length && !main) {
+				const backgrounds = runs.map((run) => {
+					return makeBackground(line, [], run.text, readTimeRange(line), false);
+				});
+				result[parentIndex] = attach(result[parentIndex], backgrounds);
+				changed = true;
+				continue;
+			}
+		}
+		const backgrounds = inLine ? readBackgrounds(line, wordLevel) : [];
+		if (!backgrounds.length) {
+			result.push(line);
+			continue;
+		}
+		const nextContent = stripRuns(line.content);
+		if (!nextContent) {
+			result.push(line);
+			continue;
+		}
+		const extracted = {
+			...line,
+			content: nextContent,
+			annotation: splitAnnotation(line.annotation, backgrounds)
+		};
+		result.push(attach(extracted, backgrounds));
+		changed = true;
+	}
+	if (!changed) return lyric;
+	const lines = boundOpenBackgrounds(result);
+	return {
+		...lyric,
+		lines,
+		languages: deriveLanguageUsages(lines)
+	};
+};
+var en_default$1 = {
+	$schema: "../schema.json",
+	version: 1,
+	language: "en",
+	normalization: {
+		"whitespace": "remove",
+		"case": "asciiLower"
+	},
+	groups: [
+		{
+			"id": "lyricist",
+			"kind": "role",
+			"roles": ["LYRICIST"],
+			"words": [
+				"Lyrics",
+				"Lyricsby",
+				"Lyricist",
+				"Words",
+				"Wordsby",
+				"Lyric",
+				"Lyr",
+				"Lyricists",
+				"Lyricwriting"
+			]
+		},
+		{
+			"id": "composer",
+			"kind": "role",
+			"roles": ["COMPOSER"],
+			"words": [
+				"Music",
+				"Musicby",
+				"Composer",
+				"Composedby",
+				"Compose",
+				"Composition",
+				"Melody",
+				"Melodyby",
+				"Comp",
+				"Composers",
+				"Score",
+				"Scoredby",
+				"Composed"
+			]
+		},
+		{
+			"id": "arranger",
+			"kind": "role",
+			"roles": ["ARRANGER"],
+			"words": [
+				"Arrangement",
+				"Arranger",
+				"Arrangedby",
+				"Arranged",
+				"Arrange",
+				"Arr",
+				"Orchestration",
+				"StringArrangement",
+				"VocalArrangement",
+				"ChoirArrangement",
+				"Orchestrator",
+				"Orchestratedby",
+				"Orch",
+				"AdditionalArrangement",
+				"BGVsArranger",
+				"BVArranger",
+				"BackgroundVocalArrangement",
+				"BackgroundVocalsArrangement",
+				"BackingVocalsArranger",
+				"BackingVocalArrangement",
+				"BackingVocalsArrangement",
+				"BrassArrangement",
+				"HornArrangement",
+				"OrchestralArrangement",
+				"RhythmArrangement",
+				"StringArrangedby",
+				"StringArranger",
+				"VocalArrangedby",
+				"VocalArranger"
+			]
+		},
+		{
+			"id": "producer",
+			"kind": "role",
+			"roles": ["PRODUCER"],
+			"words": [
+				"Producer",
+				"Producedby",
+				"Produced",
+				"Production",
+				"Prod",
+				"Prodby",
+				"Producers",
+				"Produce",
+				"CoProducer",
+				"Co-Producer",
+				"ExecutiveProducer",
+				"AdditionalProducer",
+				"AdditionalProduction",
+				"VocalProducer",
+				"MusicProducer",
+				"AssociateProducer",
+				"Co-Produced",
+				"Co-Producedby",
+				"Co-Production",
+				"Co-Productionby",
+				"CoProd",
+				"Coproduction",
+				"CreativeProducer",
+				"ExProd",
+				"ExecProducer",
+				"ExecutiveProducers",
+				"Productionby",
+				"VocalProduction",
+				"MusicSupervisor",
+				"Supervisor",
+				"Presentedby",
+				"Presenter"
+			]
+		},
+		{
+			"id": "performer",
+			"kind": "role",
+			"roles": ["PERFORMER"],
+			"words": [
+				"Vocals",
+				"Vocal",
+				"Vocalist",
+				"Singer",
+				"Voice",
+				"Performer",
+				"Featuring",
+				"Feat",
+				"Ft",
+				"Artist",
+				"Vocalsby",
+				"Sungby",
+				"Performedby",
+				"Performed",
+				"LeadVocal",
+				"LeadVocals",
+				"BackgroundVocals",
+				"BackingVocals",
+				"Harmony",
+				"Choir",
+				"Band",
+				"Rap",
+				"Rapper",
+				"Soloist",
+				"Musician",
+				"Player",
+				"GuestVocals",
+				"FeaturedArtist",
+				"Narrator",
+				"Guitarist",
+				"Bassist",
+				"Pianist",
+				"Drummer",
+				"Keyboardist",
+				"Violinist",
+				"Cellist",
+				"Accompaniment",
+				"Accompanist",
+				"Accordionist",
+				"Ad-lib",
+				"Ad-libs",
+				"AdditionalVocals",
+				"Adlib",
+				"Adlibs",
+				"Allvocals",
+				"Allvocalsby",
+				"BGV",
+				"BGVs",
+				"BGs",
+				"BV",
+				"BackgroundVocal",
+				"BackingVocal",
+				"Banjoist",
+				"Beatbox",
+				"Beatboxer",
+				"Bvox",
+				"CV",
+				"ChildrenVoice",
+				"Clarinetist",
+				"Contrabassist",
+				"CoverSong",
+				"Dialogue",
+				"Ensemble",
+				"FemaleVoice",
+				"Flutist",
+				"GuestArtist",
+				"GuestSinger",
+				"Harmonies",
+				"Harpist",
+				"Hornist",
+				"HumanBeatbox",
+				"HumanVoice",
+				"LeadSinger",
+				"LeadVocalist",
+				"LiveBand",
+				"MainVocal",
+				"MainVocals",
+				"MaleVoice",
+				"Mandolinist",
+				"Narration",
+				"Orchestra",
+				"Organist",
+				"OriginalSinger",
+				"Percussionist",
+				"Recitation",
+				"Saxophonist",
+				"SessionMusician",
+				"SessionPlayer",
+				"Singers",
+				"Singing",
+				"Sitarist",
+				"Trombonist",
+				"Trumpeter",
+				"Tubist",
+				"Ukuleleist",
+				"Violist",
+				"VocalPerformance",
+				"Vocalists",
+				"VoiceActor",
+				"VoiceActress",
+				"Vox",
+				"Chorus",
+				"Solo"
+			]
+		},
+		{
+			"id": "instruments",
+			"kind": "instrument",
+			"roles": ["PERFORMER"],
+			"words": [
+				"Guitar",
+				"Piano",
+				"Bass",
+				"Drums",
+				"Keyboard",
+				"Strings",
+				"Synth",
+				"Violin",
+				"Cello",
+				"Saxophone",
+				"Trumpet",
+				"Flute",
+				"Clarinet",
+				"Trombone",
+				"Horn",
+				"Organ",
+				"Percussion",
+				"Ukulele",
+				"Banjo",
+				"Mandolin",
+				"Harp",
+				"Viola",
+				"AcousticGuitar",
+				"ElectricGuitar",
+				"BassGuitar",
+				"ElectricBass",
+				"Keyboards",
+				"Keys",
+				"Synthesizer",
+				"Perc",
+				"12-StringGuitar",
+				"A.Gtr",
+				"A.Sax",
+				"Accordion",
+				"AcousticBass",
+				"AcousticElectricGuitar",
+				"Allinstrumental",
+				"Allinstrumentalby",
+				"Allinstruments",
+				"AltoSax",
+				"AltoSaxophone",
+				"AppalachianDulcimer",
+				"Autoharp",
+				"B.Cl",
+				"B.Sax",
+				"B3",
+				"BANDONEÓN",
+				"BODHRÁN",
+				"Bagpipe",
+				"Bagpipes",
+				"Balalaika",
+				"Bandoneon",
+				"Bandoneón",
+				"Banhu",
+				"Bansuri",
+				"BaritoneSax",
+				"BaritoneSaxophone",
+				"BassClarinet",
+				"BassSynth",
+				"Bassoon",
+				"Bawu",
+				"Bodhran",
+				"Bodhrán",
+				"Bongo",
+				"Bouzouki",
+				"Brass",
+				"Bsn",
+				"Bss",
+				"CAJÓN",
+				"Cajon",
+				"Cajón",
+				"Castanets",
+				"Cb",
+				"Celesta",
+				"Charango",
+				"Chimes",
+				"Cl",
+				"ClassicalGuitar",
+				"Clav",
+				"Claves",
+				"Clavinet",
+				"Cnt",
+				"Concertina",
+				"Conga",
+				"Contrabass",
+				"Cornet",
+				"Cowbell",
+				"Cymbal",
+				"Cymbals",
+				"DJ",
+				"Daegeum",
+				"Darbuka",
+				"Daruan",
+				"Didgeridoo",
+				"Dizi",
+				"Djembe",
+				"Dobro",
+				"DoubleBass",
+				"Doumbek",
+				"Dr",
+				"Drum",
+				"DrumMachine",
+				"DrumPad",
+				"DrumSet",
+				"Duduk",
+				"Dulcimer",
+				"E.Bss",
+				"E.Gtr",
+				"E.Hn",
+				"EP",
+				"ElectricPiano",
+				"ElectronicKeyboard",
+				"EnglishHorn",
+				"Erhu",
+				"Euph",
+				"Euphonium",
+				"FingerDrumming",
+				"Fingerpicking",
+				"FingerstyleGuitar",
+				"Fl",
+				"Flageolet",
+				"Flt",
+				"Flugelhorn",
+				"FrameDrum",
+				"FrenchHorn",
+				"Gaohu",
+				"Gayageum",
+				"Glockenspiel",
+				"Gong",
+				"Gtr",
+				"Guiro",
+				"Guitars",
+				"Guqin",
+				"Guzheng",
+				"GÜIRO",
+				"Güiro",
+				"Haegeum",
+				"HammeredDulcimer",
+				"Hammond",
+				"HammondOrgan",
+				"HandDrum",
+				"Handpan",
+				"HangDrum",
+				"Harmonica",
+				"Harmonium",
+				"Harpsichord",
+				"Hn",
+				"HornSection",
+				"Horns",
+				"Hpschd",
+				"Hrp",
+				"Hulusi",
+				"Hurdy-Gurdy",
+				"HurdyGurdy",
+				"Janggu",
+				"Jinghu",
+				"Kalimba",
+				"Keytar",
+				"Konghou",
+				"Kora",
+				"Koto",
+				"Kybd",
+				"LapSteel",
+				"LapSteelGuitar",
+				"LeadGuitar",
+				"Liuqin",
+				"Lute",
+				"MPC",
+				"Marimba",
+				"Matouqin",
+				"Mbira",
+				"Mellotron",
+				"Melodica",
+				"MorinKhuur",
+				"MusicalInstruments",
+				"Nyckelharpa",
+				"NylonGuitar",
+				"Ob",
+				"Oboe",
+				"Ocarina",
+				"Org",
+				"Oud",
+				"PanFlute",
+				"Panpipes",
+				"PedalSteel",
+				"PedalSteelGuitar",
+				"PennyWhistle",
+				"Picc",
+				"Piccolo",
+				"Pipa",
+				"Pno",
+				"Rebab",
+				"Recorder",
+				"Resonator",
+				"ResonatorGuitar",
+				"Rhodes",
+				"RhythmGuitar",
+				"Ruan",
+				"S.Sax",
+				"Sampler",
+				"Sanxian",
+				"Sax",
+				"Scratching",
+				"Sequencer",
+				"Shaker",
+				"Shakuhachi",
+				"Shamisen",
+				"Sheng",
+				"Sitar",
+				"SlideGuitar",
+				"Snare",
+				"SnareDrum",
+				"SopranoSax",
+				"SteelDrum",
+				"SteelGuitar",
+				"SteelPan",
+				"Str",
+				"String",
+				"StringQuartet",
+				"StringSection",
+				"SubBass",
+				"Suona",
+				"SynthBass",
+				"Synthesizers",
+				"Synths",
+				"T.Sax",
+				"Tabla",
+				"Taiko",
+				"TalkingDrum",
+				"Tamb",
+				"Tambourine",
+				"Tba",
+				"Tbn",
+				"TenorSax",
+				"TenorSaxophone",
+				"Theremin",
+				"Timbales",
+				"Timp",
+				"Timpani",
+				"TinWhistle",
+				"Tpt",
+				"Triangle",
+				"Tuba",
+				"TubularBells",
+				"Turntable",
+				"Turntables",
+				"Uke",
+				"UprightBass",
+				"Vc",
+				"Vib",
+				"Vibes",
+				"Vibraphone",
+				"Vla",
+				"Vln",
+				"Vocoder",
+				"Whistle",
+				"Winds",
+				"Woodblock",
+				"Woodwinds",
+				"Wurlitzer",
+				"Xiao",
+				"Xiaoruan",
+				"Xun",
+				"Xylo",
+				"Xylophone",
+				"Yangqin",
+				"Yueqin",
+				"Zhonghu",
+				"Zither"
+			]
+		},
+		{
+			"id": "mixer",
+			"kind": "role",
+			"roles": ["MIXER"],
+			"words": [
+				"Mix",
+				"Mixedby",
+				"Mixing",
+				"Mixer",
+				"MixingEngineer",
+				"MixEngineer",
+				"Remix",
+				"Remixedby",
+				"Remixer",
+				"Mixdown",
+				"Mixdownby",
+				"Mixed",
+				"Remixby"
+			]
+		},
+		{
+			"id": "mastering",
+			"kind": "role",
+			"roles": ["MASTERING"],
+			"words": [
+				"Mastering",
+				"Masteredby",
+				"Master",
+				"MasteringEngineer",
+				"MasterEngineer",
+				"Mst",
+				"Mastered",
+				"MasteringEngineerby",
+				"Masteringby"
+			]
+		},
+		{
+			"id": "lyrics-and-composition",
+			"kind": "role",
+			"roles": ["LYRICIST", "COMPOSER"],
+			"words": [
+				"Lyrics&Music",
+				"Music&Lyrics",
+				"Words&Music",
+				"Lyrics&Musicby",
+				"Music&Lyricsby",
+				"Words&Musicby",
+				"Composed&Writtenby",
+				"ComposedandWrittenby",
+				"Composer&Lyricist",
+				"Composer/Lyricist",
+				"Lyricist&Composer",
+				"Lyricist/Composer",
+				"Lyrics&Melody",
+				"Lyrics/Music",
+				"LyricsandMusic",
+				"LyricsandMusicby",
+				"Melody&Lyrics",
+				"Melody&Words",
+				"Music&Words",
+				"Music/Lyrics",
+				"MusicandLyrics",
+				"MusicandLyricsby",
+				"Words&Melody",
+				"Words/Music",
+				"WordsandMusic",
+				"WordsandMusicby",
+				"Written&Composedby",
+				"WrittenandComposedby"
+			]
+		},
+		{
+			"id": "composition-and-arrangement",
+			"kind": "role",
+			"roles": ["COMPOSER", "ARRANGER"],
+			"words": [
+				"Composer&Arranger",
+				"Composer/Arranger",
+				"Composed&Arrangedby",
+				"Music&Arrangement",
+				"Composed&Arranged",
+				"ComposedandArrangedby",
+				"ComposerandArranger",
+				"Composition&Arrangement",
+				"MusicandArrangement"
+			]
+		},
+		{
+			"id": "mixing-and-mastering",
+			"kind": "role",
+			"roles": ["MIXER", "MASTERING"],
+			"words": [
+				"Mix&Master",
+				"Mix/Master",
+				"Mixed&Masteredby",
+				"Mixing&Mastering",
+				"Mixing/Mastering",
+				"Mix&Mastering",
+				"MixandMaster",
+				"MixandMastering",
+				"MixedandMasteredby",
+				"Mixing&Master",
+				"MixingandMaster",
+				"MixingandMastering"
+			]
+		},
+		{
+			"id": "lyrics-and-arrangement",
+			"kind": "role",
+			"roles": ["LYRICIST", "ARRANGER"],
+			"words": [
+				"Lyrics&Arrangement",
+				"LyricsArrangement",
+				"LyricsandArrangement",
+				"Words&Arrangement",
+				"WordsArrangement"
+			]
+		},
+		{
+			"id": "lyrics-composition-and-arrangement",
+			"kind": "role",
+			"roles": [
+				"LYRICIST",
+				"COMPOSER",
+				"ARRANGER"
+			],
+			"words": [
+				"ComposedWritten&Arrangedby",
+				"ComposedWrittenandArrangedby",
+				"LyricsMusic&Arrangement",
+				"LyricsMusicArrangement",
+				"LyricsMusicandArrangement",
+				"MusicLyrics&Arrangement",
+				"WordsMusic&Arrangement",
+				"WrittenComposed&Arrangedby",
+				"WrittenComposedandArrangedby"
+			]
+		},
+		{
+			"id": "singer-songwriter",
+			"kind": "role",
+			"roles": [
+				"LYRICIST",
+				"COMPOSER",
+				"PERFORMER"
+			],
+			"words": [
+				"Singer-Songwriter",
+				"SingerSongwriter",
+				"SingerSongwriterby"
+			]
+		},
+		{
+			"id": "other",
+			"kind": "role",
+			"roles": ["OTHER"],
+			"words": [
+				"Engineer",
+				"RecordingEngineer",
+				"SoundEngineer",
+				"MixAssistant",
+				"MixingAssistant",
+				"MasteringAssistant",
+				"A&R",
+				"ArtDirection",
+				"ArtDirector",
+				"Design",
+				"Designer",
+				"Photographer",
+				"Photography",
+				"Photo",
+				"Director",
+				"Video",
+				"Manager",
+				"Management",
+				"Coordinator",
+				"Consultant",
+				"Translator",
+				"Translation",
+				"Transcription",
+				"Editor",
+				"Edit",
+				"Programmer",
+				"Programming",
+				"Conductor",
+				"Choreographer",
+				"A.Eng",
+				"Acknowledgments",
+				"AdditionalEngineering",
+				"Adjustment",
+				"AlbumArt",
+				"Animatedby",
+				"Animation",
+				"Animator",
+				"Animatorby",
+				"ArtConsultant",
+				"ArtistManagement",
+				"Artistassistant",
+				"ArtistsandRepertoire",
+				"Artwork",
+				"AssetManagement",
+				"Assistance",
+				"Assistant",
+				"AssistantEngineer",
+				"AssistantMixEngineer",
+				"AsstEng",
+				"AudioEditing",
+				"AudioEditor",
+				"AudioEngineer",
+				"Auto-Tune",
+				"BTS",
+				"Beatby",
+				"Beatmaker",
+				"Beats",
+				"Behind-the-Scenes",
+				"Behind-theScenes",
+				"Behindthe-Scenes",
+				"BehindtheScenes",
+				"CG",
+				"COO",
+				"ChiefOperatingOfficer",
+				"Choreography",
+				"Clothing",
+				"ComputerEngineer",
+				"Cond",
+				"Conductedby",
+				"Contractor",
+				"Copyist",
+				"Copywriter",
+				"Copywriting",
+				"Costume",
+				"CoverArt",
+				"CoverDesign",
+				"CreativeDirection",
+				"CreativeDirector",
+				"Designedby",
+				"Digitaledit",
+				"Digitalediting",
+				"Directedby",
+				"Distributedby",
+				"DolbyAtmos",
+				"Drawing",
+				"DrumProgramming",
+				"DrumTech",
+				"Editedby",
+				"Eng",
+				"Engineeredby",
+				"FOHEngineer",
+				"Fashion",
+				"Film",
+				"Filmedby",
+				"FineArts",
+				"Flatdesign",
+				"Foley",
+				"FoleyArtist",
+				"FrontofHouse",
+				"FrontofHouseEngineer",
+				"GraphicDesign",
+				"Graphics",
+				"Graphicvisual",
+				"GuitarTech",
+				"Hair",
+				"Hair-Stylist",
+				"HairStylist",
+				"Illustratedby",
+				"Illustration",
+				"Illustrator",
+				"Inscription",
+				"InstrumentTech",
+				"Librarian",
+				"LightTech",
+				"LightingDesigner",
+				"LiveSoundEngineer",
+				"Loops",
+				"LyricVideo",
+				"MD",
+				"MIDI",
+				"MIDIProgramming",
+				"MV",
+				"MVDirector",
+				"MainCreators",
+				"Make-up",
+				"Makeup",
+				"MakeupArtist",
+				"Making",
+				"Making-of",
+				"Makingof",
+				"Marketing",
+				"Marketing&promotion",
+				"MonitorEngineer",
+				"MusicConcept",
+				"MusicDirector",
+				"MusicVideo",
+				"MusicVideoDirector",
+				"Musicproductionassistant",
+				"OP",
+				"PGM",
+				"PRpromotion",
+				"PV",
+				"Photoby",
+				"PitchCorrection",
+				"PitchEditing",
+				"Planner",
+				"Planning",
+				"Post-production",
+				"PostMastering",
+				"PostProd",
+				"Pre-production",
+				"Printvisual",
+				"Productionassistant",
+				"Prog",
+				"Program",
+				"Programmedby",
+				"ProjectCoordinator",
+				"ProjectPlanning",
+				"Promo-Material",
+				"PromoMaterial",
+				"Promotion",
+				"Proofreading",
+				"Publicity",
+				"Publishedby",
+				"Publisher",
+				"Rec",
+				"Recordedby",
+				"Recording",
+				"RecordingAssistant",
+				"Recordist",
+				"SFX",
+				"SFXDesigner",
+				"SP",
+				"Samples",
+				"Sampling",
+				"Scoring",
+				"Short-Form",
+				"Short-Video",
+				"ShortForm",
+				"ShortVideo",
+				"Songby",
+				"Songwriter",
+				"Songwriting",
+				"SoundDes",
+				"SoundDesign",
+				"SoundDesigner",
+				"SoundEffects",
+				"SoundEffectsDesigner",
+				"SoundMixer",
+				"SpecialThanks",
+				"SpecialThanksto",
+				"StageManager",
+				"Styling",
+				"Stylist",
+				"Sub-publisher",
+				"Subpublisher",
+				"Subtitles",
+				"Supervisedby",
+				"Tech",
+				"Thanks",
+				"Thanksto",
+				"Timing",
+				"Topliner",
+				"TrackingEng",
+				"TrackingEngineer",
+				"Training",
+				"Trans",
+				"Transcriber",
+				"Translatedby",
+				"Tunedby",
+				"Tuning",
+				"Videoby",
+				"Visual",
+				"VisualDesign",
+				"VocalCoach",
+				"VocalDirectedby",
+				"VocalDirection",
+				"VocalDirector",
+				"VocalEdit",
+				"VocalEditing",
+				"VocalEditor",
+				"VocalTuning",
+				"Wardrobe",
+				"Writer",
+				"Written",
+				"Writtenby",
+				"Art",
+				"Image",
+				"Material",
+				"Marketing-Material",
+				"MarketingMaterial",
+				"Copyrightmanagement",
+				"Copyrightoperation",
+				"StudioManager",
+				"Beat",
+				"Cut",
+				"Guest",
+				"Stage"
+			]
+		}
+	]
+};
+var zh_hans_default$1 = {
+	$schema: "../schema.json",
+	version: 1,
+	language: "zh-hans",
+	normalization: {
+		"whitespace": "remove",
+		"case": "asciiLower"
+	},
+	groups: [
+		{
+			"id": "lyricist",
+			"kind": "role",
+			"roles": ["LYRICIST"],
+			"words": [
+				"作词",
+				"填词",
+				"词",
+				"歌词",
+				"作词人",
+				"词作者",
+				"作词者",
+				"填词人",
+				"词作",
+				"中文词",
+				"英文词",
+				"粤语词",
+				"韩文词",
+				"日文词",
+				"RAP词"
+			]
+		},
+		{
+			"id": "composer",
+			"kind": "role",
+			"roles": ["COMPOSER"],
+			"words": [
+				"作曲",
+				"曲",
+				"谱曲",
+				"作曲人",
+				"曲作者",
+				"作曲者"
+			]
+		},
+		{
+			"id": "arranger",
+			"kind": "role",
+			"roles": ["ARRANGER"],
+			"words": [
+				"编曲",
+				"配器",
+				"和声编写",
+				"弦乐编写",
+				"管乐编写",
+				"节奏编写",
+				"合唱编写",
+				"和声编排",
+				"弦乐编排",
+				"管弦乐编排",
+				"编曲人",
+				"编曲者",
+				"编曲师",
+				"和声编配",
+				"弦乐编配",
+				"和音编写"
+			]
+		},
+		{
+			"id": "producer",
+			"kind": "role",
+			"roles": ["PRODUCER"],
+			"words": [
+				"制作人",
+				"制作",
+				"监制",
+				"出品人",
+				"出品",
+				"音乐制作人",
+				"执行制作人",
+				"制作总监",
+				"总制作人",
+				"人声制作",
+				"人声制作人",
+				"配唱制作人",
+				"共同制作",
+				"共同制作人",
+				"协力制作人",
+				"制作协力",
+				"单曲制作",
+				"创意制作人",
+				"出品方",
+				"联合出品",
+				"联合出品方",
+				"执制",
+				"执行监制",
+				"总监制",
+				"音乐监制"
+			]
+		},
+		{
+			"id": "performer",
+			"kind": "role",
+			"roles": ["PERFORMER"],
+			"words": [
+				"演唱",
+				"主唱",
+				"歌手",
+				"唱",
+				"和声",
+				"和音",
+				"伴唱",
+				"合唱",
+				"原唱",
+				"翻唱",
+				"配唱",
+				"女声",
+				"男声",
+				"童声",
+				"人声",
+				"合声",
+				"合音",
+				"领唱",
+				"独奏",
+				"演奏",
+				"演奏者",
+				"说唱",
+				"配音",
+				"旁白",
+				"念白",
+				"对白",
+				"口技",
+				"人声打击",
+				"乐队",
+				"乐团",
+				"交响乐团",
+				"管弦乐团",
+				"弦乐团",
+				"现场乐队",
+				"乐手",
+				"乐师",
+				"伴奏",
+				"演唱者",
+				"演唱人",
+				"和声者",
+				"伴唱者",
+				"领唱者",
+				"吉他手",
+				"贝斯手",
+				"鼓手",
+				"键盘手",
+				"钢琴家",
+				"小提琴手",
+				"大提琴手",
+				"中提琴手",
+				"长笛手",
+				"萨克斯手",
+				"小号手",
+				"长号手",
+				"圆号手",
+				"打击乐手",
+				"单簧管手",
+				"口琴手",
+				"合唱团",
+				"手风琴手",
+				"竖琴手",
+				"艺人"
+			]
+		},
+		{
+			"id": "instruments",
+			"kind": "instrument",
+			"roles": ["PERFORMER"],
+			"words": [
+				"吉他",
+				"钢琴",
+				"贝斯",
+				"贝司",
+				"鼓",
+				"键盘",
+				"弦乐",
+				"小提琴",
+				"大提琴",
+				"中提琴",
+				"长笛",
+				"萨克斯",
+				"小号",
+				"长号",
+				"圆号",
+				"单簧管",
+				"双簧管",
+				"手风琴",
+				"口琴",
+				"二胡",
+				"古筝",
+				"琵琶",
+				"架子鼓",
+				"电子琴",
+				"合成器",
+				"打击乐",
+				"打击乐器",
+				"管乐",
+				"木管",
+				"铜管",
+				"三味线",
+				"三弦",
+				"三角铁",
+				"中国笛",
+				"中提",
+				"中胡",
+				"中阮",
+				"乌德琴",
+				"乐器",
+				"乐器独奏",
+				"京胡",
+				"伽倻琴",
+				"低音单簧管",
+				"低音吉他",
+				"低音提琴",
+				"克拉维奈",
+				"全部乐器",
+				"六角手风琴",
+				"军鼓",
+				"刮壶",
+				"十二弦吉他",
+				"卡洪",
+				"口风琴",
+				"古琴",
+				"合成贝斯",
+				"哈蒙德风琴",
+				"响板",
+				"哨笛",
+				"唢呐",
+				"埙",
+				"塔布拉",
+				"声码器",
+				"大号",
+				"大提",
+				"大笒",
+				"大管",
+				"大键琴",
+				"大阮",
+				"太鼓",
+				"奚琴",
+				"定音鼓",
+				"富鲁格",
+				"富鲁格号",
+				"小提",
+				"小阮",
+				"小鼓",
+				"尤克里里",
+				"尺八",
+				"巴乌",
+				"巴拉莱卡",
+				"巴松",
+				"布祖基",
+				"序列器",
+				"康加鼓",
+				"弦",
+				"德西马",
+				"恰朗戈",
+				"所有乐器",
+				"所有乐器演奏",
+				"手摇琴",
+				"手碟",
+				"手鼓",
+				"打击垫",
+				"扬琴",
+				"拇指琴",
+				"拉巴卜",
+				"指弹吉他",
+				"排笛",
+				"排箫",
+				"提琴",
+				"曼陀林",
+				"月琴",
+				"木吉他",
+				"木棒",
+				"木琴",
+				"木箱鼓",
+				"木鱼",
+				"杜杜克",
+				"板胡",
+				"柳琴",
+				"框鼓",
+				"梅洛特隆",
+				"次中音号",
+				"沙锤",
+				"波德兰鼓",
+				"洞萧",
+				"滑棒吉他",
+				"牛铃",
+				"特雷门琴",
+				"玉琴",
+				"班卓琴",
+				"班多钮",
+				"班苏里笛",
+				"瑶琴",
+				"电吉他",
+				"电子打击垫",
+				"电子鼓",
+				"电贝司",
+				"电贝斯",
+				"电钢琴",
+				"短号",
+				"短笛",
+				"竖琴",
+				"竖笛",
+				"竹笛",
+				"笙",
+				"笛子",
+				"笛萧",
+				"筝",
+				"箜篌",
+				"管钟",
+				"箫",
+				"箱琴",
+				"簧风琴",
+				"编钟",
+				"肩背键盘",
+				"自动竖琴",
+				"英国管",
+				"葫芦丝",
+				"蒂姆巴尔鼓",
+				"西塔琴",
+				"说话鼓",
+				"谐振吉他",
+				"踏板钢弦吉他",
+				"转盘",
+				"达布卡",
+				"迪吉里杜管",
+				"邦戈鼓",
+				"采样器",
+				"金贝鼓",
+				"钟琴",
+				"钢片琴",
+				"钢鼓",
+				"钹",
+				"铃鼓",
+				"锡笛",
+				"锣",
+				"键提琴",
+				"镲",
+				"长鼓",
+				"阮",
+				"陶笛",
+				"非洲鼓",
+				"颤音琴",
+				"风琴",
+				"风笛",
+				"马头琴",
+				"马林巴",
+				"高胡",
+				"鲁特琴",
+				"齐特琴"
+			]
+		},
+		{
+			"id": "mixer",
+			"kind": "role",
+			"roles": ["MIXER"],
+			"words": [
+				"混音",
+				"混音师",
+				"混",
+				"混音工程师",
+				"缩混",
+				"贴混",
+				"混音工程",
+				"重混音师"
+			]
+		},
+		{
+			"id": "mastering",
+			"kind": "role",
+			"roles": ["MASTERING"],
+			"words": [
+				"母带",
+				"母带工程师",
+				"母带处理",
+				"母带制作",
+				"母带后期",
+				"母带工程",
+				"母带师",
+				"母带制作人",
+				"母带处理制作人"
+			]
+		},
+		{
+			"id": "lyrics-and-composition",
+			"kind": "role",
+			"roles": ["LYRICIST", "COMPOSER"],
+			"words": [
+				"词曲",
+				"作词/作曲",
+				"作词作曲",
+				"词/曲",
+				"词&曲",
+				"词曲作者",
+				"词曲创作",
+				"作曲/作词",
+				"作曲、作词",
+				"作词+作曲",
+				"作词,作曲",
+				"作词·作曲",
+				"作词、作曲",
+				"作词，作曲",
+				"词/曲作",
+				"词、曲",
+				"词，曲"
+			]
+		},
+		{
+			"id": "composition-and-arrangement",
+			"kind": "role",
+			"roles": ["COMPOSER", "ARRANGER"],
+			"words": [
+				"作编曲",
+				"作曲/编曲",
+				"作曲编曲",
+				"曲/编",
+				"曲编",
+				"作曲、编曲",
+				"作曲，编曲"
+			]
+		},
+		{
+			"id": "mixing-and-mastering",
+			"kind": "role",
+			"roles": ["MIXER", "MASTERING"],
+			"words": [
+				"混音/母带",
+				"混音母带",
+				"混音&母带",
+				"混音与母带",
+				"混音及母带",
+				"母带/混音",
+				"混音、母带",
+				"混音，母带"
+			]
+		},
+		{
+			"id": "lyrics-and-arrangement",
+			"kind": "role",
+			"roles": ["LYRICIST", "ARRANGER"],
+			"words": [
+				"作词/编曲",
+				"作词、编曲",
+				"作词编曲",
+				"词/编",
+				"词编"
+			]
+		},
+		{
+			"id": "lyrics-composition-and-arrangement",
+			"kind": "role",
+			"roles": [
+				"LYRICIST",
+				"COMPOSER",
+				"ARRANGER"
+			],
+			"words": [
+				"作词/作曲/编曲",
+				"作词、作曲、编曲",
+				"作词作曲编曲",
+				"词曲编",
+				"词曲编曲"
+			]
+		},
+		{
+			"id": "singer-songwriter",
+			"kind": "role",
+			"roles": [
+				"LYRICIST",
+				"COMPOSER",
+				"PERFORMER"
+			],
+			"words": [
+				"唱作",
+				"唱作人",
+				"唱作歌手"
+			]
+		},
+		{
+			"id": "other",
+			"kind": "role",
+			"roles": ["OTHER"],
+			"words": [
+				"录音师",
+				"录音工程师",
+				"录音",
+				"录制",
+				"工程师",
+				"混音助理",
+				"母带助理",
+				"制作助理",
+				"策划",
+				"宣发",
+				"摄影师",
+				"摄像",
+				"设计师",
+				"美术",
+				"美工",
+				"视觉设计",
+				"封面设计",
+				"插画",
+				"插画师",
+				"曲绘",
+				"校对",
+				"打轴",
+				"时轴",
+				"时间轴",
+				"修音",
+				"修音师",
+				"调音",
+				"调音师",
+				"拟音",
+				"音效",
+				"音响",
+				"指挥",
+				"经纪",
+				"顾问",
+				"艺术指导",
+				"艺术总监",
+				"音乐总监",
+				"创意总监",
+				"舞台监督",
+				"灯光师",
+				"特别感谢",
+				"特别鸣谢",
+				"感谢",
+				"鸣谢",
+				"致谢",
+				"短视频",
+				"MIDI编程",
+				"OP",
+				"PGM",
+				"Program",
+				"SP",
+				"主创",
+				"乐器技师",
+				"乐谱",
+				"乐谱管理员",
+				"人声指导",
+				"人声编辑",
+				"企划宣传",
+				"企宣",
+				"分轨",
+				"分镜",
+				"制作统筹",
+				"前台工程师",
+				"剪辑",
+				"剪辑师",
+				"动画师",
+				"助工",
+				"助理",
+				"助理工程师",
+				"化妆",
+				"协力",
+				"吉他技师",
+				"后期制作",
+				"图绘",
+				"声工",
+				"声设",
+				"声音设计师",
+				"妆发",
+				"妆造",
+				"客串",
+				"宣推",
+				"平面",
+				"平面视觉",
+				"平面设计",
+				"录音助理",
+				"录音室经理",
+				"扒谱",
+				"扒谱员",
+				"承办人",
+				"技术支持",
+				"抄谱",
+				"抄谱员",
+				"拟音师",
+				"数字剪辑",
+				"数字编辑",
+				"文案策划",
+				"映像",
+				"服装",
+				"杜比全景声",
+				"歌词翻译",
+				"灯光",
+				"特约嘉宾",
+				"特邀",
+				"电脑",
+				"电脑工程师",
+				"监听",
+				"监听工程师",
+				"策监",
+				"筹划",
+				"编程",
+				"编程播放",
+				"编调",
+				"编辑",
+				"美术指导",
+				"舞台总监",
+				"艺人与产品",
+				"艺人助理",
+				"艺人统筹",
+				"艺术顾问",
+				"节拍",
+				"节拍制作",
+				"节拍制作人",
+				"营销",
+				"视觉总监",
+				"调教",
+				"调校",
+				"谱务",
+				"资产管理",
+				"跟踪工程师",
+				"辅助监督",
+				"造型",
+				"造型师",
+				"采样",
+				"音乐制作助理",
+				"音乐统筹",
+				"音乐视频导演",
+				"音响工程师",
+				"音序",
+				"音控师",
+				"音效设计",
+				"音频编辑",
+				"项目策划",
+				"项目统筹",
+				"预制作",
+				"题字",
+				"首席运营官",
+				"鼓技师",
+				"封面",
+				"海报",
+				"原版权",
+				"原始版权",
+				"次级版权",
+				"版权运营",
+				"业务",
+				"企划",
+				"宣传",
+				"推广",
+				"发行",
+				"统筹",
+				"设计",
+				"摄影",
+				"导演",
+				"翻译",
+				"后期",
+				"工程",
+				"声音",
+				"支持",
+				"艺术",
+				"指导",
+				"监督",
+				"视觉",
+				"舞台",
+				"物料",
+				"台词",
+				"字幕",
+				"文案",
+				"脚本",
+				"花絮",
+				"视频",
+				"作",
+				"封",
+				"监",
+				"编",
+				"译",
+				"谱"
+			]
+		}
+	]
+};
+//#endregion
+//#region src/transforms/credit/rules.ts
+var MATCH_CACHE_LIMIT = 256;
+var MAX_CACHED_LABEL_LENGTH = 256;
+var CREDIT_ROLES = /* @__PURE__ */ new Map([
+	["OTHER", CreditRole.OTHER],
+	["LYRICIST", CreditRole.LYRICIST],
+	["COMPOSER", CreditRole.COMPOSER],
+	["ARRANGER", CreditRole.ARRANGER],
+	["PRODUCER", CreditRole.PRODUCER],
+	["PERFORMER", CreditRole.PERFORMER],
+	["MIXER", CreditRole.MIXER],
+	["MASTERING", CreditRole.MASTERING]
+]);
+var creditRules = /* @__PURE__ */ new Map();
+var matchCache = /* @__PURE__ */ new Map();
+for (const ruleSet of [zh_hans_default$1, en_default$1]) for (const group of ruleSet.groups) {
+	const roles = group.roles.map((name) => {
+		const role = CREDIT_ROLES.get(name);
+		if (role === void 0) throw new TypeError("Unsupported credit role: " + name);
+		return role;
+	});
+	for (const word of group.words) {
+		const key = toRuleMatchKey(word);
+		if (!creditRules.has(key)) creditRules.set(key, roles);
+	}
+}
+var haveSameRoles = (first, second) => {
+	if (first === second) return true;
+	if (first.length !== second.length) return false;
+	if (first.length === 1) return first[0] === second[0];
+	return first.every((role) => second.includes(role));
+};
+var findCoveringRoles = (label, key) => {
+	const cuts = findRuleMatchCuts(label);
+	if (!cuts) return;
+	const last = cuts.length - 1;
+	let bestCount = last + 1;
+	let bestRoles;
+	const search = (from, count, roles) => {
+		if (from === last) {
+			if (count < bestCount) {
+				bestCount = count;
+				bestRoles = roles;
+				return true;
+			}
+			return count > bestCount || haveSameRoles(roles, bestRoles);
+		}
+		if (count + 1 > bestCount) return true;
+		for (let to = last; to > from; to -= 1) {
+			const matched = creditRules.get(key.slice(cuts[from], cuts[to]));
+			if (!matched || roles && !haveSameRoles(roles, matched)) continue;
+			if (!search(to, count + 1, roles ?? matched)) return false;
+		}
+		return true;
+	};
+	return search(0, 0, void 0) ? bestRoles : void 0;
+};
+/**
+* Prefers the complete alias, then accepts adjacent parts that each resolve to the same roles.
+* Parts are cut only where the source has whitespace or a script boundary, and the covering with the fewest parts wins.
+* Unknown parts, role conflicts, and equally short coverings that disagree stay unmatched so the source remains available to later processing.
+*/
+var matchCreditLabel = (label) => {
+	const cached = matchCache.get(label);
+	if (cached !== void 0) return cached ?? void 0;
+	const key = toRuleMatchKey(label);
+	const roles = creditRules.get(key) ?? findCoveringRoles(label, key);
+	if (label.length <= MAX_CACHED_LABEL_LENGTH) {
+		if (matchCache.size === MATCH_CACHE_LIMIT) {
+			const oldest = matchCache.keys().next().value;
+			if (oldest !== void 0) matchCache.delete(oldest);
+		}
+		matchCache.set(label, roles ?? null);
+	}
+	return roles;
+};
+//#endregion
+//#region src/transforms/credit/extract.ts
+var DEFAULT_CREDIT_NAME_SEPARATORS = [
+	"+",
+	"：",
+	"/"
+];
+var createCreditIndex = (credits) => {
+	const creditIndex = /* @__PURE__ */ new Map();
+	for (let index = 0; index < credits.length; index += 1) {
+		const credit = credits[index];
+		let entries = creditIndex.get(credit.raw);
+		if (!entries) {
+			entries = /* @__PURE__ */ new Map();
+			creditIndex.set(credit.raw, entries);
+		}
+		let entry = entries.get(credit.role);
+		if (!entry) {
+			entry = {
+				index,
+				names: /* @__PURE__ */ new Set()
+			};
+			entries.set(credit.role, entry);
+		}
+		for (const name of credit.names) entry.names.add(name.text);
+	}
+	return creditIndex;
+};
+var prepareCreditSeparators = (selected) => {
+	if (!selected || selected === DEFAULT_CREDIT_NAME_SEPARATORS) return DEFAULT_CREDIT_NAME_SEPARATORS;
+	if (selected.length === DEFAULT_CREDIT_NAME_SEPARATORS.length && selected.every((separator, index) => separator === DEFAULT_CREDIT_NAME_SEPARATORS[index])) return DEFAULT_CREDIT_NAME_SEPARATORS;
+	return [...new Set(selected)].filter(Boolean).sort((first, second) => second.length - first.length);
+};
+var readCreditNames = (text, separators) => {
+	if (!separators.some((separator) => text.includes(separator))) {
+		const name = trimRuleWhitespace(text);
+		return name ? [name] : [];
+	}
+	let names = [text];
+	for (const separator of separators) if (names.some((name) => name.includes(separator))) names = names.flatMap((name) => name.split(separator));
+	const unique = /* @__PURE__ */ new Set();
+	for (const name of names) {
+		const trimmed = trimRuleWhitespace(name);
+		if (trimmed) unique.add(trimmed);
+	}
+	return [...unique];
+};
+var canRemoveSourceLine = (line) => {
+	if (line.backgrounds.length || line.annotation) return false;
+	return !line.content?.words.some(({ annotation }) => {
+		if (!annotation) return false;
+		return !!(annotation.translations.length || annotation.romans.length);
+	});
+};
+var hasCreditColon = (word) => {
+	return word.text.includes(":") || word.text.includes("：");
+};
+/**
+* Preserves source labels and name spelling while matching normalized credit labels in normal lead lines.
+* Merges names by role and original label without inferring their language.
+*
+* @returns The input when unchanged, or a new lyric sharing all unchanged nodes.
+*/
+var extractCredits = (lyric, options = {}) => {
+	const separators = prepareCreditSeparators(options.nameSeparators);
+	const originalCredits = lyric.meta?.credits ?? [];
+	let credits = originalCredits;
+	let creditIndex;
+	const originalLines = lyric.lines;
+	let remainingLines;
+	for (let index = 0; index < originalLines.length; index += 1) {
+		const line = originalLines[index];
+		if (line.type !== LineType.NORMAL) {
+			remainingLines?.push(line);
+			continue;
+		}
+		const content = line.content;
+		if (!(content?.text !== void 0 || (content?.words.some(hasCreditColon) ?? false))) {
+			remainingLines?.push(line);
+			continue;
+		}
+		const text = getContentText(content);
+		const colon = text.search(/[:：]/);
+		if (colon === -1) {
+			remainingLines?.push(line);
+			continue;
+		}
+		const raw = trimRuleWhitespace(text.slice(0, colon));
+		const roles = matchCreditLabel(raw);
+		const names = roles ? readCreditNames(text.slice(colon + 1), separators) : [];
+		if (!roles || !names.length) {
+			remainingLines?.push(line);
+			continue;
+		}
+		creditIndex ??= createCreditIndex(originalCredits);
+		let entries = creditIndex.get(raw);
+		if (!entries) {
+			entries = /* @__PURE__ */ new Map();
+			creditIndex.set(raw, entries);
+		}
+		for (const role of roles) {
+			let entry = entries.get(role);
+			const additions = names.filter((name) => !entry?.names.has(name));
+			if (!additions.length) continue;
+			if (credits === originalCredits) credits = [...originalCredits];
+			const nameNodes = additions.map((name) => makeText({ text: name }));
+			if (!entry) {
+				entry = {
+					index: credits.length,
+					names: /* @__PURE__ */ new Set()
+				};
+				entries.set(role, entry);
+				credits.push(makeMetaCredit({
+					role,
+					raw,
+					names: nameNodes
+				}));
+			} else {
+				const credit = credits[entry.index];
+				credits[entry.index] = {
+					...credit,
+					names: [...credit.names, ...nameNodes]
+				};
+			}
+			for (const name of additions) entry.names.add(name);
+		}
+		if (options.removeSourceLines && canRemoveSourceLine(line)) remainingLines ??= originalLines.slice(0, index);
+		else remainingLines?.push(line);
+	}
+	if (credits === originalCredits && !remainingLines) return lyric;
+	const removed = !!remainingLines;
+	const lines = remainingLines ?? originalLines;
+	let timing = lyric.timing;
+	if (removed && timing === Timing.WORD) {
+		if (!lines.some((line) => {
+			return isWordLevelLine(line) || line.backgrounds.some(isWordLevelLine);
+		})) timing = Timing.LINE;
+	}
+	const meta = credits === originalCredits ? lyric.meta : lyric.meta ? {
+		...lyric.meta,
+		credits
+	} : makeMeta({ credits });
+	return {
+		...lyric,
+		meta,
+		lines,
+		timing,
+		languages: removed ? deriveLanguageUsages(lines) : lyric.languages
+	};
+};
+//#endregion
+//#region src/transforms/emphasis/index.ts
+var deriveContentEmphasis = (content, durationThreshold) => {
+	if (!content) return content;
+	const words = mapShared(content.words, (word) => {
+		if (word.type !== WordType.NORMAL || word.emphasis?.derived === false) return word;
+		const time = word.time;
+		if (!!time && time.end !== void 0 && !validateTimeRange(time).length && time.end - time.start > durationThreshold) {
+			if (word.emphasis?.value) return word;
+			return {
+				...word,
+				emphasis: makeWordEmphasis({
+					value: true,
+					derived: true
+				})
+			};
+		}
+		if (!word.emphasis) return word;
+		return {
+			...word,
+			emphasis: void 0
+		};
+	});
+	return words === content.words ? content : {
+		...content,
+		words
+	};
+};
+/**
+* Derives emphasis for normal words in lead and background vocals using complete, valid word ranges.
+* The stored word duration must strictly exceed durationThreshold; metadata offset and duration have no effect.
+*
+* Source emphasis, including an explicit false, is preserved; derived emphasis is cleared when a word no longer qualifies.
+*
+* @returns The input when unchanged, or a new lyric sharing all unchanged nodes.
+*
+* @throws {RangeError} If durationThreshold is not a non-negative safe integer in milliseconds.
+*/
+var deriveWordEmphasis = (lyric, options = {}) => {
+	const durationThreshold = options.durationThreshold ?? 3e3;
+	if (!Number.isSafeInteger(durationThreshold) || durationThreshold < 0) throw new RangeError("durationThreshold must be a non-negative safe integer in milliseconds");
+	const lines = mapShared(lyric.lines, (line) => {
+		if (line.type !== LineType.NORMAL) return line;
+		const content = deriveContentEmphasis(line.content, durationThreshold);
+		const backgrounds = mapShared(line.backgrounds, (background) => {
+			const content = deriveContentEmphasis(background.content, durationThreshold);
+			return content === background.content ? background : {
+				...background,
+				content
+			};
+		});
+		return content === line.content && backgrounds === line.backgrounds ? line : {
+			...line,
+			content,
+			backgrounds
+		};
+	});
+	return lines === lyric.lines ? lyric : {
+		...lyric,
+		lines
+	};
+};
+//#endregion
+//#region src/transforms/filter/rules.ts
+var nonLyricGroups = [{
+	$schema: "../schema.json",
+	version: 1,
+	language: "zh-hans",
+	normalization: {
+		"whitespace": "remove",
+		"case": "asciiLower"
+	},
+	groups: [
+		{
+			"id": "copyright-notice",
+			"category": "copyright",
+			"match": "contains",
+			"words": [
+				"版权所有",
+				"保留所有权利",
+				"侵权必究",
+				"翻版必究",
+				"违者必究",
+				"未经授权",
+				"未经许可",
+				"版权归",
+				"版权属于",
+				"不得转载",
+				"严禁转载",
+				"盗版必究",
+				"禁止转载"
+			]
+		},
+		{
+			"id": "copyright-label",
+			"category": "copyright",
+			"match": "whole",
+			"words": ["版权", "授权"]
+		},
+		{
+			"id": "adaptation-label",
+			"category": "adaptation",
+			"match": "whole",
+			"words": [
+				"改编",
+				"翻唱",
+				"致敬"
+			]
+		},
+		{
+			"id": "disclaimer-notice",
+			"category": "disclaimer",
+			"match": "contains",
+			"words": [
+				"仅供学习",
+				"仅供个人",
+				"仅供参考",
+				"仅供交流",
+				"禁止商业用途",
+				"非商业用途"
+			]
+		},
+		{
+			"id": "organization-label",
+			"category": "organization",
+			"match": "contains",
+			"words": [
+				"唱片公司",
+				"制作公司",
+				"发行公司",
+				"承办单位",
+				"次级发行方",
+				"厂牌"
+			]
+		},
+		{
+			"id": "studio-label",
+			"category": "studio",
+			"match": "contains",
+			"words": [
+				"录音室",
+				"录音棚",
+				"混音室",
+				"混音工作室",
+				"混音录音室",
+				"母带录音室",
+				"母带处理录音室"
+			]
+		}
+	]
+}, {
+	$schema: "../schema.json",
+	version: 1,
+	language: "en",
+	normalization: {
+		"whitespace": "remove",
+		"case": "asciiLower"
+	},
+	groups: [
+		{
+			"id": "copyright-notice",
+			"category": "copyright",
+			"match": "contains",
+			"words": [
+				"Allrightsreserved",
+				"Allrightsofthe",
+				"Nopartofthis",
+				"Unauthorizedreproduction",
+				"Unauthorizedduplication",
+				"Unauthorizedcopying",
+				"Unauthorizeduse",
+				"Underexclusivelicense",
+				"Allrightsreservedby",
+				"Anyunauthorizeduse",
+				"Usedbypermission"
+			]
+		},
+		{
+			"id": "copyright-label",
+			"category": "copyright",
+			"match": "whole",
+			"words": ["Copyright", "License"]
+		},
+		{
+			"id": "adaptation-label",
+			"category": "adaptation",
+			"match": "whole",
+			"words": [
+				"Cover",
+				"Remake",
+				"Tribute",
+				"Adaptation"
+			]
+		},
+		{
+			"id": "disclaimer-notice",
+			"category": "disclaimer",
+			"match": "contains",
+			"words": [
+				"Foreducationalpurposes",
+				"Fornon-commercial",
+				"Fornoncommercial",
+				"Fornonprofitable",
+				"Forpersonaluse",
+				"Forpromotionalpurposes"
+			]
+		},
+		{
+			"id": "organization-label",
+			"category": "organization",
+			"match": "contains",
+			"words": [
+				"ManufacturingCompany",
+				"RecordCompany",
+				"RecordLabel",
+				"Distribution"
+			]
+		},
+		{
+			"id": "studio-label",
+			"category": "studio",
+			"match": "contains",
+			"words": [
+				"RecordingStudio",
+				"MasteringStudio",
+				"Mixingstudio",
+				"Mixstudio",
+				"StudioPersonnel"
+			]
+		}
+	]
+}].flatMap((ruleSet) => {
+	return ruleSet.groups.map((group) => {
+		if (group.match !== "contains" && group.match !== "whole") throw new TypeError("Unsupported filter match: " + group.match);
+		return {
+			category: group.category,
+			whole: group.match === "whole",
+			words: group.words.map(toRuleMatchKey)
+		};
+	});
+});
+/**
+* Categories the bundled filter rules identify, in rule order.
+*/
+var NON_LYRIC_CATEGORIES = [...new Set(nonLyricGroups.map((group) => group.category))];
+/**
+* Keeps rule order so earlier groups still take precedence within a selection; undefined selects every group.
+*/
+var selectNonLyricGroups = (categories) => {
+	if (!categories) return nonLyricGroups;
+	return nonLyricGroups.filter((group) => categories.includes(group.category));
+};
+/**
+* Returns the category of the first group that identifies the normalized text.
+* whole needs the complete text to equal a word, while contains accepts a word anywhere because the rules carry no word boundaries.
+*/
+var matchNonLyricCategory = (text, groups) => {
+	const key = toRuleMatchKey(text);
+	if (!key) return;
+	for (const group of groups) if (group.whole ? group.words.includes(key) : group.words.some((word) => key.includes(word))) return group.category;
+};
+//#endregion
+//#region src/transforms/filter/remove.ts
+var toMusicInfoMatchText = (text) => {
+	return text.normalize("NFC").trim().replace(/\s+/gu, " ").replace(/[A-Z]+/g, (run) => run.toLowerCase());
+};
+var findFirstMusicInfoLine = (lyric, musicInfo) => {
+	const titles = (musicInfo.titles ?? []).map(toMusicInfoMatchText).filter(Boolean);
+	const artists = (musicInfo.artists ?? []).map(toMusicInfoMatchText).filter(Boolean);
+	if (!titles.length || !artists.length) return -1;
+	const index = lyric.lines.findIndex((line) => {
+		return line.type === LineType.NORMAL && !!getContentText(line.content).trim();
+	});
+	if (index === -1) return -1;
+	const parts = getContentText(lyric.lines[index].content).trim().split(" - ");
+	if (parts.length !== 2) return -1;
+	const left = toMusicInfoMatchText(parts[0]);
+	const right = toMusicInfoMatchText(parts[1]);
+	if (!left || !right) return -1;
+	const titleOnLeft = titles.some((title) => left.includes(title));
+	const titleOnRight = titles.some((title) => right.includes(title));
+	const artistOnLeft = artists.some((artist) => left.includes(artist));
+	const artistOnRight = artists.some((artist) => right.includes(artist));
+	return titleOnLeft && artistOnRight || artistOnLeft && titleOnRight ? index : -1;
+};
+/**
+* Removes normal lead lines matched by the shared notice rules and, when musicInfo is provided, first-line song information.
+* The first non-empty normal line must have one literal " - " separator and a known title and artist on opposite sides; either order and extra text such as bracketed aliases are accepted.
+* Drops attached annotations and backgrounds, refreshes language usages, and falls back to line timing when no word-level content remains.
+*
+* @returns The input when unchanged, or a new lyric sharing all unchanged nodes.
+*/
+var removeNonLyricLines = (lyric, options = {}) => {
+	const groups = selectNonLyricGroups(options.categories);
+	const musicInfoIndex = options.musicInfo ? findFirstMusicInfoLine(lyric, options.musicInfo) : -1;
+	if (!groups.length && musicInfoIndex === -1) return lyric;
+	const lines = lyric.lines.filter((line, index) => {
+		if (index === musicInfoIndex) return false;
+		return line.type !== LineType.NORMAL || matchNonLyricCategory(getContentText(line.content), groups) === void 0;
+	});
+	if (lines.length === lyric.lines.length) return lyric;
+	let timing = lyric.timing;
+	if (timing === Timing.WORD) {
+		if (!lines.some((line) => {
+			return isWordLevelLine(line) || line.backgrounds.some(isWordLevelLine);
+		})) timing = Timing.LINE;
+	}
+	return {
+		...lyric,
+		lines,
+		timing,
+		languages: deriveLanguageUsages(lines)
+	};
+};
+//#endregion
+//#region src/transforms/instrumental/index.ts
+var MAX_TIME = 2 ** 31 - 1;
+var readMinimum = (value, fallback, name) => {
+	const minimum = value ?? fallback;
+	if (!Number.isSafeInteger(minimum) || minimum < 0) throw new RangeError(`${name} must be a non-negative safe integer in milliseconds`);
+	return minimum;
+};
+var readEndTime = (value) => {
+	if (value !== void 0 && (!Number.isInteger(value) || value < 0 || value > MAX_TIME)) throw new RangeError(`endTime must be a non-negative integer in milliseconds no greater than ${MAX_TIME}`);
+	return value;
+};
+var compareTimeRanges = (left, right) => {
+	const leftStart = left?.start ?? Infinity;
+	const rightStart = right?.start ?? Infinity;
+	if (leftStart !== rightStart) return leftStart - rightStart;
+	const leftEnd = left?.end ?? Infinity;
+	const rightEnd = right?.end ?? Infinity;
+	return leftEnd === rightEnd ? 0 : leftEnd - rightEnd;
+};
+var readOccupiedTimeline = (lyric) => {
+	const ranges = [];
+	let firstSungStart = Infinity;
+	const append = (time, sung) => {
+		if (!time || validateTimeRange(time).length) return false;
+		if (time.end === time.start) return true;
+		ranges.push(time);
+		if (sung) firstSungStart = Math.min(firstSungStart, time.start);
+		return true;
+	};
+	for (const line of lyric.lines) {
+		if (!append(line.time, line.type === LineType.NORMAL)) return;
+		for (const background of line.backgrounds) if (!append(background.time, true)) return;
+	}
+	ranges.sort(compareTimeRanges);
+	return {
+		ranges,
+		firstSungStart
+	};
+};
+var compareLineTimes = (left, right) => {
+	return compareTimeRanges(left.time, right.time);
+};
+var mergeLines = (lines, inserted) => {
+	let source = lines;
+	for (const [index, line] of lines.entries()) {
+		const previous = lines[index - 1];
+		if (previous && compareLineTimes(previous, line) > 0) {
+			source = [...lines].sort(compareLineTimes);
+			break;
+		}
+	}
+	const merged = [];
+	let nextIndex = 0;
+	for (const line of source) {
+		let next = inserted[nextIndex];
+		while (next && compareLineTimes(next, line) < 0) {
+			merged.push(next);
+			nextIndex += 1;
+			next = inserted[nextIndex];
+		}
+		merged.push(line);
+	}
+	merged.push(...inserted.slice(nextIndex));
+	return merged;
+};
+/**
+* Inserts derived instrumental lines into uncovered gaps on the stored timeline, starting at zero.
+* Existing lines and background vocals occupy their full ranges; an unknown end blocks later gaps.
+*
+* An outro requires an explicit endTime; metadata duration and offset do not affect insertion.
+*
+* @returns The input when unchanged, or a new lyric and lines array sharing existing nodes.
+*/
+var insertInstrumentalLines = (lyric, options = {}) => {
+	const minDuration = readMinimum(options.minDuration, 1e4, "minDuration");
+	const minIntroDuration = readMinimum(options.minIntroDuration, 5e3, "minIntroDuration");
+	const endTime = readEndTime(options.endTime);
+	if (lyric.timing !== Timing.LINE && lyric.timing !== Timing.WORD || !lyric.lines.length) return lyric;
+	const occupied = readOccupiedTimeline(lyric);
+	if (!occupied || occupied.firstSungStart === Infinity) return lyric;
+	const inserted = [];
+	let coveredEnd = 0;
+	const appendGap = (end, minimum) => {
+		const duration = end - coveredEnd;
+		if (duration > 0 && duration >= minimum) inserted.push(makeLineInstrumental({ time: makeTimeRange({
+			start: coveredEnd,
+			end
+		}) }));
+	};
+	for (const range of occupied.ranges) {
+		appendGap(range.start, range.start <= occupied.firstSungStart ? minIntroDuration : minDuration);
+		coveredEnd = Math.max(coveredEnd, range.end ?? Infinity);
+		if (coveredEnd === Infinity) break;
+	}
+	if (endTime !== void 0) appendGap(endTime, minDuration);
+	if (!inserted.length) return lyric;
+	return {
+		...lyric,
+		lines: mergeLines(lyric.lines, inserted)
+	};
+};
+//#endregion
+//#region src/transforms/space/constants.ts
+/**
+* Groups of characters a source may write without a space where one belongs.
+*/
+var InsertSpacesRules = {
+	/**
+	* A CJK character touching a Latin letter, as in `ABC中文`.
+	*/
+	CJK_ENGLISH: "cjkEnglish",
+	/**
+	* A CJK character touching a digit, as in `2026年`.
+	*/
+	CJK_NUMBER: "cjkNumber",
+	/**
+	* A comma, semicolon, exclamation mark, question mark or colon touching a character, as in `a,b`; a clock time or thousands separator such as `10:30` stays as written.
+	*/
+	PUNCTUATION: "punctuation",
+	/**
+	* A quotation mark touching a neighbouring character.
+	*/
+	QUOTE: "quote",
+	/**
+	* A bracket touching the character outside it.
+	*/
+	BRACKET_OUTSIDE: "bracketOutside",
+	/**
+	* A plus, equals or ampersand touching a character, as in `a+b`; a compound operator such as `a+=b` stays as written.
+	*/
+	MATH_OPERATOR: "mathOperator",
+	/**
+	* A hyphen touching a CJK character, as in `中-文`; a compound word such as `well-known` stays as written.
+	*/
+	HYPHEN: "hyphen",
+	/**
+	* A slash touching a character, as in `and/or`; a fraction such as `1/2` stays as written.
+	*/
+	SLASH: "slash",
+	/**
+	* Runs of two or more spaces, collapsed to one.
+	*/
+	COMPRESS_SPACES: "compressSpaces",
+	/**
+	* Spaces just inside a bracket or quotation mark, removed.
+	*/
+	TRIM_INSIDE_SYMBOLS: "trimInsideSymbols"
+};
+var INSERT_SPACES_RULES = Object.values(InsertSpacesRules);
+//#endregion
+//#region src/transforms/space/rules.ts
+var CJK_RANGE = "぀-ヿ㐀-䶿一-鿿豈-﫿";
+var LATIN_RANGE = "A-Za-z";
+var DIGIT_RANGE = "0-9";
+var SYMBOL_RANGE = "!@#$%^&+\\-=/|<>";
+var WORD_RANGE = `${LATIN_RANGE}${DIGIT_RANGE}${CJK_RANGE}`;
+var ALL_RANGE = `${WORD_RANGE}${SYMBOL_RANGE}`;
+var CJK_LATIN = new RegExp(`([${CJK_RANGE}])([${LATIN_RANGE}])`, "gu");
+var LATIN_CJK = new RegExp(`([${LATIN_RANGE}])([${CJK_RANGE}])`, "gu");
+var CJK_DIGIT = new RegExp(`([${CJK_RANGE}])([${DIGIT_RANGE}])`, "gu");
+var DIGIT_CJK = new RegExp(`([${DIGIT_RANGE}])([${CJK_RANGE}])`, "gu");
+var PUNCTUATION = new RegExp(`([${ALL_RANGE}])([!;,\\?:])(?=[${ALL_RANGE}])`, "gu");
+var QUOTE_BEFORE = new RegExp(`([${CJK_RANGE}${LATIN_RANGE}${DIGIT_RANGE}])(["\`“‘])`, "gu");
+var QUOTE_AFTER = new RegExp(`(["”’])([${CJK_RANGE}${LATIN_RANGE}${DIGIT_RANGE}])`, "gu");
+var BRACKET_BEFORE = new RegExp(`([${WORD_RANGE}])([\\[({<])`, "gu");
+var BRACKET_AFTER = new RegExp(`([\\])}>])([${WORD_RANGE}])`, "gu");
+var MATH_OPERATOR = new RegExp(`([${ALL_RANGE}])([+=&])(?=[${ALL_RANGE}])`, "gu");
+var HYPHEN = new RegExp(`(?<=[${WORD_RANGE}])-(?=[${WORD_RANGE}])`, "gu");
+var SLASH = new RegExp(`([${WORD_RANGE}])(/)(?=[${WORD_RANGE}])`, "gu");
+var TRIM_INSIDE_SYMBOLS = /* @__PURE__ */ new RegExp("([<[{\"“‘(])\\s*([^<>[\\]{}()\"“‘”’]*?)\\s*([>\\]}\"”’)])", "gu");
+var REPEATED_SPACES = / {2,}/gu;
+var REPEATED_MARKS = /[!;,\\?:+\-=/&]{2,}/gu;
+var PLACEHOLDER = /\u0001(\d+)\u0001/gu;
+var isDigit = (char) => {
+	return !!char && char >= "0" && char <= "9";
+};
+var isLatin = (char) => {
+	return !!char && (char >= "A" && char <= "Z" || char >= "a" && char <= "z");
+};
+/**
+* A comma or colon between two digits belongs to one number or clock time, so it stays tight.
+*/
+var applyPunctuation = (text) => {
+	return text.replace(PUNCTUATION, (match, before, mark, offset, source) => {
+		if ((mark === "," || mark === ":") && isDigit(before) && isDigit(source[offset + match.length])) return match;
+		return `${before}${mark} `;
+	});
+};
+/**
+* A hyphen between two digits is a date, range or phone number, and one between two Latin letters joins a compound word.
+*
+* An edge hyphen is left alone, since it reads as a sign or a list marker rather than a dash.
+*/
+var applyHyphen = (text) => {
+	return text.replace(HYPHEN, (match, offset, source) => {
+		const left = source[offset - 1];
+		const right = source[offset + 1];
+		return isDigit(left) && isDigit(right) || isLatin(left) && isLatin(right) ? match : " - ";
+	});
+};
+/**
+* A slash between two digits is a fraction or date, so it stays tight.
+*/
+var applySlash = (text) => {
+	return text.replace(SLASH, (match, before, slash, offset, source) => {
+		return isDigit(before) && isDigit(source[offset + match.length]) ? match : `${before} ${slash} `;
+	});
+};
+/**
+* Trims the spaces just inside a bracket or quotation mark, without touching a nested pair inside it.
+*/
+var applyTrimInsideSymbols = (text) => {
+	return text.replace(TRIM_INSIDE_SYMBOLS, (match, left, inner, right) => {
+		return `${left}${inner.trim()}${right}`;
+	});
+};
+var APPLIERS = {
+	[InsertSpacesRules.CJK_ENGLISH]: (text) => {
+		return text.replace(CJK_LATIN, "$1 $2").replace(LATIN_CJK, "$1 $2");
+	},
+	[InsertSpacesRules.CJK_NUMBER]: (text) => {
+		return text.replace(CJK_DIGIT, "$1 $2").replace(DIGIT_CJK, "$1 $2");
+	},
+	[InsertSpacesRules.PUNCTUATION]: applyPunctuation,
+	[InsertSpacesRules.QUOTE]: (text) => {
+		return text.replace(QUOTE_BEFORE, "$1 $2").replace(QUOTE_AFTER, "$1 $2");
+	},
+	[InsertSpacesRules.BRACKET_OUTSIDE]: (text) => {
+		return text.replace(BRACKET_BEFORE, "$1 $2").replace(BRACKET_AFTER, "$1 $2");
+	},
+	[InsertSpacesRules.MATH_OPERATOR]: (text) => {
+		return text.replace(MATH_OPERATOR, "$1 $2 ");
+	},
+	[InsertSpacesRules.HYPHEN]: applyHyphen,
+	[InsertSpacesRules.SLASH]: applySlash,
+	[InsertSpacesRules.COMPRESS_SPACES]: (text) => {
+		return text.replace(REPEATED_SPACES, " ");
+	},
+	[InsertSpacesRules.TRIM_INSIDE_SYMBOLS]: applyTrimInsideSymbols
+};
+var APPLY_ORDER = [
+	InsertSpacesRules.CJK_ENGLISH,
+	InsertSpacesRules.CJK_NUMBER,
+	InsertSpacesRules.PUNCTUATION,
+	InsertSpacesRules.QUOTE,
+	InsertSpacesRules.BRACKET_OUTSIDE,
+	InsertSpacesRules.MATH_OPERATOR,
+	InsertSpacesRules.HYPHEN,
+	InsertSpacesRules.SLASH,
+	InsertSpacesRules.TRIM_INSIDE_SYMBOLS,
+	InsertSpacesRules.COMPRESS_SPACES
+];
+/**
+* Falls back to every rule only when no list was given, so an explicit empty list means "apply nothing".
+*/
+var resolveRules = (rules) => {
+	return new Set(rules ?? INSERT_SPACES_RULES);
+};
+/**
+* Applies the selected rules to one text, returning it trimmed.
+*
+* Repeated marks are held aside first, so a rule that widens a single mark never splits a run that belongs together.
+*/
+var insertSpaces = (text, rules) => {
+	if (!text.trim()) return text;
+	const held = [];
+	let result = text.replace(REPEATED_MARKS, (match) => {
+		held.push(match);
+		return `\u0001${held.length - 1}\u0001`;
+	});
+	for (const rule of APPLY_ORDER) if (rules.has(rule)) result = APPLIERS[rule](result);
+	return result.replace(PLACEHOLDER, (match, index) => {
+		return held[Number(index)] ?? match;
+	}).trim();
+};
+//#endregion
+//#region src/transforms/space/insert.ts
+/**
+* Maps the rewritten text back onto the original words.
+*
+* Every non-space character of the original survives in order, so walking both strings keeps each word's time,
+* language and annotation while the inserted spaces become their own words.
+* A word whose characters stay adjacent in the rewrite is kept whole, so only a word the space actually cuts is split.
+*/
+var alignWords = (words, text) => {
+	const source = words.filter(isNormalWord);
+	const result = [];
+	let cursor = 0;
+	const takeSpaces = () => {
+		let spaces = "";
+		while (text[cursor] === " ") {
+			spaces += " ";
+			cursor += 1;
+		}
+		return spaces;
+	};
+	for (const word of source) {
+		const spaces = takeSpaces();
+		if (spaces) result.push(makeWordSpace({ text: spaces }));
+		if (text.startsWith(word.text, cursor)) {
+			result.push(word);
+			cursor += word.text.length;
+			continue;
+		}
+		let remaining = word.text;
+		while (remaining) {
+			let taken = 0;
+			while (taken < remaining.length && text[cursor + taken] === remaining[taken]) taken += 1;
+			if (taken === 0) return;
+			result.push({
+				...word,
+				text: remaining.slice(0, taken)
+			});
+			cursor += taken;
+			remaining = remaining.slice(taken);
+			if (!remaining) break;
+			const split = takeSpaces();
+			if (!split) return;
+			result.push(makeWordSpace({ text: split }));
+		}
+	}
+	const tail = takeSpaces();
+	if (tail) result.push(makeWordSpace({ text: tail }));
+	if (cursor !== text.length) return;
+	return result;
+};
+/**
+* Applies the rules to a word-level content, keeping it unchanged when the alignment fails.
+*/
+var applyToWords = (content, rules) => {
+	const text = content.words.map((word) => word.text).join("");
+	const rewritten = insertSpaces(text, rules);
+	if (rewritten === text) return content;
+	const words = alignWords(content.words, rewritten);
+	if (!words) return content;
+	return words.length ? makeLineContentWords(words) : void 0;
+};
+/**
+* Applies the rules to a plain-text content, dropping a line the rules would leave empty.
+*/
+var applyToText = (content, rules) => {
+	const text = content.text ?? "";
+	const rewritten = insertSpaces(text, rules);
+	if (rewritten === text) return content;
+	return rewritten ? makeLineContentText(rewritten) : void 0;
+};
+/**
+* Applies the rules to one content by the shape it carries.
+*/
+var applyToContent = (content, rules) => {
+	if (!content) return content;
+	return content.words.length ? applyToWords(content, rules) : applyToText(content, rules);
+};
+/**
+* Applies the rules to the line annotation, keeping the entries they leave untouched.
+*/
+var applyToAnnotation = (annotation, rules) => {
+	if (!annotation) return annotation;
+	let changed = false;
+	const romans = annotation.romans.map((item) => {
+		const text = insertSpaces(item.text, rules);
+		if (text === item.text) return item;
+		changed = true;
+		return makeLineAnnotationRoman({
+			...item,
+			text
+		});
+	});
+	const translations = annotation.translations.map((item) => {
+		const text = insertSpaces(item.text, rules);
+		if (text === item.text) return item;
+		changed = true;
+		return makeLineAnnotationTranslation({
+			...item,
+			text
+		});
+	});
+	return changed ? {
+		...annotation,
+		romans,
+		translations
+	} : annotation;
+};
+/**
+* Inserts the spaces a source left out, so CJK text set against Latin letters, digits or punctuation reads evenly.
+*
+* A word-level line keeps every word's time and annotation: an inserted space becomes its own space word,
+* and a word the rules split yields one word per character, all sharing the original range.
+* A plain-text line and the annotation tracks are rewritten as whole strings.
+*
+* @returns The input when unchanged, or a new lyric sharing all unchanged nodes.
+*/
+var insertSpacesInLines = (lyric, options = {}) => {
+	const rules = resolveRules(options.rules);
+	const annotations = options.annotations ?? true;
+	const applyToBackground = (background) => {
+		const content = applyToContent(background.content, rules);
+		const annotation = annotations ? applyToAnnotation(background.annotation, rules) : background.annotation;
+		if (content === background.content && annotation === background.annotation) return background;
+		return {
+			...background,
+			content,
+			annotation
+		};
+	};
+	const lines = mapShared(lyric.lines, (line) => {
+		if (line.type !== LineType.NORMAL) return line;
+		const content = applyToContent(line.content, rules);
+		const annotation = annotations ? applyToAnnotation(line.annotation, rules) : line.annotation;
+		const backgrounds = mapShared(line.backgrounds, applyToBackground);
+		if (content === line.content && annotation === line.annotation && backgrounds === line.backgrounds) return line;
+		return {
+			...line,
+			content,
+			annotation,
+			backgrounds
+		};
+	});
+	return lines === lyric.lines ? lyric : {
+		...lyric,
+		lines
+	};
+};
+//#endregion
+export { DEFAULT_CREDIT_NAME_SEPARATORS, INSERT_SPACES_RULES, InsertSpacesRules, NON_LYRIC_CATEGORIES, deriveWordEmphasis, extractAgents, extractBackgroundLines, extractCredits, insertInstrumentalLines, insertSpacesInLines, removeNonLyricLines, stripBackgroundBrackets };
+
+//# sourceMappingURL=transforms.js.map