musicxml-io 0.12.0 → 0.12.2

package/dist/chunk-6EKVRPFF.js

@@ -0,0 +1,407 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkOEX7NVZNjs = require('./chunk-OEX7NVZN.js');
+
+
+
+
+
+
+var _chunk626TXMVPjs = require('./chunk-626TXMVP.js');
+
+// src/exporters/midi.ts
+var DYNAMICS_VELOCITY = {
+  pppppp: 12,
+  ppppp: 20,
+  pppp: 25,
+  ppp: 30,
+  pp: 40,
+  p: 50,
+  mp: 60,
+  mf: 75,
+  f: 90,
+  ff: 105,
+  fff: 115,
+  ffff: 120,
+  fffff: 125,
+  ffffff: 127,
+  fp: 90,
+  // forte-piano: forte attack
+  n: 25,
+  // niente
+  pf: 70
+};
+var SF_ACCENT_MULTIPLIER = {
+  sf: 1.3,
+  sfz: 1.35,
+  sffz: 1.45,
+  fz: 1.3,
+  rf: 1.2,
+  rfz: 1.3,
+  sfp: 1.3,
+  sfpp: 1.3
+};
+var ARTICULATION_VELOCITY = {
+  "accent": 1.25,
+  "strong-accent": 1.35,
+  "marcato": 1.35,
+  "tenuto": 1.05,
+  "stress": 1.15,
+  "unstress": 0.85,
+  "soft-accent": 0.8
+};
+var GRACE_VELOCITY_MULTIPLIER = 0.85;
+function clampVelocity(v) {
+  return Math.round(Math.min(127, Math.max(1, v)));
+}
+function articulationVelocityMultiplier(note) {
+  if (!note.notations) return 1;
+  let mult = 1;
+  for (const n of note.notations) {
+    if (n.type === "articulation") {
+      const m = ARTICULATION_VELOCITY[n.articulation];
+      if (m) mult *= m;
+    }
+  }
+  return mult;
+}
+function scheduleGraceNotes(graceNotes, targetTick, baseVelocity, chromaticTranspose, ticksPerQuarterNote, noteEvents) {
+  if (graceNotes.length === 0) return;
+  const graceUnit = Math.max(1, Math.round(ticksPerQuarterNote / 8));
+  const slots = [];
+  let slot = -1;
+  for (const g of graceNotes) {
+    if (!g.chord || slot < 0) slot++;
+    slots.push(slot);
+  }
+  const numSlots = slot + 1;
+  const velocity = clampVelocity(baseVelocity * GRACE_VELOCITY_MULTIPLIER);
+  for (let i = 0; i < graceNotes.length; i++) {
+    const g = graceNotes[i];
+    if (!g.pitch) continue;
+    const s = slots[i];
+    const onset = Math.max(0, targetTick - (numSlots - s) * graceUnit);
+    const off = Math.max(onset + 1, targetTick - (numSlots - s - 1) * graceUnit);
+    const midiNote = pitchToMidiNote(g.pitch, chromaticTranspose);
+    noteEvents.push({ tick: onset, type: "on", note: midiNote, velocity });
+    noteEvents.push({ tick: off, type: "off", note: midiNote, velocity: 0 });
+  }
+}
+function exportMidi(score, options = {}) {
+  const { tracks, ticksPerQuarterNote } = buildMidiTracks(score, options);
+  return buildMidiFile(tracks, ticksPerQuarterNote);
+}
+function exportMidiWithTimingMap(score, options = {}) {
+  const { tracks, ticksPerQuarterNote, defaultTempo, grid } = buildMidiTracks(score, options);
+  return {
+    midi: buildMidiFile(tracks, ticksPerQuarterNote),
+    sidecar: _chunk626TXMVPjs.buildTimingSidecar.call(void 0, grid, defaultTempo, ticksPerQuarterNote)
+  };
+}
+function buildMidiTracks(score, options) {
+  const ticksPerQuarterNote = _nullishCoalesce(options.ticksPerQuarterNote, () => ( 480));
+  const defaultTempo = _nullishCoalesce(options.defaultTempo, () => ( 120));
+  const defaultVelocity = _nullishCoalesce(options.defaultVelocity, () => ( 80));
+  const tracks = [];
+  const sequence = _chunk626TXMVPjs.generatePlaybackSequence.call(void 0, score);
+  const measureOrder = sequence.map((m) => m.measureIndex);
+  const grid = _chunk626TXMVPjs.buildGridTimeline.call(void 0, score, ticksPerQuarterNote, sequence, {
+    defaultTempo,
+    fermataHoldMultiplier: options.fermataHoldMultiplier,
+    caesuraSeconds: options.caesuraSeconds,
+    breathSeconds: options.breathSeconds,
+    tempoRampSteps: options.tempoRampSteps
+  });
+  tracks.push(createConductorTrack(score, defaultTempo, grid));
+  const scoreParts = score.partList.filter((entry) => entry.type === "score-part");
+  for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
+    const part = score.parts[partIndex];
+    const partEntry = scoreParts[partIndex];
+    let channel = partIndex % 16;
+    let program = 1;
+    if (partEntry && _optionalChain([partEntry, 'access', _ => _.midiInstruments, 'optionalAccess', _2 => _2[0]])) {
+      const midiInst = partEntry.midiInstruments[0];
+      if (midiInst.channel !== void 0) {
+        channel = Math.min(16, Math.max(1, midiInst.channel)) - 1;
+      }
+      program = Math.min(128, Math.max(1, _nullishCoalesce(midiInst.program, () => ( program))));
+    }
+    const trackData = createPartTrack(
+      part,
+      score,
+      channel,
+      program,
+      ticksPerQuarterNote,
+      defaultVelocity,
+      measureOrder
+    );
+    tracks.push(trackData);
+  }
+  return { tracks, ticksPerQuarterNote, defaultTempo, grid };
+}
+function pitchToMidiNote(pitch, chromaticTranspose = 0) {
+  const stepValues = {
+    "C": 0,
+    "D": 2,
+    "E": 4,
+    "F": 5,
+    "G": 7,
+    "A": 9,
+    "B": 11
+  };
+  const baseMidi = (pitch.octave + 1) * 12 + stepValues[pitch.step] + (_nullishCoalesce(pitch.alter, () => ( 0)));
+  return baseMidi + chromaticTranspose;
+}
+function createConductorTrack(score, defaultTempo, grid) {
+  const metaEvents = [];
+  const tempoBytes = (bpm) => {
+    const us = _chunk626TXMVPjs.bpmToUsPerQuarter.call(void 0, bpm);
+    return [255, 81, 3, us >> 16 & 255, us >> 8 & 255, us & 255];
+  };
+  const tempoEvents = [...grid.tempoEvents].sort((a, b) => a.tick - b.tick);
+  const startBpm = tempoEvents.length > 0 && tempoEvents[0].tick === 0 ? tempoEvents[0].bpm : defaultTempo;
+  metaEvents.push({ tick: 0, order: 0, bytes: tempoBytes(startBpm) });
+  let lastBpm = startBpm;
+  for (const ev of tempoEvents) {
+    if (ev.tick === 0) continue;
+    if (ev.bpm === lastBpm) continue;
+    metaEvents.push({ tick: ev.tick, order: 0, bytes: tempoBytes(ev.bpm) });
+    lastBpm = ev.bpm;
+  }
+  const part = score.parts.length > 0 ? score.parts[0] : void 0;
+  if (part) {
+    let lastSig = null;
+    for (const m of grid.measures) {
+      const time = _optionalChain([part, 'access', _3 => _3.measures, 'access', _4 => _4[m.measureIndex], 'optionalAccess', _5 => _5.attributes, 'optionalAccess', _6 => _6.time]);
+      if (!time) continue;
+      const numerator = parseInt(time.beats, 10) || 4;
+      const denominator = Math.log2(time.beatType);
+      const sig = `${numerator}/${denominator}`;
+      if (sig === lastSig) continue;
+      lastSig = sig;
+      metaEvents.push({
+        tick: m.startTick,
+        order: 1,
+        bytes: [255, 88, 4, numerator, denominator, 24, 8]
+      });
+    }
+  }
+  metaEvents.sort((a, b) => a.tick - b.tick || a.order - b.order);
+  const events = [];
+  let lastTick = 0;
+  for (const ev of metaEvents) {
+    events.push(...writeVariableLength(ev.tick - lastTick), ...ev.bytes);
+    lastTick = ev.tick;
+  }
+  events.push(
+    ...writeVariableLength(Math.max(0, grid.totalTicks - lastTick)),
+    255,
+    47,
+    0
+  );
+  return new Uint8Array(events);
+}
+function createPartTrack(part, _score, channel, program, ticksPerQuarterNote, defaultVelocity, measureOrder) {
+  const events = [];
+  events.push(
+    ...writeVariableLength(0),
+    192 | channel & 15,
+    program - 1 & 127
+    // MIDI programs are 0-indexed
+  );
+  const noteEvents = [];
+  let currentTick = 0;
+  let divisions = 1;
+  let chromaticTranspose = 0;
+  let currentVelocity = defaultVelocity;
+  let pendingAccent = 1;
+  let accentBound = false;
+  let pendingGrace = [];
+  for (const measureIndex of measureOrder) {
+    const measure = part.measures[measureIndex];
+    if (!measure) continue;
+    if (_optionalChain([measure, 'access', _7 => _7.attributes, 'optionalAccess', _8 => _8.divisions])) {
+      divisions = measure.attributes.divisions;
+    }
+    if (_optionalChain([measure, 'access', _9 => _9.attributes, 'optionalAccess', _10 => _10.transpose])) {
+      chromaticTranspose = measure.attributes.transpose.chromatic;
+    }
+    const measureStartTick = currentTick;
+    let position = 0;
+    let chordBasePosition = 0;
+    let maxPosition = 0;
+    for (const entry of measure.entries) {
+      if (entry.type === "note") {
+        const note = entry;
+        if (note.grace) {
+          if (note.pitch) pendingGrace.push(note);
+          continue;
+        }
+        if (!note.chord) {
+          if (accentBound) {
+            pendingAccent = 1;
+            accentBound = false;
+          }
+          if (pendingAccent !== 1) accentBound = true;
+        }
+        if (note.pitch) {
+          const midiNote = pitchToMidiNote(note.pitch, chromaticTranspose);
+          const notePosition = note.chord ? chordBasePosition : position;
+          const startTick = measureStartTick + Math.round(notePosition * ticksPerQuarterNote / divisions);
+          const durationTicks = Math.round(note.duration * ticksPerQuarterNote / divisions);
+          if (!note.chord && pendingGrace.length > 0) {
+            scheduleGraceNotes(pendingGrace, startTick, currentVelocity, chromaticTranspose, ticksPerQuarterNote, noteEvents);
+            pendingGrace = [];
+          }
+          const velocity = clampVelocity(currentVelocity * pendingAccent * articulationVelocityMultiplier(note));
+          const isTieStop = _chunkOEX7NVZNjs.hasTieStop.call(void 0, note);
+          const isTieStart = _chunkOEX7NVZNjs.hasTieStart.call(void 0, note);
+          if (!isTieStop) {
+            noteEvents.push({ tick: startTick, type: "on", note: midiNote, velocity });
+          }
+          if (!isTieStart) {
+            noteEvents.push({ tick: startTick + durationTicks, type: "off", note: midiNote, velocity: 0 });
+          }
+        }
+        if (!note.chord) {
+          chordBasePosition = position;
+          position += note.duration;
+          if (position > maxPosition) {
+            maxPosition = position;
+          }
+        }
+      } else if (entry.type === "direction") {
+        for (const dt of entry.directionTypes) {
+          if (dt.kind === "dynamics" && dt.value) {
+            const abs = DYNAMICS_VELOCITY[dt.value];
+            if (abs !== void 0) {
+              currentVelocity = abs;
+            } else {
+              const accent = SF_ACCENT_MULTIPLIER[dt.value];
+              if (accent !== void 0) {
+                pendingAccent = accent;
+                accentBound = false;
+              }
+            }
+          }
+        }
+      } else if (entry.type === "backup") {
+        position -= entry.duration;
+      } else if (entry.type === "forward") {
+        position += entry.duration;
+        if (position > maxPosition) {
+          maxPosition = position;
+        }
+      }
+    }
+    currentTick = _chunk626TXMVPjs.measureEndTick.call(void 0, 
+      measure,
+      part,
+      divisions,
+      measureStartTick,
+      maxPosition,
+      ticksPerQuarterNote
+    );
+  }
+  if (pendingGrace.length > 0) {
+    scheduleGraceNotes(pendingGrace, currentTick, currentVelocity, chromaticTranspose, ticksPerQuarterNote, noteEvents);
+    pendingGrace = [];
+  }
+  const onCounts = /* @__PURE__ */ new Map();
+  const offCounts = /* @__PURE__ */ new Map();
+  for (const e of noteEvents) {
+    const map = e.type === "on" ? onCounts : offCounts;
+    map.set(e.note, (_nullishCoalesce(map.get(e.note), () => ( 0))) + 1);
+  }
+  for (const [note, onCount] of onCounts) {
+    const offCount = _nullishCoalesce(offCounts.get(note), () => ( 0));
+    for (let i = 0; i < onCount - offCount; i++) {
+      noteEvents.push({ tick: currentTick, type: "off", note, velocity: 0 });
+    }
+  }
+  noteEvents.sort((a, b) => {
+    if (a.tick !== b.tick) return a.tick - b.tick;
+    if (a.type !== b.type) return a.type === "off" ? -1 : 1;
+    return a.note - b.note;
+  });
+  let lastTick = 0;
+  for (const event of noteEvents) {
+    const deltaTick = event.tick - lastTick;
+    lastTick = event.tick;
+    if (event.type === "on") {
+      events.push(
+        ...writeVariableLength(deltaTick),
+        144 | channel & 15,
+        event.note & 127,
+        event.velocity & 127
+      );
+    } else {
+      events.push(
+        ...writeVariableLength(deltaTick),
+        128 | channel & 15,
+        event.note & 127,
+        0
+      );
+    }
+  }
+  events.push(...writeVariableLength(0), 255, 47, 0);
+  return new Uint8Array(events);
+}
+function writeVariableLength(value) {
+  if (value < 0) value = 0;
+  const bytes = [];
+  bytes.unshift(value & 127);
+  value >>= 7;
+  while (value > 0) {
+    bytes.unshift(value & 127 | 128);
+    value >>= 7;
+  }
+  return bytes;
+}
+function writeUint32BE(value) {
+  return [
+    value >> 24 & 255,
+    value >> 16 & 255,
+    value >> 8 & 255,
+    value & 255
+  ];
+}
+function writeUint16BE(value) {
+  return [
+    value >> 8 & 255,
+    value & 255
+  ];
+}
+function buildMidiFile(tracks, ticksPerQuarterNote) {
+  const header = Uint8Array.from([
+    77,
+    84,
+    104,
+    100,
+    ...writeUint32BE(6),
+    ...writeUint16BE(1),
+    ...writeUint16BE(tracks.length),
+    ...writeUint16BE(ticksPerQuarterNote)
+  ]);
+  let total = header.length;
+  for (const track of tracks) total += 8 + track.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  out.set(header, offset);
+  offset += header.length;
+  for (const track of tracks) {
+    out.set([77, 84, 114, 107], offset);
+    offset += 4;
+    out.set(writeUint32BE(track.length), offset);
+    offset += 4;
+    out.set(track, offset);
+    offset += track.length;
+  }
+  return out;
+}
+
+
+
+
+exports.exportMidi = exportMidi; exports.exportMidiWithTimingMap = exportMidiWithTimingMap;

