@miadi/ava8-measure 0.1.0

package/dist/midi.js

@@ -0,0 +1,651 @@
+/**
+ * midi.ts — read a *rendered* Standard MIDI File and prove what is inside it.
+ *
+ * Hand-written, and it must stay hand-written. The Python this is ported from
+ * (`atelier_midi.py`) refuses to import `mido`, `pretty_midi` or `music21`
+ * because none of them exist on the host the atelier runs on, and a plugin
+ * that assumes them fails on the one machine it was built for. The same
+ * discipline here costs nothing and buys everything: a decoder you can audit
+ * in one sitting, with no dependency that can rot underneath it.
+ *
+ * The port keeps that promise and adds one of its own — **bytes in, never a
+ * path**. `read` takes a `Uint8Array` and uses `DataView`, so the whole
+ * measuring surface runs unchanged in a browser. Nothing here touches
+ * `node:fs`, and nothing here touches `Buffer`.
+ *
+ * WHAT THIS MODULE IS FOR
+ *   Verification re-reads the rendered artefact, never the source. A note
+ *   count that comes out right in the generator is not proof; the same count
+ *   read back out of the .mid that `abc2midi` produced is. Every function
+ *   answers one question that decided something in the atelier:
+ *
+ *     registers()       did a voice land in a register it was told to avoid
+ *     bandOccupancy()   is the singer's band empty  (the 45-53 rule)
+ *     pitchClasses()    what mode does the rendered piece actually sit in
+ *     modePurity()      how much of it stays inside the field
+ *     samePitches()     were his notes changed between source and render
+ *     drumPositions()   is the kick really on the floor, eighth by eighth
+ *     tempos            did the mid-tune tempo change survive (a bare Q: does not)
+ *
+ * UNITS
+ *   Tick durations are musical durations. Pitch-class and purity shares are
+ *   weighted in ticks on purpose: they describe the written field, and a tempo
+ *   change must not reweight it. Anything reported in seconds says so.
+ *
+ * @packageDocumentation
+ */
+import { parseMode } from "@miadi/ava8-atelier";
+/**
+ * Channel index 9 — "channel 10" in ABC, in General MIDI, and in every manual.
+ *
+ * Note the deliberate divergence from `@miadi/ava8-atelier`, whose
+ * `DRUM_CHANNEL` is `10` because it names the channel the way a musician
+ * writes it. A decoder reads the wire, and on the wire the nibble is 9.
+ */
+export const DRUM_CHANNEL = 9;
+/** The General MIDI drum names the atelier actually uses, by note number. */
+export const GM_DRUM_NAMES = {
+    35: "kick 2", 36: "kick", 37: "side stick", 38: "snare", 39: "clap",
+    40: "snare 2", 41: "low tom", 42: "hat closed", 43: "low tom 2",
+    44: "hat pedal", 45: "mid tom", 46: "hat open", 47: "mid tom 2",
+    48: "high tom", 49: "crash", 50: "high tom 2", 51: "ride",
+    54: "tambourine", 56: "cowbell", 57: "crash 2", 59: "ride 2",
+};
+/** Sharp spellings, because a decoder has no key signature to spell against. */
+export const PC_NAMES = [
+    "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B",
+];
+/** Sounding length in ticks. A musical duration, never seconds. */
+export function noteDuration(note) {
+    return note.endTick - note.startTick;
+}
+const MTHD = [0x4d, 0x54, 0x68, 0x64];
+const MTRK = [0x4d, 0x54, 0x72, 0x6b];
+const TEXT = new TextDecoder("utf-8");
+/** MIDI variable-length quantity. Returns `[value, position after it]`. */
+function varlen(bytes, start) {
+    let v = 0;
+    let p = start;
+    for (;;) {
+        const b = byteAt(bytes, p);
+        p += 1;
+        v = (v << 7) | (b & 0x7f);
+        if (!(b & 0x80))
+            return [v, p];
+    }
+}
+/** Bounds-checked byte read. Runs off the end and it says so, like Python's IndexError. */
+function byteAt(bytes, p) {
+    if (p < 0 || p >= bytes.length) {
+        throw new RangeError(`MIDI read ran past the end of the file at byte ${p}`);
+    }
+    return bytes[p];
+}
+/**
+ * Read a Standard MIDI File into paired notes. This is the only door in.
+ *
+ * Handles: format 0 and 1 (and 2, read as independent tracks), running status,
+ * meta events, sysex (`0xF0` and the `0xF7` escape form), tempo and
+ * time-signature maps, unknown chunk types (skipped by their declared length,
+ * as the spec instructs), and note-on-with-velocity-0 as note-off.
+ *
+ * Note-offs are paired FIFO per `(track, channel, pitch)` — pairing on pitch
+ * alone silently merges two voices that happen to share a pitch on different
+ * channels, and the merge is invisible in the output, which is the worst kind
+ * of wrong. Notes left hanging at end of track are closed at the last tick
+ * seen and counted in `unclosed`; a non-zero count means the file is malformed
+ * and every duration-weighted measure below it is approximate.
+ *
+ * The sort order is load-bearing, not cosmetic: `(startTick, track, channel,
+ * pitch)`. {@link samePitches} re-sorts on top of it and relies on a stable
+ * sort to keep the track/channel order under equal pitches, so two readers
+ * that disagree here will disagree about whether a file was altered.
+ *
+ * @param bytes the whole file. Never a path — the library must run in a browser.
+ * @param path a label to carry through for reporting. Nothing is opened.
+ */
+export function read(bytes, path = "<bytes>") {
+    if (bytes.length < 14 || !MTHD.every((b, i) => bytes[i] === b)) {
+        throw new TypeError(`${path}: not a Standard MIDI File (no MThd header)`);
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const hdrLen = view.getUint32(4, false);
+    const format = view.getUint16(8, false);
+    const nTracks = view.getUint16(10, false);
+    const division = view.getUint16(12, false);
+    let p = 8 + hdrLen;
+    const notes = [];
+    const tempos = [];
+    const tsigs = [];
+    const names = new Map();
+    let unclosed = 0;
+    let track = -1;
+    while (p + 8 <= bytes.length) {
+        const isTrack = MTRK.every((b, i) => bytes[p + i] === b);
+        const clen = view.getUint32(p + 4, false);
+        p += 8;
+        const end = Math.min(p + clen, bytes.length);
+        if (!isTrack) {
+            // alien chunk: the spec says skip it by its declared length
+            p = end;
+            continue;
+        }
+        track += 1;
+        let t = 0;
+        let run = null;
+        // insertion-ordered, so hanging notes are emitted in the order they opened
+        const on = new Map();
+        while (p < end) {
+            const [delta, afterDelta] = varlen(bytes, p);
+            p = afterDelta;
+            t += delta;
+            if (p >= end)
+                break;
+            let st = byteAt(bytes, p);
+            if (st & 0x80) {
+                // any status byte refreshes running status, meta and sysex included.
+                // That is what the Python does, and a decoder that "corrects" it
+                // silently disagrees with the file the atelier already verified.
+                run = st;
+                p += 1;
+            }
+            else {
+                if (run === null) {
+                    throw new TypeError(`${path}: running status with no preceding status byte`);
+                }
+                st = run;
+            }
+            if (st === 0xff) {
+                const mtype = byteAt(bytes, p);
+                p += 1;
+                const [ln, afterLen] = varlen(bytes, p);
+                p = afterLen;
+                const payload = bytes.subarray(p, Math.min(p + ln, bytes.length));
+                p += ln;
+                if (mtype === 0x51 && ln === 3) {
+                    const us = (payload[0] << 16) | (payload[1] << 8) | payload[2];
+                    tempos.push({ tick: t, usecPerQuarter: us, bpm: us ? 60_000_000 / us : 0, track });
+                }
+                else if (mtype === 0x58 && ln >= 4) {
+                    tsigs.push({
+                        tick: t,
+                        numerator: payload[0],
+                        denominator: 1 << payload[1],
+                        clocksPerClick: payload[2],
+                        notated32ndPerQuarter: payload[3],
+                        track,
+                    });
+                }
+                else if (mtype === 0x03) {
+                    names.set(track, TEXT.decode(payload));
+                }
+                else if (mtype === 0x2f) {
+                    break;
+                }
+            }
+            else if (st === 0xf0 || st === 0xf7) {
+                const [ln, afterLen] = varlen(bytes, p);
+                p = afterLen + ln;
+            }
+            else {
+                const hi = st & 0xf0;
+                const ch = st & 0x0f;
+                const nb = hi === 0xc0 || hi === 0xd0 ? 1 : 2;
+                const a = byteAt(bytes, p);
+                const b2 = nb === 2 && p + 1 < bytes.length ? bytes[p + 1] : 0;
+                p += nb;
+                const key = ch * 128 + a;
+                if (hi === 0x90 && b2 > 0) {
+                    let q = on.get(key);
+                    if (!q) {
+                        q = [];
+                        on.set(key, q);
+                    }
+                    q.push({ tick: t, velocity: b2 });
+                }
+                else if (hi === 0x80 || (hi === 0x90 && b2 === 0)) {
+                    const q = on.get(key);
+                    if (q && q.length) {
+                        const head = q.shift();
+                        notes.push({
+                            startTick: head.tick,
+                            endTick: t,
+                            pitch: a,
+                            velocity: head.velocity,
+                            channel: ch,
+                            track,
+                        });
+                    }
+                }
+            }
+        }
+        for (const [key, q] of on) {
+            const ch = Math.floor(key / 128);
+            const pitch = key % 128;
+            for (const held of q) {
+                unclosed += 1;
+                notes.push({
+                    startTick: held.tick,
+                    endTick: Math.max(held.tick + 1, t),
+                    pitch,
+                    velocity: held.velocity,
+                    channel: ch,
+                    track,
+                });
+            }
+        }
+        p = end;
+    }
+    notes.sort(compareNotes);
+    tempos.sort((x, y) => x.tick - y.tick);
+    tsigs.sort((x, y) => x.tick - y.tick);
+    return {
+        notes,
+        division,
+        tempos,
+        timeSignatures: tsigs,
+        format,
+        nTracks,
+        trackNames: names,
+        unclosed,
+        path,
+    };
+}
+/**
+ * The canonical note order: `(startTick, track, channel, pitch)`.
+ *
+ * Exported because it is a contract, not an implementation detail. Reproduce
+ * it wrong and {@link samePitches} reports a file altered that was not, or
+ * misses one that was. Ties on `startTick` are broken by track first, which is
+ * why a two-voice render reads voice-by-voice inside each chord.
+ */
+export function compareNotes(x, y) {
+    return (x.startTick - y.startTick ||
+        x.track - y.track ||
+        x.channel - y.channel ||
+        x.pitch - y.pitch);
+}
+/**
+ * Ticks per quarter note, or `null` when the file uses SMPTE timing.
+ *
+ * A SMPTE division (the 0x8000 bit) carries frames and subframes, not a beat
+ * grid, so every bar-relative measure — {@link drumPositions} above all — must
+ * refuse rather than guess. Returning `null` is how the refusal is made
+ * unmissable at the type level.
+ */
+export function ticksPerBeat(division) {
+    if (division & 0x8000)
+        return null;
+    return division;
+}
+/**
+ * Absolute seconds for a tick, walking the tempo map. Reporting only.
+ *
+ * Used to say *when* something happened out loud, to a human who is listening
+ * rather than counting. No musical decision is taken on seconds: they drift
+ * with every tempo event, tick durations do not. With no tempo written, the
+ * SMF default of 120 bpm applies — which is exactly the trap a bare `Q:` in an
+ * ABC body falls into.
+ */
+export function tickToSeconds(tick, division, tempos = []) {
+    const tpb = ticksPerBeat(division);
+    if (tpb === null) {
+        const frames = 256 - ((division >> 8) & 0xff);
+        const perFrame = division & 0xff;
+        return tick / (frames * perFrame || 1);
+    }
+    if (tempos.length === 0)
+        return (tick * 0.5) / tpb;
+    let sec = 0;
+    let prevTick = 0;
+    let us = 500000;
+    for (const tp of tempos) {
+        if (tp.tick >= tick)
+            break;
+        sec += ((tp.tick - prevTick) * us) / 1e6 / tpb;
+        prevTick = tp.tick;
+        us = tp.usecPerQuarter;
+    }
+    return sec + ((tick - prevTick) * us) / 1e6 / tpb;
+}
+/**
+ * Per-track pitch extent and count, plus the overlap between every pair.
+ *
+ * Decides: whether a voice went where it was told not to go, and whether two
+ * voices meant to stay out of each other's way in fact cross. The atelier
+ * reads this before publishing, on the *rendered* file — an ABC window that
+ * looks disjoint on paper can still collide once `abc2midi` has chosen an
+ * octave, because `clef=treble-8` sounds an octave below what is written.
+ *
+ * Overlaps come back as an array ordered by `(a, b)` rather than a
+ * tuple-keyed map, because JavaScript has no tuple key that survives a round
+ * trip through JSON.
+ */
+export function registers(notes) {
+    const per = new Map();
+    for (const n of notes) {
+        let e = per.get(n.track);
+        if (!e) {
+            e = {
+                min: n.pitch,
+                max: n.pitch,
+                count: 0,
+                span: 0,
+                channels: [],
+                pitches: [],
+                channelSet: new Set(),
+                pitchSet: new Set(),
+            };
+            per.set(n.track, e);
+        }
+        e.min = Math.min(e.min, n.pitch);
+        e.max = Math.max(e.max, n.pitch);
+        e.count += 1;
+        e.channelSet.add(n.channel);
+        e.pitchSet.add(n.pitch);
+    }
+    const tracks = new Map();
+    for (const key of [...per.keys()].sort((x, y) => x - y)) {
+        const e = per.get(key);
+        tracks.set(key, {
+            min: e.min,
+            max: e.max,
+            count: e.count,
+            span: e.max - e.min,
+            channels: [...e.channelSet].sort((x, y) => x - y),
+            pitches: [...e.pitchSet].sort((x, y) => x - y),
+        });
+    }
+    const overlaps = [];
+    const keys = [...tracks.keys()];
+    for (let i = 0; i < keys.length; i += 1) {
+        for (let j = i + 1; j < keys.length; j += 1) {
+            const a = keys[i];
+            const b = keys[j];
+            const ta = tracks.get(a);
+            const tb = tracks.get(b);
+            const low = Math.max(ta.min, tb.min);
+            const high = Math.min(ta.max, tb.max);
+            const bPitches = new Set(tb.pitches);
+            overlaps.push({
+                a,
+                b,
+                low,
+                high,
+                semitones: high >= low ? high - low + 1 : 0,
+                sharedPitches: ta.pitches.filter((pc) => bPitches.has(pc)),
+            });
+        }
+    }
+    return { tracks, overlaps };
+}
+/**
+ * How many notes fall inside a MIDI range, inclusive.
+ *
+ * This is how "the singer's band is empty" is proven, and it is the only check
+ * in the atelier that is pass/fail rather than a number to read. His band was
+ * measured on the day: 94.1 % of the park drone lives in MIDI 45-53, so 45-53
+ * stays empty in every piece written for him to sing over. Every other measure
+ * here reports and lets the human judge; this one has a verdict because the
+ * band belongs to a person, not to a threshold someone picked.
+ *
+ * Returns the count, the share of all notes, the offending notes, and which
+ * tracks they came from — naming the track is what makes the correction one
+ * edit instead of a hunt.
+ */
+export function bandOccupancy(notes, lo, hi) {
+    const all = [...notes];
+    const inside = all.filter((n) => n.pitch >= lo && n.pitch <= hi);
+    const byTrack = new Map();
+    for (const n of inside)
+        byTrack.set(n.track, (byTrack.get(n.track) ?? 0) + 1);
+    return {
+        low: lo,
+        high: hi,
+        count: inside.length,
+        total: all.length,
+        share: all.length ? inside.length / all.length : 0,
+        empty: inside.length === 0,
+        byTrack,
+        notes: inside,
+        pitches: [...new Set(inside.map((n) => n.pitch))].sort((x, y) => x - y),
+    };
+}
+/**
+ * Pitch-class histogram weighted by sounding duration, in ticks.
+ *
+ * Decides the mode. Counting note *events* lies: a drone struck once and held
+ * thirty seconds counts as one, and the piece then reads as whatever the busy
+ * voice happens to be doing. Weighting by duration is what found MI PHRYGIEN
+ * in his Songbird take — the mi2/re#2 beat held thirty seconds *was* the piece.
+ *
+ * The drum channel is excluded, because a kick is not a pitch class.
+ */
+export function pitchClasses(notes) {
+    const ticks = new Array(12).fill(0);
+    const events = new Array(12).fill(0);
+    for (const n of notes) {
+        if (n.channel === DRUM_CHANNEL)
+            continue;
+        const pc = ((n.pitch % 12) + 12) % 12;
+        ticks[pc] = ticks[pc] + Math.max(0, noteDuration(n));
+        events[pc] = events[pc] + 1;
+    }
+    const total = ticks.reduce((s, v) => s + v, 0);
+    const byPc = ticks.map((tk, pc) => ({
+        ticks: tk,
+        share: total ? tk / total : 0,
+        events: events[pc],
+    }));
+    const ranked = Array.from({ length: 12 }, (_, i) => i).sort((x, y) => ticks[y] - ticks[x]);
+    return { totalTicks: total, byPc, ranked };
+}
+/**
+ * Share of sounding duration that sits inside a given pitch-class set.
+ *
+ * Decides whether a take stays in the field, and names what leaves it. The
+ * number is not a verdict on its own: 21 % outside the white field of the bed
+ * was not an error in his Songbird — it was the material the intruder in
+ * opus 019 is made of. Report the share, name the strays, let the human read.
+ *
+ * A mode given as text (`"ddorian"`, `"e phrygian"`, `"Bb-major"`, or a bare
+ * `"0,2,4,5,7,9,11"`) is handed to `parseMode` from `@miadi/ava8-atelier`.
+ * The atelier owns what a mode *is*; this package only owns what a rendered
+ * file *did*. Two copies of that table would eventually disagree, and the
+ * disagreement would surface as a purity number nobody could explain.
+ */
+export function modePurity(notes, allowedPcs) {
+    const raw = typeof allowedPcs === "string" ? parseMode(allowedPcs) : [...allowedPcs];
+    const allowed = new Set(raw.map((p) => (((Math.trunc(p) % 12) + 12) % 12)));
+    const h = pitchClasses(notes);
+    let inside = 0;
+    const outside = [];
+    for (let pc = 0; pc < 12; pc += 1) {
+        const v = h.byPc[pc];
+        if (allowed.has(pc))
+            inside += v.ticks;
+        else if (v.ticks)
+            outside.push({ pc, share: v.share });
+    }
+    outside.sort((x, y) => y.share - x.share);
+    return {
+        allowed: [...allowed].sort((x, y) => x - y),
+        purity: h.totalTicks ? inside / h.totalTicks : 0,
+        insideTicks: inside,
+        totalTicks: h.totalTicks,
+        outside,
+    };
+}
+/**
+ * Compare two renders note-for-note **and** as a multiset.
+ *
+ * This is what proves "his notes are unchanged". Two answers, and they are not
+ * the same answer — reporting only one of them would let a real change pass or
+ * would condemn an honest one:
+ *
+ *   `noteForNote`  same pitches in the same order. A variation that keeps his
+ *                  order — a register split, a re-voicing — passes this.
+ *   `multiset`     same pitches in any order. A mirror or a re-ordering passes
+ *                  only this, and that is then the honest claim to make about
+ *                  it: his material, his order changed.
+ *
+ * On divergence, `firstDivergence` gives the index and both pitches, which is
+ * where to look and nowhere else.
+ *
+ * The comparison re-sorts by `(startTick, pitch)` on top of the canonical
+ * order from {@link read}, and relies on the sort being stable so that equal
+ * pitches keep their track and channel order. That is why {@link compareNotes}
+ * is a contract.
+ */
+export function samePitches(a, b) {
+    const na = a instanceof Uint8Array ? read(a).notes : [...a];
+    const nb = b instanceof Uint8Array ? read(b).notes : [...b];
+    const byStartThenPitch = (x, y) => x.startTick - y.startTick || x.pitch - y.pitch;
+    const pa = [...na].sort(byStartThenPitch).map((n) => n.pitch);
+    const pb = [...nb].sort(byStartThenPitch).map((n) => n.pitch);
+    const ca = new Map();
+    const cb = new Map();
+    for (const p of pa)
+        ca.set(p, (ca.get(p) ?? 0) + 1);
+    for (const p of pb)
+        cb.set(p, (cb.get(p) ?? 0) + 1);
+    let first = null;
+    const n = Math.min(pa.length, pb.length);
+    for (let i = 0; i < n; i += 1) {
+        if (pa[i] !== pb[i]) {
+            first = { index: i, a: pa[i], b: pb[i] };
+            break;
+        }
+    }
+    if (first === null && pa.length !== pb.length) {
+        first = { index: n, a: null, b: null };
+    }
+    const multisetDelta = [];
+    for (const pitch of [...new Set([...ca.keys(), ...cb.keys()])].sort((x, y) => x - y)) {
+        const delta = (cb.get(pitch) ?? 0) - (ca.get(pitch) ?? 0);
+        if (delta !== 0)
+            multisetDelta.push({ pitch, delta });
+    }
+    return {
+        countA: pa.length,
+        countB: pb.length,
+        noteForNote: pa.length === pb.length && pa.every((v, i) => v === pb[i]),
+        multiset: multisetDelta.length === 0,
+        firstDivergence: first,
+        multisetDelta,
+    };
+}
+/** Python's round-half-to-even, because `int(round(x))` decides the slot. */
+function pyRound(x) {
+    const f = Math.floor(x);
+    const diff = x - f;
+    if (diff > 0.5)
+        return f + 1;
+    if (diff < 0.5)
+        return f;
+    return f % 2 === 0 ? f : f + 1;
+}
+/**
+ * For channel 10, the eighth-note position of every drum note within its bar.
+ *
+ * This is what proved four-on-the-floor: the kick reads 0, 2, 4, 6 and nothing
+ * else. Reading the ABC would only prove what was *written*; the grid that
+ * actually reaches the ear is the one in the rendered file.
+ *
+ * Bar length follows the time-signature map (numerator x 4/denominator
+ * quarters), with 4/4 assumed when the file declares nothing and for anything
+ * before the first declaration. `exact` is the unrounded position — a drum
+ * that lands on 1.97 instead of 2 is a rounding artefact of the writer, and
+ * you want to see that rather than have it quantised away behind your back.
+ *
+ * Refuses on SMPTE division, which carries no beat grid: there is no honest
+ * bar number to return, so it throws instead of inventing one.
+ */
+export function drumPositions(notes, division, timeSignatures = []) {
+    const tpb = ticksPerBeat(division);
+    if (tpb === null) {
+        throw new RangeError("SMPTE division carries no beat grid; bar positions are undefined");
+    }
+    const eighth = tpb / 2;
+    const segs = timeSignatures.length > 0
+        ? timeSignatures.map((ts) => [ts.tick, ts.numerator, ts.denominator])
+        : [[0, 4, 4]];
+    if (segs[0][0] !== 0)
+        segs.unshift([0, 4, 4]);
+    const barOf = (tick) => {
+        let segI = 0;
+        for (let i = 0; i < segs.length; i += 1) {
+            if (segs[i][0] <= tick)
+                segI = i;
+            else
+                break;
+        }
+        const [st, num, den] = segs[segI];
+        const barTicks = num * (4 / den) * tpb;
+        const off = tick - st;
+        let barsBefore = 0;
+        for (let k = 0; k < segI; k += 1) {
+            barsBefore +=
+                Math.max(0, segs[k + 1][0] - segs[k][0]) / (segs[k][1] * (4 / segs[k][2]) * tpb);
+        }
+        return {
+            bar: Math.trunc(barsBefore + Math.floor(off / barTicks)),
+            within: off % barTicks,
+            barTicks,
+            num,
+            den,
+        };
+    };
+    const hits = [];
+    for (const n of notes) {
+        if (n.channel !== DRUM_CHANNEL)
+            continue;
+        const { bar, within, barTicks, num, den } = barOf(n.startTick);
+        const exact = within / eighth;
+        const slots = Math.max(1, pyRound(barTicks / eighth));
+        hits.push({
+            pitch: n.pitch,
+            name: GM_DRUM_NAMES[n.pitch] ?? `midi ${n.pitch}`,
+            tick: n.startTick,
+            bar,
+            eighth: ((pyRound(exact) % slots) + slots) % slots,
+            exact,
+            eighthsPerBar: barTicks / eighth,
+            meter: `${num}/${den}`,
+            track: n.track,
+        });
+    }
+    const counts = new Map();
+    for (const h of hits) {
+        let c = counts.get(h.pitch);
+        if (!c) {
+            c = new Map();
+            counts.set(h.pitch, c);
+        }
+        c.set(h.eighth, (c.get(h.eighth) ?? 0) + 1);
+    }
+    const byPitch = new Map();
+    const names = new Map();
+    for (const pitch of [...counts.keys()].sort((x, y) => x - y)) {
+        const c = counts.get(pitch);
+        const sorted = new Map();
+        for (const slot of [...c.keys()].sort((x, y) => x - y))
+            sorted.set(slot, c.get(slot));
+        byPitch.set(pitch, sorted);
+        names.set(pitch, GM_DRUM_NAMES[pitch] ?? `midi ${pitch}`);
+    }
+    const fourOnTheFloor = new Map();
+    for (const pitch of [35, 36]) {
+        const c = counts.get(pitch);
+        if (c && c.size) {
+            const slots = [...c.keys()].sort((x, y) => x - y);
+            fourOnTheFloor.set(pitch, slots.length === 4 && slots[0] === 0 && slots[1] === 2 && slots[2] === 4 && slots[3] === 6);
+        }
+    }
+    return { hits, count: hits.length, byPitch, names, fourOnTheFloor };
+}
+/** `60` -> `"C4"`. Sharp spellings, middle C at 60, as every decoder prints it. */
+export function pitchName(p) {
+    return `${PC_NAMES[((p % 12) + 12) % 12]}${Math.floor(p / 12) - 1}`;
+}
+//# sourceMappingURL=midi.js.map