trackparse 0.2.1 → 0.3.1

package/dist/tracklist.js

@@ -0,0 +1,827 @@
+import { headerWordsData, createListParser, SPEC_VERSION, stringList, PhraseTable, markerWordsData, digitRun, isWhitespace, asciiLower, splitWords, inVocab, isDigit } from './chunk-3TS4DITR.js';
+
+// 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/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 scan = ctx.lines[index].scan;
+  if (!scan.style || !scan.time) throw new InvalidEdit();
+  const clamped = value < 0;
+  const f = formatTime(clamped ? 0 : value, scan.style, oneDigit);
+  if (!f) throw new InvalidEdit();
+  const p = scan.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/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 scan = scanTime(line.raw);
+    const blank = isBlank(line.raw);
+    const row = {
+      line,
+      scan,
+      blank,
+      candidate: false,
+      dash: false,
+      probe: null,
+      bare: null,
+      track: null,
+      separated: false,
+      marker: false
+    };
+    if (blank) return row;
+    const probe = lp.probe(scan.parts.rest);
+    row.probe = probe;
+    row.dash = probe.spacedDash;
+    row.candidate = scan.time !== null || row.dash;
+    row.bare = bareCandidate(scan.parts.rest, probe.position);
+    return row;
+  });
+  let candidates = 0;
+  let dashes = 0;
+  for (const r of rows) {
+    if (!r.candidate) continue;
+    candidates++;
+    if (r.dash) dashes++;
+  }
+  const listContext = candidates > 0 && 2 * dashes >= candidates;
+  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 probe = bare ? lp.probe(bare.stripped) : r.probe;
+    r.marker = hasMarkerWord(bare ? bare.stripped : r.scan.parts.rest, markers);
+    const track = probe.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, probe.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 };
+}
+
+export { applyEdits, parseTracklist };