trackparse 0.2.1 → 0.3.1

package/dist/tracklist.cjs

@@ -0,0 +1,3135 @@
+'use strict';
+
+// src/words.ts
+function isWhitespaceCode(cp) {
+  return cp >= 9 && cp <= 13 || cp === 32 || cp === 133 || cp === 160 || cp === 5760 || cp >= 8192 && cp <= 8202 || cp === 8232 || cp === 8233 || cp === 8239 || cp === 8287 || cp === 12288;
+}
+function isWhitespace(ch) {
+  return ch !== void 0 && ch.length > 0 && isWhitespaceCode(ch.charCodeAt(0));
+}
+function isDigit(ch) {
+  return ch !== void 0 && ch.length === 1 && ch >= "0" && ch <= "9";
+}
+function isAllDigits(s) {
+  if (s.length === 0) return false;
+  for (let i = 0; i < s.length; i++) if (!isDigit(s[i])) return false;
+  return true;
+}
+var LETTER = /^\p{L}$/u;
+function isLetterAt(s, index) {
+  const cp = s.codePointAt(index);
+  if (cp === void 0) return false;
+  return LETTER.test(String.fromCodePoint(cp));
+}
+function isLetterBefore(s, index) {
+  const low = s.charCodeAt(index - 1);
+  const high = s.charCodeAt(index - 2);
+  const pair = low >= 56320 && low <= 57343 && high >= 55296 && high <= 56319;
+  const start = pair ? index - 2 : index - 1;
+  return start >= 0 && isLetterAt(s, start);
+}
+var UPPER = /^\p{Lu}$/u;
+function isUpperAt(s, index) {
+  const cp = s.codePointAt(index);
+  if (cp === void 0) return false;
+  return UPPER.test(String.fromCodePoint(cp));
+}
+function asciiLower(s) {
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    out += c >= 65 && c <= 90 ? String.fromCharCode(c + 32) : s[i];
+  }
+  return out;
+}
+var KEY_STRIPPABLE = ".,!?:;";
+function stripKeyPunct(lower) {
+  const last = lower[lower.length - 1];
+  return last !== void 0 && KEY_STRIPPABLE.includes(last) ? lower.slice(0, -1) : lower;
+}
+function wordKey(word) {
+  return stripKeyPunct(asciiLower(word));
+}
+function wordMatches(word, token) {
+  const lower = asciiLower(word);
+  return lower === token || stripKeyPunct(lower) === token;
+}
+function inVocab(word, vocab) {
+  const lower = asciiLower(word);
+  return vocab.has(lower) || vocab.has(stripKeyPunct(lower));
+}
+function collapseSpaces(s) {
+  let out = "";
+  let pendingSpace = false;
+  for (const ch of s) {
+    if (isWhitespaceCode(ch.codePointAt(0) ?? 0)) {
+      pendingSpace = out.length > 0;
+    } else {
+      if (pendingSpace) out += " ";
+      pendingSpace = false;
+      out += ch;
+    }
+  }
+  return out;
+}
+function splitWords(s) {
+  const words = [];
+  let current = "";
+  for (const ch of s) {
+    if (isWhitespaceCode(ch.codePointAt(0) ?? 0)) {
+      if (current) words.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current) words.push(current);
+  return words;
+}
+function wordSpans(s) {
+  const spans = [];
+  let start = -1;
+  for (let i = 0; i <= s.length; i++) {
+    const boundary = i === s.length || isWhitespace(s[i]);
+    if (boundary) {
+      if (start >= 0) spans.push({ text: s.slice(start, i), start, end: i });
+      start = -1;
+    } else if (start < 0) {
+      start = i;
+    }
+  }
+  return spans;
+}
+var COMBINING_START = 768;
+var COMBINING_END = 879;
+function dedupKey(s) {
+  let out = "";
+  for (const ch of s.toLowerCase().normalize("NFD")) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (cp >= COMBINING_START && cp <= COMBINING_END) continue;
+    out += ch;
+  }
+  return collapseSpaces(out);
+}
+function yearOf(word) {
+  const key = wordKey(word);
+  if (key.length !== 4 || !isAllDigits(key)) return null;
+  const n = Number(key);
+  return n >= 1900 && n <= 2099 ? n : null;
+}
+var PhraseTable = class {
+  constructor(entries) {
+    this.byFirst = /* @__PURE__ */ new Map();
+    this.byLast = /* @__PURE__ */ new Map();
+    this.keys = /* @__PURE__ */ new Map();
+    for (const [rawKey, value] of entries) this.add(rawKey, value);
+  }
+  add(rawKey, value) {
+    const key = asciiLower(rawKey).trim();
+    const tokens = splitWords(key);
+    const first = tokens[0];
+    const last = tokens[tokens.length - 1];
+    if (first === void 0 || last === void 0 || this.keys.has(key)) return;
+    this.keys.set(key, value);
+    const entry = { key, tokens, value };
+    insertSorted(this.byFirst, first, entry);
+    insertSorted(this.byLast, last, entry);
+  }
+  has(key) {
+    return this.keys.has(key);
+  }
+  /** Longest entry matching words[start …]. */
+  matchAt(words, start) {
+    const word = words[start];
+    if (word === void 0) return null;
+    let best = null;
+    for (const entry of candidates(this.byFirst, word)) {
+      const n = entry.tokens.length;
+      if (best && n <= best.length) continue;
+      if (start + n > words.length) continue;
+      if (tokensMatch(words, start, entry.tokens)) best = { entry, length: n };
+    }
+    return best;
+  }
+  /** Longest entry matching words[… end-1] (end exclusive). */
+  matchEnding(words, end) {
+    const word = words[end - 1];
+    if (word === void 0) return null;
+    let best = null;
+    for (const entry of candidates(this.byLast, word)) {
+      const n = entry.tokens.length;
+      if (best && n <= best.length) continue;
+      if (end - n < 0) continue;
+      if (tokensMatch(words, end - n, entry.tokens)) best = { entry, length: n };
+    }
+    return best;
+  }
+  /** The whole word list is exactly one entry. */
+  matchWhole(words) {
+    const m = this.matchAt(words, 0);
+    return m && m.length === words.length ? m : null;
+  }
+};
+function insertSorted(map, k, e) {
+  const list = map.get(k) ?? [];
+  list.push(e);
+  list.sort((a, b) => b.tokens.length - a.tokens.length);
+  map.set(k, list);
+}
+function candidates(map, word) {
+  const lower = asciiLower(word);
+  const stripped = stripKeyPunct(lower);
+  const a = map.get(lower) ?? [];
+  if (stripped === lower) return a;
+  const b = map.get(stripped) ?? [];
+  return a.length === 0 ? b : b.length === 0 ? a : [...a, ...b];
+}
+function tokensMatch(words, start, tokens) {
+  for (let k = 0; k < tokens.length; k++) {
+    const w = words[start + k];
+    const t = tokens[k];
+    if (w === void 0 || t === void 0 || !wordMatches(w, t)) return false;
+  }
+  return true;
+}
+
+// src/tracklist/split.ts
+function splitLines(text) {
+  const lines = [];
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 10) {
+      lines.push({ raw: text.slice(start, i), eol: "\n" });
+      start = i + 1;
+    } else if (c === 13) {
+      if (text.charCodeAt(i + 1) === 10) {
+        lines.push({ raw: text.slice(start, i), eol: "\r\n" });
+        i++;
+      } else {
+        lines.push({ raw: text.slice(start, i), eol: "\r" });
+      }
+      start = i + 1;
+    }
+  }
+  if (start < text.length) lines.push({ raw: text.slice(start), eol: "" });
+  return lines;
+}
+function joinLines(lines) {
+  let out = "";
+  for (const l of lines) out += l.raw + l.eol;
+  return out;
+}
+function hasLineBreak(s) {
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 10 || c === 13) return true;
+  }
+  return false;
+}
+
+// src/digits.ts
+function digitRun(s, from) {
+  let i = from;
+  while (isDigit(s[i])) i++;
+  return i - from;
+}
+function twoDigitsUpTo59(s, at) {
+  if (!isDigit(s[at]) || !isDigit(s[at + 1]) || isDigit(s[at + 2])) return null;
+  const n = Number(s.slice(at, at + 2));
+  return n <= 59 ? n : null;
+}
+
+// src/tracklist/times.ts
+function isGapSeparator(ch) {
+  return ch === "-" || ch === "\u2013" || ch === "\u2014" || ch === "|" || ch === "." || ch === ":";
+}
+function skipWhitespace(s, from) {
+  let i = from;
+  while (i < s.length && isWhitespace(s[i])) i++;
+  return i;
+}
+function isBullet(ch) {
+  return ch === "-" || ch === "\u2013" || ch === "\u2014" || ch === "*" || ch === "\u2022";
+}
+function untimed(raw, invalid) {
+  const at = skipWhitespace(raw, 0);
+  let lead = "";
+  if (isBullet(raw[at]) && isWhitespace(raw[at + 1]))
+    lead = raw.slice(0, skipWhitespace(raw, at + 1));
+  return {
+    parts: { lead, time: "", gap: "", rest: raw.slice(lead.length) },
+    time: null,
+    style: null,
+    invalid
+  };
+}
+function secondsOf(whole, frac) {
+  return frac.length === 0 ? whole : Number(`${whole}.${frac}`);
+}
+function shapeAt(s, at) {
+  const na = digitRun(s, at);
+  if (na === 0 || s[at + na] !== ":" || !isDigit(s[at + na + 1])) return null;
+  const parts = [s.slice(at, at + na)];
+  let end = at + na;
+  while (s[end] === ":" && isDigit(s[end + 1])) {
+    const n = digitRun(s, end + 1);
+    parts.push(s.slice(end + 1, end + 1 + n));
+    end += 1 + n;
+  }
+  return { parts, end };
+}
+function shapeSeconds(parts) {
+  if (parts.length < 2 || parts.length > 3) return null;
+  const [a, b, c] = parts;
+  if (c !== void 0) {
+    if (a.length < 1 || a.length > 2 || b.length !== 2 || c.length !== 2) return null;
+    const m = Number(b);
+    const sec2 = Number(c);
+    if (m > 59 || sec2 > 59) return null;
+    return Number(a) * 3600 + m * 60 + sec2;
+  }
+  if (a.length < 1 || a.length > 3 || b.length !== 2) return null;
+  const sec = Number(b);
+  if (sec > 59) return null;
+  return Number(a) * 60 + sec;
+}
+function scanTime(raw) {
+  let i = skipWhitespace(raw, 0);
+  const closer = raw[i] === "[" ? "]" : raw[i] === "(" ? ")" : null;
+  if (closer) i++;
+  const leadEnd = i;
+  const shape = shapeAt(raw, i);
+  if (!shape) return untimed(raw, false);
+  const whole = shapeSeconds(shape.parts);
+  if (whole === null) return untimed(raw, true);
+  let j = shape.end;
+  let fracSep = "";
+  let frac = "";
+  const sep = raw[j];
+  if (sep === "." || sep === ",") {
+    const n = digitRun(raw, j + 1);
+    if (n >= 1 && n <= 3) {
+      fracSep = sep;
+      frac = raw.slice(j + 1, j + 1 + n);
+      j += 1 + n;
+    }
+  }
+  const timeEnd = j;
+  if (closer) {
+    if (raw[j] !== closer) return untimed(raw, false);
+    j++;
+  } else if (j < raw.length && !isWhitespace(raw[j]) && !isGapSeparator(raw[j])) {
+    return untimed(raw, false);
+  }
+  j = skipWhitespace(raw, j);
+  if (isGapSeparator(raw[j])) j = skipWhitespace(raw, j + 1);
+  if (raw.startsWith("==>", j)) j = skipWhitespace(raw, j + 3);
+  else if (raw.startsWith("=>", j)) j = skipWhitespace(raw, j + 2);
+  const timeRaw = raw.slice(leadEnd, timeEnd);
+  const hours = shape.parts.length === 3;
+  const first = shape.parts[0];
+  const longMinutes = !hours && Number(first) >= 60;
+  return {
+    parts: {
+      lead: raw.slice(0, leadEnd),
+      time: timeRaw,
+      gap: raw.slice(timeEnd, j),
+      rest: raw.slice(j)
+    },
+    time: { raw: timeRaw, seconds: secondsOf(whole, frac) },
+    style: {
+      hours,
+      hourWidth: hours ? first.length : 0,
+      // R13.9.2: a long-minute time's minimum minute width is min(width, 2), so it never
+      // keeps 3 minute digits once it is short again (`125:30` − 7000 s → `08:50`).
+      minuteWidth: hours ? shape.parts[1].length : longMinutes ? Math.min(first.length, 2) : first.length,
+      longMinutes,
+      fracSep,
+      fracDigits: frac.length
+    },
+    invalid: false
+  };
+}
+var pad = (n, width) => String(n).padStart(width, "0");
+function formatTime(seconds, style, oneDigitHours2) {
+  const scale = 10 ** style.fracDigits;
+  const units = Math.floor(seconds * scale + 0.5);
+  if (!Number.isSafeInteger(units) || units < 0) return null;
+  const whole = Math.floor(units / scale);
+  const fracUnits = units - whole * scale;
+  const frac = style.fracDigits > 0 ? style.fracSep + pad(fracUnits, style.fracDigits) : "";
+  const sec = whole % 60;
+  if (whole >= 100 * 3600) return null;
+  if (style.hours) {
+    const h = Math.floor(whole / 3600);
+    const m2 = Math.floor(whole % 3600 / 60);
+    return {
+      raw: `${pad(h, style.hourWidth)}:${pad(m2, style.minuteWidth)}:${pad(sec, 2)}${frac}`,
+      upgraded: false
+    };
+  }
+  if (style.longMinutes) {
+    const m2 = Math.floor(whole / 60);
+    if (m2 > 999) return null;
+    return { raw: `${pad(m2, style.minuteWidth)}:${pad(sec, 2)}${frac}`, upgraded: false };
+  }
+  if (whole >= 3600) {
+    const h = Math.floor(whole / 3600);
+    const m2 = Math.floor(whole % 3600 / 60);
+    return {
+      raw: `${pad(h, oneDigitHours2 ? 1 : 2)}:${pad(m2, 2)}:${pad(sec, 2)}${frac}`,
+      upgraded: true
+    };
+  }
+  const m = Math.floor(whole / 60);
+  return { raw: `${pad(m, style.minuteWidth)}:${pad(sec, 2)}${frac}`, upgraded: false };
+}
+
+// src/tracklist/edits.ts
+var InvalidEdit = class extends Error {
+};
+function workLine(raw, eol, changed) {
+  return { raw, eol, changed, scan: scanTime(raw) };
+}
+function countHours(ctx, line, by) {
+  const style = line.scan.style;
+  if (!style?.hours) return;
+  if (style.hourWidth === 1) ctx.oneDigit += by;
+  else ctx.wideHours += by;
+}
+function countEol(ctx, eol, by) {
+  if (eol !== "") ctx.eols.set(eol, (ctx.eols.get(eol) ?? 0) + by);
+}
+function setEol(ctx, line, eol) {
+  countEol(ctx, line.eol, -1);
+  line.eol = eol;
+  line.changed = true;
+  countEol(ctx, eol, 1);
+}
+function countLine(ctx, line, by) {
+  countHours(ctx, line, by);
+  countEol(ctx, line.eol, by);
+}
+function setRaw(ctx, line, raw) {
+  countHours(ctx, line, -1);
+  line.raw = raw;
+  line.scan = scanTime(raw);
+  line.changed = true;
+  countHours(ctx, line, 1);
+}
+function warnEdit(ctx, code, line) {
+  ctx.warnings.push({ code, edit: ctx.index, line });
+}
+function field(edit, key) {
+  return edit[key];
+}
+function has(edit, key) {
+  return field(edit, key) !== void 0;
+}
+function lineIndex(ctx, value) {
+  if (typeof value !== "number" || !Number.isInteger(value)) throw new InvalidEdit();
+  if (value < 1 || value > ctx.lines.length) throw new InvalidEdit();
+  return value - 1;
+}
+function finite(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) throw new InvalidEdit();
+  return value;
+}
+function singleLine(value) {
+  if (typeof value !== "string" || hasLineBreak(value)) throw new InvalidEdit();
+  return value;
+}
+function oneDigitHours(ctx) {
+  return ctx.oneDigit > 0 && ctx.wideHours === 0;
+}
+function retime(ctx, index, value, oneDigit) {
+  const scan2 = ctx.lines[index].scan;
+  if (!scan2.style || !scan2.time) throw new InvalidEdit();
+  const clamped = value < 0;
+  const f = formatTime(clamped ? 0 : value, scan2.style, oneDigit);
+  if (!f) throw new InvalidEdit();
+  const p = scan2.parts;
+  return { index, raw: p.lead + f.raw + p.gap + p.rest, clamped, upgraded: f.upgraded };
+}
+function commit(ctx, changes) {
+  for (const c of changes) {
+    setRaw(ctx, ctx.lines[c.index], c.raw);
+    if (c.clamped) warnEdit(ctx, "time-clamped", c.index + 1);
+    if (c.upgraded) warnEdit(ctx, "style-upgraded", c.index + 1);
+  }
+}
+function setTime(ctx, edit) {
+  const index = lineIndex(ctx, field(edit, "line"));
+  const value = finite(field(edit, "seconds"));
+  commit(ctx, [retime(ctx, index, value, oneDigitHours(ctx))]);
+  return [];
+}
+function shift(ctx, edit) {
+  const delta = finite(field(edit, "seconds"));
+  let targets;
+  if (has(edit, "lines")) {
+    const list = field(edit, "lines");
+    if (!Array.isArray(list)) throw new InvalidEdit();
+    const set = new Set(list.map((v) => lineIndex(ctx, v)));
+    targets = [...set].sort((a, b) => a - b);
+  } else {
+    const from = has(edit, "from") ? lineIndex(ctx, field(edit, "from")) : 0;
+    targets = [];
+    for (let i = from; i < ctx.lines.length; i++) targets.push(i);
+  }
+  const oneDigit = oneDigitHours(ctx);
+  const changes = [];
+  for (const i of targets) {
+    const time = ctx.lines[i].scan.time;
+    if (time) changes.push(retime(ctx, i, time.seconds + delta, oneDigit));
+  }
+  commit(ctx, changes);
+  return [];
+}
+function sortByTime(ctx) {
+  const lines = ctx.lines;
+  const first = lines.findIndex((l) => l.scan.time !== null);
+  if (first < 0) return [];
+  const blocks = [];
+  for (let i = first; i < lines.length; i++) {
+    const t = lines[i].scan.time;
+    if (t) blocks.push({ seconds: t.seconds, from: i, to: i + 1 });
+    else blocks[blocks.length - 1].to = i + 1;
+  }
+  const sorted = blocks.map((b, k) => ({ b, k })).sort((x, y) => x.b.seconds - y.b.seconds || x.k - y.k).map((x) => x.b);
+  const order = [];
+  for (let i = 0; i < first; i++) order.push(i);
+  for (const b of sorted) for (let i = b.from; i < b.to; i++) order.push(i);
+  const old = ctx.lines;
+  ctx.lines = order.map((src, slot) => {
+    const line = old[src];
+    const eol = old[slot].eol;
+    return { raw: line.raw, eol, changed: line.changed || src !== slot, scan: line.scan };
+  });
+  return null;
+}
+function setRest(ctx, edit) {
+  const index = lineIndex(ctx, field(edit, "line"));
+  const rest = singleLine(field(edit, "rest"));
+  const line = ctx.lines[index];
+  const p = line.scan.parts;
+  const spaced = p.gap.length > 0 && isWhitespace(p.gap[p.gap.length - 1]);
+  const gap = p.time !== "" && !spaced && rest !== "" ? `${p.gap} ` : p.gap;
+  setRaw(ctx, line, p.lead + p.time + gap + rest);
+  return [index];
+}
+function commonEol(ctx) {
+  let best = 0;
+  const top = [];
+  for (const [eol, n] of ctx.eols) {
+    if (n <= 0 || n < best) continue;
+    if (n > best) top.length = 0;
+    best = n;
+    top.push(eol);
+  }
+  if (top.length === 0) return "\n";
+  if (top.length === 1) return top[0];
+  for (const l of ctx.lines) if (top.includes(l.eol)) return l.eol;
+  return "\n";
+}
+function insert(ctx, edit) {
+  const after = field(edit, "after");
+  if (typeof after !== "number" || !Number.isInteger(after)) throw new InvalidEdit();
+  if (after < 0 || after > ctx.lines.length) throw new InvalidEdit();
+  const text = singleLine(field(edit, "text"));
+  const eol = commonEol(ctx);
+  const last = ctx.lines[ctx.lines.length - 1];
+  const line = workLine(text, ctx.lines.length === 0 ? "" : eol, true);
+  if (after === ctx.lines.length && last && last.eol === "") {
+    setEol(ctx, last, eol);
+    line.eol = "";
+  }
+  ctx.lines.splice(after, 0, line);
+  countLine(ctx, line, 1);
+  return [after];
+}
+function remove(ctx, edit) {
+  const index = lineIndex(ctx, field(edit, "line"));
+  const [gone] = ctx.lines.splice(index, 1);
+  if (gone) countLine(ctx, gone, -1);
+  const last = ctx.lines[ctx.lines.length - 1];
+  if (gone && index === ctx.lines.length && last && last.eol !== gone.eol) {
+    setEol(ctx, last, gone.eol);
+  }
+  return [index];
+}
+function mergeAt(ctx, k) {
+  const prev = ctx.lines[k];
+  const next = ctx.lines[k + 1];
+  if (!prev || !next || prev.eol !== "\r" || next.raw !== "" || next.eol !== "\n") return;
+  setEol(ctx, prev, "\r\n");
+  ctx.lines.splice(k + 1, 1);
+  countLine(ctx, next, -1);
+}
+function canonical(ctx, touched) {
+  const lines = ctx.lines;
+  let starts;
+  if (touched === null) {
+    starts = [];
+    for (let k = lines.length - 2; k >= 0; k--) starts.push(k);
+  } else {
+    const set = /* @__PURE__ */ new Set([lines.length - 2]);
+    for (const t of touched) {
+      set.add(t - 1);
+      set.add(t);
+    }
+    starts = [...set].sort((a, b) => b - a);
+  }
+  for (const k of starts) mergeAt(ctx, k);
+  const last = lines[lines.length - 1];
+  if (last && last.raw === "" && last.eol === "") {
+    lines.pop();
+    countLine(ctx, last, -1);
+  }
+}
+function applyOne(ctx, edit) {
+  if (typeof edit !== "object" || edit === null || Array.isArray(edit)) throw new InvalidEdit();
+  const op = field(edit, "op");
+  if (op === "set-time") return setTime(ctx, edit);
+  if (op === "shift") return shift(ctx, edit);
+  if (op === "sort-by-time") return sortByTime(ctx);
+  if (op === "set-rest") return setRest(ctx, edit);
+  if (op === "insert") return insert(ctx, edit);
+  if (op === "delete") return remove(ctx, edit);
+  throw new InvalidEdit();
+}
+function invalidLine(edit) {
+  if (typeof edit !== "object" || edit === null) return null;
+  try {
+    for (const key of ["line", "after"]) {
+      const value = field(edit, key);
+      if (typeof value === "number" && Number.isInteger(value)) return value;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function applyEdits(text, edits, options) {
+  const source = typeof text === "string" ? text : "";
+  const list = Array.isArray(edits) ? edits : [];
+  if (list.length === 0) return { text: source, changed: [], warnings: [] };
+  const ctx = {
+    lines: splitLines(source).map((l) => workLine(l.raw, l.eol, false)),
+    index: 0,
+    warnings: [],
+    oneDigit: 0,
+    wideHours: 0,
+    eols: /* @__PURE__ */ new Map()
+  };
+  for (const l of ctx.lines) countLine(ctx, l, 1);
+  for (let i = 0; i < list.length; i++) {
+    ctx.index = i;
+    const warningsBefore = ctx.warnings.length;
+    try {
+      canonical(ctx, applyOne(ctx, list[i]));
+    } catch {
+      ctx.warnings.length = warningsBefore;
+      warnEdit(ctx, "edit-invalid", invalidLine(list[i]));
+    }
+  }
+  const changed = [];
+  ctx.lines.forEach((l, i) => {
+    if (l.changed) changed.push(i + 1);
+  });
+  return { text: joinLines(ctx.lines), changed, warnings: ctx.warnings };
+}
+
+// src/data.generated.ts
+var SPEC_VERSION = "0.3.1";
+var descriptorsData = {
+  "descriptors": [
+    "radio",
+    "extended",
+    "club",
+    "original",
+    "instrumental",
+    "dub",
+    "vip",
+    "acoustic",
+    "live",
+    "demo",
+    "vocal",
+    "clean",
+    "dirty",
+    "explicit",
+    "short",
+    "long",
+    "full",
+    "album",
+    "single",
+    "alternate",
+    "alt",
+    "alternative",
+    "main",
+    "special",
+    "bonus",
+    "deluxe",
+    "mono",
+    "stereo",
+    "new",
+    "official",
+    "orchestral",
+    "piano",
+    "unplugged",
+    '12"',
+    '7"',
+    "12''",
+    "7''",
+    "12 inch",
+    "7 inch",
+    "re",
+    "final",
+    "second",
+    "2nd",
+    "3rd"
+  ]
+};
+var extensionsData = {
+  "extensions": [
+    "mp3",
+    "flac",
+    "wav",
+    "m4a",
+    "ogg",
+    "opus",
+    "aac",
+    "aiff",
+    "aif",
+    "wma",
+    "alac",
+    "mp4",
+    "webm",
+    "mkv"
+  ]
+};
+var featMarkersData = {
+  "markers": [
+    "feat.",
+    "feat",
+    "ft.",
+    "ft",
+    "featuring",
+    "feat:",
+    "ft:"
+  ],
+  "bracketOnly": [
+    "with",
+    "w/"
+  ],
+  "producer": [
+    "prod.",
+    "prod",
+    "produced",
+    "prod.by",
+    "prod:"
+  ],
+  "titleMarkers": [
+    "feat.",
+    "ft.",
+    "featuring"
+  ],
+  "titleProducer": [
+    "prod.",
+    "prod. by",
+    "produced by",
+    "prod.by"
+  ]};
+var genresData = {
+  "genres": [
+    "d'n'b",
+    "dnb",
+    "d&b",
+    "d & b",
+    "drum & bass",
+    "drum&bass",
+    "drum and bass",
+    "drum n bass",
+    "drum 'n' bass",
+    "drum'n'bass",
+    "neurofunk",
+    "neuro",
+    "liquid",
+    "liquid funk",
+    "jump up",
+    "jump-up",
+    "jungle",
+    "halftime",
+    "dancefloor",
+    "dubstep",
+    "riddim",
+    "brostep",
+    "trap",
+    "future bass",
+    "house",
+    "deep house",
+    "tech house",
+    "progressive house",
+    "electro house",
+    "techno",
+    "trance",
+    "psytrance",
+    "psy",
+    "hardstyle",
+    "hardcore",
+    "breaks",
+    "breakbeat",
+    "garage",
+    "uk garage",
+    "ukg",
+    "2step",
+    "2-step",
+    "grime",
+    "bass",
+    "bass house",
+    "edm",
+    "electronic",
+    "idm",
+    "synthwave",
+    "phonk",
+    "hip hop",
+    "hip-hop",
+    "rap",
+    "pop",
+    "rock",
+    "metal",
+    "ambient",
+    "chillout",
+    "lofi",
+    "lo-fi"
+  ]
+};
+var headerWordsData = {
+  "words": [
+    "tracklist",
+    "setlist",
+    "playlist",
+    "part",
+    "hour",
+    "cd",
+    "disc",
+    "side",
+    "chapter",
+    "segment",
+    "set"
+  ]
+};
+var joinersData = {
+  "spaced": [
+    {
+      "raw": "&",
+      "canonical": "&"
+    },
+    {
+      "raw": "and",
+      "canonical": "&",
+      "kind": "and"
+    },
+    {
+      "raw": "x",
+      "canonical": "x",
+      "caseSensitive": true
+    },
+    {
+      "raw": "\xD7",
+      "canonical": "x"
+    },
+    {
+      "raw": "vs.",
+      "canonical": "vs."
+    },
+    {
+      "raw": "vs",
+      "canonical": "vs."
+    },
+    {
+      "raw": "versus",
+      "canonical": "vs."
+    },
+    {
+      "raw": "/",
+      "canonical": "/"
+    },
+    {
+      "raw": "+",
+      "canonical": "+"
+    },
+    {
+      "raw": "with",
+      "canonical": "with"
+    },
+    {
+      "raw": "meets",
+      "canonical": "meets"
+    },
+    {
+      "raw": "pres.",
+      "canonical": "pres."
+    },
+    {
+      "raw": "presents",
+      "canonical": "pres."
+    },
+    {
+      "raw": "b2b",
+      "canonical": "b2b"
+    }
+  ],
+  "tight": [
+    {
+      "raw": ",",
+      "canonical": ","
+    },
+    {
+      "raw": ";",
+      "canonical": ","
+    }
+  ],
+  "featCanonical": "feat."
+};
+var junkData = {
+  "phrases": {
+    "official video": "video",
+    "official music video": "video",
+    "music video": "video",
+    "official video clip": "video",
+    "video clip": "video",
+    "official clip": "video",
+    "clip officiel": "video",
+    "official hd video": "video",
+    "official 4k video": "video",
+    "official mv": "video",
+    "mv": "video",
+    "m/v": "video",
+    "video": "video",
+    "official visualizer": "video",
+    "official visualiser": "video",
+    "visualizer": "video",
+    "visualiser": "video",
+    "audio visualizer": "video",
+    "official animated video": "video",
+    "animated video": "video",
+    "live video": "video",
+    "official live video": "video",
+    "performance video": "video",
+    "official performance video": "video",
+    "official audio": "audio",
+    "audio": "audio",
+    "audio only": "audio",
+    "full audio": "audio",
+    "official lyric video": "lyrics",
+    "official lyrics video": "lyrics",
+    "lyric video": "lyrics",
+    "lyrics video": "lyrics",
+    "lyrics": "lyrics",
+    "lyric": "lyrics",
+    "with lyrics": "lyrics",
+    "lyrics on screen": "lyrics",
+    "letra": "lyrics",
+    "hd": "quality",
+    "hq": "quality",
+    "uhd": "quality",
+    "4k": "quality",
+    "8k": "quality",
+    "1080p": "quality",
+    "720p": "quality",
+    "480p": "quality",
+    "high quality": "quality",
+    "full hd": "quality",
+    "free download": "promo",
+    "free dl": "promo",
+    "out now": "promo",
+    "premiere": "promo",
+    "exclusive": "promo",
+    "preview": "promo",
+    "teaser": "promo",
+    "snippet": "promo",
+    "new song": "promo",
+    "available now": "promo",
+    "ncs release": "label",
+    "monstercat release": "label",
+    "official": "other"
+  },
+  "connectors": [
+    "-",
+    "|",
+    "/",
+    "&",
+    "+",
+    ","
+  ],
+  "labelSuffixes": [
+    "release",
+    "records",
+    "recordings"
+  ]
+};
+var markerWordsData = {
+  "words": [
+    "intro",
+    "outro",
+    "break",
+    "interlude",
+    "intermission",
+    "jingle",
+    "ad",
+    "advert",
+    "advertisement",
+    "talk",
+    "interview",
+    "speech",
+    "announcement",
+    "shoutout",
+    "shout-out",
+    "pause",
+    "start",
+    "end",
+    "silence",
+    "applause",
+    "skit"
+  ]
+};
+var noSplitBeforeData = {
+  "words": [
+    "sons",
+    "daughters",
+    "friends",
+    "co",
+    "co.",
+    "company",
+    "his",
+    "her",
+    "their",
+    "orchestra"
+  ]
+};
+var platformSuffixesData = {
+  "suffixes": [
+    " - YouTube Music",
+    " - YouTube",
+    " | Free Listening on SoundCloud",
+    " - SoundCloud",
+    " | SoundCloud",
+    " - Topic",
+    " | Bandcamp",
+    " - Bandcamp"
+  ]
+};
+var stopwordsData = {
+  "words": [
+    "you",
+    "me",
+    "him",
+    "her",
+    "us",
+    "them",
+    "it",
+    "i",
+    "love",
+    "my",
+    "your",
+    "our",
+    "the",
+    "a",
+    "an",
+    "this",
+    "that",
+    "myself",
+    "yourself",
+    "everyone",
+    "everybody",
+    "somebody",
+    "someone",
+    "nobody",
+    "nothing",
+    "all",
+    "night",
+    "side",
+    "day"
+  ]
+};
+var unknownTokensData = {
+  "caseSensitive": [
+    "ID",
+    "IDs",
+    "ID?"
+  ],
+  "caseInsensitive": [
+    "unknown",
+    "unknown artist",
+    "unknown title",
+    "untitled",
+    "?",
+    "??",
+    "???"
+  ]
+};
+var versionKeywordsData = {
+  "heads": {
+    "remix": "remix",
+    "rmx": "remix",
+    "mix": "mix",
+    "bootleg": "bootleg",
+    "vip": "vip",
+    "edit": "edit",
+    "re-edit": "edit",
+    "reedit": "edit",
+    "flip": "flip",
+    "refix": "refix",
+    "rework": "rework",
+    "re-work": "rework",
+    "mashup": "mashup",
+    "mash-up": "mashup",
+    "mash up": "mashup",
+    "blend": "blend",
+    "dub": "dub",
+    "version": "version",
+    "ver": "version",
+    "remaster": "remaster",
+    "remastered": "remaster",
+    "cover": "cover",
+    "reprise": "reprise"
+  },
+  "genericHeads": [
+    "mix",
+    "edit",
+    "version"
+  ],
+  "typeCapableModifiers": {
+    "radio": "radio",
+    "extended": "extended",
+    "club": "club",
+    "original": "original",
+    "instrumental": "instrumental",
+    "dub": "dub",
+    "vip": "vip",
+    "acoustic": "acoustic",
+    "live": "live",
+    "acapella": "acapella",
+    "a cappella": "acapella",
+    "a capella": "acapella",
+    "acappella": "acapella",
+    "demo": "demo"
+  },
+  "prefixForms": {
+    "live": "live",
+    "remastered": "remaster",
+    "remaster": "remaster",
+    "acoustic": "acoustic",
+    "instrumental": "instrumental",
+    "acapella": "acapella",
+    "a cappella": "acapella",
+    "demo": "demo",
+    "sped up": "spedUp",
+    "speed up": "spedUp",
+    "slowed + reverb": "slowed",
+    "slowed & reverb": "slowed",
+    "slowed and reverb": "slowed",
+    "slowed": "slowed",
+    "nightcore": "nightcore"
+  }};
+
+// src/tables.ts
+function stringList(value) {
+  return Array.isArray(value) ? value.filter((s) => typeof s === "string") : [];
+}
+function stringEntries(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return [];
+  return Object.entries(value).filter((e) => typeof e[1] === "string");
+}
+function lowerKeys(list) {
+  return stringList(list).map((s) => asciiLower(s).trim()).filter((s) => s.length > 0);
+}
+function buildTables(keywords) {
+  const featMarkers = new PhraseTable(
+    [...featMarkersData.markers, ...lowerKeys(keywords?.featMarkers)].map((m) => [m, true])
+  );
+  const bracketOnlyFeat = new PhraseTable(featMarkersData.bracketOnly.map((m) => [m, true]));
+  const producerMarkers = new PhraseTable(featMarkersData.producer.map((m) => [m, true]));
+  const titleFeatMarkers = new PhraseTable(
+    [...featMarkersData.titleMarkers, ...lowerKeys(keywords?.featMarkers)].map((m) => [m, true])
+  );
+  const titleProducerMarkers = new PhraseTable(
+    featMarkersData.titleProducer.map((m) => [m, true])
+  );
+  const junkEntries = [
+    ...Object.entries(junkData.phrases),
+    ...stringEntries(keywords?.junk)
+  ];
+  const genres = [...genresData.genres, ...lowerKeys(keywords?.genres)];
+  const junkPhrases = new PhraseTable(junkEntries);
+  const junkOrGenre = new PhraseTable([
+    ...junkEntries,
+    ...genres.map((g) => [g, "genre"])
+  ]);
+  const headEntries = [
+    ...Object.entries(versionKeywordsData.heads),
+    ...stringEntries(keywords?.versionHeads)
+  ];
+  const heads = new PhraseTable(headEntries);
+  const runInfo = /* @__PURE__ */ new Map();
+  const note = (key, patch) => {
+    const k = asciiLower(key).trim();
+    runInfo.set(k, { ...runInfo.get(k), ...patch });
+  };
+  for (const [k, t] of Object.entries(versionKeywordsData.typeCapableModifiers)) {
+    note(k, { typeCapable: t });
+  }
+  for (const d of [...descriptorsData.descriptors, ...lowerKeys(keywords?.descriptors)]) {
+    note(d, { descriptor: asciiLower(d).trim() });
+  }
+  for (const g of genres) note(g, { genre: true });
+  for (const [k, t] of headEntries) note(k, { head: t });
+  return {
+    featMarkers,
+    bracketOnlyFeat,
+    producerMarkers,
+    titleFeatMarkers,
+    titleProducerMarkers,
+    junkOrGenre,
+    junkPhrases,
+    junkConnectors: new Set(junkData.connectors),
+    labelSuffixes: new Set(junkData.labelSuffixes),
+    heads,
+    genericHeadTypes: new Set(versionKeywordsData.genericHeads),
+    runWords: new PhraseTable(runInfo),
+    prefixForms: new PhraseTable(
+      Object.entries(versionKeywordsData.prefixForms)
+    ),
+    spacedJoiners: joinersData.spaced.map((j) => ({
+      raw: j.raw,
+      canonical: j.canonical,
+      isAnd: "kind" in j && j.kind === "and",
+      caseSensitive: "caseSensitive" in j && j.caseSensitive === true
+    })),
+    tightJoiners: new Map(joinersData.tight.map((j) => [j.raw, j.canonical])),
+    featCanonical: joinersData.featCanonical,
+    noSplitBefore: new Set(noSplitBeforeData.words),
+    stopwords: new Set(stopwordsData.words),
+    unknownCaseSensitive: new Set(unknownTokensData.caseSensitive),
+    unknownCaseInsensitive: new Set(unknownTokensData.caseInsensitive),
+    extensions: new Set(extensionsData.extensions),
+    platformSuffixes: [...platformSuffixesData.suffixes].sort((a, b) => b.length - a.length)
+  };
+}
+var defaultTables = null;
+function getDefaultTables() {
+  defaultTables ?? (defaultTables = buildTables());
+  return defaultTables;
+}
+function tablesFor(keywords) {
+  return keywords ? buildTables(keywords) : getDefaultTables();
+}
+function isUnknownToken(text, t) {
+  return t.unknownCaseSensitive.has(text) || t.unknownCaseInsensitive.has(asciiLower(text));
+}
+
+// src/context.ts
+function makeCtx(t, options) {
+  const known = stringList(options?.knownArtists);
+  const knownKeys = new Set(known.map(dedupKey).filter((k) => k.length > 0));
+  const knownMaxLen = known.reduce((m, k) => Math.max(m, k.length), 0);
+  const splitAnd = options?.splitAnd ?? "auto";
+  return { t, knownKeys, knownMaxLen, splitAnd, warnings: [], listSeq: 0 };
+}
+function warn(ctx, w) {
+  if (!ctx.warnings.includes(w)) ctx.warnings.push(w);
+}
+function matchKnownAt(text, start, ctx, extraBoundary = "") {
+  if (ctx.knownKeys.size === 0) return 0;
+  const limit = Math.min(text.length, start + ctx.knownMaxLen * 2 + 8);
+  for (let end = limit; end > start; end--) {
+    const next = text[end];
+    const boundary = end === text.length || next === "," || next === ";" || isWhitespace(next) || extraBoundary !== "" && next === extraBoundary;
+    if (!boundary) continue;
+    if (ctx.knownKeys.has(dedupKey(text.slice(start, end)))) return end - start;
+  }
+  return 0;
+}
+function isKnownArtist(text, ctx) {
+  return ctx.knownKeys.size > 0 && ctx.knownKeys.has(dedupKey(text));
+}
+
+// src/scanner.ts
+var PH = "\uE000";
+var CLOSER = { "(": ")", "[": "]", "{": "}" };
+function isOpener(ch) {
+  return ch === "(" || ch === "[" || ch === "{";
+}
+function scan(str, base = 0) {
+  let text = "";
+  const pos = [];
+  const groups = /* @__PURE__ */ new Map();
+  const stack = [];
+  let groupStart = -1;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    if (stack.length === 0) {
+      if (isOpener(ch)) {
+        stack.push(CLOSER[ch]);
+        groupStart = i;
+      } else {
+        text += ch;
+        pos.push(base + i);
+      }
+      continue;
+    }
+    if (isOpener(ch)) {
+      stack.push(CLOSER[ch]);
+    } else if (ch === stack[stack.length - 1]) {
+      stack.pop();
+      if (stack.length === 0) {
+        addGroup(str, groupStart, i + 1, true, base, groups);
+        text += PH;
+        pos.push(base + groupStart);
+      }
+    }
+  }
+  const unbalanced = stack.length > 0;
+  if (unbalanced) {
+    addGroup(str, groupStart, str.length, false, base, groups);
+    text += PH;
+    pos.push(base + groupStart);
+  }
+  return { skel: { text, pos, groups }, unbalanced };
+}
+function addGroup(str, start, end, closed, base, groups) {
+  const open = str[start];
+  const inner = str.slice(start + 1, closed ? end - 1 : end);
+  groups.set(base + start, {
+    open,
+    inner: collapseSpaces(inner),
+    raw: str.slice(start, end),
+    closed,
+    pos: base + start,
+    end: base + end
+  });
+}
+function sliceSkel(s, start, end = s.text.length) {
+  const a = Math.max(0, Math.min(start, s.text.length));
+  const b = Math.max(a, Math.min(end, s.text.length));
+  return { text: s.text.slice(a, b), pos: s.pos.slice(a, b), groups: s.groups };
+}
+function trimSkel(s) {
+  let a = 0;
+  let b = s.text.length;
+  while (a < b && isWhitespace(s.text[a])) a++;
+  while (b > a && isWhitespace(s.text[b - 1])) b--;
+  return sliceSkel(s, a, b);
+}
+function concatSkel(a, b) {
+  return { text: a.text + b.text, pos: [...a.pos, ...b.pos], groups: a.groups };
+}
+function cutSkel(s, start, end) {
+  return concatSkel(sliceSkel(s, 0, start), sliceSkel(s, end));
+}
+function groupAt(s, index) {
+  if (s.text[index] !== PH) return void 0;
+  const p = s.pos[index];
+  return p === void 0 ? void 0 : s.groups.get(p);
+}
+function groupsOf(s) {
+  const out = [];
+  for (let i = 0; i < s.text.length; i++) {
+    const g = groupAt(s, i);
+    if (g) out.push({ index: i, group: g });
+  }
+  return out;
+}
+function hasGroup(s) {
+  return s.text.includes(PH);
+}
+function renderSkel(s) {
+  if (!s.text.includes(PH)) return s.text;
+  let out = "";
+  for (let i = 0; i < s.text.length; i++) {
+    const g = groupAt(s, i);
+    out += g ? g.raw : s.text[i];
+  }
+  return out;
+}
+function removeGroups(s, remove2) {
+  if (remove2.size === 0) return s;
+  let text = "";
+  const pos = [];
+  for (let i = 0; i < s.text.length; i++) {
+    const p = s.pos[i];
+    if (s.text[i] === PH && remove2.has(p)) continue;
+    text += s.text[i];
+    pos.push(p);
+  }
+  return { text, pos, groups: s.groups };
+}
+function isSpacedDashAt(text, i) {
+  return text[i] === "-" && text[i - 1] === " " && text[i + 1] === " ";
+}
+function hasSpacedDash(text) {
+  for (let i = 1; i < text.length - 1; i++) if (isSpacedDashAt(text, i)) return true;
+  return false;
+}
+function trimmedSegment(s, start, end) {
+  let a = start;
+  let b = Math.max(start, end);
+  while (a < b && isWhitespace(s.text[a])) a++;
+  while (b > a && isWhitespace(s.text[b - 1])) b--;
+  return { skel: sliceSkel(s, a, b), start: a, end: b };
+}
+function splitAtSpacedDashes(s, allowLeading = false) {
+  const segments = [];
+  const t = s.text;
+  let start = 0;
+  if (allowLeading && t[0] === "-" && t[1] === " ") {
+    segments.push({ skel: sliceSkel(s, 0, 0), start: 0, end: 0 });
+    start = 2;
+  }
+  for (let i = Math.max(start, 1); i < t.length - 1; i++) {
+    if (isSpacedDashAt(t, i)) {
+      segments.push(trimmedSegment(s, start, i - 1));
+      start = i + 2;
+    }
+  }
+  segments.push(trimmedSegment(s, start, t.length));
+  return segments;
+}
+
+// src/credits.ts
+var AND_LIKE = /* @__PURE__ */ new Set(["&", "and", "+"]);
+function wordAt(text, start) {
+  let end = start;
+  while (end < text.length && !isWhitespace(text[end])) end++;
+  return end;
+}
+function nextWord(text, from) {
+  let a = from;
+  while (a < text.length && isWhitespace(text[a])) a++;
+  let b = a;
+  while (b < text.length && !isWhitespace(text[b]) && text[b] !== "," && text[b] !== ";") b++;
+  return text.slice(a, b);
+}
+function findJoiner(text, from, splitAtComma, opts, ctx) {
+  for (let p = from; p < text.length; p++) {
+    const ch = text[p];
+    if (ch === "," || ch === ";") {
+      if (ch === "," && isDigit(text[p - 1]) && isDigit(text[p + 1])) continue;
+      return { start: p, end: p + 1, raw: ch };
+    }
+    if (p === 0 || text[p - 1] !== " " || isWhitespace(ch)) continue;
+    const end = wordAt(text, p);
+    if (end >= text.length || text[end] !== " ") continue;
+    const word = text.slice(p, end);
+    const hit = spacedJoiner(word, text, end, splitAtComma, opts, ctx);
+    if (hit) return { start: p, end, raw: word };
+  }
+  return null;
+}
+function spacedJoiner(word, text, end, splitAtComma, opts, ctx) {
+  if (opts.featMarkersJoin && ctx.t.featMarkers.matchAt([word], 0)) return true;
+  for (const j of ctx.t.spacedJoiners) {
+    const matches = j.caseSensitive ? word === j.raw : wordMatches(word, j.raw);
+    if (!matches) continue;
+    if (j.raw === "with" && !opts.splitWith) return false;
+    if (j.isAnd) {
+      if (ctx.splitAnd === "never") return false;
+      if (ctx.splitAnd === "auto" && !splitAtComma) return false;
+    }
+    if (AND_LIKE.has(j.raw) && inVocab(nextWord(text, end), ctx.t.noSplitBefore)) return false;
+    return true;
+  }
+  return false;
+}
+function cleanName(raw) {
+  let name = collapseSpaces(raw);
+  const first = name[0];
+  if (name.length >= 2 && (first === '"' || first === "'") && name[name.length - 1] === first) {
+    name = collapseSpaces(name.slice(1, -1));
+  }
+  while (name.endsWith(",") || name.endsWith(";")) name = name.slice(0, -1).trimEnd();
+  const space = name.indexOf(" ");
+  if (space > 0 && wordKey(name.slice(0, space)) === "by") name = name.slice(space + 1);
+  return collapseSpaces(name);
+}
+function unwrapList(list) {
+  const t = trimSkel(list);
+  const q = t.text[0];
+  if (t.text.length < 2 || q !== '"' && q !== "'" || t.text[t.text.length - 1] !== q) return t;
+  if (t.text.indexOf(q, 1) !== t.text.length - 1) return t;
+  return trimSkel(sliceSkel(t, 1, t.text.length - 1));
+}
+function splitCredits(input, opts, ctx) {
+  const list = unwrapList(input);
+  const text = list.text;
+  const raw = [];
+  let joiner = opts.lead;
+  let splitAtComma = false;
+  let start = 0;
+  while (start <= text.length) {
+    while (start < text.length && isWhitespace(text[start])) start++;
+    const known = matchKnownAt(text, start, ctx, "-");
+    const hit = findJoiner(text, start + known, splitAtComma, opts, ctx);
+    const end = hit ? hit.start : text.length;
+    raw.push({
+      name: cleanName(renderSkel(sliceSkel(list, start, end))),
+      joiner,
+      pos: list.pos[start] ?? list.pos[list.pos.length - 1] ?? 0
+    });
+    if (!hit) break;
+    if (hit.raw === "," || hit.raw === ";") splitAtComma = true;
+    joiner = hit.raw;
+    start = hit.end;
+  }
+  return finishNames(raw, opts, ctx);
+}
+function finishNames(raw, opts, ctx) {
+  const named = raw.filter((r) => r.name.length > 0);
+  let unknown = false;
+  const years = [];
+  const kept = named.filter((r) => {
+    if (isUnknownToken(r.name, ctx.t)) {
+      unknown = true;
+      return false;
+    }
+    const year = isAllDigits(r.name) ? yearOf(r.name) : null;
+    if (year !== null && named.length > 1) {
+      years.push({ year, pos: r.pos });
+      return false;
+    }
+    return true;
+  });
+  const list = ctx.listSeq++;
+  const credits = kept.map(
+    (r, i) => ({
+      name: r.name,
+      role: opts.role,
+      joiner: i === 0 ? opts.lead : r.joiner,
+      source: opts.source,
+      pos: r.pos,
+      list
+    })
+  );
+  return { credits, unknown, years };
+}
+
+// src/classify.ts
+var EXPLICIT_FLAGS = /* @__PURE__ */ new Set(["explicit", "explicit version", "dirty", "dirty version"]);
+var CLEAN_FLAGS = /* @__PURE__ */ new Set(["clean", "clean version", "radio clean"]);
+function classify(inner, site, ctx) {
+  const words = splitWords(inner);
+  if (words.length === 0) return { kind: "unknown" };
+  const junkKind = junkKindOf(words, ctx);
+  if (junkKind) return { kind: "junk", junkKind };
+  const credit = featOrProducer(inner, site, ctx);
+  if (credit) return credit;
+  const flag = flagOf(words);
+  if (flag) return { kind: "flag", flag };
+  if (words.length === 1 && isAllDigits(words[0])) {
+    const year = yearOf(words[0]);
+    if (year !== null) return { kind: "year", year };
+  }
+  const versions = multiVersion(inner, site, ctx) ?? singleVersion(inner, site, ctx);
+  if (versions) return { kind: "versions", versions };
+  return { kind: "unknown" };
+}
+function junkKindOf(words, ctx) {
+  let firstKind = null;
+  let i = 0;
+  while (i < words.length) {
+    const m = ctx.t.junkOrGenre.matchAt(words, i);
+    if (m) {
+      firstKind ?? (firstKind = m.entry.value);
+      i += m.length;
+      continue;
+    }
+    const w = words[i];
+    if (ctx.t.junkConnectors.has(w) || ctx.t.junkConnectors.has(wordKey(w)) || yearOf(w) !== null) {
+      i++;
+      continue;
+    }
+    firstKind = null;
+    break;
+  }
+  if (firstKind) return firstKind;
+  const last = words[words.length - 1];
+  if (words.length >= 2 && last !== void 0 && inVocab(last, ctx.t.labelSuffixes)) return "label";
+  return null;
+}
+function featOrProducer(inner, site, ctx) {
+  const spans = wordSpans(inner);
+  const words = spans.map((s) => s.text);
+  const feat = ctx.t.featMarkers.matchAt(words, 0);
+  const bracketOnly = feat ? null : ctx.t.bracketOnlyFeat.matchAt(words, 0);
+  const featLen = feat?.length ?? bracketOnly?.length ?? 0;
+  if (featLen > 0 && words.length > featLen) {
+    const next = words[featLen];
+    if (!bracketOnly || !inVocab(next, ctx.t.stopwords)) {
+      const r = creditsAfter(inner, spans, featLen, "featured", site, ctx);
+      return { kind: "feat", ...r };
+    }
+  }
+  const prod = ctx.t.producerMarkers.matchAt(words, 0);
+  if (prod) {
+    let len = prod.length;
+    if (words[len] !== void 0 && wordKey(words[len]) === "by") len++;
+    if (words.length > len) {
+      const r = creditsAfter(inner, spans, len, "producer", site, ctx);
+      return { kind: "producer", ...r };
+    }
+  }
+  return null;
+}
+function creditsAfter(inner, spans, markerWords2, role, site, ctx) {
+  const lastMarker = spans[markerWords2 - 1];
+  const firstName = spans[markerWords2];
+  const lead = inner.slice(spans[0].start, lastMarker.end);
+  return listFromText(inner.slice(firstName.start), site.pos + 1 + firstName.start, ctx, {
+    role,
+    source: site.source,
+    lead,
+    splitWith: false,
+    featMarkersJoin: role === "featured"
+  });
+}
+function listFromText(text, base, ctx, opts) {
+  return splitCredits(scan(text, base).skel, opts, ctx);
+}
+function flagOf(words) {
+  const key = words.map(wordKey).join(" ");
+  if (EXPLICIT_FLAGS.has(key)) return "explicit";
+  if (CLEAN_FLAGS.has(key)) return "clean";
+  return null;
+}
+function splitMultiParts(inner) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if ((ch === ")" || ch === "]" || ch === "}") && depth > 0) depth--;
+    else if (depth === 0 && ch === "/" && inner[i - 1] === " " && inner[i + 1] === " ") {
+      parts.push(inner.slice(start, i - 1));
+      start = i + 2;
+    } else if (depth === 0 && ch === ";" && inner[i + 1] === " ") {
+      parts.push(inner.slice(start, i));
+      start = i + 2;
+    }
+  }
+  parts.push(inner.slice(start));
+  return parts.map((p) => p.trim());
+}
+function multiVersion(inner, site, ctx) {
+  const parts = splitMultiParts(inner);
+  if (parts.length < 2) return null;
+  const out = [];
+  for (const part of parts) {
+    const v = part ? singleVersion(part, site, ctx) : null;
+    if (!v) return null;
+    out.push(...v);
+  }
+  return out;
+}
+function singleVersion(raw, site, ctx) {
+  const spans = wordSpans(raw);
+  const words = spans.map((s) => s.text);
+  const v = headBy(raw, spans, words, site, ctx) ?? headScan(raw, words, site, ctx);
+  const result = v ?? prefixForm(raw, words, site, ctx);
+  return result ? [result] : null;
+}
+function baseVersion(raw, type, site) {
+  return {
+    type,
+    raw,
+    artists: [],
+    modifiers: [],
+    descriptor: null,
+    year: null,
+    unknownArtist: false,
+    delimiter: site.delimiter,
+    pos: site.pos,
+    ambiguousMix: false,
+    prefixForm: false
+  };
+}
+function remixerOpts() {
+  return {
+    role: "remixer",
+    source: "version",
+    lead: null,
+    splitWith: false,
+    featMarkersJoin: false
+  };
+}
+function dedupRemixers(credits) {
+  const seen = /* @__PURE__ */ new Set();
+  return credits.filter((c) => {
+    const k = dedupKey(c.name);
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
+function setCredits(v, text, site, ctx) {
+  const r = listFromText(text, site.pos, ctx, remixerOpts());
+  v.artists = dedupRemixers(r.credits);
+  if (r.unknown) v.unknownArtist = true;
+  const dropped = r.years[0];
+  if (dropped) v.year ?? (v.year = dropped.year);
+}
+function headBy(raw, spans, words, site, ctx) {
+  const head = ctx.t.heads.matchAt(words, 0);
+  if (!head) return null;
+  const by = words[head.length];
+  const rest = spans[head.length + 1];
+  if (by === void 0 || wordKey(by) !== "by" || rest === void 0) return null;
+  const v = baseVersion(raw, head.entry.value, site);
+  setCredits(v, raw.slice(rest.start), site, ctx);
+  return v;
+}
+function collectRun(words, end, ctx) {
+  const items = [];
+  let j = end;
+  while (j > 0) {
+    const m = ctx.t.runWords.matchEnding(words, j);
+    if (m) {
+      items.unshift({ start: j - m.length, end: j, info: m.entry.value, year: null });
+      j -= m.length;
+      continue;
+    }
+    const year = yearOf(words[j - 1]);
+    if (year === null) break;
+    items.unshift({ start: j - 1, end: j, info: {}, year });
+    j--;
+  }
+  return items;
+}
+function headScan(raw, words, site, ctx) {
+  const head = ctx.t.heads.matchEnding(words, words.length);
+  if (!head) return null;
+  const headType = head.entry.value;
+  const headStart = words.length - head.length;
+  const run2 = collectRun(words, headStart, ctx);
+  const creditEnd = run2[0]?.start ?? headStart;
+  const creditWords = words.slice(0, creditEnd);
+  const left = run2[run2.length - 1];
+  const generic = ctx.t.genericHeadTypes.has(headType);
+  let type = headType;
+  let typeItem = null;
+  let viaMix = false;
+  const nearestHead = generic ? nearestNonGenericHead(run2, ctx) : null;
+  if (generic && left?.info.typeCapable) {
+    type = left.info.typeCapable;
+    typeItem = left;
+  } else if (nearestHead?.info.head) {
+    type = nearestHead.info.head;
+    typeItem = nearestHead;
+  } else if (headType === "mix" && creditWords.length > 0) {
+    type = "remix";
+    viaMix = true;
+  }
+  const v = baseVersion(raw, type, site);
+  const descriptors = [];
+  for (const item of run2) {
+    const text = words.slice(item.start, item.end).join(" ");
+    if (item.year !== null) {
+      v.year ?? (v.year = item.year);
+      continue;
+    }
+    const modifier = item.info.typeCapable ?? item.info.descriptor;
+    if (modifier !== void 0) {
+      if (item !== typeItem && !v.modifiers.includes(modifier)) v.modifiers.push(modifier);
+    } else if (item.info.genre) {
+      descriptors.push(text);
+    }
+  }
+  if (creditWords.length > 0) {
+    const credit = creditWords.join(" ");
+    const lastWord = asciiLower(creditWords[creditWords.length - 1]);
+    if (isUnknownToken(credit, ctx.t)) {
+      v.unknownArtist = true;
+    } else if (type === "version" || type === "cover" || isAllJunkPhrases(creditWords, ctx)) {
+      descriptors.unshift(credit);
+    } else {
+      const name = lastWord.endsWith("'s") ? credit.slice(0, -2) : credit;
+      setCredits(v, name, site, ctx);
+      const lastName = v.artists[v.artists.length - 1];
+      if (viaMix && lastName && splitWords(lastName.name).length >= 3) {
+        v.ambiguousMix = true;
+      }
+    }
+  }
+  v.descriptor = descriptors.length > 0 ? descriptors.join(" ") : null;
+  return v;
+}
+function nearestNonGenericHead(run2, ctx) {
+  for (let i = run2.length - 1; i >= 0; i--) {
+    const head = run2[i].info.head;
+    if (head !== void 0 && !ctx.t.genericHeadTypes.has(head)) return run2[i];
+  }
+  return null;
+}
+function isAllJunkPhrases(words, ctx) {
+  let i = 0;
+  while (i < words.length) {
+    const m = ctx.t.junkPhrases.matchAt(words, i);
+    if (!m) return false;
+    i += m.length;
+  }
+  return words.length > 0;
+}
+function prefixForm(raw, words, site, ctx) {
+  const m = ctx.t.prefixForms.matchAt(words, 0);
+  if (!m) return null;
+  const v = baseVersion(raw, m.entry.value, site);
+  v.prefixForm = true;
+  const rest = [];
+  for (const w of words.slice(m.length)) {
+    const year = v.year === null ? yearOf(w) : null;
+    if (year !== null) v.year = year;
+    else rest.push(w);
+  }
+  v.descriptor = rest.length > 0 ? rest.join(" ") : null;
+  return v;
+}
+
+// src/artists.ts
+function findFeatMarker(s, ctx, from = 0) {
+  const spans = wordSpans(s.text);
+  const words = spans.map((w) => w.text);
+  for (let i = 0; i < spans.length; i++) {
+    const span = spans[i];
+    if (!span || span.start < from) continue;
+    const before = s.text[span.start - 1];
+    if (before !== " " && before !== PH) continue;
+    const m = ctx.t.featMarkers.matchAt(words, i);
+    if (!m) continue;
+    const last = spans[i + m.length - 1];
+    if (!last || s.text[last.end] !== " ") continue;
+    return { start: span.start, end: last.end, marker: s.text.slice(span.start, last.end) };
+  }
+  return null;
+}
+function parseArtistSide(side, ctx) {
+  const result = {
+    credits: [],
+    junk: [],
+    years: [],
+    unknownArtist: false,
+    explicit: false,
+    clean: false
+  };
+  const removed = /* @__PURE__ */ new Set();
+  for (const { group } of groupsOf(side)) {
+    const site = { source: "artist", delimiter: group.open, pos: group.pos };
+    const c = classify(group.inner, site, ctx);
+    if (c.kind === "feat" || c.kind === "producer") {
+      result.credits.push(...c.credits);
+      result.years.push(...c.years);
+      if (c.unknown) result.unknownArtist = true;
+    } else if (c.kind === "flag") {
+      result[c.flag] = true;
+    } else if (c.kind === "year") {
+      result.years.push({ year: c.year, pos: group.pos });
+    } else if (c.kind === "junk") {
+      result.junk.push({ raw: group.inner, kind: c.junkKind, pos: group.pos });
+    } else {
+      continue;
+    }
+    removed.add(group.pos);
+  }
+  const text = removeGroups(side, removed);
+  const feat = findFeatMarker(text, ctx);
+  const main = feat ? trimSkel(sliceSkel(text, 0, feat.start)) : trimSkel(text);
+  const mainList = splitCredits(
+    main,
+    { role: "primary", source: "artist", lead: null, splitWith: true, featMarkersJoin: false },
+    ctx
+  );
+  result.credits.push(...mainList.credits);
+  result.years.push(...mainList.years);
+  if (mainList.unknown) result.unknownArtist = true;
+  if (feat) {
+    const featured = splitCredits(
+      trimSkel(sliceSkel(text, feat.end)),
+      {
+        role: "featured",
+        source: "artist",
+        lead: feat.marker,
+        splitWith: false,
+        featMarkersJoin: true
+      },
+      ctx
+    );
+    result.credits.push(...featured.credits);
+    result.years.push(...featured.years);
+    if (featured.unknown) result.unknownArtist = true;
+  }
+  result.credits.sort((a, b) => a.pos - b.pos);
+  return result;
+}
+
+// src/assemble.ts
+var PRECEDENCE = { primary: 2, featured: 1, producer: 0, remixer: 0 };
+function toArtist(c) {
+  return { name: c.name, role: c.role, joiner: c.joiner, source: c.source };
+}
+function passJoiner(entries, e, joiner) {
+  const members = entries.filter((x) => x.alive && x.list === e.list);
+  if (members[0] !== e) return;
+  const next = members[1];
+  if (next) next.a.joiner = joiner;
+}
+function dedupArtists(credits) {
+  const entries = credits.map((c, i) => ({
+    a: toArtist(c),
+    list: "list" in c ? c.list : -1 - i,
+    alive: true
+  }));
+  const index = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const key = `${e.a.role === "producer" ? "p" : "c"}:${dedupKey(e.a.name)}`;
+    const kept = index.get(key);
+    if (!kept) {
+      index.set(key, e);
+      continue;
+    }
+    if (PRECEDENCE[e.a.role] > PRECEDENCE[kept.a.role]) {
+      passJoiner(entries, kept, kept.a.joiner);
+      kept.a.role = e.a.role;
+      kept.a.joiner = e.a.joiner;
+      kept.a.source = e.a.source;
+      kept.list = e.list;
+      e.alive = false;
+    } else {
+      passJoiner(entries, e, e.a.joiner);
+      e.alive = false;
+    }
+  }
+  return entries.filter((e) => e.alive).map((e) => e.a);
+}
+function toVersion(v) {
+  return {
+    type: v.type,
+    raw: v.raw,
+    artists: v.artists.map(toArtist),
+    modifiers: [...v.modifiers],
+    descriptor: v.descriptor,
+    year: v.year,
+    unknownArtist: v.unknownArtist,
+    delimiter: v.delimiter
+  };
+}
+function renderVersion(v) {
+  switch (v.delimiter) {
+    case "(":
+      return `(${v.raw})`;
+    case "[":
+      return `[${v.raw}]`;
+    case "{":
+      return `{${v.raw}}`;
+    default:
+      return `- ${v.raw}`;
+  }
+}
+function fullTitleOf(title, versions) {
+  return [title, ...versions.map(renderVersion)].filter((s) => s.length > 0).join(" ");
+}
+function byPos(items) {
+  return [...items].sort((a, b) => a.pos - b.pos);
+}
+
+// src/mode.ts
+function stripPlatformSuffixes(s, ctx, junk) {
+  let str = s;
+  let stripped = true;
+  while (stripped) {
+    stripped = false;
+    const lower = asciiLower(str);
+    for (const suffix of ctx.t.platformSuffixes) {
+      if (!lower.endsWith(asciiLower(suffix))) continue;
+      const start = str.length - suffix.length;
+      junk.push({ raw: str.slice(start + 3), kind: "platform", pos: start + 3 });
+      str = str.slice(0, start);
+      stripped = true;
+      break;
+    }
+  }
+  return str;
+}
+function extensionOf(s, ctx) {
+  const dot = s.lastIndexOf(".");
+  if (dot < 0) return null;
+  const ext = asciiLower(s.slice(dot + 1));
+  return ctx.t.extensions.has(ext) ? ext : null;
+}
+function splitPipes(skel) {
+  const t = skel.text;
+  const cuts = [];
+  for (let i = 1; i < t.length; i++) {
+    if (t[i - 1] !== " " || t[i] !== "|") continue;
+    const bars = t[i + 1] === "|" ? 2 : 1;
+    if (t[i + bars] === " " && t[i + bars] !== void 0) {
+      cuts.push([i - 1, i + bars + 1]);
+      i += bars;
+    }
+  }
+  const segments = [];
+  let start = 0;
+  for (const [a, b] of [...cuts, [t.length, t.length]]) {
+    let s = start;
+    let e = a;
+    while (s < e && t[s] === " ") s++;
+    while (e > s && t[e - 1] === " ") e--;
+    segments.push({ skel: sliceSkel(skel, s, e), start: s, end: e });
+    start = b;
+  }
+  return segments;
+}
+function trailingJunkPhrase(text, ctx) {
+  const spans = wordSpans(text);
+  const m = ctx.t.junkPhrases.matchEnding(
+    spans.map((s) => s.text),
+    spans.length
+  );
+  if (!m) return null;
+  const first = spans[spans.length - m.length];
+  return first ? { start: first.start, kind: m.entry.value } : null;
+}
+function isJunkText(text, ctx) {
+  const words = splitWords(text);
+  return words.length > 0 ? junkKindOf(words, ctx) : null;
+}
+function looksLikeYoutube(skel, ctx) {
+  if (splitPipes(skel).length > 1) return true;
+  for (const { group } of groupsOf(skel)) {
+    const kind = isJunkText(group.inner, ctx);
+    if (kind && kind !== "genre") return true;
+  }
+  return trailingJunkPhrase(skel.text, ctx) !== null;
+}
+function prelude(normalized, requested, ctx) {
+  const junk = [];
+  let str = stripPlatformSuffixes(normalized, ctx, junk);
+  const hadPlatform = junk.length > 0;
+  let mode;
+  if (requested === "clean" || requested === "youtube" || requested === "filename" || requested === "tracklist") {
+    mode = requested;
+  } else if (extensionOf(str, ctx)) {
+    mode = "filename";
+  } else {
+    mode = "clean";
+  }
+  if (mode === "filename") {
+    if (extensionOf(str, ctx)) str = str.slice(0, str.lastIndexOf("."));
+    str = str.trim();
+    if (!str.includes(" ") && str.includes("_")) str = str.split("_").join(" ").trim();
+  }
+  const { skel, unbalanced } = scan(str, 0);
+  if (unbalanced) warn(ctx, "unbalancedBrackets");
+  if (requested === "auto" || requested === void 0) {
+    if (mode === "clean" && (hadPlatform || looksLikeYoutube(skel, ctx))) mode = "youtube";
+  }
+  const whole = { text: str, base: 0 };
+  if (mode !== "youtube") return { mode, working: whole, pipeTitle: null, junk };
+  return { mode, ...splitYoutubePipes(skel, ctx, junk), junk };
+}
+function pieceOf(seg) {
+  return { text: renderSkel(seg.skel), base: seg.skel.pos[0] ?? 0 };
+}
+function splitYoutubePipes(skel, ctx, junk) {
+  const segments = splitPipes(skel);
+  if (segments.length <= 1)
+    return { working: { text: renderSkel(skel), base: 0 }, pipeTitle: null };
+  const remaining = [];
+  for (const seg of segments) {
+    const text = collapseSpaces(renderSkel(seg.skel));
+    const kind = hasSpacedDash(seg.skel.text) ? null : isJunkText(text, ctx);
+    if (kind) junk.push({ raw: text, kind, pos: seg.skel.pos[0] ?? 0 });
+    else if (text.length > 0) remaining.push(seg);
+  }
+  const pushOther = (keep, title = null) => {
+    for (const seg of remaining) {
+      if (seg === keep || seg === title) continue;
+      junk.push({
+        raw: collapseSpaces(renderSkel(seg.skel)),
+        kind: "other",
+        pos: seg.skel.pos[0] ?? 0
+      });
+    }
+  };
+  const withDash = remaining.find((seg) => hasSpacedDash(seg.skel.text));
+  if (withDash) {
+    pushOther(withDash);
+    return { working: pieceOf(withDash), pipeTitle: null };
+  }
+  const [first, second] = remaining;
+  if (remaining.length === 2 && first && second) {
+    warn(ctx, "ambiguousSeparator");
+    return { working: pieceOf(first), pipeTitle: pieceOf(second) };
+  }
+  if (first) {
+    pushOther(first);
+    return { working: pieceOf(first), pipeTitle: null };
+  }
+  return { working: { text: "", base: 0 }, pipeTitle: null };
+}
+
+// src/normalize.ts
+var REMOVED = /* @__PURE__ */ new Set([8203, 8288, 65279, 173, 57344]);
+var CHAR_MAP = /* @__PURE__ */ new Map([
+  [65288, "("],
+  [65289, ")"],
+  [65339, "["],
+  [12304, "["],
+  [12308, "["],
+  [65341, "]"],
+  [12305, "]"],
+  [12309, "]"],
+  [65371, "{"],
+  [65373, "}"],
+  [8220, '"'],
+  [8221, '"'],
+  [8222, '"'],
+  [171, '"'],
+  [187, '"'],
+  [12300, '"'],
+  [12301, '"'],
+  [12302, '"'],
+  [12303, '"'],
+  [65282, '"'],
+  [8216, "'"],
+  [8217, "'"],
+  [8218, "'"],
+  [96, "'"],
+  [180, "'"],
+  [8722, "-"],
+  [65112, "-"],
+  [65123, "-"],
+  [65293, "-"]
+]);
+function mapChar(cp) {
+  if (REMOVED.has(cp)) return null;
+  if (cp >= 8208 && cp <= 8213) return "-";
+  return CHAR_MAP.get(cp) ?? String.fromCodePoint(cp);
+}
+function collapseSpacedDashRuns(chars) {
+  const out = [];
+  let i = 0;
+  while (i < chars.length) {
+    if (chars[i] !== "-") {
+      out.push(chars[i]);
+      i++;
+      continue;
+    }
+    let j = i;
+    while (chars[j] === "-") j++;
+    const before = chars[i - 1];
+    const after = chars[j];
+    const spaced = j - i >= 2 && before !== void 0 && after !== void 0 && isWhitespaceCode(before.codePointAt(0) ?? 0) && isWhitespaceCode(after.codePointAt(0) ?? 0);
+    if (spaced) out.push("-");
+    else for (let k = i; k < j; k++) out.push("-");
+    i = j;
+  }
+  return out;
+}
+function collapseWhitespace(chars) {
+  let out = "";
+  let pending = false;
+  for (const ch of chars) {
+    if (isWhitespaceCode(ch.codePointAt(0) ?? 0)) {
+      pending = out.length > 0;
+      continue;
+    }
+    if (pending) out += " ";
+    pending = false;
+    out += ch;
+  }
+  return out;
+}
+function normalize(input) {
+  if (typeof input !== "string") return "";
+  const chars = [];
+  for (const ch of input.normalize("NFC")) {
+    const mapped = mapChar(ch.codePointAt(0) ?? 0);
+    if (mapped !== null) chars.push(mapped);
+  }
+  return collapseWhitespace(collapseSpacedDashRuns(chars)).normalize("NFC");
+}
+
+// src/prefix.ts
+function matchTime(s, at) {
+  const lead = digitRun(s, at);
+  if (lead < 1 || lead > 2 || s[at + lead] !== ":") return null;
+  const first = Number(s.slice(at, at + lead));
+  const mid = twoDigitsUpTo59(s, at + lead + 1);
+  if (mid === null) return null;
+  const afterMid = at + lead + 3;
+  if (s[afterMid] === ":") {
+    const sec = twoDigitsUpTo59(s, afterMid + 1);
+    if (sec !== null) {
+      const end = afterMid + 3;
+      return { raw: s.slice(at, end), seconds: first * 3600 + mid * 60 + sec, end };
+    }
+  }
+  if (lead === 2 && first > 59) return null;
+  return { raw: s.slice(at, afterMid), seconds: first * 60 + mid, end: afterMid };
+}
+function skipSpaceAndDash(s, at) {
+  let i = at;
+  if (s[i] === " ") i++;
+  if (s[i] === "-" && s[i + 1] === " ") i += 2;
+  return i;
+}
+function matchTimestamp(s) {
+  const bracket = s[0] === "[" ? "]" : s[0] === "(" ? ")" : null;
+  const t = matchTime(s, bracket ? 1 : 0);
+  if (!t) return null;
+  let end = t.end;
+  if (bracket) {
+    if (s[end] !== bracket) return null;
+    end++;
+  }
+  if (end < s.length && s[end] !== " ") return null;
+  return { ts: { raw: t.raw, seconds: t.seconds }, end: skipSpaceAndDash(s, end) };
+}
+function containsSpacedDash(s) {
+  return hasSpacedDash(scan(s).skel.text);
+}
+function matchPosition(s, mode) {
+  const n = digitRun(s, 0);
+  if (n < 1 || n > 3) return null;
+  const c = s[n];
+  const zeroPadded = s[0] === "0" && n >= 2;
+  if ((c === "." || c === ")") && (s[n + 1] === " " || n + 1 === s.length)) {
+    return skipSpaceAndDash(s, n + 1);
+  }
+  if (zeroPadded && c === " ") return skipSpaceAndDash(s, n);
+  if (c === " " && s[n + 1] === "-" && s[n + 2] === " ") {
+    if (mode === "filename" || containsSpacedDash(s.slice(n + 3))) return n + 3;
+    return null;
+  }
+  if (mode === "filename") {
+    if ((c === "-" || c === "_" || c === ".") && s[n + 1] !== void 0 && s[n + 1] !== " ") {
+      return n + 1;
+    }
+    if (c === " " && !containsSpacedDash(s.slice(n + 1))) return skipSpaceAndDash(s, n);
+  }
+  return null;
+}
+function stripPrefixes(str, base, mode, ctx) {
+  let rest = str;
+  let offset = base;
+  let timestamp = null;
+  let position = null;
+  const ts = matchTimestamp(rest);
+  if (ts) {
+    timestamp = ts.ts;
+    rest = rest.slice(ts.end);
+    offset += ts.end;
+  }
+  if (matchKnownAt(rest, 0, ctx, "-") === 0) {
+    const end = matchPosition(rest, mode);
+    if (end !== null && end < rest.length) {
+      const raw = rest.slice(0, digitRun(rest, 0));
+      position = { raw, number: Number(raw) };
+      rest = rest.slice(end);
+      offset += end;
+    }
+  }
+  return { rest, base: offset, timestamp, position };
+}
+
+// src/separator.ts
+function classifySegment(seg, ctx) {
+  if (hasGroup(seg)) return { kind: "unknown" };
+  const text = collapseSpaces(seg.text);
+  return classify(text, { source: "title", delimiter: "-", pos: seg.pos[0] ?? 0 }, ctx);
+}
+function isPeelable(c) {
+  return c.kind === "junk" || c.kind === "flag" || c.kind === "year" || c.kind === "versions";
+}
+function peelSuffixes(segments, relaxed, ctx) {
+  const remaining = [...segments];
+  const peeled = [];
+  while (remaining.length >= 2) {
+    const last = remaining[remaining.length - 1];
+    const cls = classifySegment(last.skel, ctx);
+    if (!isPeelable(cls)) break;
+    const words = splitWords(last.skel.text);
+    const prefixForm2 = cls.kind === "versions" && cls.versions.every((v) => v.prefixForm);
+    const ok = relaxed || remaining.length - 1 >= 2 || words.length >= 2 && !prefixForm2 || words.some((w) => yearOf(w) !== null) || cls.kind === "junk";
+    if (!ok) break;
+    peeled.unshift({ cls, raw: collapseSpaces(last.skel.text), pos: last.skel.pos[0] ?? 0 });
+    remaining.pop();
+  }
+  return { remaining, peeled };
+}
+function nonEmpty(s) {
+  const t = trimSkel(s);
+  return t.text.length > 0 ? t : null;
+}
+function splitAt(s, cutStart, cutEnd) {
+  return { artist: nonEmpty(sliceSkel(s, 0, cutStart)), title: trimSkel(sliceSkel(s, cutEnd)) };
+}
+function findSeparator(input, ctx) {
+  const { skel, mode } = input;
+  const segments = splitAtSpacedDashes(skel, true);
+  if (mode === "tracklist")
+    return tracklistSeparator(skel, segments, input.listContext === true, ctx);
+  const { remaining, peeled } = peelSuffixes(segments, false, ctx);
+  if (remaining.length >= 2) {
+    const first = remaining[0];
+    const second = remaining[1];
+    const lastSeg = remaining[remaining.length - 1];
+    const artist2 = first.skel.text.length > 0 ? first.skel : null;
+    const title = sliceSkel(skel, second.start, lastSeg.end);
+    return { artist: artist2, title, split: artist2 !== null, peeled };
+  }
+  const rest = remaining[0].skel;
+  const other = splitWithoutSpacedDash(rest, mode, ctx);
+  if (other) return { ...other, split: other.artist !== null, peeled };
+  const artist = mode === "youtube" ? input.uploader : null;
+  if (rest.text.length > 0 && artist === null) warn(ctx, "noSeparator");
+  return { artist, title: rest, split: false, peeled };
+}
+function tracklistSeparator(skel, segments, listContext, ctx) {
+  if (segments.length >= 2) {
+    const first = segments[0];
+    const second = segments[1];
+    const lastSeg = segments[segments.length - 1];
+    const artist = first.skel.text.length > 0 ? first.skel : null;
+    const title = sliceSkel(skel, second.start, lastSeg.end);
+    return { artist, title, split: artist !== null, peeled: [] };
+  }
+  const rest = segments[0].skel;
+  const asym = asymmetricDash(rest.text);
+  if (asym >= 0) {
+    warn(ctx, "asymmetricDashSplit");
+    const parts = splitAt(rest, asym, asym + 1);
+    return { ...parts, split: parts.artist !== null, peeled: [] };
+  }
+  const underscore = rest.text.indexOf("_-_");
+  if (underscore >= 0) {
+    warn(ctx, "unspacedDashSplit");
+    const parts = splitAt(rest, underscore, underscore + 3);
+    return { ...parts, split: parts.artist !== null, peeled: [] };
+  }
+  if (listContext) {
+    const tight = tightUpperDash(rest.text);
+    if (tight >= 0) {
+      warn(ctx, "unspacedDashSplit");
+      const parts = splitAt(rest, tight, tight + 1);
+      return { ...parts, split: parts.artist !== null, peeled: [] };
+    }
+  }
+  if (rest.text.length > 0) warn(ctx, "noSeparator");
+  return { artist: null, title: rest, split: false, peeled: [] };
+}
+function tightUpperDash(t) {
+  for (let i = t.length - 2; i >= 1; i--) {
+    if (t[i] !== "-") continue;
+    if (isLetterBefore(t, i) && isUpperAt(t, i + 1)) return i;
+  }
+  return -1;
+}
+function splitWithoutSpacedDash(s, mode, ctx) {
+  const asym = asymmetricDash(s.text);
+  if (asym >= 0) {
+    warn(ctx, "asymmetricDashSplit");
+    return splitAt(s, asym, asym + 1);
+  }
+  if (mode === "youtube") {
+    const quoted = quotedTitle(s);
+    if (quoted) {
+      warn(ctx, "quotedTitleSplit");
+      return quoted;
+    }
+    const by = bySplit(s, ctx);
+    if (by >= 0) {
+      warn(ctx, "bySplit");
+      const parts = splitAt(s, by, by + 4);
+      return { artist: parts.title.text.length > 0 ? parts.title : null, title: parts.artist ?? s };
+    }
+  }
+  if (mode === "youtube" || mode === "filename") {
+    const dash = unspacedDash(s, ctx);
+    if (dash >= 0) {
+      warn(ctx, "unspacedDashSplit");
+      return splitAt(s, dash, dash + 1);
+    }
+  }
+  return null;
+}
+function asymmetricDash(t) {
+  for (let i = 1; i < t.length - 1; i++) {
+    if (t[i] !== "-") continue;
+    const left = isWhitespace(t[i - 1]);
+    const right = isWhitespace(t[i + 1]);
+    if (left !== right) return i;
+  }
+  return -1;
+}
+function quotedTitle(s) {
+  const t = s.text;
+  const open = t.indexOf('"');
+  if (open <= 0) return null;
+  const close = t.indexOf('"', open + 1);
+  if (close < 0) return null;
+  let artist = trimSkel(sliceSkel(s, 0, open));
+  const last = artist.text[artist.text.length - 1];
+  if (last === ":" || last === "-") artist = trimSkel(sliceSkel(artist, 0, artist.text.length - 1));
+  const title = trimSkel(concatSkel(sliceSkel(s, open + 1, close), sliceSkel(s, close + 1)));
+  return { artist: artist.text.length > 0 ? artist : null, title };
+}
+function bySplit(s, ctx) {
+  const t = s.text;
+  for (let i = t.lastIndexOf(" by "); i > 0; i = t.lastIndexOf(" by ", i - 1)) {
+    const right = splitWords(t.slice(i + 4)).filter((w) => w !== PH);
+    if (right.length === 0) continue;
+    if (right.length === 1 && inVocab(right[0], ctx.t.stopwords)) continue;
+    return i;
+  }
+  return -1;
+}
+function unspacedDash(s, ctx) {
+  const t = s.text;
+  let lastCandidate = -1;
+  for (let i = 1; i < t.length - 1; i++) {
+    if (t[i] !== "-" || isWhitespace(t[i - 1]) || isWhitespace(t[i + 1])) continue;
+    if (!(t[i + 1] === '"' || isLetterAt(t, i + 1))) continue;
+    if (ctx.knownKeys.size > 0 && isKnownArtist(renderSkel(sliceSkel(s, 0, i)), ctx)) return i;
+    lastCandidate = i;
+  }
+  return lastCandidate;
+}
+
+// src/title.ts
+function emptyExtracted() {
+  return {
+    credits: [],
+    versions: [],
+    junk: [],
+    years: [],
+    flags: { explicit: false, clean: false, unknownArtist: false }
+  };
+}
+function addPeeled(out, peeled) {
+  for (const p of peeled) {
+    const c = p.cls;
+    if (c.kind === "versions") out.versions.push(...c.versions);
+    else if (c.kind === "junk") out.junk.push({ raw: p.raw, kind: c.junkKind, pos: p.pos });
+    else if (c.kind === "flag") out.flags[c.flag] = true;
+    else out.years.push({ year: c.year, pos: p.pos });
+  }
+}
+function parseTitleSide(input, out, ctx) {
+  let skel = input.skel;
+  const removed = extractGroups(skel, out, ctx);
+  const segments = splitAtSpacedDashes(skel);
+  const { remaining, peeled } = peelSuffixes(segments, input.relaxed, ctx);
+  addPeeled(out, peeled);
+  const lastKept = remaining[remaining.length - 1];
+  skel = sliceSkel(skel, 0, lastKept.end);
+  skel = extractUnbracketedCredits(skel, out, ctx);
+  skel = removeGroups(skel, removed);
+  if (input.youtube) skel = stripTrailingJunk(skel, out, ctx);
+  const title = cleanupTitle(renderSkel(skel));
+  return { title, unknownTitle: title.length > 0 && isUnknownToken(title, ctx.t) };
+}
+function extractGroups(skel, out, ctx) {
+  const removed = /* @__PURE__ */ new Set();
+  for (const { group } of groupsOf(skel)) {
+    const site = { source: "title", delimiter: group.open, pos: group.pos };
+    const c = classify(group.inner, site, ctx);
+    switch (c.kind) {
+      case "versions":
+        out.versions.push(...c.versions);
+        break;
+      case "junk":
+        out.junk.push({ raw: group.inner, kind: c.junkKind, pos: group.pos });
+        break;
+      case "flag":
+        out.flags[c.flag] = true;
+        break;
+      case "year":
+        out.years.push({ year: c.year, pos: group.pos });
+        break;
+      case "feat":
+      case "producer":
+        out.credits.push(...c.credits);
+        out.years.push(...c.years);
+        if (c.unknown) out.flags.unknownArtist = true;
+        break;
+      case "unknown":
+        continue;
+    }
+    removed.add(group.pos);
+  }
+  return removed;
+}
+function titleMarkers(s, ctx) {
+  const spans = wordSpans(s.text);
+  const words = spans.map((w) => w.text);
+  const hits = [];
+  for (let i = 0; i < spans.length; i++) {
+    const span = spans[i];
+    if (s.text[span.start - 1] !== " ") continue;
+    let role = "featured";
+    let lastIndex = -1;
+    const feat = ctx.t.titleFeatMarkers.matchAt(words, i);
+    if (feat) {
+      lastIndex = i + feat.length - 1;
+    } else {
+      const prod = ctx.t.titleProducerMarkers.matchAt(words, i);
+      if (!prod) continue;
+      role = "producer";
+      lastIndex = i + prod.length - 1;
+    }
+    const last = spans[lastIndex];
+    if (s.text[last.end] !== " ") continue;
+    hits.push({
+      start: span.start,
+      end: last.end,
+      marker: s.text.slice(span.start, last.end),
+      role
+    });
+    i = lastIndex;
+  }
+  return hits;
+}
+function extractUnbracketedCredits(input, out, ctx) {
+  const markers = titleMarkers(input, ctx);
+  const cuts = [];
+  let i = 0;
+  while (i < markers.length) {
+    const hit = markers[i];
+    let listEnd = input.text.indexOf(PH, hit.end);
+    if (listEnd < 0) listEnd = input.text.length;
+    const other = markers.find((m, k) => k > i && m.role !== hit.role && m.start >= hit.end);
+    if (other && other.start < listEnd) listEnd = other.start;
+    const list = trimSkel(sliceSkel(input, hit.end, listEnd));
+    if (list.text.length > 0) {
+      const r = splitCredits(
+        list,
+        {
+          role: hit.role,
+          source: "title",
+          lead: hit.marker,
+          splitWith: false,
+          featMarkersJoin: hit.role === "featured"
+        },
+        ctx
+      );
+      out.credits.push(...r.credits);
+      out.years.push(...r.years);
+      if (r.unknown) out.flags.unknownArtist = true;
+      cuts.push([hit.start, listEnd]);
+    } else {
+      listEnd = hit.end;
+    }
+    while (i < markers.length && markers[i].start < listEnd) i++;
+  }
+  let skel = input;
+  for (const [start, end] of cuts.reverse()) skel = cutSkel(skel, start, end);
+  return skel;
+}
+function stripTrailingJunk(input, out, ctx) {
+  const skel = trimSkel(input);
+  const spans = wordSpans(skel.text);
+  const words = spans.map((s) => s.text);
+  let end = spans.length;
+  for (; ; ) {
+    const m = ctx.t.junkPhrases.matchEnding(words, end);
+    if (!m) break;
+    const first = end - m.length;
+    let keep = first;
+    if (keep > 0 && isLoneEdge(words[keep - 1])) keep--;
+    if (keep === 0) break;
+    const from = spans[first]?.start ?? 0;
+    const to = spans[end - 1]?.end ?? skel.text.length;
+    out.junk.push({
+      raw: collapseSpaces(skel.text.slice(from, to)),
+      kind: m.entry.value,
+      pos: skel.pos[from] ?? 0
+    });
+    end = keep;
+  }
+  if (end === spans.length) return skel;
+  return trimSkel(sliceSkel(skel, 0, spans[end - 1]?.end ?? 0));
+}
+function isLoneEdge(word) {
+  return word === "-" || word === "|";
+}
+function stripLoneEdges(s) {
+  const words = s.split(" ");
+  while (words.length > 0 && isLoneEdge(words[0])) words.shift();
+  while (words.length > 0 && isLoneEdge(words[words.length - 1])) words.pop();
+  return words.join(" ");
+}
+function cleanupTitle(raw) {
+  let title = stripLoneEdges(collapseSpaces(raw));
+  const q = title[0];
+  if (title.length >= 2 && (q === '"' || q === "'") && title[title.length - 1] === q) {
+    title = stripLoneEdges(collapseSpaces(title.slice(1, -1)));
+  }
+  return title;
+}
+
+// src/parser.ts
+var UPLOADER_BASE = -1e9;
+function emptyTrack(input, mode) {
+  return {
+    input,
+    mode,
+    position: null,
+    timestamp: null,
+    artists: [],
+    title: "",
+    fullTitle: "",
+    versions: [],
+    year: null,
+    flags: { explicit: false, clean: false, unknownArtist: false, unknownTitle: false },
+    junk: [],
+    warnings: []
+  };
+}
+function skelOf(piece, ctx) {
+  const r = scan(piece.text, piece.base);
+  if (r.unbalanced) warn(ctx, "unbalancedBrackets");
+  return trimSkel(r.skel);
+}
+function uploaderSkel(uploader) {
+  if (typeof uploader !== "string") return null;
+  let u = normalize(uploader);
+  if (u.endsWith(" - Topic")) u = u.slice(0, -" - Topic".length);
+  if (u.endsWith("VEVO")) u = u.slice(0, -"VEVO".length).trimEnd();
+  if (u.length === 0) return null;
+  return scan(u, UPLOADER_BASE).skel;
+}
+function stage(input, options, t) {
+  const ctx = makeCtx(t, options);
+  const norm = normalize(input);
+  const requested = options.mode ?? "auto";
+  const pre = prelude(norm, requested, ctx);
+  const track = emptyTrack(typeof input === "string" ? input : "", pre.mode);
+  if (norm.length === 0) {
+    return { ctx, options, pre, track, working: null };
+  }
+  const prefix = stripPrefixes(pre.working.text, pre.working.base, pre.mode, ctx);
+  track.timestamp = prefix.timestamp;
+  track.position = prefix.position;
+  const working = skelOf({ text: prefix.rest, base: prefix.base }, ctx);
+  return { ctx, options, pre, track, working };
+}
+function run(input, options, t, listContext = false) {
+  return finish(stage(input, options, t), listContext);
+}
+function finish(st, listContext) {
+  const { ctx, options, pre, track, working } = st;
+  if (working === null) return track;
+  const out = emptyExtracted();
+  let artistSkel;
+  let titleSkel;
+  let relaxed;
+  if (pre.pipeTitle) {
+    artistSkel = working.text.length > 0 ? working : null;
+    titleSkel = skelOf(pre.pipeTitle, ctx);
+    relaxed = artistSkel !== null;
+  } else {
+    const sep = findSeparator(
+      { skel: working, mode: pre.mode, uploader: uploaderSkel(options.uploader), listContext },
+      ctx
+    );
+    addPeeled(out, sep.peeled);
+    artistSkel = sep.artist;
+    titleSkel = sep.title;
+    relaxed = sep.split;
+  }
+  const artistSide = artistSkel ? parseArtistSide(artistSkel, ctx) : null;
+  const titleSide = parseTitleSide(
+    { skel: titleSkel, relaxed, youtube: pre.mode === "youtube" },
+    out,
+    ctx
+  );
+  const versions = byPos(out.versions);
+  for (const v of versions) if (v.ambiguousMix) warn(ctx, "ambiguousMixCredit");
+  track.artists = dedupArtists([...artistSide?.credits ?? [], ...byPos(out.credits)]);
+  track.title = titleSide.title;
+  track.versions = versions.map(toVersion);
+  track.fullTitle = fullTitleOf(track.title, track.versions);
+  const years = byPos([...artistSide?.years ?? [], ...out.years]);
+  track.year = years[0]?.year ?? null;
+  track.flags = {
+    explicit: out.flags.explicit || (artistSide?.explicit ?? false),
+    clean: out.flags.clean || (artistSide?.clean ?? false),
+    unknownArtist: (artistSide?.unknownArtist ?? false) || out.flags.unknownArtist,
+    unknownTitle: titleSide.unknownTitle
+  };
+  track.junk = byPos([...pre.junk, ...artistSide?.junk ?? [], ...out.junk]).map((j) => ({
+    raw: j.raw,
+    kind: j.kind
+  }));
+  track.warnings = ctx.warnings;
+  return track;
+}
+function runArtists(input, options, t) {
+  const ctx = makeCtx(t, options);
+  const norm = normalize(input);
+  if (norm.length === 0) return [];
+  const side = parseArtistSide(scan(norm, 0).skel, ctx);
+  return dedupArtists(side.credits).map((a) => ({ ...a, source: "artist" }));
+}
+function safeOptions(options) {
+  if (options === null || typeof options !== "object") return {};
+  return Object.fromEntries(
+    Object.entries(options).filter(([, v]) => v !== void 0)
+  );
+}
+function createParser(base = {}) {
+  const baseOptions = safeOptions(base);
+  const baseTables = tablesFor(baseOptions.keywords);
+  const resolve = (options) => {
+    const merged = { ...baseOptions, ...safeOptions(options) };
+    const tables = options?.keywords ? tablesFor(mergeKeywords(baseOptions, options)) : baseTables;
+    return { merged, tables };
+  };
+  return {
+    parse(input, options) {
+      const { merged, tables } = resolve(options);
+      return run(input, merged, tables);
+    },
+    parseArtists(input, options) {
+      const { merged, tables } = resolve(options);
+      return runArtists(input, merged, tables);
+    }
+  };
+}
+function probe(input, options, t) {
+  const st = stage(input, options, t);
+  return {
+    position: st.track.position !== null,
+    spacedDash: st.working !== null && !st.pre.pipeTitle && splitAtSpacedDashes(st.working, true).length >= 2,
+    empty: st.working === null,
+    finish: (listContext) => finish(st, listContext)
+  };
+}
+function createListParser(base) {
+  const options = safeOptions(base);
+  const tables = tablesFor(options.keywords);
+  return {
+    parse: (input, listContext) => run(input, options, tables, listContext),
+    probe: (input) => probe(input, options, tables)
+  };
+}
+function mergeKeywords(a, b) {
+  const x = isRecord(a.keywords) ? a.keywords : {};
+  const y = isRecord(b.keywords) ? b.keywords : {};
+  const map = (k) => Object.fromEntries([...stringEntries(x[k]), ...stringEntries(y[k])]);
+  const list = (k) => [...stringList(x[k]), ...stringList(y[k])];
+  return {
+    versionHeads: map("versionHeads"),
+    descriptors: list("descriptors"),
+    genres: list("genres"),
+    junk: map("junk"),
+    featMarkers: list("featMarkers")
+  };
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+createParser();
+
+// src/tracklist/kinds.ts
+var headerWords = new Set(headerWordsData.words);
+var defaultMarkers = null;
+function markerTable(extra) {
+  const more = stringList(extra);
+  const entry = (w) => [markerWords(w).join(" "), true];
+  if (more.length === 0) {
+    defaultMarkers ?? (defaultMarkers = new PhraseTable(markerWordsData.words.map(entry)));
+    return defaultMarkers;
+  }
+  return new PhraseTable([...markerWordsData.words, ...more].map(entry));
+}
+var isMarkerBreak = (ch) => ch === "/" || ch === "-" || isWhitespace(ch);
+var isBracket = (ch) => ch === "(" || ch === ")" || ch === "[" || ch === "]" || ch === "{" || ch === "}";
+function markerWords(text) {
+  const out = [];
+  let current = "";
+  const flush = () => {
+    let a = 0;
+    let b = current.length;
+    while (a < b && isBracket(current[a])) a++;
+    while (b > a && isBracket(current[b - 1])) b--;
+    if (b > a) out.push(current.slice(a, b));
+    current = "";
+  };
+  for (const ch of text) {
+    if (isMarkerBreak(ch)) flush();
+    else current += ch;
+  }
+  flush();
+  return out;
+}
+function isBlank(raw) {
+  for (let i = 0; i < raw.length; i++) if (!isWhitespace(raw[i])) return false;
+  return true;
+}
+function trimWs(s) {
+  let a = 0;
+  let b = s.length;
+  while (a < b && isWhitespace(s[a])) a++;
+  while (b > a && isWhitespace(s[b - 1])) b--;
+  return s.slice(a, b);
+}
+function isLink(rest) {
+  const t = asciiLower(trimWs(rest).slice(0, 8));
+  return t.startsWith("http://") || t.startsWith("https://") || t.startsWith("www.");
+}
+function isHeader(rest) {
+  const t = trimWs(rest);
+  if (t.endsWith(":")) return true;
+  const words = splitWords(t);
+  const first = words[0];
+  return first !== void 0 && words.length <= 2 && inVocab(first, headerWords);
+}
+function hasMarkerWord(trackPart, markers) {
+  const words = markerWords(trackPart);
+  for (let i = 0; i < words.length; i++) if (markers.matchAt(words, i)) return true;
+  return false;
+}
+function hasSeparator(track, empty) {
+  if (empty || track.warnings.includes("noSeparator")) return false;
+  return track.flags.unknownArtist || track.artists.some((a) => a.role === "primary");
+}
+
+// src/tracklist/options.ts
+var MODES = /* @__PURE__ */ new Set(["auto", "clean", "youtube", "filename", "tracklist"]);
+var SPLIT_AND = /* @__PURE__ */ new Set(["auto", "always", "never"]);
+function read(options, key) {
+  try {
+    return options[key];
+  } catch {
+    return void 0;
+  }
+}
+function resolveOptions(options) {
+  const o = typeof options === "object" && options !== null ? options : {};
+  const mode = read(o, "mode");
+  const splitAnd = read(o, "splitAnd");
+  const keywords = read(o, "keywords");
+  const known = read(o, "knownArtists");
+  const audio = read(o, "audioSeconds");
+  const parse = {
+    mode: typeof mode === "string" && MODES.has(mode) ? mode : "tracklist"
+  };
+  if (Array.isArray(known)) parse.knownArtists = known;
+  if (typeof splitAnd === "string" && SPLIT_AND.has(splitAnd)) {
+    parse.splitAnd = splitAnd;
+  }
+  if (typeof keywords === "object" && keywords !== null && !Array.isArray(keywords)) {
+    parse.keywords = keywords;
+  }
+  return {
+    parse,
+    audioSeconds: typeof audio === "number" && Number.isFinite(audio) && audio >= 0 ? audio : null,
+    markerWords: read(o, "markerWords")
+  };
+}
+
+// src/tracklist/positions.ts
+function bareCandidate(rest, positionTaken) {
+  if (positionTaken) return null;
+  const n = digitRun(rest, 0);
+  if (n < 1 || n > 3 || rest[n] !== " ") return null;
+  const stripped = rest.slice(n + 1);
+  for (let i = 0; i < stripped.length; i++) {
+    if (!isWhitespace(stripped[i])) {
+      const raw = rest.slice(0, n);
+      return { raw, number: Number(raw), stripped };
+    }
+  }
+  return null;
+}
+function confirmPositions(bare, candidateLine) {
+  const n = bare.length;
+  const prev = new Array(n).fill(-1);
+  const next = new Array(n).fill(-1);
+  let last = -1;
+  for (let i = 0; i < n; i++) {
+    prev[i] = last;
+    if (candidateLine[i]) last = i;
+  }
+  last = -1;
+  for (let i = n - 1; i >= 0; i--) {
+    next[i] = last;
+    if (candidateLine[i]) last = i;
+  }
+  const adjacent = (b, j) => {
+    const o = j >= 0 ? bare[j] : null;
+    return o != null && (o.number === b.number - 1 || o.number === b.number + 1);
+  };
+  return bare.map(
+    (b, i) => b !== null && (adjacent(b, prev[i]) || adjacent(b, next[i]))
+  );
+}
+
+// src/tracklist/warnings.ts
+var ORDER = [
+  "time-missing",
+  "time-out-of-order",
+  "time-duplicate",
+  "no-start-at-zero",
+  "time-after-audio-end",
+  "invalid-time",
+  "position-gap",
+  "position-duplicate",
+  "line-unparsed"
+];
+function searchTime(raw, lo, hi) {
+  let fracStart = raw.length;
+  for (let i = 0; i < raw.length; i++) {
+    if (raw[i] === "." || raw[i] === ",") {
+      fracStart = i;
+      break;
+    }
+  }
+  const frac = raw.slice(fracStart + 1);
+  const values = [0];
+  const slots = [];
+  for (let i = 0; i < fracStart; i++) {
+    const ch = raw[i];
+    if (ch === ":") values.push(0);
+    else if (isDigit(ch)) {
+      const f = values.length - 1;
+      values[f] = values[f] * 10 + Number(ch);
+      slots.push({ at: i, field: f, place: 0, digit: Number(ch) });
+    }
+  }
+  for (let k = slots.length - 1, place = 1, field2 = -1; k >= 0; k--) {
+    const slot = slots[k];
+    if (slot.field !== field2) {
+      field2 = slot.field;
+      place = 1;
+    }
+    slot.place = place;
+    place *= 10;
+  }
+  const mult = values.length === 3 ? [3600, 60, 1] : [60, 1];
+  const valueWith = (changes) => {
+    const v = [...values];
+    for (const [slot, d] of changes) {
+      v[slot.field] = v[slot.field] + (d - slot.digit) * slot.place;
+    }
+    let whole = 0;
+    for (let f = 0; f < v.length; f++) {
+      if (f > 0 && v[f] > 59) return null;
+      whole += v[f] * mult[f];
+    }
+    const t = secondsOf(whole, frac);
+    return (lo === null || lo < t) && (hi === null || t < hi) ? t : null;
+  };
+  const render = (changes) => {
+    const chars = [...raw];
+    for (const [slot, d] of changes) chars[slot.at] = String(d);
+    return chars.join("");
+  };
+  let found = null;
+  let count = 0;
+  for (const slot of slots) {
+    for (let d = 0; d <= 9; d++) {
+      if (d === slot.digit) continue;
+      const change = [[slot, d]];
+      if (valueWith(change) === null) continue;
+      count++;
+      found = change;
+    }
+  }
+  if (count === 0) {
+    for (let x = 0; x < slots.length && count < 2; x++) {
+      for (let y = x + 1; y < slots.length && count < 2; y++) {
+        const a = slots[x];
+        const b = slots[y];
+        for (let da = 0; da <= 9 && count < 2; da++) {
+          if (da === a.digit) continue;
+          for (let db = 0; db <= 9 && count < 2; db++) {
+            if (db === b.digit) continue;
+            const change = [
+              [a, da],
+              [b, db]
+            ];
+            if (valueWith(change) === null) continue;
+            count++;
+            found = change;
+          }
+        }
+      }
+    }
+  }
+  if (count === 0 || found === null) return { kind: "none" };
+  if (count > 1) return { kind: "many" };
+  return { kind: "one", time: { raw: render(found), seconds: valueWith(found) } };
+}
+function suggestFix(times, k) {
+  const cur = times[k];
+  const prev = times[k - 1];
+  const next = times[k + 1];
+  const own = searchTime(cur.time.raw, prev.time.seconds, next ? next.time.seconds : null);
+  if (own.kind === "one") return { line: cur.line, ...own.time };
+  if (own.kind === "many") return null;
+  const before = times[k - 2];
+  const back = searchTime(prev.time.raw, before ? before.time.seconds : null, cur.time.seconds);
+  return back.kind === "one" ? { line: prev.line, ...back.time } : null;
+}
+function tracklistWarnings(input) {
+  const { entries, invalid, unparsed, audioSeconds } = input;
+  const perLine = entries.map(() => []);
+  const add = (i, code, suggestion = null) => {
+    const line = entries[i].line;
+    const severity = code === "no-start-at-zero" ? "info" : "warning";
+    perLine[i].push({ code, line, severity, suggestion });
+  };
+  const timed = [];
+  entries.forEach((e, i) => {
+    if (e.time) timed.push(i);
+  });
+  entries.forEach((e, i) => {
+    if (e.kind === "track" && e.time === null && timed.length > 0) add(i, "time-missing");
+    if (invalid[i]) add(i, "invalid-time");
+    if (unparsed[i]) add(i, "line-unparsed");
+  });
+  const times = timed.map((i) => {
+    const e = entries[i];
+    return { line: e.line, time: e.time };
+  });
+  timed.forEach((i, k) => {
+    const t = times[k].time;
+    if (k === 0 && t.seconds !== 0) add(i, "no-start-at-zero");
+    if (k > 0) {
+      const p = times[k - 1].time.seconds;
+      if (t.seconds < p) add(i, "time-out-of-order", suggestFix(times, k));
+      else if (t.seconds === p) add(i, "time-duplicate");
+    }
+    if (audioSeconds !== null && t.seconds > audioSeconds) add(i, "time-after-audio-end");
+  });
+  let prevPos = null;
+  entries.forEach((e, i) => {
+    const pos = e.kind === "track" ? e.track?.position : null;
+    if (!pos) return;
+    if (prevPos !== null) {
+      if (pos.number === prevPos) add(i, "position-duplicate");
+      else if (pos.number !== prevPos + 1) add(i, "position-gap");
+    }
+    prevPos = pos.number;
+  });
+  const rank = (c) => ORDER.indexOf(c);
+  return perLine.flatMap((ws) => ws.sort((a, b) => rank(a.code) - rank(b.code)));
+}
+
+// src/tracklist/parse.ts
+function parseTracklist(text, options) {
+  const opts = resolveOptions(options);
+  const markers = markerTable(opts.markerWords);
+  const lines = splitLines(typeof text === "string" ? text : "");
+  const lp = createListParser(opts.parse);
+  const rows = lines.map((line) => {
+    const scan2 = scanTime(line.raw);
+    const blank = isBlank(line.raw);
+    const row = {
+      line,
+      scan: scan2,
+      blank,
+      candidate: false,
+      dash: false,
+      probe: null,
+      bare: null,
+      track: null,
+      separated: false,
+      marker: false
+    };
+    if (blank) return row;
+    const probe2 = lp.probe(scan2.parts.rest);
+    row.probe = probe2;
+    row.dash = probe2.spacedDash;
+    row.candidate = scan2.time !== null || row.dash;
+    row.bare = bareCandidate(scan2.parts.rest, probe2.position);
+    return row;
+  });
+  let candidates2 = 0;
+  let dashes = 0;
+  for (const r of rows) {
+    if (!r.candidate) continue;
+    candidates2++;
+    if (r.dash) dashes++;
+  }
+  const listContext = candidates2 > 0 && 2 * dashes >= candidates2;
+  const confirmed = confirmPositions(
+    rows.map((r) => r.bare),
+    rows.map((r) => r.candidate)
+  );
+  rows.forEach((r, i) => {
+    if (r.blank || !r.probe) return;
+    const bare = confirmed[i] ? r.bare : null;
+    const probe2 = bare ? lp.probe(bare.stripped) : r.probe;
+    r.marker = hasMarkerWord(bare ? bare.stripped : r.scan.parts.rest, markers);
+    const track = probe2.finish(listContext && r.scan.time !== null && !r.marker);
+    if (bare) track.position = { raw: bare.raw, number: bare.number };
+    r.track = track;
+    r.separated = hasSeparator(track, probe2.empty);
+  });
+  const entries = rows.map((r, i) => {
+    const kind = kindOf(r);
+    const keep = kind === "track" || kind === "marker";
+    return {
+      line: i + 1,
+      kind,
+      eol: r.line.eol,
+      raw: r.line.raw,
+      parts: r.scan.parts,
+      time: r.scan.time,
+      track: keep ? r.track : null
+    };
+  });
+  const warnings = tracklistWarnings({
+    entries,
+    invalid: rows.map((r) => r.scan.invalid),
+    // R13.7 line-unparsed: a track entry whose track part has no separator (R13.3).
+    unparsed: rows.map((r, i) => entries[i].kind === "track" && !r.separated),
+    audioSeconds: opts.audioSeconds
+  });
+  return { specVersion: SPEC_VERSION, entries, warnings, stats: statsOf(entries) };
+}
+function kindOf(r) {
+  if (r.blank || !r.track) return "blank";
+  const marker = !r.separated && r.marker;
+  if (r.scan.time) return marker ? "marker" : "track";
+  const rest = r.scan.parts.rest;
+  if (isLink(rest)) return "link";
+  if (isHeader(rest)) return "header";
+  if (marker) return "marker";
+  return r.separated ? "track" : "note";
+}
+function statsOf(entries) {
+  let tracks = 0;
+  let markers = 0;
+  let timed = 0;
+  let firstTime = null;
+  let lastTime = null;
+  for (const e of entries) {
+    if (e.kind === "track") tracks++;
+    if (e.kind === "marker") markers++;
+    if (e.time) {
+      timed++;
+      firstTime ?? (firstTime = e.time.seconds);
+      lastTime = e.time.seconds;
+    }
+  }
+  return { lines: entries.length, tracks, markers, timed, firstTime, lastTime };
+}
+
+exports.applyEdits = applyEdits;
+exports.parseTracklist = parseTracklist;