package/dist/chunk-776XPK66.js

@@ -0,0 +1,45 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/beams.ts
+var BEAM_LEVELS = {
+  eighth: 1,
+  "16th": 2,
+  "32nd": 3,
+  "64th": 4,
+  "128th": 5,
+  "256th": 6,
+  "512th": 7,
+  "1024th": 8
+};
+function beamLevel(note) {
+  return note.rest || !note.noteType ? 0 : _nullishCoalesce(BEAM_LEVELS[note.noteType], () => ( 0));
+}
+function applyBeamGroup(group) {
+  const levels = group.map(beamLevel);
+  const beams = group.map(() => []);
+  const maxLevel = Math.max(...levels);
+  for (let lv = 1; lv <= maxLevel; lv++) {
+    for (let i = 0; i < group.length; ) {
+      if (levels[i] < lv) {
+        i++;
+        continue;
+      }
+      let j = i;
+      while (j + 1 < group.length && levels[j + 1] >= lv) j++;
+      if (i === j) {
+        beams[i].push({ number: lv, type: i === group.length - 1 ? "backward hook" : "forward hook" });
+      } else {
+        for (let k = i; k <= j; k++) {
+          beams[k].push({ number: lv, type: k === i ? "begin" : k === j ? "end" : "continue" });
+        }
+      }
+      i = j + 1;
+    }
+  }
+  group.forEach((n, i) => {
+    n.beam = beams[i];
+  });
+}
+
+
+
+
+exports.beamLevel = beamLevel; exports.applyBeamGroup = applyBeamGroup;

