@ugfoundation/swaralipi-js 0.11.1 → 0.13.0

package/dist/viewer/index.cjs

@@ -70,8 +70,10 @@ var init_taals = __esm({
       // ঝম্পক
       dhamaar: { id: "dhamaar", numBeats: 14, bhaags: [5, 2, 3, 4], sam: 0, khaali: [7] },
       // ধামার
-      rupakra: { id: "rupakra", numBeats: 8, bhaags: [3, 2, 3], sam: 0 }
+      rupakra: { id: "rupakra", numBeats: 8, bhaags: [3, 2, 3], sam: 0 },
       // রূপকড়া
+      khemta: { id: "khemta", numBeats: 12, bhaags: [3, 3, 3, 3], sam: 0, khaali: [6] }
+      // খেমটা
     };
     TAAL_FERTA = "\u09A4\u09BE\u09B2\u09AB\u09C7\u09B0\u09A4\u09BE";
   }
@@ -284,7 +286,7 @@ var init_spec = __esm({
     init_grace();
     init_lay();
     init_svara();
-    SPEC_VERSION = "0.11.1";
+    SPEC_VERSION = "0.13.0";
   }
 });
 
@@ -366,9 +368,305 @@ function sampleFileName(midi) {
   return midiToSampleName(midi).toLowerCase().replace("#", "s");
 }
 
-// src/player/schedule.ts
+// 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/player/repeats.ts
 var UNDECODED_CELL = /[srgmpqnvtduka]/i;
 var isSilent = (n) => n.svara === void 0 && n.rest !== true && n.sustain !== true && !(n.raw !== void 0 && UNDECODED_CELL.test(n.raw));
