@scorelabs/core 1.0.1

package/dist/importers/MusicXMLParser.d.ts

@@ -0,0 +1,36 @@
+import { ScoreJSON } from '../models/Score';
+/**
+ * MusicXML Parser
+ *
+ * Shared implementation for both frontend and backend.
+ * Expects a DOMParser-compatible constructor in Node.js environments.
+ */
+export declare class MusicXMLParser {
+    private currentKeyFifths;
+    private currentBeats;
+    private currentBeatType;
+    private instrumentPitchMap;
+    private _domParser;
+    constructor(domParserInstance?: any);
+    private parseFromString;
+    parseBinary(data: ArrayBuffer): Promise<ScoreJSON>;
+    parse(xmlString: string): ScoreJSON;
+    private parseSubtitle;
+    private parseTitle;
+    private parseComposer;
+    private parsePartList;
+    private parseParts;
+    private parsePart;
+    private parseNote;
+    private parseHarmony;
+    private parseBarlines;
+    private postProcess;
+    private cleanAccidentals;
+    private pitchToMidi;
+    private mapDuration;
+    private mapClef;
+    private mapAccidental;
+    private stepToNumber;
+    private getText;
+    private getNumber;
+}

package/dist/importers/MusicXMLParser.js

@@ -0,0 +1,610 @@
+import JSZip from 'jszip';
+import { Clef, Duration, Accidental, Articulation, BarlineStyle, } from '../models/types';
+/**
+ * MusicXML Parser
+ *
+ * Shared implementation for both frontend and backend.
+ * Expects a DOMParser-compatible constructor in Node.js environments.
+ */
+export class MusicXMLParser {
+    currentKeyFifths = 0;
+    currentBeats = 4;
+    currentBeatType = 4;
+    instrumentPitchMap = new Map();
+    _domParser;
+    constructor(domParserInstance) {
+        this._domParser = domParserInstance || (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
+    }
+    parseFromString(xmlString) {
+        if (!this._domParser) {
+            throw new Error('No DOMParser available. Please provide one in the constructor for Node.js environments.');
+        }
+        return this._domParser.parseFromString(xmlString, 'application/xml');
+    }
+    async parseBinary(data) {
+        const uint8 = new Uint8Array(data);
+        if (uint8[0] === 0x50 && uint8[1] === 0x4b) {
+            const zip = await JSZip.loadAsync(data);
+            const containerXml = await zip.file('META-INF/container.xml')?.async('text');
+            if (!containerXml)
+                throw new Error('Invalid MXL: Missing META-INF/container.xml');
+            const containerDoc = this.parseFromString(containerXml);
+            const rootfile = containerDoc.querySelector('rootfile');
+            const fullPath = rootfile?.getAttribute('full-path');
+            if (!fullPath)
+                throw new Error('Invalid MXL: Could not find main score file path');
+            const scoreXml = await zip.file(fullPath)?.async('text');
+            if (!scoreXml)
+                throw new Error(`Invalid MXL: Could not find file ${fullPath}`);
+            return this.parse(scoreXml);
+        }
+        else {
+            const decoder = new TextDecoder();
+            return this.parse(decoder.decode(data));
+        }
+    }
+    parse(xmlString) {
+        this.instrumentPitchMap.clear();
+        const doc = this.parseFromString(xmlString);
+        const parseError = doc.querySelector('parsererror');
+        if (parseError)
+            throw new Error(`XML parsing error: ${parseError.textContent}`);
+        const root = doc.documentElement;
+        if (root.tagName !== 'score-partwise')
+            throw new Error(`Unsupported format: ${root.tagName}`);
+        const title = this.parseTitle(doc);
+        const subtitle = this.parseSubtitle(doc);
+        const composer = this.parseComposer(doc);
+        const partNames = this.parsePartList(doc);
+        const parts = this.parseParts(doc, partNames);
+        let globalBpm = 120;
+        let globalTempoDuration = Duration.Quarter;
+        let globalTempoIsDotted = false;
+        if (parts.length > 0 && parts[0].staves.length > 0 && parts[0].staves[0].measures.length > 0) {
+            const firstMeasure = parts[0].staves[0].measures[0];
+            if (firstMeasure.tempo) {
+                globalBpm = firstMeasure.tempo.bpm;
+                globalTempoDuration = firstMeasure.tempo.duration;
+                globalTempoIsDotted = firstMeasure.tempo.isDotted;
+            }
+        }
+        const score = {
+            title, subtitle, composer,
+            timeSignature: { beats: this.currentBeats, beatType: this.currentBeatType },
+            keySignature: { fifths: this.currentKeyFifths },
+            parts,
+            bpm: globalBpm,
+            tempoDuration: globalTempoDuration,
+            tempoIsDotted: globalTempoIsDotted,
+        };
+        return this.postProcess(score);
+    }
+    parseSubtitle(doc) {
+        let subtitle = this.getText(doc.documentElement, 'movement-subtitle');
+        if (subtitle)
+            return subtitle;
+        const work = doc.querySelector('work');
+        if (work) {
+            subtitle = this.getText(work, 'work-subtitle');
+            if (subtitle)
+                return subtitle;
+            subtitle = this.getText(work, 'work-number');
+            if (subtitle)
+                return subtitle;
+        }
+        const credits = doc.querySelectorAll('credit');
+        for (const credit of Array.from(credits)) {
+            const type = credit.querySelector('credit-type');
+            if (type?.textContent?.toLowerCase() === 'subtitle') {
+                const words = credit.querySelector('credit-words');
+                if (words?.textContent)
+                    return words.textContent;
+            }
+        }
+        return '';
+    }
+    parseTitle(doc) {
+        let title = this.getText(doc.documentElement, 'work-title');
+        if (!title)
+            title = this.getText(doc.documentElement, 'movement-title');
+        return title ?? 'Untitled';
+    }
+    parseComposer(doc) {
+        const creators = doc.querySelectorAll('identification creator');
+        for (const creator of Array.from(creators)) {
+            if (creator.getAttribute('type') === 'composer')
+                return creator.textContent ?? 'Unknown';
+        }
+        return doc.querySelector('identification creator')?.textContent ?? 'Unknown';
+    }
+    parsePartList(doc) {
+        const partNames = new Map();
+        const scoreParts = doc.querySelectorAll('part-list score-part');
+        for (const scorePart of Array.from(scoreParts)) {
+            const id = scorePart.getAttribute('id');
+            const name = this.getText(scorePart, 'part-name');
+            if (id)
+                partNames.set(id, name?.trim() || 'Part');
+            const midiInstruments = scorePart.querySelectorAll('midi-instrument');
+            for (const midiInst of Array.from(midiInstruments)) {
+                const instId = midiInst.getAttribute('id');
+                const unpitched = this.getNumber(midiInst, 'midi-unpitched');
+                if (instId && unpitched !== null)
+                    this.instrumentPitchMap.set(instId, unpitched);
+            }
+        }
+        return partNames;
+    }
+    parseParts(doc, partNames) {
+        const parts = [];
+        const partElements = doc.querySelectorAll('part');
+        for (const partElement of Array.from(partElements)) {
+            const id = partElement.getAttribute('id');
+            const name = partNames.get(id ?? '') ?? 'Part';
+            parts.push({ name, staves: this.parsePart(partElement) });
+        }
+        return parts;
+    }
+    parsePart(partElement) {
+        const measureElements = partElement.querySelectorAll('measure');
+        let numStaves = 1;
+        const firstMeasure = partElement.querySelector('measure');
+        if (firstMeasure) {
+            const stavesNode = firstMeasure.querySelector('attributes staves');
+            if (stavesNode)
+                numStaves = parseInt(stavesNode.textContent || '1');
+        }
+        const staves = Array.from({ length: numStaves }, () => ({ clef: 'treble', measures: [] }));
+        const staffClefs = Array(numStaves).fill(Clef.Treble);
+        for (const measureElement of Array.from(measureElements)) {
+            let measureTimeSignature;
+            let measureKeySignature;
+            const isPickup = measureElement.getAttribute('implicit') === 'yes';
+            const attributes = measureElement.querySelector('attributes');
+            if (attributes) {
+                const fifths = this.getNumber(attributes, 'key fifths');
+                if (fifths !== null) {
+                    this.currentKeyFifths = fifths;
+                    measureKeySignature = { fifths: this.currentKeyFifths };
+                }
+                const beats = this.getNumber(attributes, 'time beats');
+                const beatType = this.getNumber(attributes, 'time beat-type');
+                if (beats !== null) {
+                    this.currentBeats = beats;
+                    if (beatType !== null)
+                        this.currentBeatType = beatType;
+                    const timeElement = attributes.querySelector('time');
+                    let symbol = 'normal';
+                    if (timeElement) {
+                        const symAttr = timeElement.getAttribute('symbol');
+                        if (symAttr === 'common')
+                            symbol = 'common';
+                        if (symAttr === 'cut')
+                            symbol = 'cut';
+                    }
+                    measureTimeSignature = { beats: this.currentBeats, beatType: this.currentBeatType, symbol };
+                }
+                const clefElements = attributes.querySelectorAll('clef');
+                clefElements.forEach((clef) => {
+                    const number = parseInt(clef.getAttribute('number') || '1');
+                    const sign = this.getText(clef, 'sign');
+                    if (sign && number <= numStaves) {
+                        const line = this.getNumber(clef, 'line') || 0;
+                        staffClefs[number - 1] = this.mapClef(sign, line);
+                    }
+                });
+                const staffDetails = attributes.querySelectorAll('staff-details');
+                staffDetails.forEach((sd) => {
+                    const number = parseInt(sd.getAttribute('number') || '1');
+                    const lines = this.getNumber(sd, 'staff-lines');
+                    if (lines !== null && number <= numStaves)
+                        staves[number - 1].lineCount = lines;
+                });
+            }
+            let measureTempo = undefined;
+            let rehearsalMark = undefined;
+            let systemText = undefined;
+            let contextDynamic = undefined;
+            const directions = measureElement.querySelectorAll('direction');
+            directions.forEach((dir) => {
+                const metronome = dir.querySelector('metronome');
+                if (metronome) {
+                    const beatUnit = this.getText(metronome, 'beat-unit') || 'quarter';
+                    const bpm = parseInt(this.getText(metronome, 'per-minute') || '120');
+                    const isDotted = metronome.querySelector('beat-unit-dot') !== null;
+                    measureTempo = { bpm, duration: this.mapDuration(beatUnit), isDotted };
+                }
+                const rehearsal = dir.querySelector('rehearsal');
+                if (rehearsal)
+                    rehearsalMark = rehearsal.textContent || undefined;
+                const words = dir.querySelector('words');
+                if (words)
+                    systemText = words.textContent || undefined;
+                const dynamics = dir.querySelector('dynamics');
+                if (dynamics && dynamics.firstElementChild)
+                    contextDynamic = dynamics.firstElementChild.nodeName.toLowerCase();
+            });
+            const { repeats, volta, barlineStyle } = this.parseBarlines(measureElement);
+            const measureVoices = Array.from({ length: numStaves }, () => []);
+            const children = Array.from(measureElement.children);
+            let pendingChord = undefined;
+            let currentNoteSetMap = new Map();
+            const beamGroupIdMap = new Map();
+            let globalBeamId = 1;
+            children.forEach((child) => {
+                if (child.nodeName === 'harmony')
+                    pendingChord = this.parseHarmony(child);
+                else if (child.nodeName === 'note') {
+                    const staffNum = parseInt(this.getText(child, 'staff') || '1');
+                    const staffIdx = Math.min(Math.max(staffNum - 1, 0), numStaves - 1);
+                    const isChord = child.querySelector('chord') !== null;
+                    const note = this.parseNote(child);
+                    if (note) {
+                        const beamEl = child.querySelector('beam[number="1"]');
+                        if (beamEl) {
+                            const beamType = beamEl.textContent;
+                            if (beamType === 'begin') {
+                                const newId = globalBeamId++;
+                                beamGroupIdMap.set(staffIdx, newId);
+                                note.beamGroup = newId;
+                            }
+                            else if (beamType === 'continue' || beamType === 'end') {
+                                const currentId = beamGroupIdMap.get(staffIdx);
+                                if (currentId !== undefined) {
+                                    note.beamGroup = currentId;
+                                    if (beamType === 'end')
+                                        beamGroupIdMap.delete(staffIdx);
+                                }
+                            }
+                        }
+                        if (pendingChord) {
+                            note.chord = pendingChord;
+                            pendingChord = undefined;
+                        }
+                        if (contextDynamic) {
+                            note.dynamic = contextDynamic;
+                            contextDynamic = undefined;
+                        }
+                        if (isChord) {
+                            const existing = currentNoteSetMap.get(staffIdx);
+                            if (existing)
+                                existing.push(note);
+                            else
+                                currentNoteSetMap.set(staffIdx, [note]);
+                        }
+                        else {
+                            const existing = currentNoteSetMap.get(staffIdx);
+                            if (existing)
+                                measureVoices[staffIdx].push({ notes: existing });
+                            currentNoteSetMap.set(staffIdx, [note]);
+                        }
+                    }
+                }
+                else if (child.nodeName === 'backup' || child.nodeName === 'forward') {
+                    for (const [sIdx, notes] of currentNoteSetMap.entries()) {
+                        if (notes.length > 0)
+                            measureVoices[sIdx].push({ notes });
+                    }
+                    currentNoteSetMap.clear();
+                }
+            });
+            for (const [sIdx, notes] of currentNoteSetMap.entries()) {
+                if (notes.length > 0)
+                    measureVoices[sIdx].push({ notes });
+            }
+            for (let i = 0; i < numStaves; i++) {
+                staves[i].measures.push({
+                    voices: [measureVoices[i]],
+                    timeSignature: measureTimeSignature,
+                    keySignature: measureKeySignature,
+                    isPickup: isPickup || undefined,
+                    tempo: i === 0 ? measureTempo : undefined,
+                    repeats: repeats.length > 0 ? repeats : undefined,
+                    volta,
+                    rehearsalMark: i === 0 ? rehearsalMark : undefined,
+                    systemText: i === 0 ? systemText : undefined,
+                    barlineStyle,
+                });
+                staves[i].clef = staffClefs[i];
+            }
+        }
+        return staves;
+    }
+    parseNote(noteElement) {
+        const isRest = noteElement.querySelector('rest') !== null;
+        const type = this.getText(noteElement, 'type');
+        const duration = type ? this.mapDuration(type) : Duration.Quarter;
+        const isDotted = noteElement.querySelector('dot') !== null;
+        if (isRest)
+            return { duration, isRest: true, isDotted };
+        let step = 'C', octave = 4, alter = 0;
+        const unpitched = noteElement.querySelector('unpitched');
+        if (unpitched) {
+            step = this.getText(unpitched, 'display-step') || 'C';
+            octave = this.getNumber(unpitched, 'display-octave') ?? 4;
+        }
+        else {
+            const pitch = noteElement.querySelector('pitch');
+            if (!pitch)
+                return null;
+            step = this.getText(pitch, 'step') || 'C';
+            octave = this.getNumber(pitch, 'octave') ?? 4;
+            alter = this.getNumber(pitch, 'alter') ?? 0;
+        }
+        let midiNumber = this.pitchToMidi(step, octave, alter);
+        const instrument = noteElement.querySelector('instrument');
+        if (instrument) {
+            const instId = instrument.getAttribute('id');
+            if (instId && this.instrumentPitchMap.has(instId))
+                midiNumber = this.instrumentPitchMap.get(instId);
+        }
+        let accidental = this.mapAccidental(alter);
+        const accidentalEl = this.getText(noteElement, 'accidental');
+        if (accidentalEl) {
+            if (accidentalEl === 'sharp')
+                accidental = Accidental.Sharp;
+            else if (accidentalEl === 'flat')
+                accidental = Accidental.Flat;
+            else if (accidentalEl === 'natural')
+                accidental = Accidental.Natural;
+            else if (accidentalEl === 'double-sharp')
+                accidental = Accidental.DoubleSharp;
+            else if (accidentalEl === 'flat-flat')
+                accidental = Accidental.DoubleFlat;
+        }
+        let notehead = undefined;
+        const noteheadEl = this.getText(noteElement, 'notehead');
+        if (noteheadEl) {
+            if (noteheadEl === 'x')
+                notehead = 'cross';
+            else if (['diamond', 'triangle', 'slash', 'square'].includes(noteheadEl))
+                notehead = noteheadEl;
+        }
+        const notations = noteElement.querySelector('notations');
+        let slur = undefined;
+        const slurEl = notations?.querySelector('slur');
+        if (slurEl) {
+            const type = slurEl.getAttribute('type');
+            if (type === 'start' || type === 'stop') {
+                slur = { placement: type };
+                const orientation = slurEl.getAttribute('orientation');
+                if (orientation === 'over')
+                    slur.direction = 'up';
+                else if (orientation === 'under')
+                    slur.direction = 'down';
+            }
+        }
+        const tie = noteElement.querySelector('tie')?.getAttribute('type') === 'start' || undefined;
+        let articulation = undefined;
+        const articEl = notations?.querySelector('articulations');
+        if (articEl) {
+            if (articEl.querySelector('staccato'))
+                articulation = Articulation.Staccato;
+            else if (articEl.querySelector('accent'))
+                articulation = Articulation.Accent;
+            else if (articEl.querySelector('tenuto'))
+                articulation = Articulation.Tenuto;
+            else if (articEl.querySelector('marcato'))
+                articulation = Articulation.Marcato;
+            else if (articEl.querySelector('staccatissimo'))
+                articulation = Articulation.Staccatissimo;
+        }
+        if (notations?.querySelector('fermata'))
+            articulation = Articulation.Fermata;
+        const notesDyn = notations?.querySelector('dynamics');
+        const dynamic = notesDyn?.firstElementChild?.nodeName.toLowerCase();
+        const lyrics = [];
+        noteElement.querySelectorAll('lyric').forEach((lyricEl) => {
+            let text = this.getText(lyricEl, 'text') || '';
+            const syllabic = this.getText(lyricEl, 'syllabic');
+            const number = parseInt(lyricEl.getAttribute('number') || '1');
+            if (text) {
+                if (syllabic === 'begin' || syllabic === 'middle')
+                    text += '-';
+                lyrics[number - 1] = text;
+            }
+        });
+        return {
+            duration, pitch: { midiNumber, step: this.stepToNumber(step), alter, octave },
+            isDotted, accidental, slur, tie, articulation, dynamic,
+            lyrics: lyrics.length > 0 ? lyrics : undefined, notehead,
+        };
+    }
+    parseHarmony(harmonyElement) {
+        const root = harmonyElement.querySelector('root');
+        if (!root)
+            return '';
+        const step = this.getText(root, 'root-step');
+        if (!step)
+            return '';
+        const alter = this.getNumber(root, 'root-alter') || 0;
+        const kind = this.getText(harmonyElement, 'kind') || 'major';
+        let accidental = '';
+        if (alter === 1)
+            accidental = '#';
+        else if (alter === -1)
+            accidental = 'b';
+        else if (alter === 2)
+            accidental = '##';
+        else if (alter === -2)
+            accidental = 'bb';
+        let kindNotation = '';
+        switch (kind) {
+            case 'major':
+                kindNotation = '';
+                break;
+            case 'minor':
+                kindNotation = 'm';
+                break;
+            case 'dominant':
+                kindNotation = '7';
+                break;
+            case 'major-seventh':
+                kindNotation = 'maj7';
+                break;
+            case 'minor-seventh':
+                kindNotation = 'm7';
+                break;
+            case 'diminished':
+                kindNotation = 'dim';
+                break;
+            case 'diminished-seventh':
+                kindNotation = 'dim7';
+                break;
+            case 'half-diminished':
+                kindNotation = 'm7b5';
+                break;
+            case 'augmented':
+                kindNotation = '+';
+                break;
+            case 'suspended-fourth':
+                kindNotation = 'sus4';
+                break;
+            case 'suspended-second':
+                kindNotation = 'sus2';
+                break;
+            case 'major-sixth':
+                kindNotation = '6';
+                break;
+            case 'minor-sixth':
+                kindNotation = 'm6';
+                break;
+        }
+        const bass = harmonyElement.querySelector('bass');
+        let bassPart = '';
+        if (bass) {
+            const bStep = this.getText(bass, 'bass-step');
+            const bAlter = this.getNumber(bass, 'bass-alter') || 0;
+            if (bStep) {
+                let bAcc = '';
+                if (bAlter === 1)
+                    bAcc = '#';
+                else if (bAlter === -1)
+                    bAcc = 'b';
+                bassPart = '/' + bStep + bAcc;
+            }
+        }
+        return step + accidental + kindNotation + bassPart;
+    }
+    parseBarlines(measureElement) {
+        const repeats = [];
+        let volta = undefined;
+        let barlineStyle = BarlineStyle.Regular;
+        measureElement.querySelectorAll('barline').forEach((barline) => {
+            const location = barline.getAttribute('location') || 'right';
+            const barStyle = this.getText(barline, 'bar-style');
+            if (location === 'right') {
+                if (barStyle === 'light-light')
+                    barlineStyle = BarlineStyle.Double;
+                else if (barStyle === 'light-heavy')
+                    barlineStyle = BarlineStyle.Final;
+                else if (barStyle === 'dotted')
+                    barlineStyle = BarlineStyle.Dotted;
+            }
+            if (barline.querySelector('repeat'))
+                repeats.push({ type: barline.querySelector('repeat')?.getAttribute('direction') === 'forward' ? 'start' : 'end' });
+            const ending = barline.querySelector('ending');
+            if (ending) {
+                const type = ending.getAttribute('type');
+                const number = parseInt(ending.getAttribute('number') || '1');
+                if (type === 'start')
+                    volta = { type: 'start', number };
+                else if (type === 'stop')
+                    volta = { type: 'stop', number };
+                else if (type === 'discontinue')
+                    volta = { type: 'both', number };
+            }
+        });
+        return { repeats, volta, barlineStyle };
+    }
+    postProcess(score) {
+        this.cleanAccidentals(score);
+        return score;
+    }
+    cleanAccidentals(score) {
+        const fifths = score.keySignature?.fifths ?? 0;
+        const orderOfSharps = ['F', 'C', 'G', 'D', 'A', 'E', 'B'];
+        const orderOfFlats = ['B', 'E', 'A', 'D', 'G', 'C', 'F'];
+        const getKeyMap = () => {
+            const map = { C: 0, D: 0, E: 0, F: 0, G: 0, A: 0, B: 0 };
+            if (fifths > 0)
+                for (let i = 0; i < Math.min(fifths, 7); i++)
+                    map[orderOfSharps[i]] = 1;
+            else if (fifths < 0)
+                for (let i = 0; i < Math.min(Math.abs(fifths), 7); i++)
+                    map[orderOfFlats[i]] = -1;
+            return map;
+        };
+        const stepNames = ['C', 'D', 'E', 'F', 'G', 'A', 'B'];
+        score.parts.forEach((part) => {
+            part.staves.forEach((staff) => {
+                staff.measures.forEach((measure) => {
+                    const state = getKeyMap();
+                    (measure.voices || []).forEach((voice) => {
+                        voice.forEach((ns) => {
+                            ns.notes.forEach((note) => {
+                                if (note.isRest || !note.pitch)
+                                    return;
+                                const step = stepNames[note.pitch.step];
+                                const alter = note.pitch.alter ?? 0;
+                                if (note.accidental) {
+                                    if (state[step] === alter)
+                                        note.accidental = undefined;
+                                    else
+                                        state[step] = alter;
+                                }
+                                else if (state[step] !== alter) {
+                                    note.accidental = alter === 0 ? Accidental.Natural : alter === 1 ? Accidental.Sharp : Accidental.Flat;
+                                    state[step] = alter;
+                                }
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    }
+    pitchToMidi(step, octave, alter = 0) {
+        const steps = { C: 0, D: 2, E: 4, F: 5, G: 7, A: 9, B: 11 };
+        return (octave + 1) * 12 + (steps[step.toUpperCase()] ?? 0) + alter;
+    }
+    mapDuration(type) {
+        const map = { whole: Duration.Whole, half: Duration.Half, quarter: Duration.Quarter, eighth: Duration.Eighth, '16th': Duration.Sixteenth, '32nd': Duration.ThirtySecond, '64th': Duration.SixtyFourth };
+        return map[type] ?? Duration.Quarter;
+    }
+    mapClef(sign, line = 0) {
+        switch (sign.toUpperCase()) {
+            case 'G': return Clef.Treble;
+            case 'F': return Clef.Bass;
+            case 'C': return line === 4 ? Clef.Tenor : Clef.Alto;
+            case 'PERCUSSION': return Clef.Percussion;
+            case 'TAB': return Clef.Tab;
+            default: return Clef.Treble;
+        }
+    }
+    mapAccidental(alter) {
+        if (alter === 1)
+            return Accidental.Sharp;
+        if (alter === -1)
+            return Accidental.Flat;
+        if (alter === 0)
+            return Accidental.Natural;
+        if (alter === 2)
+            return Accidental.DoubleSharp;
+        if (alter === -2)
+            return Accidental.DoubleFlat;
+        return undefined;
+    }
+    stepToNumber(step) {
+        const map = { C: 0, D: 1, E: 2, F: 3, G: 4, A: 5, B: 6 };
+        return map[step.toUpperCase()] ?? 0;
+    }
+    getText(element, tagName) {
+        const child = element.querySelector(tagName);
+        return child?.textContent ?? null;
+    }
+    getNumber(element, tagName) {
+        const text = this.getText(element, tagName);
+        return text !== null ? parseFloat(text) : null;
+    }
+}

package/dist/importers/index.d.ts

@@ -0,0 +1 @@
+export * from './MusicXMLParser';

package/dist/importers/index.js

@@ -0,0 +1 @@
+export * from './MusicXMLParser';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './models';
+export * from './importers';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './models';
+export * from './importers';

package/dist/models/Instrument.d.ts

@@ -0,0 +1,26 @@
+export declare enum InstrumentType {
+    String = "string",
+    Brass = "brass",
+    Woodwind = "woodwind",
+    Percussion = "percussion",
+    Keyboard = "keyboard",
+    Synth = "synth"
+}
+export declare enum InstrumentPreset {
+    Piano = "piano",
+    Violin = "violin",
+    Cello = "cello",
+    Guitar = "guitar",
+    ElectricGuitar = "electric-guitar",
+    Bass = "bass",
+    Flute = "flute",
+    Trumpet = "trumpet",
+    Drums = "drums"
+}
+export interface Instrument {
+    name: string;
+    midiProgram: number;
+    type?: InstrumentType;
+}
+export declare const PRESET_INSTRUMENTS: Record<string, Instrument>;
+export declare function getInstrumentByProgram(program: number): Instrument;