package/dist/chunk-7D4MLQKO.js

@@ -0,0 +1,69 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkHP4DAUGTjs = require('./chunk-HP4DAUGT.js');
+
+// src/importers/musicxml-compressed.ts
+var _fflate = require('fflate');
+function parseCompressed(data) {
+  const containerPath = "META-INF/container.xml";
+  const xmlFiles = [];
+  const files = _fflate.unzipSync.call(void 0, data, {
+    filter: ({ name }) => {
+      if (name.endsWith(".xml") && !name.startsWith("META-INF")) {
+        xmlFiles.push(name);
+      }
+      return name === containerPath;
+    }
+  });
+  const containerData = files[containerPath];
+  let rootFilePath;
+  if (containerData) {
+    const containerXml = _fflate.strFromU8.call(void 0, containerData);
+    const rootfileMatch = containerXml.match(/full-path="([^"]+)"/);
+    if (rootfileMatch) {
+      rootFilePath = rootfileMatch[1];
+    }
+  }
+  if (!rootFilePath) {
+    if (xmlFiles.length === 1) {
+      rootFilePath = xmlFiles[0];
+    } else {
+      const commonNames = ["score.xml", "musicxml.xml"];
+      for (const name of commonNames) {
+        if (xmlFiles.includes(name)) {
+          rootFilePath = name;
+          break;
+        }
+      }
+    }
+  }
+  if (!rootFilePath) {
+    throw new Error("Could not find MusicXML file in compressed archive");
+  }
+  const xmlData = _fflate.unzipSync.call(void 0, data, {
+    filter: ({ name }) => name === rootFilePath
+  })[rootFilePath];
+  if (!xmlData) {
+    throw new Error("Could not find MusicXML file in compressed archive");
+  }
+  const xmlString = _fflate.strFromU8.call(void 0, xmlData);
+  return _chunkHP4DAUGTjs.parse.call(void 0, xmlString);
+}
+function isCompressed(data) {
+  return data.length >= 2 && data[0] === 80 && data[1] === 75;
+}
+function parseAuto(data) {
+  if (typeof data === "string") {
+    return _chunkHP4DAUGTjs.parse.call(void 0, data);
+  }
+  if (isCompressed(data)) {
+    return parseCompressed(data);
+  }
+  return _chunkHP4DAUGTjs.parse.call(void 0, data);
+}
+
+
+
+
+
+exports.parseCompressed = parseCompressed; exports.isCompressed = isCompressed; exports.parseAuto = parseAuto;