+var STOP_MARK = /^\|+$/;
+var EPS = 1e-6;
+var edges = (n, kind, edge) => n.brackets?.filter((b) => b.kind === kind && b.edge === edge).length ?? 0;
+var sounds = (n) => n.svara !== void 0 || n.rest === true || n.sustain === true;
+var matra = (notes) => notes.reduce((sum, n) => sum + (n.durationMatra ?? 1), 0);
+function playOrder(doc) {
+  const tokens = [];
+  doc.parts.forEach(
+    (part, p) => part.rows.forEach(
+      (row, r) => row.notes.forEach((note, i) => tokens.push({ p, r, i, note, timed: note.bar === void 0 && !isSilent(note) }))
+    )
+  );
+  const { asthayi, stop, returns } = form(tokens);
+  const changed = changedNotes(tokens);
+  const out = [];
+  const sing = (lo, hi, useChanged) => {
+    const repeats = [];
+    let owed = 0;
+    for (let k = lo; k < hi; ) {
+      const t = tokens[k];
+      if (edges(t.note, "repeat", "open") > 0 && repeats.at(-1)?.open !== k) repeats.push({ open: k, again: false });
+      const again = repeats.at(-1)?.again === true;
+      const skipTo = again && edges(t.note, "skip", "open") > 0 ? skipEnd(tokens, k, hi) : -1;
+      if (skipTo >= 0) {
+        if (edges(tokens[skipTo].note, "repeat", "close") > 0) repeats.pop();
+        k = skipTo + 1;
+        owed = 0;
+        continue;
+      }
+      if (owed > EPS && t.timed) owed -= matra([t.note]);
+      else {
+        const sub = useChanged || again ? changed.get(k) : void 0;
+        const fits = sub !== void 0 && matra(sub) >= matra([t.note]) - EPS;
+        for (const note of fits ? sub : [t.note]) out.push({ p: t.p, r: t.r, i: t.i, note });
+        owed = fits ? matra(sub) - matra([t.note]) : 0;
+      }
+      const loop = edges(t.note, "repeat", "close") > 0 ? repeats.at(-1) : void 0;
+      if (loop !== void 0 && !loop.again) {
+        loop.again = true;
+        k = loop.open;
+        owed = 0;
+        continue;
+      }
+      if (loop !== void 0) repeats.pop();
+      k++;
+    }
+  };
+  let from = 0;
+  for (const ret of returns) {
+    sing(from, ret.resume, false);
+    sing(asthayi, stop + 1, ret.changed);
+    from = ret.resume;
+  }
+  sing(from, tokens.length, false);
+  return out;
+}
+function form(tokens) {
+  const first = /* @__PURE__ */ new Map();
+  const last = /* @__PURE__ */ new Map();
+  tokens.forEach((t, k) => {
+    if (!t.timed) return;
+    const row = `${t.p}.${t.r}`;
+    if (!first.has(row)) first.set(row, k);
+    last.set(row, k);
+  });
+  const opens = [];
+  let opening = false;
+  tokens.forEach((t, k) => {
+    if (t.note.bar !== "double") return;
+    const row = `${t.p}.${t.r}`;
+    const before = (first.get(row) ?? Infinity) < k;
+    const after = (last.get(row) ?? -1) > k;
+    opening = before !== after ? after : !opening;
+    if (opening) opens.push(k);
+  });
+  const returns = [];
+  for (let k = 0; k < tokens.length; k++) {
+    let at = -1;
+    let open = false;
+    let changed = false;
+    let end = false;
+    for (; k < tokens.length && !tokens[k].timed; k++) {
+      const n = tokens[k].note;
+      if (n.bar === "quad") end = true;
+      if (n.bar === "double" && !opens.includes(k)) at = k;
+      if (edges(n, "alt", "open") > 0) open = true;
+      if (open && edges(n, "alt", "close") > 0) {
+        at = k;
+        changed = true;
+      }
+    }
+    if (at >= 0 && !end) returns.push({ resume: at + 1, changed });
+  }
+  const top = opens[0];
+  const asthayi = top !== void 0 && top < (returns[0]?.resume ?? Infinity) ? top : 0;
+  const asthayiEnd = Math.min(returns[0]?.resume ?? Infinity, opens.find((k) => k > asthayi) ?? Infinity, tokens.length);
+  const lastSung = tokens.reduce((last2, t, k) => t.timed ? k : last2, -1);
+  const stop = tokens.findIndex(
+    (t, k) => k >= asthayi && k < asthayiEnd && k < lastSung && t.note.above?.some((a) => STOP_MARK.test(a.raw ?? "")) === true
+  );
+  if (stop < 0) return { asthayi, stop, returns: [] };
+  const atClose = returns[0]?.resume === asthayiEnd && !tokens.slice(stop + 1, asthayiEnd).some((t) => t.timed);
+  return { asthayi, stop, returns: atClose ? returns.slice(1) : returns };
+}
+function changedNotes(tokens) {
+  const out = /* @__PURE__ */ new Map();
+  let row = "";
+  let inside = false;
+  tokens.forEach((t, k) => {
+    if (row !== `${t.p}.${t.r}`) {
+      row = `${t.p}.${t.r}`;
+      inside = false;
+    }
+    const notes = [];
+    for (const above of t.note.above ?? []) {
+      const read = above.raw !== void 0 && !sounds(above) && above.brackets === void 0;
+      for (const a of read ? decodeCell(above.raw).notes : [above]) {
+        if (edges(a, "alt", "open") > 0) inside = true;
+        if (inside && sounds(a)) notes.push(a);
+        if (edges(a, "alt", "close") > 0) inside = false;
+      }
+    }
+    if (notes.length > 0) out.set(k, notes);
+  });
+  return out;
+}
+function skipEnd(tokens, k, hi) {
+  for (let depth = 0, j = k; j < hi; j++) {
+    depth += edges(tokens[j].note, "skip", "open") - edges(tokens[j].note, "skip", "close");
+    if (depth <= 0) return j;
+  }
+  return -1;
+}
+
+// src/player/schedule.ts
 var ARC_RAW_RE = /^[wWxXyYjJeEzZ$=_<>`\\]+$/;
 var isArcRaw = (raw) => raw !== void 0 && ARC_RAW_RE.test(raw);
 var MEEND_MARKS = { start: "w", end: "x", both: "xw" };
@@ -412,67 +710,76 @@ function buildSchedule(doc, opts = {}) {
   let cursor = 0;
   let lastPitched = -1;
   let samMatra;
-  let matra = 0;
+  let matra2 = 0;
   const speeds = resolveLaySpeeds(doc.meta.laySpeeds, opts.laySpeeds);
   const withLay = opts.lay !== false;
   const tempo = [{ beat: 0, endBeat: 0, scale: 1, lay: "drut", taal: doc.meta.taal }];
+  const rows = /* @__PURE__ */ new Map();
   let scale = 1;
+  let layNow = "drut";
   let taal = doc.meta.taal;
-  doc.parts.forEach((part, p) => {
-    part.rows.forEach((row, r) => {
+  doc.parts.forEach(
+    (part, p) => part.rows.forEach((row, r) => {
       const lay = withLay ? rowLay(row) : void 0;
-      const layChanged = lay !== void 0 && speeds[lay] !== scale;
-      const nextTaal = row.taal !== void 0 ? row.taal : taal;
-      if (layChanged || !sameTaal(nextTaal, taal)) {
-        if (layChanged) scale = speeds[lay];
-        taal = nextTaal;
-        const last = tempo[tempo.length - 1];
-        const seg = { beat: cursor, endBeat: cursor, scale, lay: layChanged ? lay : last.lay, taal };
+      if (lay !== void 0 && speeds[lay] !== scale) {
+        scale = speeds[lay];
+        layNow = lay;
+      }
+      if (row.taal !== void 0) taal = row.taal;
+      rows.set(`${p}.${r}`, { scale, lay: layNow, taal, glides: meendContinuations(row.notes) });
+    })
+  );
+  const visits = opts.repeats === true ? playOrder(doc) : doc.parts.flatMap((part, p) => part.rows.flatMap((row, r) => row.notes.map((note, i) => ({ p, r, i, note }))));
+  let rowNow = "";
+  for (const { p, r, i, note } of visits) {
+    const row = rows.get(`${p}.${r}`);
+    if (rowNow !== `${p}.${r}`) {
+      rowNow = `${p}.${r}`;
+      const last = tempo[tempo.length - 1];
+      if (row.scale !== last.scale || !sameTaal(row.taal, last.taal)) {
+        const seg = { beat: cursor, endBeat: cursor, scale: row.scale, lay: row.lay, taal: row.taal };
         if (last.beat === cursor) tempo[tempo.length - 1] = seg;
         else {
           last.endBeat = cursor;
           tempo.push(seg);
         }
       }
-      const glides = meendContinuations(row.notes);
-      row.notes.forEach((note, i) => {
-        if (samMatra === void 0 && note.above !== void 0) {
-          for (const a of note.above) {
-            if (a.raw !== void 0 && SAM_TICK.test(a.raw)) {
-              samMatra = matra;
-              break;
-            }
-          }
-        }
-        if (note.bar !== void 0 || isSilent(note)) return;
-        const path = `${p}.${r}.${i}`;
-        const written = note.durationMatra ?? 1;
-        const dur = written / scale;
-        const kan = graceMidis(note.kan, tonicPc, baseOctave);
-        const resh = graceMidis(note.resh, tonicPc, baseOctave);
-        if (note.svara !== void 0) {
-          events.push({
-            beat: cursor,
-            durationBeats: dur,
-            midi: svaraToMidi(note, tonicPc, baseOctave),
-            kan,
-            resh,
-            path,
-            kind: note.sustain === true ? "sustain" : "note",
-            ...glides.has(i) && lastPitched >= 0 ? { glide: true } : {}
-          });
-          lastPitched = events.length - 1;
-        } else if (note.sustain === true) {
-          if (lastPitched >= 0) events[lastPitched].durationBeats += dur;
-          events.push({ beat: cursor, durationBeats: dur, midi: null, kan, resh, path, kind: "sustain" });
-        } else {
-          events.push({ beat: cursor, durationBeats: dur, midi: null, kan, resh, path, kind: "rest" });
+    }
+    if (samMatra === void 0 && note.above !== void 0) {
+      for (const a of note.above) {
+        if (a.raw !== void 0 && SAM_TICK.test(a.raw)) {
+          samMatra = matra2;
+          break;
         }
-        cursor += dur;
-        matra += written;
+      }
+    }
+    if (note.bar !== void 0 || isSilent(note)) continue;
+    const path = `${p}.${r}.${i}`;
+    const written = note.durationMatra ?? 1;
+    const dur = written / row.scale;
+    const kan = graceMidis(note.kan, tonicPc, baseOctave);
+    const resh = graceMidis(note.resh, tonicPc, baseOctave);
+    if (note.svara !== void 0) {
+      events.push({
+        beat: cursor,
+        durationBeats: dur,
+        midi: svaraToMidi(note, tonicPc, baseOctave),
+        kan,
+        resh,
+        path,
+        kind: note.sustain === true ? "sustain" : "note",
+        ...row.glides.has(i) && lastPitched >= 0 ? { glide: true } : {}
       });
-    });
-  });
+      lastPitched = events.length - 1;
+    } else if (note.sustain === true) {
+      if (lastPitched >= 0) events[lastPitched].durationBeats += dur;
+      events.push({ beat: cursor, durationBeats: dur, midi: null, kan, resh, path, kind: "sustain" });
+    } else {
+      events.push({ beat: cursor, durationBeats: dur, midi: null, kan, resh, path, kind: "rest" });
+    }
+    cursor += dur;
+    matra2 += written;
+  }
   const numBeats = tempo[0].taal?.numBeats;
   const pickupMatra = samMatra !== void 0 && numBeats !== void 0 && numBeats > 0 ? (numBeats - samMatra % numBeats) % numBeats : 0;
   tempo[tempo.length - 1].endBeat = cursor;
@@ -564,8 +871,8 @@ function localizeDigits(s, lang) {
 }
 
 // src/viewer/render.ts
-var EPS = 1e-6;
-var isIntegral = (x) => Math.abs(x - Math.round(x)) < EPS;
+var EPS2 = 1e-6;
+var isIntegral = (x) => Math.abs(x - Math.round(x)) < EPS2;
 function escapeHtml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
@@ -606,7 +913,7 @@ function groupRowIntoCells(notes) {
     cur ??= { kind: "group", start: i, notes: [] };
     cur.notes.push(note);
     acc += d;
-    if (note.halfMatra === true || acc > EPS && isIntegral(acc)) close();
+    if (note.halfMatra === true || acc > EPS2 && isIntegral(acc)) close();
   });
   close();
   return mergeStructural(absorbBrackets(cells));
@@ -629,15 +936,15 @@ function absorbBrackets(cells) {
   const out = [];
   for (let i = 0; i < cells.length; i++) {
     const cell = cells[i];
-    const edges = bracketEdges(cell);
-    if (edges !== void 0 && edges.open !== edges.close) {
+    const edges2 = bracketEdges(cell);
+    if (edges2 !== void 0 && edges2.open !== edges2.close) {
       const prev = out[out.length - 1];
       const next = cells[i + 1];
-      if (edges.close && prev?.kind === "group") {
+      if (edges2.close && prev?.kind === "group") {
         prev.notes = [...prev.notes, ...cell.notes];
         continue;
       }
-      if (edges.open && next?.kind === "group") {
+      if (edges2.open && next?.kind === "group") {
         next.notes = [...cell.notes, ...next.notes];
         next.start = cell.start;
         continue;
@@ -838,7 +1145,7 @@ function cellMatra(cell) {
   const pitched = cell.notes.filter(isPitched);
   const total = pitched.reduce((a, n) => a + (n.durationMatra ?? 1), 0);
   const half = pitched.some((n) => n.halfMatra === true);
-  const whole = Math.floor(total + EPS);
+  const whole = Math.floor(total + EPS2);
   return { matras: half ? whole : Math.max(1, whole), half };
 }
 function cellPitchedOpts(cell) {
@@ -1604,19 +1911,19 @@ function buildAbc(schedule, lyricOf, opts) {
   const tokens = [];
   const words = [];
   let barPos = 0;
-  const EPS2 = 1e-6;
+  const EPS3 = 1e-6;
   const advance = (dur) => {
     barPos += dur;
-    while (barPos >= beatsPerBar - EPS2) {
+    while (barPos >= beatsPerBar - EPS3) {
       tokens.push("|");
       words.push("|");
       barPos -= beatsPerBar;
     }
   };
   schedule.events.forEach((ev, i) => {
-    while (m + 1 < meters.length && ev.beat >= meters[m + 1].beat - EPS2) {
+    while (m + 1 < meters.length && ev.beat >= meters[m + 1].beat - EPS3) {
       m++;
-      if (barPos > EPS2) {
+      if (barPos > EPS3) {
         tokens.push("|");
         words.push("|");
       }