musicxml-io 0.1.0 → 0.2.0

package/dist/accessors/index.mjs

@@ -178,21 +178,1271 @@ 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);
+}
 export {
+  buildVoiceToStaffMap,
+  buildVoiceToStaffMapForPart,
+  findBarlines,
+  findDirectionsByType,
+  findNotesWithNotation,
   getAbsolutePosition,
+  getAdjacentNotes,
   getAllNotes,
+  getBeamGroups,
+  getChordProgression,
   getChords,
+  getClefChanges,
+  getClefForStaff,
+  getDirections,
+  getDirectionsAtPosition,
+  getDynamics,
+  getEffectiveStaff,
+  getEndings,
+  getEntriesAtPosition,
+  getEntriesForStaff,
+  getEntriesInRange,
+  getHarmonies,
+  getHarmonyAtPosition,
+  getKeyChanges,
+  getLyricText,
+  getLyrics,
+  getNextNote,
   getNormalizedDuration,
   getNormalizedPosition,
+  getNotesAtPosition,
   getNotesForStaff,
   getNotesForVoice,
+  getNotesInRange,
+  getOctaveShifts,
+  getPartByIndex,
+  getPartCount,
+  getPartIds,
+  getPedalMarkings,
+  getPrevNote,
+  getRepeatStructure,
+  getSlurSpans,
+  getStaffRange,
   getStaves,
+  getStructuralChanges,
+  getTempoMarkings,
+  getTiedNoteGroups,
+  getTimeChanges,
+  getTupletGroups,
+  getVerseCount,
+  getVerticalSlice,
+  getVoiceLine,
+  getVoiceLineInRange,
   getVoices,
+  getVoicesForStaff,
+  getWedges,
   groupByStaff,
   groupByVoice,
   hasNotes,
+  inferStaff,
   isRestMeasure,
+  iterateEntries,
   iterateNotes,
   withAbsolutePositions
 };
-//# sourceMappingURL=index.mjs.map