musicxml-io 0.2.7 → 0.2.8

package/dist/query/index.js

@@ -20,20 +20,83 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/query/index.ts
 var query_exports = {};
 __export(query_exports, {
+  buildVoiceToStaffMap: () => buildVoiceToStaffMap,
+  buildVoiceToStaffMapForPart: () => buildVoiceToStaffMapForPart,
   countNotes: () => countNotes,
+  findBarlines: () => findBarlines,
+  findDirectionsByType: () => findDirectionsByType,
   findNotes: () => findNotes,
+  findNotesWithNotation: () => findNotesWithNotation,
+  getAbsolutePosition: () => getAbsolutePosition,
+  getAdjacentNotes: () => getAdjacentNotes,
+  getAllNotes: () => getAllNotes,
   getAttributesAtMeasure: () => getAttributesAtMeasure,
+  getBeamGroups: () => getBeamGroups,
+  getChordProgression: () => getChordProgression,
+  getChords: () => getChords,
+  getClefChanges: () => getClefChanges,
+  getClefForStaff: () => getClefForStaff,
+  getDirections: () => getDirections,
+  getDirectionsAtPosition: () => getDirectionsAtPosition,
   getDivisions: () => getDivisions,
   getDuration: () => getDuration,
+  getDynamics: () => getDynamics,
+  getEffectiveStaff: () => getEffectiveStaff,
+  getEndings: () => getEndings,
+  getEntriesAtPosition: () => getEntriesAtPosition,
+  getEntriesForStaff: () => getEntriesForStaff,
+  getEntriesInRange: () => getEntriesInRange,
+  getHarmonies: () => getHarmonies,
+  getHarmonyAtPosition: () => getHarmonyAtPosition,
+  getKeyChanges: () => getKeyChanges,
+  getLyricText: () => getLyricText,
+  getLyrics: () => getLyrics,
   getMeasure: () => getMeasure,
   getMeasureByIndex: () => getMeasureByIndex,
   getMeasureCount: () => getMeasureCount,
+  getNextNote: () => getNextNote,
+  getNormalizedDuration: () => getNormalizedDuration,
+  getNormalizedPosition: () => getNormalizedPosition,
+  getNotesAtPosition: () => getNotesAtPosition,
+  getNotesForStaff: () => getNotesForStaff,
+  getNotesForVoice: () => getNotesForVoice,
+  getNotesInRange: () => getNotesInRange,
+  getOctaveShifts: () => getOctaveShifts,
   getPartById: () => getPartById,
+  getPartByIndex: () => getPartByIndex,
+  getPartCount: () => getPartCount,
+  getPartIds: () => getPartIds,
   getPartIndex: () => getPartIndex,
+  getPedalMarkings: () => getPedalMarkings,
+  getPrevNote: () => getPrevNote,
+  getRepeatStructure: () => getRepeatStructure,
+  getSlurSpans: () => getSlurSpans,
+  getStaffRange: () => getStaffRange,
   getStaveCount: () => getStaveCount,
+  getStaves: () => getStaves,
+  getStructuralChanges: () => getStructuralChanges,
+  getTempoMarkings: () => getTempoMarkings,
+  getTiedNoteGroups: () => getTiedNoteGroups,
+  getTimeChanges: () => getTimeChanges,
+  getTupletGroups: () => getTupletGroups,
+  getVerseCount: () => getVerseCount,
+  getVerticalSlice: () => getVerticalSlice,
+  getVoiceLine: () => getVoiceLine,
+  getVoiceLineInRange: () => getVoiceLineInRange,
+  getVoices: () => getVoices,
+  getVoicesForStaff: () => getVoicesForStaff,
+  getWedges: () => getWedges,
+  groupByStaff: () => groupByStaff,
+  groupByVoice: () => groupByVoice,
   hasMultipleStaves: () => hasMultipleStaves,
+  hasNotes: () => hasNotes,
+  inferStaff: () => inferStaff,
+  isRestMeasure: () => isRestMeasure,
+  iterateEntries: () => iterateEntries,
+  iterateNotes: () => iterateNotes,
   measureRoundtrip: () => measureRoundtrip,
-  scoresEqual: () => scoresEqual
+  scoresEqual: () => scoresEqual,
+  withAbsolutePositions: () => withAbsolutePositions
 });
 module.exports = __toCommonJS(query_exports);
 
@@ -50,8 +113,1388 @@ var STEP_SEMITONES = {
 function pitchToSemitone(pitch) {
   return pitch.octave * 12 + STEP_SEMITONES[pitch.step] + (pitch.alter ?? 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;
+}
 
 // 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;
+    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);
+    }
+  }
+  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;
+      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;
+        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);
+  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);
+      }
+    }
+  }
+  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,
+                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;
@@ -254,18 +1697,81 @@ function pitchesEqual(a, b) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildVoiceToStaffMap,
+  buildVoiceToStaffMapForPart,
   countNotes,
+  findBarlines,
+  findDirectionsByType,
   findNotes,
+  findNotesWithNotation,
+  getAbsolutePosition,
+  getAdjacentNotes,
+  getAllNotes,
   getAttributesAtMeasure,
+  getBeamGroups,
+  getChordProgression,
+  getChords,
+  getClefChanges,
+  getClefForStaff,
+  getDirections,
+  getDirectionsAtPosition,
   getDivisions,
   getDuration,
+  getDynamics,
+  getEffectiveStaff,
+  getEndings,
+  getEntriesAtPosition,
+  getEntriesForStaff,
+  getEntriesInRange,
+  getHarmonies,
+  getHarmonyAtPosition,
+  getKeyChanges,
+  getLyricText,
+  getLyrics,
   getMeasure,
   getMeasureByIndex,
   getMeasureCount,
+  getNextNote,
+  getNormalizedDuration,
+  getNormalizedPosition,
+  getNotesAtPosition,
+  getNotesForStaff,
+  getNotesForVoice,
+  getNotesInRange,
+  getOctaveShifts,
   getPartById,
+  getPartByIndex,
+  getPartCount,
+  getPartIds,
   getPartIndex,
+  getPedalMarkings,
+  getPrevNote,
+  getRepeatStructure,
+  getSlurSpans,
+  getStaffRange,
   getStaveCount,
+  getStaves,
+  getStructuralChanges,
+  getTempoMarkings,
+  getTiedNoteGroups,
+  getTimeChanges,
+  getTupletGroups,
+  getVerseCount,
+  getVerticalSlice,
+  getVoiceLine,
+  getVoiceLineInRange,
+  getVoices,
+  getVoicesForStaff,
+  getWedges,
+  groupByStaff,
+  groupByVoice,
   hasMultipleStaves,
+  hasNotes,
+  inferStaff,
+  isRestMeasure,
+  iterateEntries,
+  iterateNotes,
   measureRoundtrip,
-  scoresEqual
+  scoresEqual,
+  withAbsolutePositions
 });