@gondola-lyrics/kit 0.3.0 → 0.5.0

package/dist/generator.d.ts

@@ -3,15 +3,18 @@ import { runtime } from '@gondola-lyrics/model';
 /**
  * Generates text in the requested format, which need not match `lyric.format`.
  *
- * The writer map pairs each format's options with its result and requires a writer for every supported format.
+ * The writer map pairs options with results only for formats that have an implemented writer.
  * An unknown target returns `null`.
  */
-export declare const generate: <Target extends LyricFormat>(lyric: runtime.Lyric, target: Target, options?: GenerateOptions[Target]) => GenerateResults[Target] | null;
+export declare const generate: <Target extends GenerateFormat>(lyric: runtime.Lyric, target: Target, options?: GenerateOptions[Target]) => GenerateResults[Target] | null;
+
+export declare type GenerateFormat = keyof GenerateOptions;
 
 /**
  * Generates the LRC text plus the annotations a single file cannot hold.
  *
  * Word tags appear only for a word-timed lyric when `wordTiming` is not `none`; otherwise every line stays whole.
+ * Word romanizations retain token boundaries; explicit line romanizations take precedence for the same language.
  */
 export declare const generateLrc: (lyric: runtime.Lyric, options?: LrcGenerateOptions) => LrcGenerateResult;
 
