musicxml-io 0.2.7 → 0.2.9

package/dist/accessors/index.mjs

@@ -1,1448 +0,0 @@
-// src/utils/index.ts
-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/accessors/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);
-}
-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
-};