@gondola-lyrics/kit 0.4.0 → 0.6.0

package/dist/parser.js

@@ -1,3 +1,3 @@
-import { detectFormat, parse, parseLrc, parseTtml } from "./formats.js";
-import { InsertSpacesRules, deriveWordEmphasis, extractBackgroundLines, insertInstrumentalLines, insertSpacesInLines, stripBackgroundBrackets } from "./transforms.js";
-export { InsertSpacesRules, deriveWordEmphasis, detectFormat, extractBackgroundLines, insertInstrumentalLines, insertSpacesInLines, parse, parseLrc, parseTtml, stripBackgroundBrackets };
+import { detectFormat, parse, parseKrc, parseKwrc, parseLrc, parseQrc, parseTtml, parseYrc } from "./formats.js";
+import { DEFAULT_CREDIT_NAME_SEPARATORS, InsertSpacesRules, NON_LYRIC_CATEGORIES, deriveWordEmphasis, extractAgents, extractBackgroundLines, extractCredits, insertInstrumentalLines, insertSpacesInLines, removeNonLyricLines, stripBackgroundBrackets } from "./transforms.js";
+export { DEFAULT_CREDIT_NAME_SEPARATORS, InsertSpacesRules, NON_LYRIC_CATEGORIES, deriveWordEmphasis, detectFormat, extractAgents, extractBackgroundLines, extractCredits, insertInstrumentalLines, insertSpacesInLines, parse, parseKrc, parseKwrc, parseLrc, parseQrc, parseTtml, parseYrc, removeNonLyricLines, stripBackgroundBrackets };

package/dist/rules.js