@@ -30,6 +33,7 @@ declare interface GenerateResults {
  *
  * Offsets are baked into timestamps; a negative result or a missing required time throws.
  * Profile mappings retain the lead agent and first AMLL ruby, omitting unsupported fields and instrumental nodes.
+ * Word romanizations are emitted as line text without their token timing.
  */
 export declare const generateTtml: (lyric: runtime.Lyric, options?: TtmlGenerateOptions) => TtmlGenerateResult;
 
@@ -63,7 +67,7 @@ export declare type LrcGenerateResult = LrcContent;
 /**
  * Values match the lowercase format names stored in `Lyric.format`.
  */
-export declare type LyricFormat = 'lrc' | 'ttml';
+export declare type LyricFormat = 'lrc' | 'qrc' | 'ttml';
 
 export declare interface TtmlGenerateOptions {
     /**

package/dist/index.d.ts

@@ -1,6 +1,29 @@
 import { Diagnostic } from '@gondola-lyrics/model/runtime';
 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.
+ *
+ * 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.
+ */
+export declare const deriveWordEmphasis: (lyric: runtime.Lyric, options?: DeriveWordEmphasisOptions) => runtime.Lyric;
+
+export declare interface DeriveWordEmphasisOptions {
+    /**
+     * Word duration must strictly exceed this threshold, expressed as a non-negative safe integer in milliseconds.
+     *
+     * @default 3000
+     */
+    durationThreshold?: number;
+}
+
 /**
  * Recognition reads only the original text; the annotation tracks never decide the format.
  *
@@ -8,18 +31,106 @@ import { runtime } from '@gondola-lyrics/model';
  */
 export declare const detectFormat: (input: unknown) => LyricFormat | undefined;
 
+/**
+ * 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.
+ *
+ * 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.
+ */
+export declare const extractBackgroundLines: (lyric: runtime.Lyric, options?: ExtractBackgroundLinesOptions) => runtime.Lyric;
+
+export declare interface ExtractBackgroundLinesOptions {
+    /**
+     * Turn a line holding nothing but brackets into a background line of the line before it.
+     *
+     * @default true
+     */
+    fullLine?: boolean;
+    /**
+     * Pull the bracketed runs inside a line out into background lines of that same line.
+     *
+     * @default true
+     */
+    inLine?: boolean;
+    /**
+     * Join a bracket opened on one line and closed on a later one, attaching it to the line before them.
+     *
+     * @default true
+     */
+    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.
+ *
+ * @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 {
+    /**
+     * Removes extracted source lines unless they carry background vocals, line annotations, or word translations or romanizations.
+     * Ruby annotations alone do not prevent removal.
+     *
+     * 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[];
+}
+
 /**
  * Generates text in the requested format, which need not match `lyric.format`.
  *
- * The writer map pairs each format's options with its result and requires a writer for every supported format.
+ * The writer map pairs options with results only for formats that have an implemented writer.
  * An unknown target returns `null`.
  */
-export declare const generate: <Target extends LyricFormat>(lyric: runtime.Lyric, target: Target, options?: GenerateOptions[Target]) => GenerateResults[Target] | null;
+export declare const generate: <Target extends GenerateFormat>(lyric: runtime.Lyric, target: Target, options?: GenerateOptions[Target]) => GenerateResults[Target] | null;
+
+export declare type GenerateFormat = keyof GenerateOptions;
 
 /**
  * Generates the LRC text plus the annotations a single file cannot hold.
  *
  * Word tags appear only for a word-timed lyric when `wordTiming` is not `none`; otherwise every line stays whole.
+ * Word romanizations retain token boundaries; explicit line romanizations take precedence for the same language.
  */
 export declare const generateLrc: (lyric: runtime.Lyric, options?: LrcGenerateOptions) => LrcGenerateResult;
 
@@ -38,9 +149,112 @@ declare interface GenerateResults {
  *
  * Offsets are baked into timestamps; a negative result or a missing required time throws.
  * Profile mappings retain the lead agent and first AMLL ruby, omitting unsupported fields and instrumental nodes.
+ * Word romanizations are emitted as line text without their token timing.
  */
 export declare const generateTtml: (lyric: runtime.Lyric, options?: TtmlGenerateOptions) => TtmlGenerateResult;
 
+/**
+ * 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.
+ */
+export declare const insertInstrumentalLines: (lyric: runtime.Lyric, options?: InsertInstrumentalLinesOptions) => runtime.Lyric;
+
+export declare interface InsertInstrumentalLinesOptions {
+    /**
+     * Minimum gap duration in milliseconds, including an outro.
+     *
+     * @default 10000
+     */
+    minDuration?: number;
+    /**
+     * Minimum gap duration before the first vocal in milliseconds.
+     *
+     * @default 5000
+     */
+    minIntroDuration?: number;
+    /**
+     * Outro boundary in milliseconds, measured on the same timeline as line ranges.
+     * An omitted boundary leaves the outro unknown.
+     */
+    endTime?: number;
+}
+
+/**
+ * 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.
+ */
+export declare const insertSpacesInLines: (lyric: runtime.Lyric, options?: InsertSpacesOptions) => runtime.Lyric;
+
+export declare interface InsertSpacesOptions {
+    /**
+     * Rules to apply; omitting the list applies all of them.
+     */
+    rules?: InsertSpacesRule[];
+    /**
+     * Rewrite the translation and romanization tracks too.
+     *
+     * @default true
+     */
+    annotations?: boolean;
+}
+
+export declare type InsertSpacesRule = (typeof InsertSpacesRules)[keyof typeof InsertSpacesRules];
+
+/**
+ * Groups of characters a source may write without a space where one belongs.
+ */
+export declare const InsertSpacesRules: {
+    /**
+     * A CJK character touching a Latin letter, as in `ABC中文`.
+     */
+    readonly CJK_ENGLISH: "cjkEnglish";
+    /**
+     * A CJK character touching a digit, as in `2026年`.
+     */
+    readonly 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.
+     */
+    readonly PUNCTUATION: "punctuation";
+    /**
+     * A quotation mark touching a neighbouring character.
+     */
+    readonly QUOTE: "quote";
+    /**
+     * A bracket touching the character outside it.
+     */
+    readonly 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.
+     */
+    readonly MATH_OPERATOR: "mathOperator";
+    /**
+     * A hyphen touching a CJK character, as in `中-文`; a compound word such as `well-known` stays as written.
+     */
+    readonly HYPHEN: "hyphen";
+    /**
+     * A slash touching a character, as in `and/or`; a fraction such as `1/2` stays as written.
+     */
+    readonly SLASH: "slash";
+    /**
+     * Runs of two or more spaces, collapsed to one.
+     */
+    readonly COMPRESS_SPACES: "compressSpaces";
+    /**
+     * Spaces just inside a bracket or quotation mark, removed.
+     */
+    readonly TRIM_INSIDE_SYMBOLS: "trimInsideSymbols";
+};
+
 declare interface LrcContent {
     original: string;
     translations?: string;
@@ -76,28 +290,60 @@ export declare interface LrcParseOptions {
      * Defaults to `0`, which requires an exact match.
      */
     annotationTolerance?: number;
+    /**
+     * Maximum roman token drift outside a matched word, in milliseconds; matched boundaries are adjusted to that word.
+     * Original word timing is preserved, and incomplete word matches retain the source line romanization.
+     *
+     * @default 0
+     */
+    wordAnnotationTolerance?: number;
+    /**
+     * Recovers unmatched roman fragments from unique two-kana combination starts or equal-sized gaps between timing anchors.
+     * Only a base kana followed by its small kana combines; doubled consonants and long vowels retain the whole line romanization.
+     * Recovered token times are clipped to their original word; untimed fragments inherit its range.
+     *
+     * @default false
+     */
+    wordAnnotationFallback?: boolean;
 }
 
 /**
  * Values match the lowercase format names stored in `Lyric.format`.
  */
-export declare type LyricFormat = 'lrc' | 'ttml';
+export declare type LyricFormat = 'lrc' | 'qrc' | 'ttml';
+
+/**
+ * Categories the bundled filter rules identify, in rule order.
+ */
+export declare const NON_LYRIC_CATEGORIES: readonly string[];
 
 /**
  * Unrecognized text returns `null`; a recognized format returns its canonical lyric and diagnostics.
  * Annotation tracks travel with the source and are attached by the format's parser.
  */
-export declare const parse: (input: unknown, options?: LrcParseOptions & TtmlParseOptions) => ParseResult | null;
+export declare const parse: (input: unknown, options?: LrcParseOptions & QrcParseOptions & TtmlParseOptions) => ParseResult | null;
 
 /**
- * Source order, empty timed lines, and missing word times are preserved for model validation.
+ * Empty timed rows become instrumental lines; source order and missing word times remain for model validation.
  *
  * Annotation tracks are read as lines too and attached by timestamp, and rows that match no line are dropped.
+ * Complete roman tracks attach to words by timing and optional local recovery; other tracks retain their source line text.
  *
  * `INVALID` means no readable timed lines; the returned diagnostics carry whatever the canonical tree breaks.
  */
 export declare const parseLrc: (input: string | LrcParseInput, options?: LrcParseOptions) => ParseResult;
 
+/**
+ * Parses plaintext or XML QRC, retaining explicit timing, word romanization, and ruby from kana metadata.
+ * Original-track kana supplies ruby and is removed from the returned metadata.
+ *
+ * @param input Original lyrics with optional translation and romanization tracks.
+ * @param options Independent line and word tolerances, with optional local roman recovery.
+ *
+ * @returns Canonical lyrics and source diagnostics; an empty result has INVALID status.
+ */
+export declare const parseQrc: (input: string | QrcParseInput, options?: QrcParseOptions) => ParseResult;
+
 /**
  * A parsed lyric in canonical form, with every rule it breaks.
  */
@@ -114,6 +360,75 @@ export declare interface ParseResult {
  */
 export declare const parseTtml: (input: TtmlParseInput, options?: TtmlParseOptions) => ParseResult;
 
+declare interface QrcContent {
+    original: string;
+    translations?: string;
+    romans?: string;
+}
+
+export declare type QrcParseInput = QrcContent;
+
+export declare interface QrcParseOptions {
+    /**
+     * Extra tolerance in milliseconds for line annotations left after exact time and row order matching.
+     *
+     * @default 0
+     */
+    annotationTolerance?: number;
+    /**
+     * Extra word-boundary tolerance in milliseconds; native QRC tracks allow at least 1ms for rounding.
+     * LRC auxiliary tracks use exact word boundaries by default, and incomplete matches retain the whole line romanization.
+     *
+     * @default 0
+     */
+    wordAnnotationTolerance?: number;
+    /**
+     * Recovers unmatched roman fragments from unique two-kana combination starts or equal-sized gaps between timing anchors.
+     * Only a base kana followed by its small kana combines; doubled consonants and long vowels retain the whole line romanization.
+     * Recovered token times are clipped to their original word; untimed fragments inherit its range.
+     *
+     * @default false
+     */
+    wordAnnotationFallback?: boolean;
+}
+
+/**
+ * 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.
+ *
+ * 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.
+ */
+export declare const stripBackgroundBrackets: (lyric: runtime.Lyric) => runtime.Lyric;
+
 export declare interface TtmlGenerateOptions {
     /**
      * Defaults to the source TTML profile, or `amll` when the lyric came from another format.

package/dist/index.js

@@ -1,3 +1,5 @@
-export { detectFormat, generate, generateLrc, generateTtml, parse, parseLrc, parseTtml } from "./formats.js";
+import { detectFormat, generate, generateLrc, generateTtml, parse, parseLrc, parseQrc, parseTtml } from "./formats.js";
+import { DEFAULT_CREDIT_NAME_SEPARATORS, InsertSpacesRules, NON_LYRIC_CATEGORIES, deriveWordEmphasis, extractAgents, extractBackgroundLines, extractCredits, insertInstrumentalLines, insertSpacesInLines, removeNonLyricLines, stripBackgroundBrackets } from "./transforms.js";
 import "./parser.js";
 import "./generator.js";
+export { DEFAULT_CREDIT_NAME_SEPARATORS, InsertSpacesRules, NON_LYRIC_CATEGORIES, deriveWordEmphasis, detectFormat, extractAgents, extractBackgroundLines, extractCredits, generate, generateLrc, generateTtml, insertInstrumentalLines, insertSpacesInLines, parse, parseLrc, parseQrc, parseTtml, removeNonLyricLines, stripBackgroundBrackets };

package/dist/language.js

@@ -0,0 +1,117 @@
+//#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
+export { mapShared as i, lowerTag as n, lowerBound as r, findScriptRunEnd as t };
+
+//# sourceMappingURL=language.js.map

package/dist/language.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"language.js","names":[],"sources":["../src/utils/array.ts","../src/utils/language.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"],"mappings":"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"}