package/dist/chunk-A2CGW2UF.js

@@ -0,0 +1,25 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk2EH2MGBYjs = require('./chunk-2EH2MGBY.js');
+
+// src/exporters/musicxml-compressed.ts
+var _fflate = require('fflate');
+function serializeCompressed(score, options = {}) {
+  const xmlString = _chunk2EH2MGBYjs.serialize.call(void 0, score, options);
+  const rootFileName = "score.xml";
+  const containerXml = `<?xml version="1.0" encoding="UTF-8"?>
+<container>
+  <rootfiles>
+    <rootfile full-path="${rootFileName}"/>
+  </rootfiles>
+</container>`;
+  const files = {
+    "META-INF/container.xml": _fflate.strToU8.call(void 0, containerXml),
+    [rootFileName]: _fflate.strToU8.call(void 0, xmlString)
+  };
+  return _fflate.zipSync.call(void 0, files, { level: 6 });
+}
+
+
+
+exports.serializeCompressed = serializeCompressed;

package/dist/chunk-AOSK4RGV.mjs

@@ -0,0 +1,45 @@
+// src/beams.ts
+var BEAM_LEVELS = {
+  eighth: 1,
+  "16th": 2,
+  "32nd": 3,
+  "64th": 4,
+  "128th": 5,
+  "256th": 6,
+  "512th": 7,
+  "1024th": 8
+};
+function beamLevel(note) {
+  return note.rest || !note.noteType ? 0 : BEAM_LEVELS[note.noteType] ?? 0;
+}
+function applyBeamGroup(group) {
+  const levels = group.map(beamLevel);
+  const beams = group.map(() => []);
+  const maxLevel = Math.max(...levels);
+  for (let lv = 1; lv <= maxLevel; lv++) {
+    for (let i = 0; i < group.length; ) {
+      if (levels[i] < lv) {
+        i++;
+        continue;
+      }
+      let j = i;
+      while (j + 1 < group.length && levels[j + 1] >= lv) j++;
+      if (i === j) {
+        beams[i].push({ number: lv, type: i === group.length - 1 ? "backward hook" : "forward hook" });
+      } else {
+        for (let k = i; k <= j; k++) {
+          beams[k].push({ number: lv, type: k === i ? "begin" : k === j ? "end" : "continue" });
+        }
+      }
+      i = j + 1;
+    }
+  }
+  group.forEach((n, i) => {
+    n.beam = beams[i];
+  });
+}
+
+export {
+  beamLevel,
+  applyBeamGroup
+};