@ugfoundation/swaralipi-js 0.1.0

package/dist/chunk-N3NNWAOW.js

@@ -0,0 +1,593 @@
+import { swaralipiSchema, SPEC_VERSION } from './chunk-C6O7DYU5.js';
+import { TAALS } from './chunk-GWXI2HJA.js';
+
+// src/convert/codec.ts
+var LETTERS = {
+  s: { letter: "s" },
+  r: { letter: "r" },
+  g: { letter: "g" },
+  m: { letter: "m" },
+  p: { letter: "p" },
+  q: { letter: "d" },
+  // ধ — shuddha dha
+  n: { letter: "n" },
+  d: { letter: "d", komal: true },
+  // দ
+  t: { letter: "g", komal: true },
+  // জ্ঞ
+  k: { letter: "m", tivra: true },
+  // ক্ষ
+  u: { letter: "n", komal: true },
+  // ণ
+  v: { letter: "r", komal: true }
+  // ঋ
+};
+var STRUCTURALS = {
+  "%": () => ({ svara: ["madhyam", "s"] }),
+  // precomposed সা
+  "&": () => ({ svara: ["madhyam", "n"] })
+  // precomposed নি
+};
+var BAR_RUN_RE = /^(-)?([lLA[\]]+)$/;
+function decodeBarRun(body) {
+  const m = body.match(BAR_RUN_RE);
+  if (!m || !/[lLA]/.test(m[2])) return void 0;
+  const notes = [];
+  if (m[1]) notes.push({ sustain: true });
+  const run = m[2];
+  let i = 0;
+  while (i < run.length) {
+    const ch = run[i];
+    if (ch === "l" || ch === "L") {
+      let j = i;
+      while (j < run.length && run[j] === ch) j++;
+      const strokes = (j - i) * (ch === "L" ? 2 : 1);
+      notes.push({ bar: strokes >= 4 ? "quad" : strokes >= 2 ? "double" : "single" });
+      i = j;
+    } else if (ch === "A") {
+      notes.push({ bar: "dari" });
+      i++;
+    } else {
+      notes.push({ brackets: [{ kind: "alt", edge: ch === "[" ? "open" : "close" }] });
+      i++;
+    }
+  }
+  return notes;
+}
+var KNOWN_RAW_RE = [
+  /^[wxyjEJ$<>=_]+$/,
+  // arc & line drawing segments
+  /^\|+$/,
+  // thin yugal-dari stop mark
+  /^[0-9!@#]{1,2}[fF]?:?$/,
+  // beat-number labels incl. 10–16 (sam tick = f/F, e.g. 1f / 1F / 2:)
+  /^[oOe`+,.;:iI~^*bcBCWXYFHZz'"?]$/
+  // dots, ticks, duration marks, legacy forms
+];
+var OPEN_BRACKETS = {
+  "{": "repeat",
+  "(": "skip",
+  "[": "alt"
+};
+var CLOSE_BRACKETS = {
+  "}": "repeat",
+  ")": "skip",
+  "]": "alt"
+};
+function octaveOf(mark) {
+  if (mark === "f" || mark === "F") return "taar";
+  if (mark === "h" || mark === "H") return "mandra";
+  return "madhyam";
+}
+var BODY_RE = /^([0-9!@][fF]?)?([zj]*)(-)?([i:])?(?:([SRGMPQNDTKUV])([fFhH])?)?((?:[srgmpqndtkuv][fh]?[i:]?)+)?(a)?([fh])?([i:])?(?:([SRGMPQNDTKUV])([fFhH])?)?([0-9!@][fF]?)?(-)?$/;
+function decodeChunk(chunk) {
+  const opens = [];
+  const closes = [];
+  let body = chunk;
+  while (body.length > 0) {
+    const kind = OPEN_BRACKETS[body[0]];
+    if (kind === void 0) break;
+    opens.push(kind);
+    body = body.slice(1);
+  }
+  while (body.length > 0) {
+    const kind = CLOSE_BRACKETS[body[body.length - 1]];
+    if (kind === void 0) break;
+    closes.unshift(kind);
+    body = body.slice(0, -1);
+  }
+  const finish = (notes, kind) => {
+    if (notes.length === 0) notes.push({});
+    const first = notes[0];
+    const last = notes[notes.length - 1];
+    if (opens.length > 0) first.brackets = [...opens.map((kind_) => ({ kind: kind_, edge: "open" })), ...first.brackets ?? []];
+    if (closes.length > 0) last.brackets = [...last.brackets ?? [], ...closes.map((kind_) => ({ kind: kind_, edge: "close" }))];
+    return { notes, kind };
+  };
+  if (body === "") return finish([{}], "decoded");
+  const barRun = decodeBarRun(body);
+  if (barRun) return finish(barRun, "decoded");
+  const structural = STRUCTURALS[body];
+  if (structural) return finish([structural()], "decoded");
+  if (KNOWN_RAW_RE.some((re) => re.test(body))) return finish([{}], "known");
+  const m = body.match(BODY_RE);
+  if (m) {
+    const [, , , hyphen, , kanLetter, kanOct, unitsStr, aakar, postOct, , trailKan, trailKanOct] = m;
+    const attachKan = (note, letter, oct) => {
+      const def = LETTERS[letter.toLowerCase()];
+      note.kan = [octaveOf(oct?.toLowerCase()), def.letter];
+    };
+    if (unitsStr) {
+      const units = unitsStr.match(/[srgmpqndtkuv][fh]?/g) ?? [];
+      const notes = units.map((unit) => {
+        const def = LETTERS[unit[0]];
+        const note = { svara: [octaveOf(unit[1]), def.letter] };
+        if (def.komal) note.komal = true;
+        if (def.tivra) note.tivra = true;
+        if (units.length > 1) note.durationMatra = 1 / units.length;
+        return note;
+      });
+      const last = notes[notes.length - 1];
+      if (postOct && last.svara[0] === "madhyam") {
+        last.svara = [octaveOf(postOct), last.svara[1]];
+      }
+      if (hyphen) notes[0].sustain = true;
+      if (kanLetter) attachKan(notes[0], kanLetter, kanOct);
+      if (trailKan && last.kan === void 0) attachKan(last, trailKan, trailKanOct);
+      return finish(notes, "decoded");
+    }
+    if (aakar) {
+      const note = hyphen ? { sustain: true } : { rest: true };
+      if (trailKan) attachKan(note, trailKan, trailKanOct);
+      else if (kanLetter) attachKan(note, kanLetter, kanOct);
+      return finish([note], "decoded");
+    }
+    if (hyphen && !kanLetter && !trailKan) {
+      return finish([{ sustain: true }], "decoded");
+    }
+  }
+  return finish([{}], "unknown");
+}
+function decodeCell(text) {
+  const chunks = text.split(/\s+/).filter((c) => c.length > 0);
+  const out = { notes: [], unknownTokens: [], knownRawTokens: [], decoded: false };
+  for (const chunk of chunks) {
+    const { notes, kind } = decodeChunk(chunk);
+    notes[0].raw = chunk;
+    if (kind === "decoded") out.decoded = true;
+    else if (kind === "known") out.knownRawTokens.push(chunk);
+    else out.unknownTokens.push(chunk);
+    out.notes.push(...notes);
+  }
+  return out;
+}
+
+// src/convert/grid.ts
+var ROLES = ["above", "notation", "below", "lyric"];
+function buildSystems(page) {
+  const warnings = [];
+  const byIndex = /* @__PURE__ */ new Map();
+  let styleMismatches = 0;
+  for (const cell of page.cells) {
+    if (cell.text === "") continue;
+    const role = ROLES[cell.row % 4];
+    const expected = role === "lyric" ? "style2" : "style1";
+    if (cell.style !== expected) styleMismatches++;
+    const index = Math.floor(cell.row / 4);
+    let system = byIndex.get(index);
+    if (!system) {
+      system = {
+        index,
+        above: /* @__PURE__ */ new Map(),
+        notation: /* @__PURE__ */ new Map(),
+        below: /* @__PURE__ */ new Map(),
+        lyric: /* @__PURE__ */ new Map(),
+        maxCol: 0
+      };
+      byIndex.set(index, system);
+    }
+    system[role].set(cell.col, cell.text);
+    if (cell.col > system.maxCol) system.maxCol = cell.col;
+  }
+  if (styleMismatches > 0) {
+    warnings.push(`${styleMismatches} cell(s) had an unexpected style class for their row role`);
+  }
+  const systems = [...byIndex.values()].sort((a, b) => a.index - b.index);
+  return { systems, warnings };
+}
+
+// src/convert/taal-map.ts
+var BN_DIGIT_MAP = {
+  "\u09E6": "0",
+  "\u09E7": "1",
+  "\u09E8": "2",
+  "\u09E9": "3",
+  "\u09EA": "4",
+  "\u09EB": "5",
+  "\u09EC": "6",
+  "\u09ED": "7",
+  "\u09EE": "8",
+  "\u09EF": "9"
+};
+function bnInt(s) {
+  if (s === void 0) return void 0;
+  const ascii = s.trim().replace(/[০-৯]/g, (d) => BN_DIGIT_MAP[d] ?? d);
+  return /^\d+$/.test(ascii) ? Number(ascii) : void 0;
+}
+var BN_TAAL_MAP = {
+  \u09A6\u09BE\u09A6\u09B0\u09BE: "dadra",
+  \u0995\u09BE\u09B9\u09BE\u09B0\u09AC\u09BE: "kehrwa",
+  \u098F\u0995\u09A4\u09BE\u09B2\u09BE: "ektaal",
+  \u098F\u0995\u09A4\u09BE\u09B2: "ektaal",
+  \u09A4\u09BF\u09A8\u09A4\u09BE\u09B2\u09BE: "teentaal",
+  \u09A4\u09CD\u09B0\u09BF\u09A4\u09BE\u09B2: "teentaal",
+  \u099D\u09BE\u0981\u09AA\u09A4\u09BE\u09B2: "jhaptaal",
+  \u099D\u09BE\u0981\u09AA: "jhaptaal",
+  \u09B0\u09C1\u09AA\u0995: "rupak",
+  \u09B0\u09C2\u09AA\u0995: "rupak",
+  \u0986\u09A1\u09BC\u09BE\u099A\u09CC\u09A4\u09BE\u09B2: "adachautaal"
+};
+var BN_TAAL_DEFS = {
+  \u09A4\u09C7\u0993\u09A1\u09BC\u09BE: { id: "teora", numBeats: 7, bhaags: [3, 2, 2], sam: 0 },
+  \u09A4\u09C7\u0993\u09B0\u09BE: { id: "teora", numBeats: 7, bhaags: [3, 2, 2], sam: 0 },
+  \u099D\u09AE\u09CD\u09AA\u0995: { id: "jhampak", numBeats: 5, bhaags: [3, 2], sam: 0 },
+  \u09B7\u09B7\u09CD\u09A0\u09C0: { id: "shashthi", numBeats: 6, bhaags: [2, 4], sam: 0 },
+  \u09B0\u09C1\u09AA\u0995\u09A1\u09BC\u09BE: { id: "rupakda", numBeats: 8, bhaags: [3, 2, 3], sam: 0 },
+  \u09B0\u09C2\u09AA\u0995\u09A1\u09BC\u09BE: { id: "rupakda", numBeats: 8, bhaags: [3, 2, 3], sam: 0 },
+  \u09A8\u09AC\u09A4\u09BE\u09B2: { id: "nabataal", numBeats: 9, bhaags: [5, 4], sam: 0 },
+  \u098F\u0995\u09BE\u09A6\u09B6\u09C0: { id: "ekadashi", numBeats: 11, bhaags: [3, 4, 4], sam: 0 },
+  \u09A8\u09AC\u09AA\u099E\u09CD\u099A: { id: "nabapancha", numBeats: 18, bhaags: [2, 4, 4, 4, 4], sam: 0 },
+  \u09A7\u09BE\u09AE\u09BE\u09B0: { id: "dhamar", numBeats: 14, bhaags: [3, 2, 2, 3, 4], sam: 0 },
+  \u099A\u09CC\u09A4\u09BE\u09B2: { id: "choutaal", numBeats: 12, bhaags: [2, 2, 2, 2, 2, 2], sam: 0 },
+  \u09B8\u09C1\u09B0\u09AB\u09BE\u0981\u0995: { id: "surphank", numBeats: 10, sam: 0 }
+};
+var BN_TAAL_IDS = {
+  \u0995\u09BE\u0993\u09AF\u09BC\u09BE\u09B2\u09BF: "kawali",
+  \u0996\u09C7\u09AE\u099F\u09BE: "khemta",
+  \u0986\u09A1\u09BC\u09BE\u09A0\u09C7\u0995\u09BE: "araatheka",
+  \u0995\u09BE\u09B6\u09CD\u09AE\u09C0\u09B0\u09BF: "kashmiri",
+  "\u09AF\u09CE": "yat",
+  \u09AE\u09A7\u09CD\u09AF\u09AE\u09BE\u09A8: "madhyaman",
+  \u0985\u09B0\u09CD\u09A6\u09CD\u09A7\u099D\u09BE\u0981\u09AA: "ardhajhanp",
+  \u0985\u09B0\u09CD\u09A7\u099D\u09BE\u0981\u09AA: "ardhajhanp",
+  "\u09AC\u09BF\u09B2\u09AE\u09CD\u09AC\u09BF\u09A4 \u09A4\u09CD\u09B0\u09BF\u09A4\u09BE\u09B2": "vilambit-teentaal"
+};
+var TAAL_FREE = "\u09A4\u09BE\u09B2\u09AE\u09C1\u0995\u09CD\u09A4";
+var BAR_TOKENS = /* @__PURE__ */ new Set(["l", "ll", "lll", "llll", "L", "LL", "|"]);
+var DARI_TOKEN = "A";
+function deriveGeometry(systems) {
+  let numCols = 0;
+  for (const system of systems) {
+    if (system.notation.size === 0) continue;
+    const cols = [...system.notation.keys()].sort((a, b) => a - b);
+    numCols = Math.max(numCols, cols.length);
+    const barCols = cols.filter((c) => BAR_TOKENS.has(system.notation.get(c)));
+    if (barCols.length < 2) continue;
+    const from = barCols[0];
+    const to = barCols[1];
+    const inner = cols.filter((c) => c > from && c < to);
+    if (inner.length === 0) continue;
+    const bhaags = [];
+    let run = 0;
+    for (const c of inner) {
+      if (system.notation.get(c) === DARI_TOKEN) {
+        if (run > 0) bhaags.push(run);
+        run = 0;
+      } else {
+        run++;
+      }
+    }
+    if (run > 0) bhaags.push(run);
+    const numBeats = bhaags.reduce((a, b) => a + b, 0);
+    if (numBeats === 0) continue;
+    return { numCols: cols.length, numBeats, bhaags: bhaags.length > 1 ? bhaags : void 0 };
+  }
+  return numCols > 0 ? { numCols } : void 0;
+}
+function resolveTaal(nameRaw, avartanRaw, geometry) {
+  const warnings = [];
+  const avartan = bnInt(avartanRaw);
+  const taalName = nameRaw?.trim() || void 0;
+  if (!taalName || taalName === TAAL_FREE) {
+    return { taalName, avartan, matched: "none", warnings };
+  }
+  const parenMatch = taalName.match(/^(.*?)\s*\(([০-৯\d/\s]+)\)\s*$/);
+  const base = (parenMatch ? parenMatch[1] : taalName).trim();
+  let hintBhaags;
+  if (parenMatch) {
+    const parts = parenMatch[2].split("/").map((p) => bnInt(p));
+    if (parts.every((p) => p !== void 0) && parts.length > 0) {
+      hintBhaags = parts;
+    }
+  }
+  const akhandaMatch = base.match(/^অখন্ড\s+([০-৯\d]+)\s*মাত্রা$/);
+  let taal;
+  let matched = "none";
+  const mappedId = BN_TAAL_MAP[base];
+  if (mappedId) {
+    taal = { ...TAALS[mappedId] };
+    matched = "taals";
+  } else if (BN_TAAL_DEFS[base]) {
+    taal = { ...BN_TAAL_DEFS[base] };
+    matched = "table";
+  } else if (akhandaMatch) {
+    const beats = bnInt(akhandaMatch[1]);
+    if (beats) {
+      taal = { id: `akhanda-${beats}`, numBeats: beats, sam: 0 };
+      matched = "table";
+    }
+  }
+  const hintBeats = hintBhaags?.reduce((a, b) => a + b, 0);
+  if (taal) {
+    if (hintBeats !== void 0 && hintBeats !== taal.numBeats) {
+      warnings.push(
+        `taal ${taal.id}: name declares ${hintBeats} beats (${hintBhaags.join("/")}), table says ${taal.numBeats} \u2014 using the name's`
+      );
+      taal = { id: taal.id, numBeats: hintBeats, sam: 0 };
+      if (hintBhaags.length > 1) taal.bhaags = hintBhaags;
+    } else if (hintBhaags && hintBhaags.length > 1) {
+      const tableBhaags = taal.bhaags?.join("/");
+      if (tableBhaags && tableBhaags !== hintBhaags.join("/")) {
+        warnings.push(
+          `taal ${taal.id}: name declares bhaags ${hintBhaags.join("/")}, table says ${tableBhaags} \u2014 using the name's`
+        );
+        const { khaali: _khaali, ...rest } = taal;
+        taal = { ...rest, bhaags: hintBhaags };
+      }
+    }
+  } else if (hintBeats !== void 0 || geometry?.numBeats !== void 0) {
+    const evidenceBeats = hintBeats ?? geometry?.numBeats;
+    const evidenceBhaags = hintBhaags ?? geometry?.bhaags;
+    taal = { id: BN_TAAL_IDS[base] ?? base, numBeats: evidenceBeats, sam: 0 };
+    if (evidenceBhaags && evidenceBhaags.length > 1) taal.bhaags = evidenceBhaags;
+    matched = "geometry";
+  } else {
+    warnings.push(`unresolved taal name: ${taalName}`);
+  }
+  if (taal && geometry?.numBeats !== void 0 && geometry.numBeats !== taal.numBeats) {
+    warnings.push(
+      `grid geometry says ${geometry.numBeats} beats per cycle but taal ${taal.id} has ${taal.numBeats}`
+    );
+  }
+  return { taal, taalName, avartan, matched, warnings };
+}
+
+// src/convert/assemble.ts
+var segmenter = new Intl.Segmenter("bn", { granularity: "grapheme" });
+function splitLyric(text) {
+  return [...segmenter.segment(text)].map((s) => s.segment);
+}
+function assemble(page, opts = {}) {
+  const { systems, warnings } = buildSystems(page);
+  const geometry = deriveGeometry(systems);
+  const resolved = resolveTaal(page.header.taalNameRaw, page.header.avartanRaw, geometry);
+  warnings.push(...resolved.warnings);
+  const report = {
+    nltrId: opts.nltrId,
+    title: page.header.title ?? "",
+    taalName: resolved.taalName,
+    taalId: resolved.taal?.id,
+    taalMatched: resolved.matched,
+    systems: 0,
+    notationCells: 0,
+    lyricCells: 0,
+    annotationCells: 0,
+    decodedCells: 0,
+    knownRawCells: 0,
+    unknownCells: 0,
+    unknownTokens: {},
+    lyricAlignMismatches: 0,
+    warnings
+  };
+  const countUnknown = (tokens) => {
+    for (const t of tokens) report.unknownTokens[t] = (report.unknownTokens[t] ?? 0) + 1;
+  };
+  const rows = [];
+  for (const system of systems) {
+    const notes = [];
+    for (let col = 0; col <= system.maxCol; col++) {
+      const notationText = system.notation.get(col);
+      const lyricText = system.lyric.get(col);
+      const aboveText = system.above.get(col);
+      const belowText = system.below.get(col);
+      if (notationText === void 0 && lyricText === void 0 && aboveText === void 0 && belowText === void 0) {
+        continue;
+      }
+      let cellNotes;
+      if (notationText !== void 0) {
+        report.notationCells++;
+        const decode = decodeCell(notationText);
+        countUnknown(decode.unknownTokens);
+        if (decode.unknownTokens.length > 0) report.unknownCells++;
+        else if (decode.decoded) report.decodedCells++;
+        else report.knownRawCells++;
+        cellNotes = decode.notes;
+      } else {
+        cellNotes = [{}];
+      }
+      if (lyricText !== void 0) {
+        report.lyricCells++;
+        attachLyric(cellNotes, lyricText, report);
+      }
+      if (aboveText !== void 0) {
+        report.annotationCells++;
+        const decode = decodeCell(aboveText);
+        countUnknown(decode.unknownTokens);
+        cellNotes[0].above = decode.notes;
+      }
+      if (belowText !== void 0) {
+        report.annotationCells++;
+        const decode = decodeCell(belowText);
+        countUnknown(decode.unknownTokens);
+        cellNotes[0].below = decode.notes;
+      }
+      notes.push(...cellNotes);
+    }
+    if (notes.length > 0) {
+      rows.push({ notes });
+      report.systems++;
+    }
+  }
+  const meta = { title: page.header.title ?? `NLTR ${opts.nltrId ?? "song"}` };
+  if (opts.nltrId !== void 0) meta.nltrId = opts.nltrId;
+  if (resolved.taal) meta.taal = resolved.taal;
+  if (resolved.taalName) meta.taalName = resolved.taalName;
+  if (resolved.avartan !== void 0) meta.avartan = resolved.avartan;
+  const source = opts.source ?? (opts.nltrId !== void 0 ? `https://rabindra-rachanabali.nltr.org/node/${opts.nltrId}` : page.header.printId !== void 0 ? `https://rabindra-rachanabali.nltr.org/node/${page.header.printId}` : void 0);
+  if (source) meta.source = source;
+  const doc = swaralipiSchema.parse({ version: SPEC_VERSION, meta, parts: [{ rows }] });
+  return { doc, report };
+}
+function attachLyric(cellNotes, lyricText, report) {
+  if (cellNotes.length > 1) {
+    const clusters = splitLyric(lyricText);
+    if (clusters.length === cellNotes.length) {
+      clusters.forEach((cluster, i) => {
+        cellNotes[i].lyric = cluster;
+      });
+      return;
+    }
+    report.lyricAlignMismatches++;
+  }
+  cellNotes[0].lyric = lyricText;
+}
+
+// src/convert/extract.ts
+var ExtractError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ExtractError";
+  }
+};
+var NAMED_ENTITIES = {
+  nbsp: "\xA0",
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'"
+};
+function decodeEntities(s) {
+  return s.replace(/&(?:#x([0-9a-fA-F]+)|#(\d+)|([a-zA-Z]+));/g, (m, hex, dec, name) => {
+    if (hex) return String.fromCodePoint(parseInt(hex, 16));
+    if (dec) return String.fromCodePoint(parseInt(dec, 10));
+    return NAMED_ENTITIES[name] ?? m;
+  });
+}
+function normalizeCellText(s) {
+  return decodeEntities(s).replace(/\p{Cf}/gu, "").replace(/[\s ]+/gu, " ").trim().normalize("NFC");
+}
+var CELL_RE = /<td width='auto' id=["']?(\d+)\.(\d+)["']?\s*>\s*<span class='(style\d)'><div align='(?:center|left|right)'>([\s\S]*?)<\/div><\/span><\/td>/g;
+var META_ROW_RE = /<tr><td><div align='left'><span class='style3'>([^<]*)<\/span><\/div><\/td><td><div align='left'><span class='style3'>:<\/span><\/div><\/td><td><div align='left'><span class='style3'>([^<]*)<\/span><\/div><\/td><\/tr>/g;
+function extractPage(html) {
+  const header = {};
+  for (const m of html.matchAll(META_ROW_RE)) {
+    const label = normalizeCellText(m[1]);
+    const value = normalizeCellText(m[2]);
+    if (label === "\u09A8\u09BE\u09AE") header.title = value;
+    else if (label === "\u09A4\u09BE\u09B2") header.taalNameRaw = value;
+    else if (label === "\u0986\u09AC\u09B0\u09CD\u09A4\u09A8") header.avartanRaw = value;
+  }
+  const printMatch = html.match(/\/print\/(\d+)/);
+  if (printMatch) header.printId = Number(printMatch[1]);
+  const cells = [];
+  let maxRow = 0;
+  for (const m of html.matchAll(CELL_RE)) {
+    const row = Number(m[1]);
+    const col = Number(m[2]);
+    cells.push({ row, col, style: m[3], text: normalizeCellText(m[4]) });
+    if (row > maxRow) maxRow = row;
+  }
+  const tdCount = (html.match(/<td width='auto' id=/g) ?? []).length;
+  if (cells.length !== tdCount) {
+    throw new ExtractError(
+      `grid cell mismatch: matched ${cells.length} cells but found ${tdCount} '<td width=' openers`
+    );
+  }
+  if (cells.length === 0) throw new ExtractError("no swaralipi grid cells found");
+  if (header.title === void 0) throw new ExtractError("no \u09A8\u09BE\u09AE metadata row found");
+  return { header, cells, maxRow };
+}
+
+// src/convert/report.ts
+function aggregate(reports, failures) {
+  const out = {
+    files: reports.length + failures.length,
+    ok: reports.length,
+    failed: failures.length,
+    failures,
+    systems: 0,
+    notationCells: 0,
+    lyricCells: 0,
+    annotationCells: 0,
+    decodedCells: 0,
+    knownRawCells: 0,
+    unknownCells: 0,
+    decodeRate: 0,
+    unknownRate: 0,
+    unknownTokens: {},
+    lyricAlignMismatches: 0,
+    taals: {},
+    warningCounts: {}
+  };
+  const unknown = /* @__PURE__ */ new Map();
+  for (const r of reports) {
+    out.systems += r.systems;
+    out.notationCells += r.notationCells;
+    out.lyricCells += r.lyricCells;
+    out.annotationCells += r.annotationCells;
+    out.decodedCells += r.decodedCells;
+    out.knownRawCells += r.knownRawCells;
+    out.unknownCells += r.unknownCells;
+    out.lyricAlignMismatches += r.lyricAlignMismatches;
+    for (const [tok, n] of Object.entries(r.unknownTokens)) {
+      unknown.set(tok, (unknown.get(tok) ?? 0) + n);
+    }
+    const taalKey = r.taalName ?? "<none>";
+    const taalEntry = out.taals[taalKey] ??= { count: 0, taalId: r.taalId, matched: r.taalMatched };
+    taalEntry.count++;
+    for (const w of r.warnings) {
+      const shape = w.replace(/\d+/g, "N");
+      out.warningCounts[shape] = (out.warningCounts[shape] ?? 0) + 1;
+    }
+  }
+  out.unknownTokens = Object.fromEntries([...unknown.entries()].sort((a, b) => b[1] - a[1]));
+  if (out.notationCells > 0) {
+    out.decodeRate = out.decodedCells / out.notationCells;
+    out.unknownRate = out.unknownCells / out.notationCells;
+  }
+  return out;
+}
+function formatSummary(r) {
+  const pct = (x) => `${(x * 100).toFixed(2)}%`;
+  const lines = [
+    `files: ${r.ok}/${r.files} converted${r.failed ? ` (${r.failed} FAILED)` : ""}`,
+    `systems: ${r.systems}  notation cells: ${r.notationCells}  lyric cells: ${r.lyricCells}  annotation cells: ${r.annotationCells}`,
+    `decoded: ${r.decodedCells} (${pct(r.decodeRate)})  known-raw: ${r.knownRawCells}  unknown: ${r.unknownCells} (${pct(r.unknownRate)})`,
+    `lyric alignment fallbacks: ${r.lyricAlignMismatches}`
+  ];
+  const unknowns = Object.entries(r.unknownTokens);
+  if (unknowns.length > 0) {
+    lines.push(`unknown tokens (${unknowns.length} distinct, top 20):`);
+    for (const [tok, n] of unknowns.slice(0, 20)) lines.push(`  ${String(n).padStart(6)}  ${JSON.stringify(tok)}`);
+  }
+  const taalLines = Object.entries(r.taals).sort((a, b) => b[1].count - a[1].count);
+  lines.push(`taals (${taalLines.length} distinct):`);
+  for (const [name, info] of taalLines.slice(0, 15)) {
+    lines.push(`  ${String(info.count).padStart(5)}  ${name} \u2192 ${info.taalId ?? "\u2014"} [${info.matched}]`);
+  }
+  if (r.failed > 0) {
+    lines.push("failures:");
+    for (const f of r.failures.slice(0, 10)) lines.push(`  ${f.file}: ${f.error}`);
+  }
+  return lines.join("\n");
+}
+
+// src/convert/index.ts
+function convertNltrHtml(html, opts = {}) {
+  return assemble(extractPage(html), opts);
+}
+
+export { ExtractError, aggregate, assemble, bnInt, buildSystems, convertNltrHtml, decodeCell, deriveGeometry, extractPage, formatSummary, resolveTaal, splitLyric };
+//# sourceMappingURL=chunk-N3NNWAOW.js.map
+//# sourceMappingURL=chunk-N3NNWAOW.js.map