@@ -0,0 +1,166 @@
+//#region src/utils/array.ts
+/**
+* Preserves the input array when every element keeps its identity, so unchanged parent nodes can also be reused.
+*
+* The callback must leave inputs untouched and return the original element when unchanged.
+*/
+var mapShared = (items, transform) => {
+	let result = items;
+	for (const [index, item] of items.entries()) {
+		const transformed = transform(item);
+		if (transformed !== item) {
+			if (result === items) result = [...items];
+			result[index] = transformed;
+		}
+	}
+	return result;
+};
+/**
+* Finds the first value meeting a lower bound so range queries can skip earlier candidates.
+*
+* @param values Values sorted in ascending order.
+* @param target Inclusive lower bound.
+*
+* @returns The first matching index, or the array length when every value is smaller.
+*/
+var lowerBound = (values, target) => {
+	let left = 0;
+	let right = values.length;
+	while (left < right) {
+		const middle = Math.floor((left + right) / 2);
+		if (values[middle] < target) left = middle + 1;
+		else right = middle;
+	}
+	return left;
+};
+//#endregion
+//#region src/utils/language.ts
+var SCRIPT_PATTERNS = [
+	[/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u, 1],
+	[/\p{Script=Latin}/u, 2],
+	[/\p{Script=Hangul}/u, 3],
+	[/\p{Script=Cyrillic}/u, 4],
+	[/\p{Script=Greek}/u, 5],
+	[/\p{Script=Arabic}/u, 6],
+	[/\p{Script=Hebrew}/u, 7],
+	[/\p{Script=Devanagari}/u, 8],
+	[/\p{Script=Thai}/u, 9]
+];
+var getOtherScript = (text, start, width) => {
+	const unit = text.charCodeAt(start);
+	if (unit === 12539 || unit === 12540) return 0;
+	if (unit >= 1024 && unit <= 1153 || unit >= 1162 && unit <= 1327) return 4;
+	if (unit >= 931 && unit <= 993) return 5;
+	if (unit >= 1568 && unit <= 1599 || unit >= 1601 && unit <= 1610) return 6;
+	if (unit >= 1488 && unit <= 1514) return 7;
+	if (unit >= 2304 && unit <= 2384 || unit >= 2389 && unit <= 2403 || unit >= 2406 && unit <= 2431) return 8;
+	if (unit >= 3585 && unit <= 3642 || unit >= 3648 && unit <= 3675) return 9;
+	const character = text.slice(start, start + width);
+	for (const [pattern, script] of SCRIPT_PATTERNS) if (pattern.test(character)) return script;
+	return 0;
+};
+/**
+* Finds a boundary between supported scripts without allocating a segment list.
+* Han and kana share a group so Japanese labels stay intact; Hangul, Latin, Cyrillic, Greek, Arabic, Hebrew, Devanagari and Thai remain separate.
+* Punctuation, digits, inherited marks and unsupported scripts stay in the surrounding run.
+*
+* @param start A UTF-16 offset at a code-point boundary, usually the end returned by the previous call.
+*
+* @returns The exclusive UTF-16 end of the run, or text.length when no later boundary exists.
+*/
+var findScriptRunEnd = (text, start = 0) => {
+	let script = 0;
+	let index = start;
+	while (index < text.length) {
+		const unit = text.charCodeAt(index);
+		let nextScript = 0;
+		let width = 1;
+		if (unit <= 127) {
+			const letter = unit | 32;
+			if (letter >= 97 && letter <= 122) {
+				if (script !== 0 && script !== 2) return index;
+				script = 2;
+				do {
+					index += 1;
+					const nextLetter = text.charCodeAt(index) | 32;
+					if (nextLetter < 97 || nextLetter > 122) break;
+				} while (index < text.length);
+				continue;
+			}
+		} else if (unit >= 19968 && unit <= 40959) nextScript = 1;
+		else if (unit >= 12353 && unit <= 12438 || unit >= 12449 && unit <= 12538) nextScript = 1;
+		else if (unit >= 44032 && unit <= 55203) nextScript = 3;
+		else {
+			width = unit >= 55296 && unit <= 56319 && text.codePointAt(index) > 65535 ? 2 : 1;
+			nextScript = getOtherScript(text, index, width);
+		}
+		if (nextScript !== 0) {
+			if (script !== 0 && script !== nextScript) return index;
+			script = nextScript;
+		}
+		index += width;
+	}
+	return text.length;
+};
+/**
+* Returns a language tag in the canonical form the model stores, which is lower case.
+*
+* This mirrors the model's own helper, which it does not export.
+* Comparing tags stays with the consumer, since BCP 47 matches by subtag prefix rather than by string equality.
+*/
+var lowerTag = (tag) => {
+	return tag ? tag.toLowerCase() : void 0;
+};
+//#endregion
+//#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
+export { lowerBound as a, lowerTag as i, toRuleMatchKey as n, mapShared as o, trimRuleWhitespace as r, findRuleMatchCuts as t };
+
+//# sourceMappingURL=rules.js.map

