@real-music-packages/web-core 0.35.0 → 0.36.1

package/dist/chunk-JVSXE4X3.js

@@ -0,0 +1,706 @@
+import {
+  safeBox
+} from "./chunk-HXTRNE74.js";
+
+// src/scene/notationGeometry.ts
+var FOLLOW_BARS = 2;
+var FOLLOW_PAD = 1.06;
+function cubicEaseInOut(t) {
+  if (t < 0.5) return 4 * t * t * t;
+  const f = 2 * t - 2;
+  return 0.5 * f * f * f + 1;
+}
+function staffSpacePx(rn) {
+  const hs = (rn.measures ?? []).map((m) => m.box.h).filter((h) => h > 1).sort((a, b) => a - b);
+  if (!hs.length) return 14;
+  const med = hs[Math.floor(hs.length / 2)];
+  return Math.max(6, med / 4);
+}
+function withLedgerHeadroom(rn, box, spaces, unionInk) {
+  const pad = staffSpacePx(rn) * spaces;
+  const ch = rn.canvas.height || box.y + box.h;
+  let y0 = box.y - pad;
+  let y1 = box.y + box.h + pad;
+  if (unionInk) {
+    const c = rn.content;
+    if (c && c.h > 0) {
+      y0 = Math.min(y0, c.y);
+      y1 = Math.max(y1, c.y + c.h);
+    }
+  }
+  y0 = Math.max(0, y0);
+  y1 = Math.min(ch, y1);
+  return { x: box.x, y: y0, w: box.w, h: Math.max(1, y1 - y0) };
+}
+function lerpBox(a, b, e) {
+  return {
+    x: a.x + (b.x - a.x) * e,
+    y: a.y + (b.y - a.y) * e,
+    w: a.w + (b.w - a.w) * e,
+    h: a.h + (b.h - a.h) * e
+  };
+}
+function cropAroundBox(box, aspect, pad, cw, ch) {
+  const bw = box.w * pad;
+  const bh = box.h * pad;
+  let w = Math.max(bw, bh * aspect);
+  let h = w / aspect;
+  w = Math.min(w, cw);
+  h = Math.min(h, ch);
+  const ccx = box.x + box.w / 2;
+  const ccy = box.y + box.h / 2;
+  let x = ccx - w / 2;
+  let y = ccy - h / 2;
+  x = Math.max(0, Math.min(cw - w, x));
+  y = Math.max(0, Math.min(ch - h, y));
+  return { x, y, w, h };
+}
+function measureSpanBox(rn, lo, hi) {
+  const ms = (rn.measures ?? []).filter((m) => m.index >= lo && m.index < hi).map((m) => m.box);
+  if (!ms.length) return null;
+  const x0 = Math.min(...ms.map((b) => b.x));
+  const y0 = Math.min(...ms.map((b) => b.y));
+  const x1 = Math.max(...ms.map((b) => b.x + b.w));
+  const y1 = Math.max(...ms.map((b) => b.y + b.h));
+  return withLedgerHeadroom(rn, { x: x0, y: y0, w: x1 - x0, h: y1 - y0 }, 6, true);
+}
+function firstMeasureBox(rn) {
+  const first = (rn.measures ?? []).filter((m) => m.index === 0).map((m) => m.box);
+  if (!first.length) return rn.systems?.[0] ?? null;
+  const x0 = Math.min(...first.map((b) => b.x));
+  const y0 = Math.min(...first.map((b) => b.y));
+  const x1 = Math.max(...first.map((b) => b.x + b.w));
+  const y1 = Math.max(...first.map((b) => b.y + b.h));
+  return withLedgerHeadroom(rn, { x: x0, y: y0, w: x1 - x0, h: y1 - y0 }, 6, false);
+}
+function measureCount(rn) {
+  const idx = (rn.measures ?? []).map((m) => m.index);
+  return idx.length ? Math.max(...idx) + 1 : 0;
+}
+function distinctMeasureIndices(rn) {
+  const set = /* @__PURE__ */ new Set();
+  for (const m of rn.measures ?? []) set.add(m.index);
+  return [...set].sort((a, b) => a - b);
+}
+function followBoxAt(rn, posMeasures) {
+  const cur = Math.floor(posMeasures);
+  const frac = posMeasures - cur;
+  const a = measureSpanBox(rn, cur, cur + FOLLOW_BARS);
+  const b = measureSpanBox(rn, cur + 1, cur + 1 + FOLLOW_BARS) ?? a;
+  if (!a) return b;
+  if (!b) return a;
+  return lerpBox(a, b, frac);
+}
+var HSTACK_PLAYHEAD_LEAD = 0.35;
+function followWindowStart(rn, camProgress01) {
+  let firstIndex;
+  let nReal;
+  if (typeof rn === "number") {
+    firstIndex = 0;
+    nReal = rn;
+  } else {
+    const idx = distinctMeasureIndices(rn);
+    firstIndex = idx.length ? idx[0] : 0;
+    nReal = idx.length;
+  }
+  const p = Math.max(0, Math.min(1, camProgress01));
+  const posBars = firstIndex + p * nReal;
+  const start = posBars - HSTACK_PLAYHEAD_LEAD * FOLLOW_BARS;
+  const lastIndex = firstIndex + Math.max(0, nReal - 1);
+  const minStart = firstIndex;
+  const maxStart = Math.max(minStart, lastIndex - (FOLLOW_BARS - 1));
+  return Math.max(minStart, Math.min(maxStart, start));
+}
+function systemIndexOfBox(systems, box) {
+  if (!systems.length) return 0;
+  const cy = box.y + box.h / 2;
+  let best = 0;
+  let bestD = Infinity;
+  for (let i = 0; i < systems.length; i++) {
+    const s = systems[i];
+    if (cy >= s.y && cy <= s.y + s.h) return i;
+    const sc = s.y + s.h / 2;
+    const d = Math.abs(cy - sc);
+    if (d < bestD) {
+      bestD = d;
+      best = i;
+    }
+  }
+  return best;
+}
+function measureSystemMap(rn) {
+  const systems = rn.systems ?? [];
+  const n = measureCount(rn);
+  const map = new Array(n).fill(0);
+  for (let idx = 0; idx < n; idx++) {
+    const m = (rn.measures ?? []).find((mm) => mm.index === idx);
+    map[idx] = m ? systemIndexOfBox(systems, m.box) : 0;
+  }
+  return map;
+}
+function systemBox(rn, sys, sysMap) {
+  const map = sysMap ?? measureSystemMap(rn);
+  const boxes = (rn.measures ?? []).filter((m) => map[m.index] === sys).map((m) => m.box);
+  if (!boxes.length) return (rn.systems ?? [])[sys] ?? null;
+  const x0 = Math.min(...boxes.map((b) => b.x));
+  const y0 = Math.min(...boxes.map((b) => b.y));
+  const x1 = Math.max(...boxes.map((b) => b.x + b.w));
+  const y1 = Math.max(...boxes.map((b) => b.y + b.h));
+  return withLedgerHeadroom(rn, { x: x0, y: y0, w: x1 - x0, h: y1 - y0 }, 8, false);
+}
+function vstackFollowBox(rn, camProgress01) {
+  const sysMap = measureSystemMap(rn);
+  const nBars = measureCount(rn);
+  const nSys = (rn.systems ?? []).length || (sysMap.length ? Math.max(...sysMap) + 1 : 0);
+  if (nBars <= 0 || nSys <= 0) return null;
+  const posBars = Math.max(0, Math.min(1, camProgress01)) * nBars;
+  const curBar = Math.min(nBars - 1, Math.floor(posBars));
+  const barFrac = posBars - Math.floor(posBars);
+  const curSys = sysMap[curBar] ?? 0;
+  const isLastBarOfSys = curBar + 1 >= nBars || (sysMap[curBar + 1] ?? curSys) !== curSys;
+  const scrollFrac = isLastBarOfSys ? cubicEaseInOut(Math.min(1, Math.max(0, (barFrac - 0.66) / 0.34))) : 0;
+  const nextSys = Math.min(nSys - 1, curSys + 1);
+  const a = systemBox(rn, curSys, sysMap);
+  const b = systemBox(rn, nextSys, sysMap) ?? a;
+  if (!a) return b;
+  if (!b) return a;
+  const w = Math.max(a.w, b.w);
+  const h = Math.max(a.h, b.h);
+  const x = a.x + (b.x - a.x) * scrollFrac;
+  const y = a.y + (b.y - a.y) * scrollFrac;
+  return { x, y, w, h };
+}
+function notationLayout(rn, W, H, boxTop, boxH, opts = {}) {
+  const { zoom01 = 1, focusBox = null } = opts;
+  const sb = safeBox(W, H);
+  const maxW = sb.centeredW;
+  const c = rn.content && rn.content.w > 0 && rn.content.h > 0 ? rn.content : { x: 0, y: 0, w: rn.canvas.width || 1400, h: rn.canvas.height || 300 };
+  let src;
+  if (focusBox) {
+    const px = focusBox.w * (FOLLOW_PAD - 1) / 2;
+    const py = focusBox.h * (FOLLOW_PAD - 1) / 2;
+    src = {
+      x: Math.max(0, focusBox.x - px),
+      y: Math.max(0, focusBox.y - py),
+      w: focusBox.w + 2 * px,
+      h: focusBox.h + 2 * py
+    };
+    src.w = Math.min(src.w, rn.canvas.width - src.x);
+    src.h = Math.min(src.h, rn.canvas.height - src.y);
+  } else {
+    src = c;
+    const focal = firstMeasureBox(rn);
+    if (zoom01 < 1 && focal) {
+      const start = cropAroundBox(focal, c.w / c.h, 1.25, rn.canvas.width, rn.canvas.height);
+      src = lerpBox(start, c, cubicEaseInOut(zoom01));
+    }
+  }
+  const srcAspect = src.w / src.h;
+  let dw = maxW;
+  let dh = dw / srcAspect;
+  if (dh > boxH) {
+    dh = boxH;
+    dw = dh * srcAspect;
+  }
+  const dx = (W - dw) / 2;
+  const dy = boxTop + (boxH - dh) / 2;
+  const fx = dw / src.w;
+  const fy = dh / src.h;
+  const map = (b) => ({
+    x: dx + (b.x - src.x) * fx,
+    y: dy + (b.y - src.y) * fy,
+    w: b.w * fx,
+    h: b.h * fy
+  });
+  const systems = (rn.systems ?? []).map(map);
+  const measures = (rn.measures ?? []).map((m) => ({
+    ...m,
+    box: map(m.box),
+    noteStartX: dx + (m.noteStartX - src.x) * fx
+  }));
+  return { src, rect: { dx, dy, dw, dh }, systems, measures };
+}
+function measureColumnsFromLayout(measures) {
+  const byIndex = /* @__PURE__ */ new Map();
+  for (const m of measures) {
+    const cur = byIndex.get(m.index);
+    if (!cur) {
+      byIndex.set(m.index, { ...m.box, noteStartX: m.noteStartX });
+    } else {
+      const x0 = Math.min(cur.x, m.box.x);
+      const y0 = Math.min(cur.y, m.box.y);
+      const x1 = Math.max(cur.x + cur.w, m.box.x + m.box.w);
+      const y1 = Math.max(cur.y + cur.h, m.box.y + m.box.h);
+      byIndex.set(m.index, {
+        x: x0,
+        y: y0,
+        w: x1 - x0,
+        h: y1 - y0,
+        noteStartX: Math.min(cur.noteStartX, m.noteStartX)
+      });
+    }
+  }
+  return [...byIndex.keys()].sort((a, b) => a - b).map((k) => byIndex.get(k));
+}
+function playheadLine(layout, t01) {
+  const tt = Math.max(0, Math.min(1, t01));
+  let alpha = 0.85;
+  if (tt < 0.03) alpha *= tt / 0.03;
+  if (tt > 0.94) alpha *= Math.max(0, (1 - tt) / 0.06);
+  if (alpha <= 0.02) return null;
+  const padV = 10;
+  let x, y0, y1;
+  const cols = measureColumnsFromLayout(layout.measures);
+  if (cols.length) {
+    const pos = tt * cols.length;
+    const i = Math.min(cols.length - 1, Math.floor(pos));
+    const m = cols[i];
+    const startX = Math.min(m.noteStartX, m.x + m.w);
+    x = startX + (pos - i) * (m.x + m.w - startX);
+    y0 = m.y - padV;
+    y1 = m.y + m.h + padV;
+  } else if (layout.systems.length) {
+    const pos = tt * layout.systems.length;
+    const row = Math.min(layout.systems.length - 1, Math.floor(pos));
+    const s = layout.systems[row];
+    x = s.x + (pos - row) * s.w;
+    y0 = s.y - padV;
+    y1 = s.y + s.h + padV;
+  } else {
+    const r = layout.rect;
+    x = r.dx + tt * r.dw;
+    y0 = r.dy - padV;
+    y1 = r.dy + r.dh + padV;
+  }
+  return { x, y0, y1, alpha };
+}
+var clamp01 = (x) => x < 0 ? 0 : x > 1 ? 1 : x;
+function anchorAtColumnPos(cols, pos, padV) {
+  const i = Math.min(cols.length - 1, Math.max(0, Math.floor(pos)));
+  const m = cols[i];
+  const startX = Math.min(m.noteStartX, m.x + m.w);
+  const frac = Math.min(1, Math.max(0, pos - i));
+  return {
+    onsetMs: 0,
+    x: startX + frac * (m.x + m.w - startX),
+    y0: m.y - padV,
+    y1: m.y + m.h + padV
+  };
+}
+function noteAnchors(layout, onsetsMs, padV, barDurMs, noteCols) {
+  const cols = measureColumnsFromLayout(layout.measures);
+  if (!cols.length || !onsetsMs.length) return [];
+  const n = onsetsMs.length;
+  const first = onsetsMs[0];
+  const useEngraved = !!noteCols && noteCols.length === n;
+  return onsetsMs.map((onsetMs, k) => {
+    const pos = useEngraved ? noteCols[k] : barDurMs && barDurMs > 0 ? (onsetMs - first) / barDurMs : (n === 1 ? 0 : k / (n - 1)) * cols.length;
+    const a = anchorAtColumnPos(cols, pos, padV);
+    return { ...a, onsetMs };
+  });
+}
+function distinctOnsets(notes) {
+  const set = /* @__PURE__ */ new Set();
+  for (const n of notes) set.add(n.onsetMs);
+  return [...set].sort((a, b) => a - b);
+}
+function audioPlayheadLine(layout, onsetsMs, tMs, barDurMs, noteCols) {
+  const padV = 10;
+  const anchors = noteAnchors(layout, onsetsMs, padV, barDurMs, noteCols);
+  if (!anchors.length) return null;
+  const first = anchors[0].onsetMs;
+  const last = anchors[anchors.length - 1].onsetMs;
+  const span = last - first;
+  let a, b, frac;
+  if (tMs <= first || anchors.length === 1) {
+    a = b = anchors[0];
+    frac = 0;
+  } else if (tMs >= last) {
+    a = b = anchors[anchors.length - 1];
+    frac = 0;
+  } else {
+    let lo = 0;
+    let hi = anchors.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (anchors[mid].onsetMs <= tMs) lo = mid;
+      else hi = mid - 1;
+    }
+    a = anchors[lo];
+    b = anchors[lo + 1];
+    const dt = b.onsetMs - a.onsetMs;
+    frac = dt > 0 ? (tMs - a.onsetMs) / dt : 0;
+  }
+  const x = a.x + (b.x - a.x) * frac;
+  const y0 = a.y0 + (b.y0 - a.y0) * frac;
+  const y1 = a.y1 + (b.y1 - a.y1) * frac;
+  let alpha = 0.85;
+  if (span > 0) {
+    const fadeIn = Math.min(250, span * 0.5);
+    const fadeOut = Math.min(400, span * 0.5);
+    if (tMs < first + fadeIn) alpha *= clamp01((tMs - (first - fadeIn)) / (2 * fadeIn));
+    if (tMs > last - fadeOut) alpha *= clamp01((last + fadeOut - tMs) / (2 * fadeOut));
+  }
+  if (alpha <= 0.02) return null;
+  return { x, y0, y1, alpha };
+}
+function vstackAudioPlayheadLine(layout, onsetsMs, tMs, nBars, noteCols) {
+  const padV = 10;
+  const cols = measureColumnsFromLayout(layout.measures);
+  if (!cols.length || !onsetsMs.length || nBars <= 0) return null;
+  const n = onsetsMs.length;
+  const first = onsetsMs[0];
+  const last = onsetsMs[n - 1];
+  const span = last - first;
+  const colX = (m, f) => {
+    const sx = Math.min(m.noteStartX, m.x + m.w);
+    return sx + Math.min(1, Math.max(0, f)) * (m.x + m.w - sx);
+  };
+  const useEng = !!noteCols && noteCols.length === n;
+  const anchorFor = (k) => {
+    const pos = useEng ? noteCols[k] : (n === 1 ? 0 : k / (n - 1)) * cols.length;
+    const i = Math.min(cols.length - 1, Math.max(0, Math.floor(pos)));
+    const m = cols[i];
+    return { x: colX(m, pos - i), rowY: m.y, rowH: m.h };
+  };
+  const sameRow = (ya, yb) => Math.abs(ya - yb) < Math.max(8, ya * 0 + 8);
+  const rowRightEdge = (rowY2) => Math.max(...cols.filter((c) => sameRow(c.y, rowY2)).map((c) => c.x + c.w));
+  const rowLeftEdge = (rowY2) => Math.min(...cols.filter((c) => sameRow(c.y, rowY2)).map((c) => Math.min(c.noteStartX, c.x)));
+  let a, b, frac;
+  if (tMs <= first || n === 1) {
+    a = b = anchorFor(0);
+    frac = 0;
+  } else if (tMs >= last) {
+    a = b = anchorFor(n - 1);
+    frac = 0;
+  } else {
+    let lo = 0, hi = n - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (onsetsMs[mid] <= tMs) lo = mid;
+      else hi = mid - 1;
+    }
+    a = anchorFor(lo);
+    b = anchorFor(lo + 1);
+    frac = (tMs - onsetsMs[lo]) / (onsetsMs[lo + 1] - onsetsMs[lo]);
+  }
+  let x, rowY, rowH;
+  if (sameRow(a.rowY, b.rowY)) {
+    x = a.x + (b.x - a.x) * frac;
+    rowY = a.rowY;
+    rowH = a.rowH;
+  } else {
+    if (frac < 0.5) {
+      const s = frac / 0.5;
+      x = a.x + (rowRightEdge(a.rowY) - a.x) * s;
+      rowY = a.rowY;
+      rowH = a.rowH;
+    } else {
+      const s = (frac - 0.5) / 0.5;
+      const nl = rowLeftEdge(b.rowY);
+      x = nl + (b.x - nl) * s;
+      rowY = b.rowY;
+      rowH = b.rowH;
+    }
+  }
+  let y0 = rowY - padV;
+  let y1 = rowY + rowH + padV;
+  const bandY0 = layout.rect.dy;
+  const bandY1 = layout.rect.dy + layout.rect.dh;
+  const h = Math.max(1, y1 - y0);
+  if (y0 < bandY0) {
+    y0 = bandY0;
+    y1 = bandY0 + h;
+  }
+  if (y1 > bandY1) {
+    y1 = bandY1;
+    y0 = bandY1 - h;
+  }
+  let alpha = 0.85;
+  if (span > 0) {
+    const fadeIn = Math.min(250, span * 0.5);
+    const fadeOut = Math.min(400, span * 0.5);
+    if (tMs < first + fadeIn) alpha *= clamp01((tMs - (first - fadeIn)) / (2 * fadeIn));
+    if (tMs > last - fadeOut) alpha *= clamp01((last + fadeOut - tMs) / (2 * fadeOut));
+  }
+  if (alpha <= 0.02) return null;
+  return { x, y0, y1, alpha };
+}
+
+// src/scene/engravingStore.ts
+var STORE = /* @__PURE__ */ new WeakMap();
+function keyFor(ctx) {
+  return ctx.audioClock;
+}
+function setNotationEngraving(ctx, eng) {
+  STORE.set(keyFor(ctx), eng);
+}
+function getNotationEngraving(ctx) {
+  return STORE.get(keyFor(ctx));
+}
+function setFollowLayoutProvider(ctx, fn) {
+  const e = STORE.get(keyFor(ctx));
+  if (e) e.followLayoutAt = fn;
+}
+
+// src/scene/layers/notation.ts
+function notationLayer() {
+  let rn = null;
+  let base = null;
+  let propScale = 1;
+  let propBandTop;
+  let propBandHeight;
+  function bandTop(_ctx, sb) {
+    return propBandTop ?? sb.top;
+  }
+  function bandHeight(ctx, sb) {
+    const top = bandTop(ctx, sb);
+    return (propBandHeight ?? sb.bottom - top) * propScale;
+  }
+  return {
+    key: "notation",
+    async init(ctx, props) {
+      propScale = props.scale ?? 1;
+      propBandTop = props.bandTop;
+      propBandHeight = props.bandHeight;
+      if (props.rendered) {
+        rn = props.rendered;
+      } else if (props.xml) {
+        const { renderNotation } = await import("./promo.js");
+        rn = await renderNotation(props.xml, {
+          bars: props.bars,
+          paper: ctx.theme.paper,
+          scrollMode: props.scrollMode ?? "hstack"
+        });
+      } else {
+        throw new Error("notation layer: provide `rendered` or `xml`");
+      }
+      const sb = safeBox(ctx.W, ctx.H);
+      const top = bandTop(ctx, sb);
+      const height = bandHeight(ctx, sb);
+      base = notationLayout(rn, ctx.W, ctx.H, top, height, {});
+      setNotationEngraving(ctx, { rendered: rn, base, bandTop: top, bandHeight: height });
+    },
+    draw(ctx, tMs) {
+      if (!rn || !base) return;
+      const eng = getNotationEngraving(ctx);
+      const l = eng?.followLayoutAt ? eng.followLayoutAt(ctx, tMs) : base;
+      const c = ctx.ctx2d;
+      c.drawImage(
+        rn.canvas,
+        l.src.x,
+        l.src.y,
+        l.src.w,
+        l.src.h,
+        l.rect.dx,
+        l.rect.dy,
+        l.rect.dw,
+        l.rect.dh
+      );
+    },
+    dispose() {
+      rn = null;
+      base = null;
+    }
+  };
+}
+var notationFactory = {
+  key: "notation",
+  create: notationLayer,
+  validateProps(props) {
+    const errs = [];
+    if (props == null || typeof props !== "object") return ["notation: props must be an object"];
+    const p = props;
+    if (p.system != null && p.system !== "grand" && p.system !== "single")
+      errs.push('notation.system must be "grand" | "single"');
+    if (p.scrollMode != null && p.scrollMode !== "hstack" && p.scrollMode !== "vstack")
+      errs.push('notation.scrollMode must be "hstack" | "vstack"');
+    if (p.scale != null && (typeof p.scale !== "number" || p.scale <= 0))
+      errs.push("notation.scale must be a positive number");
+    if (p.rendered == null && typeof p.xml !== "string")
+      errs.push("notation: provide `rendered` (RenderedNotation) or `xml` (string)");
+    if (p.bars != null && (!Array.isArray(p.bars) || p.bars.length !== 2))
+      errs.push("notation.bars must be [from,to]");
+    return errs;
+  }
+};
+
+// src/scene/layers/scrollCursor.ts
+function followLayoutFor(ctx, progress01, scrollMode) {
+  const eng = getNotationEngraving(ctx);
+  if (!eng) return null;
+  const nBars = measureCount(eng.rendered);
+  if (nBars <= 0) return eng.base;
+  const focusBox = scrollMode === "vstack" ? vstackFollowBox(eng.rendered, progress01) : followBoxAt(eng.rendered, followWindowStart(eng.rendered, progress01));
+  return notationLayout(eng.rendered, ctx.W, ctx.H, eng.bandTop, eng.bandHeight, { focusBox });
+}
+function scrollCursorLayer() {
+  let scrollMode = "hstack";
+  let openingZoomMs = 900;
+  let color;
+  let barDurMs;
+  let propNoteCols;
+  function onsetsFor(ctx) {
+    const notes = ctx.score?.notes;
+    return notes && notes.length ? distinctOnsets(notes) : [];
+  }
+  function notesProgress(onsetsMs, tMs, totalMeasures, noteCols) {
+    if (tMs < openingZoomMs) return 0;
+    const n = onsetsMs.length;
+    if (n <= 1) return 0;
+    const first = onsetsMs[0];
+    const last = onsetsMs[n - 1];
+    if (tMs <= first) return 0;
+    if (tMs >= last || last <= first) return 1;
+    let lo = 0, hi = n - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (onsetsMs[mid] <= tMs) lo = mid;
+      else hi = mid - 1;
+    }
+    const segFrac = (tMs - onsetsMs[lo]) / (onsetsMs[lo + 1] - onsetsMs[lo]);
+    if (noteCols && noteCols.length === n && totalMeasures > 0) {
+      const pos = noteCols[lo] + (noteCols[lo + 1] - noteCols[lo]) * segFrac;
+      return Math.min(1, Math.max(0, pos / totalMeasures));
+    }
+    if (barDurMs && barDurMs > 0 && totalMeasures > 0) {
+      const posLo = (onsetsMs[lo] - first) / barDurMs;
+      const posHi = (onsetsMs[lo + 1] - first) / barDurMs;
+      const pos = posLo + (posHi - posLo) * segFrac;
+      return Math.min(1, Math.max(0, pos / totalMeasures));
+    }
+    return (lo + segFrac) / (n - 1);
+  }
+  function noteColsFor(ctx) {
+    const eng = getNotationEngraving(ctx)?.rendered?.noteCols;
+    const onsets = onsetsFor(ctx);
+    const n = onsets.length;
+    if (!eng || !eng.length) return propNoteCols;
+    if (eng.length === n) return eng;
+    if (!propNoteCols || propNoteCols.length !== n) return eng;
+    const measureOf = (c) => Math.floor(c + 1e-6);
+    const engByMeasure = /* @__PURE__ */ new Map();
+    for (const e of eng) {
+      const m = measureOf(e);
+      const a = engByMeasure.get(m);
+      if (a) a.push(e);
+      else engByMeasure.set(m, [e]);
+    }
+    for (const a of engByMeasure.values()) a.sort((x, y) => x - y);
+    const idxByMeasure = /* @__PURE__ */ new Map();
+    propNoteCols.forEach((c, i) => {
+      const m = measureOf(c);
+      const a = idxByMeasure.get(m);
+      if (a) a.push(i);
+      else idxByMeasure.set(m, [i]);
+    });
+    const out = propNoteCols.slice();
+    for (const [m, idxs] of idxByMeasure) {
+      const e = engByMeasure.get(m);
+      if (!e || !e.length) continue;
+      const K = idxs.length;
+      idxs.forEach((origIdx, i) => {
+        const j = K > 1 ? Math.round(i * (e.length - 1) / (K - 1)) : 0;
+        out[origIdx] = e[Math.min(j, e.length - 1)];
+      });
+    }
+    return out;
+  }
+  function followProgress(ctx, tMs) {
+    const eng = getNotationEngraving(ctx);
+    const total = eng ? measureCount(eng.rendered) : 0;
+    return notesProgress(onsetsFor(ctx), tMs, total, noteColsFor(ctx));
+  }
+  function layoutAt(ctx, tMs) {
+    const eng = getNotationEngraving(ctx);
+    return followLayoutFor(ctx, followProgress(ctx, tMs), scrollMode) ?? eng.base;
+  }
+  return {
+    key: "scroll-cursor",
+    init(ctx, props) {
+      scrollMode = props.scrollMode ?? "hstack";
+      openingZoomMs = props.openingZoomMs ?? 900;
+      color = props.color;
+      barDurMs = props.barDurMs;
+      propNoteCols = Array.isArray(props.noteCols) ? props.noteCols : void 0;
+      setFollowLayoutProvider(ctx, layoutAt);
+    },
+    draw(ctx, tMs) {
+      const eng = getNotationEngraving(ctx);
+      if (!eng) return;
+      const layout = layoutAt(ctx, tMs);
+      const onsets = onsetsFor(ctx);
+      let line;
+      if (scrollMode === "vstack") {
+        line = vstackAudioPlayheadLine(layout, onsets, tMs, measureCount(eng.rendered), noteColsFor(ctx));
+      } else {
+        line = audioPlayheadLine(layout, onsets, tMs, barDurMs, noteColsFor(ctx));
+      }
+      if (!line) return;
+      const c = ctx.ctx2d;
+      c.save();
+      c.strokeStyle = color ?? ctx.theme.accent;
+      c.globalAlpha = line.alpha;
+      c.lineWidth = 4;
+      c.beginPath();
+      c.moveTo(line.x, line.y0);
+      c.lineTo(line.x, line.y1);
+      c.stroke();
+      c.restore();
+    }
+  };
+}
+var scrollCursorFactory = {
+  key: "scroll-cursor",
+  create: scrollCursorLayer,
+  validateProps(props) {
+    const errs = [];
+    if (props == null || typeof props !== "object") return ["scroll-cursor: props must be an object"];
+    const p = props;
+    if (p.mode != null && p.mode !== "audio" && p.mode !== "linear")
+      errs.push('scroll-cursor.mode must be "audio" | "linear"');
+    if (p.scrollMode != null && p.scrollMode !== "hstack" && p.scrollMode !== "vstack")
+      errs.push('scroll-cursor.scrollMode must be "hstack" | "vstack"');
+    if (p.musicMs != null && (typeof p.musicMs !== "number" || !(p.musicMs > 0)))
+      errs.push("scroll-cursor.musicMs must be a positive number");
+    if (p.followBars != null && (typeof p.followBars !== "number" || p.followBars < 1))
+      errs.push("scroll-cursor.followBars must be a number >= 1");
+    if (p.openingZoomMs != null && (typeof p.openingZoomMs !== "number" || p.openingZoomMs < 0))
+      errs.push("scroll-cursor.openingZoomMs must be a number >= 0");
+    if (p.color != null && typeof p.color !== "string") errs.push("scroll-cursor.color must be a string");
+    if (p.barDurMs != null && (typeof p.barDurMs !== "number" || !(p.barDurMs > 0)))
+      errs.push("scroll-cursor.barDurMs must be a positive number");
+    if (p.noteCols != null && (!Array.isArray(p.noteCols) || p.noteCols.some((c) => typeof c !== "number")))
+      errs.push("scroll-cursor.noteCols must be a number[]");
+    return errs;
+  }
+};
+
+export {
+  FOLLOW_BARS,
+  FOLLOW_PAD,
+  cubicEaseInOut,
+  lerpBox,
+  cropAroundBox,
+  measureSpanBox,
+  firstMeasureBox,
+  measureCount,
+  distinctMeasureIndices,
+  followBoxAt,
+  followWindowStart,
+  measureSystemMap,
+  systemBox,
+  vstackFollowBox,
+  notationLayout,
+  measureColumnsFromLayout,
+  playheadLine,
+  distinctOnsets,
+  audioPlayheadLine,
+  vstackAudioPlayheadLine,
+  setNotationEngraving,
+  getNotationEngraving,
+  setFollowLayoutProvider,
+  notationFactory,
+  scrollCursorFactory
+};
+//# sourceMappingURL=chunk-JVSXE4X3.js.map