musicxml-io 0.3.3 → 0.3.4

package/dist/chunk-ZDAN74FN.mjs

@@ -0,0 +1,1809 @@
+// src/utils/index.ts
+var STEPS = ["C", "D", "E", "F", "G", "A", "B"];
+var STEP_SEMITONES = {
+  "C": 0,
+  "D": 2,
+  "E": 4,
+  "F": 5,
+  "G": 7,
+  "A": 9,
+  "B": 11
+};
+var SHARP_ORDER = ["F", "C", "G", "D", "A", "E", "B"];
+var FLAT_ORDER = ["B", "E", "A", "D", "G", "C", "F"];
+function pitchToSemitone(pitch) {
+  return pitch.octave * 12 + STEP_SEMITONES[pitch.step] + (pitch.alter ?? 0);
+}
+function getAlterForStepInKey(step, key) {
+  const fifths = key.fifths;
+  if (fifths > 0) {
+    const sharps = SHARP_ORDER.slice(0, fifths);
+    return sharps.includes(step) ? 1 : 0;
+  } else if (fifths < 0) {
+    const flats = FLAT_ORDER.slice(0, -fifths);
+    return flats.includes(step) ? -1 : 0;
+  }
+  return 0;
+}
+function getAlteredStepsInKey(key) {
+  const alterations = /* @__PURE__ */ new Map();
+  const fifths = key.fifths;
+  if (fifths > 0) {
+    SHARP_ORDER.slice(0, fifths).forEach((step) => alterations.set(step, 1));
+  } else if (fifths < 0) {
+    FLAT_ORDER.slice(0, -fifths).forEach((step) => alterations.set(step, -1));
+  }
+  return alterations;
+}
+function getAccidentalsInMeasure(measure, upToPosition, voice) {
+  const accidentals = /* @__PURE__ */ new Map();
+  let position = 0;
+  for (const entry of measure.entries) {
+    if (position >= upToPosition) break;
+    if (entry.type === "note") {
+      if (voice === void 0 || entry.voice === voice) {
+        if (entry.pitch && entry.accidental) {
+          const key = `${entry.pitch.step}${entry.pitch.octave}`;
+          accidentals.set(key, entry.pitch.alter ?? 0);
+        }
+      }
+      if (!entry.chord) {
+        position += entry.duration;
+      }
+    } else if (entry.type === "backup") {
+      position -= entry.duration;
+    } else if (entry.type === "forward") {
+      position += entry.duration;
+    }
+  }
+  return accidentals;
+}
+function semitoneToKeyAwarePitch(semitone, key, options) {
+  const octave = Math.floor(semitone / 12);
+  const pitchClass = (semitone % 12 + 12) % 12;
+  const keyPreferSharp = key.fifths >= 0;
+  const preferSharp = options?.preferSharp ?? keyPreferSharp;
+  for (const step of STEPS) {
+    const stepSemitone = STEP_SEMITONES[step];
+    if (stepSemitone === pitchClass) {
+      return { step, octave };
+    }
+  }
+  const keyAlterations = getAlteredStepsInKey(key);
+  for (const step of STEPS) {
+    const stepSemitone = STEP_SEMITONES[step];
+    const keyAlter = keyAlterations.get(step) ?? 0;
+    if ((stepSemitone + keyAlter) % 12 === pitchClass) {
+      return { step, octave, alter: keyAlter };
+    }
+  }
+  if (preferSharp) {
+    for (const step of STEPS) {
+      const stepSemitone = STEP_SEMITONES[step];
+      const diff = (pitchClass - stepSemitone + 12) % 12;
+      if (diff === 1) {
+        return { step, octave, alter: 1 };
+      }
+    }
+    for (const step of STEPS) {
+      const stepSemitone = STEP_SEMITONES[step];
+      const diff = (pitchClass - stepSemitone + 12) % 12;
+      if (diff === 2) {
+        return { step, octave, alter: 2 };
+      }
+    }
+  } else {
+    for (const step of STEPS) {
+      const stepSemitone = STEP_SEMITONES[step];
+      const diff = (stepSemitone - pitchClass + 12) % 12;
+      if (diff === 1) {
+        return { step, octave, alter: -1 };
+      }
+    }
+    for (const step of STEPS) {
+      const stepSemitone = STEP_SEMITONES[step];
+      const diff = (stepSemitone - pitchClass + 12) % 12;
+      if (diff === 2) {
+        return { step, octave, alter: -2 };
+      }
+    }
+  }
+  return { step: "C", octave, alter: pitchClass };
+}
+function determineAccidental(pitch, key, accidentalsInMeasure) {
+  const noteKey = `${pitch.step}${pitch.octave}`;
+  const alter = pitch.alter ?? 0;
+  const keyAlter = getAlterForStepInKey(pitch.step, key);
+  const previousAlter = accidentalsInMeasure.get(noteKey);
+  if (previousAlter !== void 0) {
+    if (alter === previousAlter) {
+      return void 0;
+    }
+  } else {
+    if (alter === keyAlter) {
+      return void 0;
+    }
+  }
+  if (alter === 0) return "natural";
+  if (alter === 1) return "sharp";
+  if (alter === -1) return "flat";
+  if (alter === 2) return "double-sharp";
+  if (alter === -2) return "double-flat";
+  return void 0;
+}
+function createPositionState() {
+  return { position: 0, lastNonChordPosition: 0 };
+}
+function updatePositionForEntry(state, entry) {
+  const pos = state.position;
+  switch (entry.type) {
+    case "note": {
+      const note = entry;
+      if (!note.chord) {
+        state.lastNonChordPosition = state.position;
+        state.position += note.duration;
+      }
+      return note.chord ? state.lastNonChordPosition : pos;
+    }
+    case "backup":
+      state.position -= entry.duration;
+      state.lastNonChordPosition = state.position;
+      return pos;
+    case "forward":
+      state.position += entry.duration;
+      state.lastNonChordPosition = state.position;
+      return pos;
+    default:
+      return pos;
+  }
+}
+function getAbsolutePositionForNote(note, measure) {
+  const state = createPositionState();
+  for (const entry of measure.entries) {
+    if (entry === note) return entry.chord ? state.lastNonChordPosition : state.position;
+    updatePositionForEntry(state, entry);
+  }
+  return state.position;
+}
+function getMeasureEndPosition(measure) {
+  const state = createPositionState();
+  for (const entry of measure.entries) updatePositionForEntry(state, entry);
+  return state.position;
+}
+
+// src/query/index.ts
+function getNotesForVoice(measure, filter) {
+  return measure.entries.filter((entry) => {
+    if (entry.type !== "note") return false;
+    if (filter.voice !== void 0 && entry.voice !== filter.voice) return false;
+    if (filter.staff !== void 0 && (entry.staff ?? 1) !== filter.staff) return false;
+    return true;
+  });
+}
+function getNotesForStaff(measure, filter) {
+  return measure.entries.filter((entry) => {
+    if (entry.type !== "note") return false;
+    return (entry.staff ?? 1) === filter.staff;
+  });
+}
+function groupByVoice(measure) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of measure.entries) {
+    if (entry.type !== "note") continue;
+    const staff = entry.staff ?? 1;
+    const voice = entry.voice ?? 1;
+    const key = `${staff}-${voice}`;
+    if (!groups.has(key)) {
+      groups.set(key, { staff, voice, notes: [] });
+    }
+    groups.get(key).notes.push(entry);
+  }
+  return Array.from(groups.values()).sort((a, b) => {
+    if (a.staff !== b.staff) return a.staff - b.staff;
+    return a.voice - b.voice;
+  });
+}
+function groupByStaff(measure) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of measure.entries) {
+    if (entry.type !== "note") continue;
+    const staff = entry.staff ?? 1;
+    if (!groups.has(staff)) {
+      groups.set(staff, { staff, notes: [] });
+    }
+    groups.get(staff).notes.push(entry);
+  }
+  return Array.from(groups.values()).sort((a, b) => a.staff - b.staff);
+}
+function getAbsolutePosition(note, measure) {
+  return getAbsolutePositionForNote(note, measure);
+}
+function withAbsolutePositions(measure) {
+  const result = [];
+  const state = createPositionState();
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      const notePosition = entry.chord ? state.lastNonChordPosition : state.position;
+      result.push({
+        ...entry,
+        absolutePosition: notePosition
+      });
+    }
+    updatePositionForEntry(state, entry);
+  }
+  return result;
+}
+function getChords(measure, filter) {
+  const notesWithPos = withAbsolutePositions(measure);
+  const filteredNotes = filter ? notesWithPos.filter((note) => {
+    if (filter.voice !== void 0 && note.voice !== filter.voice) return false;
+    if (filter.staff !== void 0 && (note.staff ?? 1) !== filter.staff) return false;
+    return true;
+  }) : notesWithPos;
+  const chordMap = /* @__PURE__ */ new Map();
+  for (const note of filteredNotes) {
+    const pos = note.absolutePosition;
+    if (!chordMap.has(pos)) {
+      chordMap.set(pos, []);
+    }
+    chordMap.get(pos).push(note);
+  }
+  const chords = [];
+  for (const [position, notes] of chordMap.entries()) {
+    const duration = notes[0].duration;
+    chords.push({
+      position,
+      duration,
+      notes: notes.map(({ absolutePosition, ...note }) => note)
+    });
+  }
+  return chords.sort((a, b) => a.position - b.position);
+}
+function* iterateNotes(score) {
+  for (const part of score.parts) {
+    for (const measure of part.measures) {
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "note") {
+          const notePosition = entry.chord ? state.lastNonChordPosition : state.position;
+          yield {
+            part,
+            measure,
+            note: entry,
+            position: notePosition
+          };
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+}
+function getAllNotes(score) {
+  return Array.from(iterateNotes(score));
+}
+function getVoices(measure) {
+  const voices = /* @__PURE__ */ new Set();
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      voices.add(entry.voice ?? 1);
+    }
+  }
+  return Array.from(voices).sort((a, b) => a - b);
+}
+function getStaves(measure) {
+  const staves = /* @__PURE__ */ new Set();
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      staves.add(entry.staff ?? 1);
+    }
+  }
+  return Array.from(staves).sort((a, b) => a - b);
+}
+function hasNotes(measure) {
+  return measure.entries.some((entry) => entry.type === "note");
+}
+function isRestMeasure(measure) {
+  const notes = measure.entries.filter((entry) => entry.type === "note");
+  return notes.length === 0 || notes.every((note) => !note.pitch);
+}
+function getNormalizedPosition(note, measure, options) {
+  const absolutePosition = getAbsolutePosition(note, measure);
+  const currentDivisions = options.currentDivisions ?? measure.attributes?.divisions ?? 1;
+  return absolutePosition * options.baseDivisions / currentDivisions;
+}
+function getNormalizedDuration(note, options) {
+  const currentDivisions = options.currentDivisions ?? 1;
+  return note.duration * options.baseDivisions / currentDivisions;
+}
+function getEntriesForStaff(measure, staff) {
+  return measure.entries.filter((entry) => {
+    if (entry.type === "note") {
+      return (entry.staff ?? 1) === staff;
+    }
+    if (entry.type === "forward") {
+      return (entry.staff ?? 1) === staff;
+    }
+    if (entry.type === "direction") {
+      return (entry.staff ?? 1) === staff;
+    }
+    if (entry.type === "backup") {
+      return false;
+    }
+    return false;
+  });
+}
+function buildVoiceToStaffMap(measure) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of measure.entries) {
+    if (entry.type === "note" && entry.staff !== void 0) {
+      const voice = entry.voice ?? 1;
+      const staff = entry.staff;
+      if (!map.has(voice)) {
+        map.set(voice, staff);
+      }
+    }
+  }
+  return {
+    get: (voice) => map.get(voice),
+    has: (voice) => map.has(voice),
+    entries: () => map.entries(),
+    size: map.size
+  };
+}
+function buildVoiceToStaffMapForPart(part) {
+  const map = /* @__PURE__ */ new Map();
+  for (const measure of part.measures) {
+    for (const entry of measure.entries) {
+      if (entry.type === "note" && entry.staff !== void 0) {
+        const voice = entry.voice ?? 1;
+        const staff = entry.staff;
+        if (!map.has(voice)) {
+          map.set(voice, staff);
+        }
+      }
+    }
+  }
+  return {
+    get: (voice) => map.get(voice),
+    has: (voice) => map.has(voice),
+    entries: () => map.entries(),
+    size: map.size
+  };
+}
+function inferStaff(entry, voiceToStaffMap) {
+  if (entry.staff !== void 0) {
+    return entry.staff;
+  }
+  const inferredStaff = voiceToStaffMap.get(entry.voice ?? 1);
+  if (inferredStaff !== void 0) {
+    return inferredStaff;
+  }
+  return 1;
+}
+function getEffectiveStaff(entry, measure) {
+  if (entry.staff !== void 0) {
+    return entry.staff;
+  }
+  const map = buildVoiceToStaffMap(measure);
+  return inferStaff(entry, map);
+}
+function getClefForStaff(score, options) {
+  const part = score.parts[options.partIndex];
+  if (!part) return void 0;
+  for (let i = options.measureIndex; i >= 0; i--) {
+    const measure = part.measures[i];
+    for (const entry of measure.entries) {
+      if (entry.type === "attributes" && entry.attributes.clef) {
+        for (const clef of entry.attributes.clef) {
+          if ((clef.staff ?? 1) === options.staff) {
+            return clef;
+          }
+        }
+      }
+    }
+    if (measure.attributes?.clef) {
+      for (const clef of measure.attributes.clef) {
+        if ((clef.staff ?? 1) === options.staff) {
+          return clef;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function getVoicesForStaff(measure, staff) {
+  const voices = /* @__PURE__ */ new Set();
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      const entryStaff = entry.staff ?? 1;
+      if (entryStaff === staff) {
+        voices.add(entry.voice ?? 1);
+      }
+    }
+  }
+  return Array.from(voices).sort((a, b) => a - b);
+}
+function getStaffRange(score, partIndex) {
+  const part = score.parts[partIndex];
+  if (!part) return { min: 1, max: 1 };
+  let min = 1;
+  let max = 1;
+  for (const measure of part.measures) {
+    if (measure.attributes?.staves !== void 0) {
+      max = Math.max(max, measure.attributes.staves);
+    }
+    for (const entry of measure.entries) {
+      if (entry.type === "note" && entry.staff !== void 0) {
+        max = Math.max(max, entry.staff);
+      }
+    }
+  }
+  return { min, max };
+}
+function getEntriesAtPosition(measure, position, options) {
+  const result = [];
+  const state = createPositionState();
+  for (const entry of measure.entries) {
+    const currentPosition = entry.type === "note" && entry.chord ? state.lastNonChordPosition : state.position;
+    if (currentPosition === position) {
+      if (entry.type === "note") {
+        if (options?.staff !== void 0 && (entry.staff ?? 1) !== options.staff) {
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+        if (options?.voice !== void 0 && entry.voice !== options.voice) {
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+        if (options?.includeChordNotes === false && entry.chord) {
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+      }
+      result.push(entry);
+    }
+    updatePositionForEntry(state, entry);
+  }
+  return result;
+}
+function getNotesAtPosition(measure, position, options) {
+  return getEntriesAtPosition(measure, position, options).filter(
+    (entry) => entry.type === "note"
+  );
+}
+function getEntriesInRange(measure, range, options) {
+  const result = [];
+  const state = createPositionState();
+  for (const entry of measure.entries) {
+    const currentPosition = entry.type === "note" && entry.chord ? state.lastNonChordPosition : state.position;
+    if (currentPosition >= range.start && currentPosition < range.end) {
+      if (entry.type === "note") {
+        if (options?.staff !== void 0 && (entry.staff ?? 1) !== options.staff) {
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+        if (options?.voice !== void 0 && entry.voice !== options.voice) {
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+        if (options?.includeChordNotes === false && entry.chord) {
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+      }
+      result.push(entry);
+    }
+    updatePositionForEntry(state, entry);
+  }
+  return result;
+}
+function getNotesInRange(measure, range, options) {
+  return getEntriesInRange(measure, range, options).filter(
+    (entry) => entry.type === "note"
+  );
+}
+function getVerticalSlice(score, options) {
+  const parts = /* @__PURE__ */ new Map();
+  for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
+    const part = score.parts[partIndex];
+    const measure = part.measures[options.measureIndex];
+    if (!measure) continue;
+    const notes = getNotesAtPosition(measure, options.position);
+    if (notes.length > 0) {
+      parts.set(partIndex, notes);
+    }
+  }
+  return {
+    measureIndex: options.measureIndex,
+    position: options.position,
+    parts
+  };
+}
+function getVoiceLine(score, options) {
+  const part = score.parts[options.partIndex];
+  if (!part) {
+    return { partIndex: options.partIndex, voice: options.voice, staff: options.staff, notes: [] };
+  }
+  const notes = [];
+  for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    const state = createPositionState();
+    for (const entry of measure.entries) {
+      if (entry.type === "note") {
+        const entryStaff = entry.staff ?? 1;
+        const matchesVoice = entry.voice === options.voice;
+        const matchesStaff = options.staff === void 0 || entryStaff === options.staff;
+        if (matchesVoice && matchesStaff) {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          notes.push({
+            note: entry,
+            part,
+            partIndex: options.partIndex,
+            measure,
+            measureIndex,
+            position
+          });
+        }
+      }
+      updatePositionForEntry(state, entry);
+    }
+  }
+  return {
+    partIndex: options.partIndex,
+    voice: options.voice,
+    staff: options.staff,
+    notes
+  };
+}
+function getVoiceLineInRange(score, options) {
+  const part = score.parts[options.partIndex];
+  if (!part) {
+    return { partIndex: options.partIndex, voice: options.voice, staff: options.staff, notes: [] };
+  }
+  const notes = [];
+  for (let measureIndex = options.startMeasure; measureIndex <= options.endMeasure && measureIndex < part.measures.length; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    const state = createPositionState();
+    for (const entry of measure.entries) {
+      if (entry.type === "note") {
+        const entryStaff = entry.staff ?? 1;
+        const matchesVoice = entry.voice === options.voice;
+        const matchesStaff = options.staff === void 0 || entryStaff === options.staff;
+        if (matchesVoice && matchesStaff) {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          notes.push({
+            note: entry,
+            part,
+            partIndex: options.partIndex,
+            measure,
+            measureIndex,
+            position
+          });
+        }
+      }
+      updatePositionForEntry(state, entry);
+    }
+  }
+  return {
+    partIndex: options.partIndex,
+    voice: options.voice,
+    staff: options.staff,
+    notes
+  };
+}
+function* iterateEntries(score) {
+  for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
+    const part = score.parts[partIndex];
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        const position = entry.type === "note" && entry.chord ? state.lastNonChordPosition : state.position;
+        yield {
+          entry,
+          part,
+          partIndex,
+          measure,
+          measureIndex,
+          position
+        };
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+}
+function getNextNote(score, context) {
+  const part = score.parts[context.partIndex];
+  if (!part) return null;
+  let foundCurrent = false;
+  for (let measureIndex = context.measureIndex; measureIndex < part.measures.length; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    const state = createPositionState();
+    for (const entry of measure.entries) {
+      if (entry.type === "note") {
+        const entryPosition = entry.chord ? state.lastNonChordPosition : state.position;
+        if (measureIndex === context.measureIndex && entry === context.note) {
+          foundCurrent = true;
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+        if (foundCurrent && entry.voice === context.note.voice && !entry.chord) {
+          if (context.note.staff !== void 0) {
+            if ((entry.staff ?? 1) !== context.note.staff) {
+              updatePositionForEntry(state, entry);
+              continue;
+            }
+          }
+          return {
+            note: entry,
+            part,
+            partIndex: context.partIndex,
+            measure,
+            measureIndex,
+            position: entryPosition
+          };
+        }
+      }
+      updatePositionForEntry(state, entry);
+    }
+  }
+  return null;
+}
+function getPrevNote(score, context) {
+  const part = score.parts[context.partIndex];
+  if (!part) return null;
+  let lastCandidate = null;
+  for (let measureIndex = 0; measureIndex <= context.measureIndex; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    const state = createPositionState();
+    for (const entry of measure.entries) {
+      if (entry.type === "note") {
+        const entryPosition = entry.chord ? state.lastNonChordPosition : state.position;
+        if (measureIndex === context.measureIndex && entry === context.note) {
+          return lastCandidate;
+        }
+        if (entry.voice === context.note.voice && !entry.chord) {
+          if (context.note.staff !== void 0) {
+            if ((entry.staff ?? 1) !== context.note.staff) {
+              updatePositionForEntry(state, entry);
+              continue;
+            }
+          }
+          lastCandidate = {
+            note: entry,
+            part,
+            partIndex: context.partIndex,
+            measure,
+            measureIndex,
+            position: entryPosition
+          };
+        }
+      }
+      updatePositionForEntry(state, entry);
+    }
+  }
+  return null;
+}
+function getAdjacentNotes(score, context) {
+  return {
+    prev: getPrevNote(score, context),
+    next: getNextNote(score, context)
+  };
+}
+function getDirections(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    const startMeasure = options?.measureIndex ?? 0;
+    const endMeasure = options?.measureIndex !== void 0 ? options.measureIndex + 1 : part.measures.length;
+    for (let measureIndex = startMeasure; measureIndex < endMeasure; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      if (!measure) continue;
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "direction") {
+          results.push({
+            direction: entry,
+            part,
+            partIndex,
+            measure,
+            measureIndex,
+            position: state.position
+          });
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getDirectionsAtPosition(measure, position) {
+  const results = [];
+  const state = createPositionState();
+  for (const entry of measure.entries) {
+    if (entry.type === "direction" && state.position === position) {
+      results.push(entry);
+    }
+    updatePositionForEntry(state, entry);
+  }
+  return results;
+}
+function findDirectionsByType(score, kind) {
+  const allDirections = getDirections(score);
+  return allDirections.filter(
+    (d) => d.direction.directionTypes.some((dt) => dt.kind === kind)
+  );
+}
+function getDynamics(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "direction") {
+          for (const dirType of entry.directionTypes) {
+            if (dirType.kind === "dynamics") {
+              results.push({
+                dynamic: dirType.value,
+                otherDynamics: dirType.otherDynamics,
+                direction: entry,
+                part,
+                partIndex,
+                measure,
+                measureIndex,
+                position: state.position
+              });
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getTempoMarkings(score) {
+  const results = [];
+  for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
+    const part = score.parts[partIndex];
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "direction") {
+          for (const dirType of entry.directionTypes) {
+            if (dirType.kind === "metronome") {
+              results.push({
+                beatUnit: dirType.beatUnit,
+                perMinute: dirType.perMinute,
+                beatUnitDot: dirType.beatUnitDot,
+                direction: entry,
+                partIndex,
+                measureIndex,
+                position: state.position
+              });
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getPedalMarkings(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "direction") {
+          for (const dirType of entry.directionTypes) {
+            if (dirType.kind === "pedal") {
+              results.push({
+                pedalType: dirType.type,
+                direction: entry,
+                partIndex,
+                measureIndex,
+                position: state.position
+              });
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getWedges(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "direction") {
+          for (const dirType of entry.directionTypes) {
+            if (dirType.kind === "wedge") {
+              results.push({
+                wedgeType: dirType.type,
+                direction: entry,
+                partIndex,
+                measureIndex,
+                position: state.position
+              });
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getOctaveShifts(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "direction") {
+          for (const dirType of entry.directionTypes) {
+            if (dirType.kind === "octave-shift") {
+              results.push({
+                shiftType: dirType.type,
+                size: dirType.size,
+                direction: entry,
+                partIndex,
+                measureIndex,
+                position: state.position
+              });
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getTiedNoteGroups(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    const pendingTies = /* @__PURE__ */ new Map();
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "note" && entry.pitch) {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          const pitchKey = `${entry.pitch.step}${entry.pitch.octave}-${entry.voice}`;
+          const context = {
+            note: entry,
+            part,
+            partIndex,
+            measure,
+            measureIndex,
+            position
+          };
+          const hasTieStart = entry.tie?.type === "start" || entry.ties?.some((t) => t.type === "start") || entry.notations?.some((n) => n.type === "tied" && n.tiedType === "start");
+          const hasTieStop = entry.tie?.type === "stop" || entry.ties?.some((t) => t.type === "stop") || entry.notations?.some((n) => n.type === "tied" && n.tiedType === "stop");
+          if (hasTieStop && pendingTies.has(pitchKey)) {
+            const group = pendingTies.get(pitchKey);
+            group.push(context);
+            if (!hasTieStart) {
+              const totalDuration = group.reduce((sum, nc) => sum + nc.note.duration, 0);
+              results.push({ notes: group, totalDuration });
+              pendingTies.delete(pitchKey);
+            }
+          } else if (hasTieStart) {
+            pendingTies.set(pitchKey, [context]);
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getSlurSpans(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    const pendingSlurs = /* @__PURE__ */ new Map();
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "note") {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          const context = {
+            note: entry,
+            part,
+            partIndex,
+            measure,
+            measureIndex,
+            position
+          };
+          if (entry.notations) {
+            for (const notation of entry.notations) {
+              if (notation.type === "slur") {
+                const slurNumber = notation.number ?? 1;
+                if (notation.slurType === "start") {
+                  pendingSlurs.set(slurNumber, { startNote: context, notes: [context] });
+                } else if (notation.slurType === "stop" && pendingSlurs.has(slurNumber)) {
+                  const pending = pendingSlurs.get(slurNumber);
+                  pending.notes.push(context);
+                  results.push({
+                    number: slurNumber,
+                    startNote: pending.startNote,
+                    endNote: context,
+                    notes: pending.notes
+                  });
+                  pendingSlurs.delete(slurNumber);
+                } else if (notation.slurType === "continue" && pendingSlurs.has(slurNumber)) {
+                  pendingSlurs.get(slurNumber).notes.push(context);
+                }
+              }
+            }
+          }
+          for (const [, pending] of pendingSlurs) {
+            const lastNote = pending.notes[pending.notes.length - 1];
+            if (lastNote !== context) {
+              pending.notes.push(context);
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getTupletGroups(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    const pendingTuplets = /* @__PURE__ */ new Map();
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "note") {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          const context = {
+            note: entry,
+            part,
+            partIndex,
+            measure,
+            measureIndex,
+            position
+          };
+          if (entry.notations) {
+            for (const notation of entry.notations) {
+              if (notation.type === "tuplet") {
+                const tupletNumber = notation.number ?? 1;
+                if (notation.tupletType === "start") {
+                  const actualNotes = entry.timeModification?.actualNotes ?? 3;
+                  const normalNotes = entry.timeModification?.normalNotes ?? 2;
+                  pendingTuplets.set(tupletNumber, {
+                    notes: [context],
+                    actualNotes,
+                    normalNotes
+                  });
+                } else if (notation.tupletType === "stop" && pendingTuplets.has(tupletNumber)) {
+                  const pending = pendingTuplets.get(tupletNumber);
+                  pending.notes.push(context);
+                  results.push({
+                    number: tupletNumber,
+                    notes: pending.notes,
+                    actualNotes: pending.actualNotes,
+                    normalNotes: pending.normalNotes
+                  });
+                  pendingTuplets.delete(tupletNumber);
+                }
+              }
+            }
+          }
+          if (entry.timeModification && !entry.notations?.some((n) => n.type === "tuplet")) {
+            for (const [, pending] of pendingTuplets) {
+              if (entry.timeModification.actualNotes === pending.actualNotes && entry.timeModification.normalNotes === pending.normalNotes) {
+                pending.notes.push(context);
+              }
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getBeamGroups(measure) {
+  const results = [];
+  const state = createPositionState();
+  const pendingBeams = /* @__PURE__ */ new Map();
+  for (const entry of measure.entries) {
+    if (entry.type === "note" && entry.beam) {
+      const position = entry.chord ? state.lastNonChordPosition : state.position;
+      const context = {
+        note: entry,
+        part: {},
+        // Will be set by caller if needed
+        partIndex: 0,
+        measure,
+        measureIndex: 0,
+        position
+      };
+      for (const beam of entry.beam) {
+        const beamNumber = beam.number;
+        if (beam.type === "begin") {
+          pendingBeams.set(beamNumber, [context]);
+        } else if (beam.type === "continue" && pendingBeams.has(beamNumber)) {
+          pendingBeams.get(beamNumber).push(context);
+        } else if (beam.type === "end" && pendingBeams.has(beamNumber)) {
+          const group = pendingBeams.get(beamNumber);
+          group.push(context);
+          results.push({
+            notes: group,
+            beamLevel: beamNumber
+          });
+          pendingBeams.delete(beamNumber);
+        }
+      }
+    }
+    updatePositionForEntry(state, entry);
+  }
+  return results;
+}
+function findNotesWithNotation(score, notationType, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "note") {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          if (entry.notations?.some((n) => n.type === notationType)) {
+            results.push({
+              note: entry,
+              part,
+              partIndex,
+              measure,
+              measureIndex,
+              position
+            });
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getHarmonies(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "harmony") {
+          results.push({
+            harmony: entry,
+            part,
+            partIndex,
+            measure,
+            measureIndex,
+            position: state.position
+          });
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getHarmonyAtPosition(measure, position) {
+  const state = createPositionState();
+  let lastHarmony;
+  for (const entry of measure.entries) {
+    if (entry.type === "harmony") {
+      if (state.position <= position) {
+        lastHarmony = entry;
+      }
+    }
+    updatePositionForEntry(state, entry);
+    if (state.position > position && lastHarmony) {
+      break;
+    }
+  }
+  return lastHarmony;
+}
+function getChordProgression(score, options) {
+  const harmonies = getHarmonies(score, options);
+  return harmonies.map((h) => {
+    const rootAlter = h.harmony.root.rootAlter ?? 0;
+    const rootAccidental = rootAlter > 0 ? "#".repeat(rootAlter) : "b".repeat(-rootAlter);
+    const root = h.harmony.root.rootStep + rootAccidental;
+    let bass;
+    if (h.harmony.bass) {
+      const bassAlter = h.harmony.bass.bassAlter ?? 0;
+      const bassAccidental = bassAlter > 0 ? "#".repeat(bassAlter) : "b".repeat(-bassAlter);
+      bass = h.harmony.bass.bassStep + bassAccidental;
+    }
+    return {
+      root,
+      kind: h.harmony.kind,
+      bass,
+      measureIndex: h.measureIndex,
+      position: h.position
+    };
+  });
+}
+function getLyrics(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "note" && entry.lyrics) {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          for (const lyric of entry.lyrics) {
+            const verse = lyric.number ?? 1;
+            if (options?.verse !== void 0 && verse !== options.verse) {
+              continue;
+            }
+            results.push({
+              lyric,
+              note: entry,
+              part,
+              partIndex,
+              measure,
+              measureIndex,
+              position,
+              verse
+            });
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getLyricText(score, options) {
+  const lyrics = getLyrics(score, options);
+  const verseMap = /* @__PURE__ */ new Map();
+  for (const lyric of lyrics) {
+    if (!verseMap.has(lyric.verse)) {
+      verseMap.set(lyric.verse, []);
+    }
+    verseMap.get(lyric.verse).push(lyric);
+  }
+  const results = [];
+  for (const [verse, verseLyrics] of verseMap) {
+    const syllables = [];
+    const textParts = [];
+    for (const lyric of verseLyrics) {
+      const text = lyric.lyric.text;
+      syllables.push({
+        text,
+        position: lyric.position,
+        measureIndex: lyric.measureIndex
+      });
+      const syllabic = lyric.lyric.syllabic;
+      if (syllabic === "begin" || syllabic === "middle") {
+        textParts.push(text + "-");
+      } else if (syllabic === "end") {
+        textParts.push(text + " ");
+      } else {
+        textParts.push(text + " ");
+      }
+    }
+    results.push({
+      verse,
+      text: textParts.join("").trim(),
+      syllables
+    });
+  }
+  return results.sort((a, b) => a.verse - b.verse);
+}
+function getVerseCount(score, options) {
+  const verses = /* @__PURE__ */ new Set();
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (const measure of part.measures) {
+      for (const entry of measure.entries) {
+        if (entry.type === "note" && entry.lyrics) {
+          for (const lyric of entry.lyrics) {
+            verses.add(lyric.number ?? 1);
+          }
+        }
+      }
+    }
+  }
+  return verses.size;
+}
+function getRepeatStructure(score, options) {
+  const results = [];
+  const partIndex = options?.partIndex ?? 0;
+  const part = score.parts[partIndex];
+  if (!part) return results;
+  for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    const measureNumber = measure.number ?? String(measureIndex + 1);
+    if (measure.barlines) {
+      for (const barline of measure.barlines) {
+        if (barline.repeat) {
+          results.push({
+            type: barline.repeat.direction,
+            times: barline.repeat.times,
+            measureIndex,
+            measureNumber
+          });
+        }
+      }
+    }
+  }
+  return results;
+}
+function findBarlines(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const measureNumber = measure.number ?? String(measureIndex + 1);
+      if (measure.barlines) {
+        for (const barline of measure.barlines) {
+          if (options?.style !== void 0 && barline.barStyle !== options.style) {
+            continue;
+          }
+          if (options?.repeat !== void 0) {
+            const hasRepeat = barline.repeat !== void 0;
+            if (hasRepeat !== options.repeat) {
+              continue;
+            }
+          }
+          results.push({
+            barline,
+            partIndex,
+            measureIndex,
+            measureNumber
+          });
+        }
+      }
+    }
+  }
+  return results;
+}
+function getEndings(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const measureNumber = measure.number ?? String(measureIndex + 1);
+      if (measure.barlines) {
+        for (const barline of measure.barlines) {
+          if (barline.ending) {
+            results.push({
+              number: barline.ending.number,
+              type: barline.ending.type,
+              partIndex,
+              measureIndex,
+              measureNumber
+            });
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+function getKeyChanges(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    let lastKey;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const measureNumber = measure.number ?? String(measureIndex + 1);
+      const state = createPositionState();
+      if (measure.attributes?.key) {
+        const key = measure.attributes.key;
+        if (!lastKey || lastKey.fifths !== key.fifths || lastKey.mode !== key.mode) {
+          results.push({
+            key,
+            partIndex,
+            measureIndex,
+            measureNumber,
+            position: 0
+          });
+          lastKey = key;
+        }
+      }
+      for (const entry of measure.entries) {
+        if (entry.type === "attributes" && entry.attributes.key) {
+          const key = entry.attributes.key;
+          if (!lastKey || lastKey.fifths !== key.fifths || lastKey.mode !== key.mode) {
+            results.push({
+              key,
+              partIndex,
+              measureIndex,
+              measureNumber,
+              position: state.position
+            });
+            lastKey = key;
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getTimeChanges(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    let lastTime;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const measureNumber = measure.number ?? String(measureIndex + 1);
+      if (measure.attributes?.time) {
+        const time = measure.attributes.time;
+        if (!lastTime || lastTime.beats !== time.beats || lastTime.beatType !== time.beatType) {
+          results.push({
+            time,
+            partIndex,
+            measureIndex,
+            measureNumber
+          });
+          lastTime = time;
+        }
+      }
+      for (const entry of measure.entries) {
+        if (entry.type === "attributes" && entry.attributes.time) {
+          const time = entry.attributes.time;
+          if (!lastTime || lastTime.beats !== time.beats || lastTime.beatType !== time.beatType) {
+            results.push({
+              time,
+              partIndex,
+              measureIndex,
+              measureNumber
+            });
+            lastTime = time;
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+function getClefChanges(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    const lastClefs = /* @__PURE__ */ new Map();
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const measureNumber = measure.number ?? String(measureIndex + 1);
+      const state = createPositionState();
+      if (measure.attributes?.clef) {
+        for (const clef of measure.attributes.clef) {
+          const staff = clef.staff ?? 1;
+          if (options?.staff !== void 0 && staff !== options.staff) {
+            continue;
+          }
+          const lastClef = lastClefs.get(staff);
+          if (!lastClef || lastClef.sign !== clef.sign || lastClef.line !== clef.line || lastClef.clefOctaveChange !== clef.clefOctaveChange) {
+            results.push({
+              clef,
+              staff,
+              partIndex,
+              measureIndex,
+              measureNumber,
+              position: 0
+            });
+            lastClefs.set(staff, clef);
+          }
+        }
+      }
+      for (const entry of measure.entries) {
+        if (entry.type === "attributes" && entry.attributes.clef) {
+          for (const clef of entry.attributes.clef) {
+            const staff = clef.staff ?? 1;
+            if (options?.staff !== void 0 && staff !== options.staff) {
+              continue;
+            }
+            const lastClef = lastClefs.get(staff);
+            if (!lastClef || lastClef.sign !== clef.sign || lastClef.line !== clef.line || lastClef.clefOctaveChange !== clef.clefOctaveChange) {
+              results.push({
+                clef,
+                staff,
+                partIndex,
+                measureIndex,
+                measureNumber,
+                position: state.position
+              });
+              lastClefs.set(staff, clef);
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getStructuralChanges(score, options) {
+  return {
+    keyChanges: getKeyChanges(score, options),
+    timeChanges: getTimeChanges(score, options),
+    clefChanges: getClefChanges(score, options)
+  };
+}
+function getPartByIndex(score, index) {
+  return score.parts[index];
+}
+function getPartCount(score) {
+  return score.parts.length;
+}
+function getPartIds(score) {
+  return score.parts.map((part) => part.id);
+}
+function getMeasure(score, options) {
+  const part = score.parts[options.part];
+  if (!part) return void 0;
+  const targetMeasure = String(options.measure);
+  return part.measures.find((m) => m.number === targetMeasure);
+}
+function getMeasureByIndex(score, options) {
+  const part = score.parts[options.part];
+  if (!part) return void 0;
+  return part.measures[options.measureIndex];
+}
+function getMeasureCount(score) {
+  if (score.parts.length === 0) return 0;
+  return score.parts[0].measures.length;
+}
+function getDivisions(score, options) {
+  const part = score.parts[options.part];
+  if (!part) return 1;
+  const targetMeasure = parseInt(String(options.measure), 10);
+  if (isNaN(targetMeasure)) return 1;
+  for (let i = 0; i < part.measures.length; i++) {
+    const m = part.measures[i];
+    const mNum = parseInt(m.number, 10);
+    if (!isNaN(mNum) && mNum > targetMeasure) break;
+    if (m.attributes?.divisions !== void 0) {
+    }
+  }
+  let divisions = 1;
+  for (const m of part.measures) {
+    const mNum = parseInt(m.number, 10);
+    if (!isNaN(mNum) && mNum > targetMeasure) break;
+    if (m.attributes?.divisions !== void 0) {
+      divisions = m.attributes.divisions;
+    }
+  }
+  return divisions;
+}
+function getAttributesAtMeasure(score, options) {
+  const part = score.parts[options.part];
+  if (!part) return {};
+  const targetMeasure = parseInt(String(options.measure), 10);
+  const result = {};
+  for (const m of part.measures) {
+    const mNum = parseInt(m.number, 10);
+    if (!isNaN(targetMeasure) && !isNaN(mNum) && mNum > targetMeasure) break;
+    if (m.attributes) {
+      if (m.attributes.divisions !== void 0) result.divisions = m.attributes.divisions;
+      if (m.attributes.time !== void 0) result.time = m.attributes.time;
+      if (m.attributes.key !== void 0) result.key = m.attributes.key;
+      if (m.attributes.clef !== void 0) result.clef = m.attributes.clef;
+      if (m.attributes.staves !== void 0) result.staves = m.attributes.staves;
+      if (m.attributes.transpose !== void 0) result.transpose = m.attributes.transpose;
+    }
+  }
+  return result;
+}
+function findNotes(score, filter) {
+  const results = [];
+  for (const part of score.parts) {
+    for (const measure of part.measures) {
+      for (const entry of measure.entries) {
+        if (entry.type !== "note") continue;
+        if (filter.pitchRange && entry.pitch) {
+          const noteValue = pitchToSemitone(entry.pitch);
+          if (filter.pitchRange.min) {
+            const minValue = pitchToSemitone(filter.pitchRange.min);
+            if (noteValue < minValue) continue;
+          }
+          if (filter.pitchRange.max) {
+            const maxValue = pitchToSemitone(filter.pitchRange.max);
+            if (noteValue > maxValue) continue;
+          }
+        }
+        if (filter.voice !== void 0 && entry.voice !== filter.voice) continue;
+        if (filter.staff !== void 0 && (entry.staff ?? 1) !== filter.staff) continue;
+        if (filter.noteType !== void 0 && entry.noteType !== filter.noteType) continue;
+        if (filter.hasTie !== void 0) {
+          const hasTie = entry.tie !== void 0;
+          if (filter.hasTie !== hasTie) continue;
+        }
+        results.push(entry);
+      }
+    }
+  }
+  return results;
+}
+function getDuration(score) {
+  if (score.parts.length === 0) return 0;
+  const part = score.parts[0];
+  let totalDuration = 0;
+  let divisions = 1;
+  for (const measure of part.measures) {
+    if (measure.attributes?.divisions !== void 0) {
+      divisions = measure.attributes.divisions;
+    }
+    let measureDuration = 0;
+    for (const entry of measure.entries) {
+      if (entry.type === "note" && !entry.chord) {
+        measureDuration = Math.max(measureDuration, entry.duration);
+      }
+    }
+    const attrs = getAttributesAtMeasure(score, { part: 0, measure: measure.number });
+    if (attrs.time) {
+      const beats = parseInt(attrs.time.beats, 10) || 4;
+      const expectedDuration = beats / attrs.time.beatType * 4 * divisions;
+      measureDuration = Math.max(measureDuration, expectedDuration);
+    }
+    totalDuration += measureDuration;
+  }
+  return totalDuration;
+}
+function getPartById(score, id) {
+  return score.parts.find((p) => p.id === id);
+}
+function getPartIndex(score, id) {
+  return score.parts.findIndex((p) => p.id === id);
+}
+function hasMultipleStaves(score, partIndex = 0) {
+  const part = score.parts[partIndex];
+  if (!part) return false;
+  for (const measure of part.measures) {
+    if (measure.attributes?.staves !== void 0 && measure.attributes.staves > 1) {
+      return true;
+    }
+  }
+  return false;
+}
+function getStaveCount(score, partIndex = 0) {
+  const part = score.parts[partIndex];
+  if (!part) return 1;
+  for (const measure of part.measures) {
+    if (measure.attributes?.staves !== void 0) {
+      return measure.attributes.staves;
+    }
+  }
+  return 1;
+}
+function measureRoundtrip(original, exported) {
+  const notesOriginal = countNotes(original);
+  const notesExported = countNotes(exported);
+  const notesPreserved = Math.min(notesOriginal, notesExported);
+  const measuresOriginal = getMeasureCount(original);
+  const measuresExported = getMeasureCount(exported);
+  const measuresPreserved = Math.min(measuresOriginal, measuresExported);
+  const partsOriginal = original.parts.length;
+  const partsExported = exported.parts.length;
+  const partsPreserved = Math.min(partsOriginal, partsExported);
+  const preservationRate = notesOriginal > 0 ? notesPreserved / notesOriginal : 1;
+  return {
+    notesOriginal,
+    notesPreserved,
+    measuresOriginal,
+    measuresPreserved,
+    partsOriginal,
+    partsPreserved,
+    preservationRate
+  };
+}
+function countNotes(score) {
+  let count = 0;
+  for (const part of score.parts) {
+    for (const measure of part.measures) {
+      for (const entry of measure.entries) {
+        if (entry.type === "note") {
+          count++;
+        }
+      }
+    }
+  }
+  return count;
+}
+function scoresEqual(a, b) {
+  if (a.parts.length !== b.parts.length) return false;
+  for (let i = 0; i < a.parts.length; i++) {
+    const partA = a.parts[i];
+    const partB = b.parts[i];
+    if (partA.measures.length !== partB.measures.length) return false;
+    for (let j = 0; j < partA.measures.length; j++) {
+      const measureA = partA.measures[j];
+      const measureB = partB.measures[j];
+      if (measureA.number !== measureB.number) return false;
+      const notesA = measureA.entries.filter((e) => e.type === "note");
+      const notesB = measureB.entries.filter((e) => e.type === "note");
+      if (notesA.length !== notesB.length) return false;
+      for (let k = 0; k < notesA.length; k++) {
+        const noteA = notesA[k];
+        const noteB = notesB[k];
+        if (!pitchesEqual(noteA.pitch, noteB.pitch)) return false;
+        if (noteA.duration !== noteB.duration) return false;
+        if (noteA.voice !== noteB.voice) return false;
+      }
+    }
+  }
+  return true;
+}
+function pitchesEqual(a, b) {
+  if (a === void 0 && b === void 0) return true;
+  if (a === void 0 || b === void 0) return false;
+  return a.step === b.step && a.octave === b.octave && (a.alter ?? 0) === (b.alter ?? 0);
+}
+
+export {
+  STEPS,
+  STEP_SEMITONES,
+  pitchToSemitone,
+  getAccidentalsInMeasure,
+  semitoneToKeyAwarePitch,
+  determineAccidental,
+  getAbsolutePositionForNote,
+  getMeasureEndPosition,
+  getNotesForVoice,
+  getNotesForStaff,
+  groupByVoice,
+  groupByStaff,
+  getAbsolutePosition,
+  withAbsolutePositions,
+  getChords,
+  iterateNotes,
+  getAllNotes,
+  getVoices,
+  getStaves,
+  hasNotes,
+  isRestMeasure,
+  getNormalizedPosition,
+  getNormalizedDuration,
+  getEntriesForStaff,
+  buildVoiceToStaffMap,
+  buildVoiceToStaffMapForPart,
+  inferStaff,
+  getEffectiveStaff,
+  getClefForStaff,
+  getVoicesForStaff,
+  getStaffRange,
+  getEntriesAtPosition,
+  getNotesAtPosition,
+  getEntriesInRange,
+  getNotesInRange,
+  getVerticalSlice,
+  getVoiceLine,
+  getVoiceLineInRange,
+  iterateEntries,
+  getNextNote,
+  getPrevNote,
+  getAdjacentNotes,
+  getDirections,
+  getDirectionsAtPosition,
+  findDirectionsByType,
+  getDynamics,
+  getTempoMarkings,
+  getPedalMarkings,
+  getWedges,
+  getOctaveShifts,
+  getTiedNoteGroups,
+  getSlurSpans,
+  getTupletGroups,
+  getBeamGroups,
+  findNotesWithNotation,
+  getHarmonies,
+  getHarmonyAtPosition,
+  getChordProgression,
+  getLyrics,
+  getLyricText,
+  getVerseCount,
+  getRepeatStructure,
+  findBarlines,
+  getEndings,
+  getKeyChanges,
+  getTimeChanges,
+  getClefChanges,
+  getStructuralChanges,
+  getPartByIndex,
+  getPartCount,
+  getPartIds,
+  getMeasure,
+  getMeasureByIndex,
+  getMeasureCount,
+  getDivisions,
+  getAttributesAtMeasure,
+  findNotes,
+  getDuration,
+  getPartById,
+  getPartIndex,
+  hasMultipleStaves,
+  getStaveCount,
+  measureRoundtrip,
+  countNotes,
+  scoresEqual
+};