package/dist/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","names":[],"sources":["../src/utils/array.ts","../src/utils/language.ts","../src/utils/rules.ts"],"sourcesContent":["/**\n * Preserves the input array when every element keeps its identity, so unchanged parent nodes can also be reused.\n *\n * The callback must leave inputs untouched and return the original element when unchanged.\n */\nexport const mapShared = <T>(items: T[], transform: (item: T) => T): T[] => {\n  let result = items\n  for (const [index, item] of items.entries()) {\n    const transformed = transform(item)\n    if (transformed !== item) {\n      if (result === items) {\n        result = [...items]\n      }\n      result[index] = transformed\n    }\n  }\n  return result\n}\n\n/**\n * Finds the first value meeting a lower bound so range queries can skip earlier candidates.\n *\n * @param values Values sorted in ascending order.\n * @param target Inclusive lower bound.\n *\n * @returns The first matching index, or the array length when every value is smaller.\n */\nexport const lowerBound = (values: readonly number[], target: number): number => {\n  let left = 0\n  let right = values.length\n  while (left < right) {\n    const middle = Math.floor((left + right) / 2)\n    if (values[middle]! < target) {\n      left = middle + 1\n    } else {\n      right = middle\n    }\n  }\n  return left\n}\n","const enum ScriptGroup {\n  NEUTRAL,\n  EAST_ASIAN,\n  LATIN,\n  HANGUL,\n  CYRILLIC,\n  GREEK,\n  ARABIC,\n  HEBREW,\n  DEVANAGARI,\n  THAI,\n}\n\nconst SCRIPT_PATTERNS: readonly (readonly [RegExp, ScriptGroup])[] = [\n  [/[\\p{Script=Han}\\p{Script=Hiragana}\\p{Script=Katakana}]/u, ScriptGroup.EAST_ASIAN],\n  [/\\p{Script=Latin}/u, ScriptGroup.LATIN],\n  [/\\p{Script=Hangul}/u, ScriptGroup.HANGUL],\n  [/\\p{Script=Cyrillic}/u, ScriptGroup.CYRILLIC],\n  [/\\p{Script=Greek}/u, ScriptGroup.GREEK],\n  [/\\p{Script=Arabic}/u, ScriptGroup.ARABIC],\n  [/\\p{Script=Hebrew}/u, ScriptGroup.HEBREW],\n  [/\\p{Script=Devanagari}/u, ScriptGroup.DEVANAGARI],\n  [/\\p{Script=Thai}/u, ScriptGroup.THAI],\n]\n\nconst getOtherScript = (text: string, start: number, width: number): ScriptGroup => {\n  const unit = text.charCodeAt(start)\n  if (unit === 0x30fb || unit === 0x30fc) {\n    return ScriptGroup.NEUTRAL\n  }\n  if ((unit >= 0x0400 && unit <= 0x0481) || (unit >= 0x048a && unit <= 0x052f)) {\n    return ScriptGroup.CYRILLIC\n  }\n  if (unit >= 0x03a3 && unit <= 0x03e1) {\n    return ScriptGroup.GREEK\n  }\n  if ((unit >= 0x0620 && unit <= 0x063f) || (unit >= 0x0641 && unit <= 0x064a)) {\n    return ScriptGroup.ARABIC\n  }\n  if (unit >= 0x05d0 && unit <= 0x05ea) {\n    return ScriptGroup.HEBREW\n  }\n  if ((unit >= 0x0900 && unit <= 0x0950) || (unit >= 0x0955 && unit <= 0x0963) || (unit >= 0x0966 && unit <= 0x097f)) {\n    return ScriptGroup.DEVANAGARI\n  }\n  if ((unit >= 0x0e01 && unit <= 0x0e3a) || (unit >= 0x0e40 && unit <= 0x0e5b)) {\n    return ScriptGroup.THAI\n  }\n\n  const character = text.slice(start, start + width)\n  for (const [pattern, script] of SCRIPT_PATTERNS) {\n    if (pattern.test(character)) {\n      return script\n    }\n  }\n  return ScriptGroup.NEUTRAL\n}\n\n/**\n * Finds a boundary between supported scripts without allocating a segment list.\n * Han and kana share a group so Japanese labels stay intact; Hangul, Latin, Cyrillic, Greek, Arabic, Hebrew, Devanagari and Thai remain separate.\n * Punctuation, digits, inherited marks and unsupported scripts stay in the surrounding run.\n *\n * @param start A UTF-16 offset at a code-point boundary, usually the end returned by the previous call.\n *\n * @returns The exclusive UTF-16 end of the run, or text.length when no later boundary exists.\n */\nexport const findScriptRunEnd = (text: string, start = 0): number => {\n  let script = ScriptGroup.NEUTRAL\n  let index = start\n\n  while (index < text.length) {\n    const unit = text.charCodeAt(index)\n    let nextScript = ScriptGroup.NEUTRAL\n    let width = 1\n\n    if (unit <= 0x7f) {\n      const letter = unit | 0x20\n      if (letter >= 0x61 && letter <= 0x7a) {\n        if (script !== ScriptGroup.NEUTRAL && script !== ScriptGroup.LATIN) {\n          return index\n        }\n        script = ScriptGroup.LATIN\n        do {\n          index += 1\n          const nextLetter = text.charCodeAt(index) | 0x20\n          if (nextLetter < 0x61 || nextLetter > 0x7a) {\n            break\n          }\n        } while (index < text.length)\n        continue\n      }\n    } else if (unit >= 0x4e00 && unit <= 0x9fff) {\n      nextScript = ScriptGroup.EAST_ASIAN\n    } else if ((unit >= 0x3041 && unit <= 0x3096) || (unit >= 0x30a1 && unit <= 0x30fa)) {\n      nextScript = ScriptGroup.EAST_ASIAN\n    } else if (unit >= 0xac00 && unit <= 0xd7a3) {\n      nextScript = ScriptGroup.HANGUL\n    } else {\n      width = unit >= 0xd800 && unit <= 0xdbff && text.codePointAt(index)! > 0xffff ? 2 : 1\n      nextScript = getOtherScript(text, index, width)\n    }\n\n    if (nextScript !== ScriptGroup.NEUTRAL) {\n      if (script !== ScriptGroup.NEUTRAL && script !== nextScript) {\n        return index\n      }\n      script = nextScript\n    }\n    index += width\n  }\n  return text.length\n}\n\n/**\n * Returns a language tag in the canonical form the model stores, which is lower case.\n *\n * This mirrors the model's own helper, which it does not export.\n * Comparing tags stays with the consumer, since BCP 47 matches by subtag prefix rather than by string equality.\n */\nexport const lowerTag = (tag: string | undefined): string | undefined => {\n  return tag ? tag.toLowerCase() : undefined\n}\n","import { findScriptRunEnd } from './language'\n\nconst RULE_WHITESPACE = /[\\u0009-\\u000D\\u0020\\u0085\\u00A0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF]/g\nconst RULE_EDGE_WHITESPACE =\n  /^[\\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\n\n/**\n * Uses the shared whitespace set and ASCII case folding to keep matching consistent across language kits.\n */\nexport const toRuleMatchKey = (text: string): string => {\n  return text.replace(RULE_WHITESPACE, '').replace(/[A-Z]+/g, (run) => run.toLowerCase())\n}\n\nconst RULE_WHITESPACE_CHARACTER = new RegExp(RULE_WHITESPACE.source)\n\n/**\n * Finds the offsets in toRuleMatchKey(text) where the source allows a cut.\n * 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.\n *\n * @param text A source label with its original spelling.\n *\n * @returns Ascending offsets from 0 to the key length, or undefined when the source has no inner cut.\n */\nexport const findRuleMatchCuts = (text: string): readonly number[] | undefined => {\n  // Most labels are a single script run without inner whitespace, so they skip the character walk.\n  if (!RULE_WHITESPACE_CHARACTER.test(text) && findScriptRunEnd(text) === text.length) {\n    return undefined\n  }\n\n  const cuts: number[] = [0]\n  let length = 0\n  let pendingCut = false\n  let runStart = 0\n  while (runStart < text.length) {\n    const runEnd = findScriptRunEnd(text, runStart)\n    if (runStart > 0) {\n      pendingCut = true\n    }\n    for (const character of text.slice(runStart, runEnd)) {\n      if (RULE_WHITESPACE_CHARACTER.test(character)) {\n        pendingCut = true\n        continue\n      }\n      if (pendingCut) {\n        if (length > 0) {\n          cuts.push(length)\n        }\n        pendingCut = false\n      }\n      length += character.length\n    }\n    runStart = runEnd\n  }\n  if (cuts.length === 1) {\n    return undefined\n  }\n  cuts.push(length)\n  return cuts\n}\n\n/**\n * Preserves internal whitespace so source labels and credited names retain their spelling.\n */\nexport const trimRuleWhitespace = (text: string): string => text.replace(RULE_EDGE_WHITESPACE, '')\n"],"mappings":"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"}

package/dist/transforms.d.ts

@@ -1,5 +1,7 @@
 import { runtime } from '@gondola-lyrics/model';
 
+export declare const DEFAULT_CREDIT_NAME_SEPARATORS: readonly ["+", "：", "/"];
+
 /**
  * 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.
@@ -21,6 +23,32 @@ export declare interface DeriveWordEmphasisOptions {
     durationThreshold?: number;
 }
 
+/**
+ * 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.
+ */
+export declare const extractAgents: (lyric: runtime.Lyric, options?: ExtractAgentsOptions) => runtime.Lyric;
+
+export declare interface ExtractAgentsOptions {
+    /**
+     * Maps complete, trimmed prefixes to existing agent ids, preserving array order for joint performers.
+     * Matching is case-sensitive and preserves internal whitespace; an empty object disables automatic inference.
+     * Omitting this option enables legacy name inference; explicit bindings override its clock exclusion.
+     */
+    bindings?: Readonly<Record<string, string | readonly string[]>>;
+    /**
+     * Removes matched prefixes and drops lines left with no sung text, including their attached content.
+     *
+     * @default true
+     */
+    removePrefixes?: boolean;
+}
+
 /**
  * Pulls bracketed background vocals out of the sung lines and attaches them to the line they accompany.
  *
@@ -53,6 +81,41 @@ export declare interface ExtractBackgroundLinesOptions {
     crossLine?: boolean;
 }
 
+/**
+ * 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.
+ * Unknown metadata is processed only when matchUnknowns is enabled; consumed entries leave the unknown list.
+ *
+ * @returns The input when unchanged, or a new lyric sharing all unchanged nodes.
+ */
+export declare const extractCredits: (lyric: runtime.Lyric, options?: ExtractCreditsOptions) => runtime.Lyric;
+
+export declare interface ExtractCreditsOptions {
+    /**
+     * Matches existing unknown metadata keys as credit labels and consumes fully readable matches.
+     * Values use nameSeparators; unrecognized keys and values with no readable names remain unchanged.
+     *
+     * @default false
+     */
+    matchUnknowns?: boolean;
+    /**
+     * Removes successfully extracted source lines together with their backgrounds and annotations.
+     * Extracted roles and names remain in metadata; attached content is not moved to other lines.
+     *
+     * Refreshes language usages and falls back to line timing when no word-level content remains.
+     *
+     * @default false
+     */
+    removeSourceLines?: boolean;
+    /**
+     * Splits names at literal separators and ignores empty strings; an empty list preserves the complete source name.
+     * Longer separators take precedence so overlapping delimiters remain predictable.
+     *
+     * @default DEFAULT_CREDIT_NAME_SEPARATORS
+     */
+    nameSeparators?: readonly string[];
+}
+
 export declare const INSERT_SPACES_RULES: InsertSpacesRule[];
 
 /**
@@ -157,6 +220,38 @@ export declare const InsertSpacesRules: {
     readonly TRIM_INSIDE_SYMBOLS: "trimInsideSymbols";
 };
 
+/**
+ * Categories the bundled filter rules identify, in rule order.
+ */
+export declare const NON_LYRIC_CATEGORIES: readonly string[];
+
+/**
+ * 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.
+ */
+export declare const removeNonLyricLines: (lyric: runtime.Lyric, options?: RemoveNonLyricLinesOptions) => runtime.Lyric;
+
+export declare interface RemoveNonLyricLinesOptions {
+    /**
+     * Removes lines identified under these categories; an empty list skips the shared rules.
+     * First-line music information is selected independently.
+     *
+     * @default NON_LYRIC_CATEGORIES
+     */
+    categories?: readonly string[];
+    /**
+     * Enables first-line music-information matching using these known titles and artists.
+     * Omitting this option, or leaving either list empty, skips the check; lyric metadata is not inferred.
+     */
+    musicInfo?: {
+        titles?: readonly string[];
+        artists?: readonly string[];
+    };
+}
+
 /**
  * Removes the brackets some sources wrap around background vocals.
  *