trackparse 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2269 @@
+'use strict';
+
+// src/data.generated.ts
+var SPEC_VERSION = "0.1.0";
+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 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 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/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 ALPHABETIC = /^\p{Alphabetic}$/u;
+function isLetterAt(s, index) {
+  const cp = s.codePointAt(index);
+  if (cp === void 0) return false;
+  return ALPHABETIC.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/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/tables.ts
+function lowerKeys(list) {
+  return (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),
+    ...Object.entries(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),
+    ...Object.entries(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/format.ts
+function resolve(o) {
+  return {
+    feat: o?.feat ?? "source",
+    featMarker: o?.featMarker,
+    canonical: o?.joiners === "canonical",
+    versions: (o?.versions ?? "all") === "all",
+    producers: o?.producers ?? true,
+    position: o?.position ?? false
+  };
+}
+function isFeatMarker(raw, t) {
+  return t.featMarkers.matchAt([raw], 0) !== null || t.bracketOnlyFeat.matchAt([raw], 0) !== null;
+}
+function canonicalJoiner(raw, t, featLead = false) {
+  if (featLead && isFeatMarker(raw, t)) return t.featCanonical;
+  const tight = t.tightJoiners.get(raw);
+  if (tight !== void 0) return tight;
+  for (const j of t.spacedJoiners) {
+    if (j.caseSensitive ? raw === j.raw : wordMatches(raw, j.raw)) return j.canonical;
+  }
+  return isFeatMarker(raw, t) ? t.featCanonical : raw;
+}
+function joinSep(joiner, o, t) {
+  const j = joiner === null ? "&" : o.canonical ? canonicalJoiner(joiner, t) : joiner;
+  return t.tightJoiners.has(j) ? `${j} ` : ` ${j} `;
+}
+function joinNames(list, o, t) {
+  return list.map((a, i) => i === 0 ? a.name : joinSep(a.joiner, o, t) + a.name).join("");
+}
+function leadMarker(first, o, t, fallback) {
+  if (o.featMarker !== void 0) return o.featMarker;
+  const raw = first.joiner ?? fallback;
+  return o.canonical ? canonicalJoiner(raw, t, true) : raw;
+}
+function format(track, options) {
+  const t = getDefaultTables();
+  const o = resolve(options);
+  const artists = Array.isArray(track?.artists) ? track.artists : [];
+  const primaries = artists.filter((a) => a.role === "primary");
+  const featured = artists.filter((a) => a.role === "featured");
+  const producers = artists.filter((a) => a.role === "producer");
+  let artistFeat = [];
+  let titleFeat = [];
+  if (o.feat === "source") {
+    artistFeat = featured.filter((a) => a.source === "artist");
+    titleFeat = featured.filter((a) => a.source !== "artist");
+  } else if (o.feat === "artist") {
+    artistFeat = featured;
+  } else if (o.feat === "title") {
+    titleFeat = featured;
+  }
+  let artistPart = joinNames(primaries, o, t);
+  const artistFeatFirst = artistFeat[0];
+  if (artistFeatFirst) {
+    const lead = leadMarker(artistFeatFirst, o, t, t.featCanonical);
+    const names = joinNames(artistFeat, o, t);
+    artistPart = artistPart ? `${artistPart} ${lead} ${names}` : `${lead} ${names}`;
+  }
+  const pieces = [];
+  if (track?.title) pieces.push(track.title);
+  const titleFeatFirst = titleFeat[0];
+  if (titleFeatFirst) {
+    const lead = leadMarker(titleFeatFirst, o, t, t.featCanonical);
+    pieces.push(`(${lead} ${joinNames(titleFeat, o, t)})`);
+  }
+  if (o.versions) for (const v of track?.versions ?? []) pieces.push(renderVersion(v));
+  const producerFirst = producers[0];
+  if (o.producers && producerFirst) {
+    const marker = producerFirst.joiner ?? "prod.";
+    pieces.push(`(${marker} ${joinNames(producers, o, t)})`);
+  }
+  const titlePart = pieces.join(" ");
+  let result = artistPart ? `${artistPart} - ${titlePart}` : titlePart;
+  if (o.position && track?.position) result = `${track.position.raw}. ${result}`;
+  return result;
+}
+function allArtists(track) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const all = [...track?.artists ?? [], ...(track?.versions ?? []).flatMap((v) => v.artists)];
+  for (const a of all) {
+    const key = dedupKey(a.name);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(a);
+  }
+  return out;
+}
+
+// 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/context.ts
+function makeCtx(t, options) {
+  const known = (options?.knownArtists ?? []).filter((k) => typeof k === "string");
+  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, remove) {
+  if (remove.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 && remove.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, markerWords, role, site, ctx) {
+  const lastMarker = spans[markerWords - 1];
+  const firstName = spans[markerWords];
+  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/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") {
+    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/prefix.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;
+}
+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);
+  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 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) {
+  let skel = trimSkel(input);
+  for (; ; ) {
+    const hit = trailingJunkPhrase(skel.text, ctx);
+    if (!hit) return skel;
+    let before = trimSkel(sliceSkel(skel, 0, hit.start));
+    const lastChar = before.text[before.text.length - 1];
+    const lone = before.text.length === 1 || before.text[before.text.length - 2] === " ";
+    if ((lastChar === "-" || lastChar === "|") && lone) {
+      before = trimSkel(sliceSkel(before, 0, before.text.length - 1));
+    }
+    if (before.text.length === 0) return skel;
+    const raw = collapseSpaces(skel.text.slice(hit.start));
+    out.junk.push({ raw, kind: hit.kind, pos: skel.pos[hit.start] ?? 0 });
+    skel = before;
+  }
+}
+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 run(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 track;
+  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);
+  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) },
+      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 resolve2 = (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 } = resolve2(options);
+      return run(input, merged, tables);
+    },
+    parseArtists(input, options) {
+      const { merged, tables } = resolve2(options);
+      return runArtists(input, merged, tables);
+    }
+  };
+}
+function mergeKeywords(a, b) {
+  const x = a.keywords ?? {};
+  const y = b.keywords ?? {};
+  return {
+    versionHeads: { ...x.versionHeads, ...y.versionHeads },
+    descriptors: [...x.descriptors ?? [], ...y.descriptors ?? []],
+    genres: [...x.genres ?? [], ...y.genres ?? []],
+    junk: { ...x.junk, ...y.junk },
+    featMarkers: [...x.featMarkers ?? [], ...y.featMarkers ?? []]
+  };
+}
+var defaultParser = createParser();
+function parse(input, options) {
+  return defaultParser.parse(input, options);
+}
+function parseArtists(input, options) {
+  return defaultParser.parseArtists(input, options);
+}
+
+exports.SPEC_VERSION = SPEC_VERSION;
+exports.allArtists = allArtists;
+exports.createParser = createParser;
+exports.format = format;
+exports.normalize = normalize;
+exports.parse = parse;
+exports.parseArtists = parseArtists;