@libraz/libcantus 0.9.5 → 1.0.0

package/dist/chunk-Q2WGKJNN.cjs

@@ -0,0 +1,1064 @@
+"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 _class; var _class2; var _class3;// src/core/errors/index.ts
+function parseFailure(error) {
+  if (isLibcantusError(error)) {
+    return { ok: false, error };
+  }
+  throw error;
+}
+function unwrapParse(result) {
+  if (result.ok) {
+    return result.value;
+  }
+  throw result.error;
+}
+var InvalidInputError = (_class = class extends RangeError {constructor(...args) { super(...args); _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  __init() {this.code = "INVALID_INPUT"}
+  __init2() {this.name = "InvalidInputError"}
+}, _class);
+var NoSolutionError = (_class2 = class extends Error {
+  __init3() {this.code = "NO_SOLUTION"}
+  __init4() {this.name = "NoSolutionError"}
+  /**
+   * Where in a sequence the failure occurred, when the operation was working
+   * through one — the chord index of a progression, say.
+   */
+  
+  constructor(message, options = {}) {
+    super(message);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);;
+    this.at = options.at;
+  }
+}, _class2);
+var BudgetExceededError = (_class3 = class extends RangeError {constructor(...args2) { super(...args2); _class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this); }
+  __init5() {this.code = "BUDGET_EXCEEDED"}
+  __init6() {this.name = "BudgetExceededError"}
+}, _class3);
+function isLibcantusError(value) {
+  if (typeof value !== "object" || value === null || !("code" in value)) {
+    return false;
+  }
+  const code = value.code;
+  return code === "INVALID_INPUT" || code === "NO_SOLUTION" || code === "BUDGET_EXCEEDED";
+}
+
+// src/core/meter/internal.ts
+var EPS = 1e-9;
+function unitBeatsOf(ts) {
+  return 4 / ts.denominator;
+}
+function isCompoundNumerator(numerator) {
+  return numerator % 3 === 0 && numerator > 3;
+}
+function groupingSumOf(ts) {
+  const grouping = ts.grouping;
+  if (grouping === void 0) {
+    return void 0;
+  }
+  let sum = 0;
+  for (const entry of grouping) {
+    sum += entry;
+  }
+  return sum;
+}
+function isAdditiveReading(ts) {
+  const grouping = ts.grouping;
+  const sum = groupingSumOf(ts);
+  if (grouping === void 0 || sum === void 0 || sum === 0) {
+    return false;
+  }
+  if (!isCompoundNumerator(ts.numerator) || sum !== ts.numerator) {
+    return false;
+  }
+  return !grouping.every((entry) => entry === 3);
+}
+function pulseCountOf(ts) {
+  if (isAdditiveReading(ts)) {
+    return ts.numerator;
+  }
+  return isCompoundNumerator(ts.numerator) ? ts.numerator / 3 : ts.numerator;
+}
+function pulseBeatsOf(ts) {
+  return ts.numerator * unitBeatsOf(ts) / pulseCountOf(ts);
+}
+function pulseGroupingOf(ts) {
+  const grouping = ts.grouping;
+  if (grouping === void 0) {
+    return void 0;
+  }
+  const pulses = pulseCountOf(ts);
+  if (groupingSumOf(ts) === pulses) {
+    return grouping;
+  }
+  return grouping.map((entry) => entry / 3);
+}
+function barBeatsOf(ts) {
+  return ts.numerator * unitBeatsOf(ts);
+}
+function isMeterMap(meter) {
+  return Array.isArray(meter);
+}
+function entryIndexOf(map, beat) {
+  let index = 0;
+  for (let i = 1; i < map.length; i += 1) {
+    if ((_nullishCoalesce(_optionalChain([map, 'access', _ => _[i], 'optionalAccess', _2 => _2.startBeat]), () => ( Number.POSITIVE_INFINITY))) > beat + EPS) {
+      break;
+    }
+    index = i;
+  }
+  return index;
+}
+function barsBeforeEntry(map, index) {
+  let bars = 0;
+  for (let i = 0; i < index; i += 1) {
+    const entry = map[i];
+    const next = map[i + 1];
+    if (entry === void 0 || next === void 0) {
+      break;
+    }
+    bars += Math.max(1, Math.ceil((next.startBeat - entry.startBeat) / barBeatsOf(entry.ts) - EPS));
+  }
+  return bars;
+}
+function barStartOf(map, beat) {
+  const entry = map[entryIndexOf(map, beat)];
+  if (entry === void 0) {
+    return 0;
+  }
+  const barLen = barBeatsOf(entry.ts);
+  return entry.startBeat + Math.floor((beat - entry.startBeat) / barLen + EPS) * barLen;
+}
+function barLengthOf(map, beat) {
+  const index = entryIndexOf(map, beat);
+  const entry = map[index];
+  if (entry === void 0) {
+    return 0;
+  }
+  const full = barBeatsOf(entry.ts);
+  const next = _optionalChain([map, 'access', _3 => _3[index + 1], 'optionalAccess', _4 => _4.startBeat]);
+  return next === void 0 ? full : Math.min(full, next - barStartOf(map, beat));
+}
+function barIndexOf(map, beat) {
+  const index = entryIndexOf(map, beat);
+  const entry = map[index];
+  if (entry === void 0) {
+    return 0;
+  }
+  const barLen = barBeatsOf(entry.ts);
+  return barsBeforeEntry(map, index) + Math.floor((beat - entry.startBeat) / barLen + EPS);
+}
+function beatOfBarIndex(map, barIndex) {
+  let base = 0;
+  for (let i = 0; i < map.length; i += 1) {
+    const entry = map[i];
+    if (entry === void 0) {
+      continue;
+    }
+    const barLen = barBeatsOf(entry.ts);
+    const next = map[i + 1];
+    if (next === void 0) {
+      return entry.startBeat + (barIndex - base) * barLen;
+    }
+    const bars = Math.max(1, Math.ceil((next.startBeat - entry.startBeat) / barLen - EPS));
+    if (barIndex < base + bars) {
+      return entry.startBeat + (barIndex - base) * barLen;
+    }
+    base += bars;
+  }
+  return 0;
+}
+
+// src/core/validation/index.ts
+var DEFAULT_GENERATION_BUDGET = 1e6;
+function assertFiniteNumber(value, name) {
+  if (!Number.isFinite(value)) {
+    throw new InvalidInputError(`${name} must be finite; received ${value}`);
+  }
+  return value;
+}
+function assertInteger(value, name, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
+  assertFiniteNumber(value, name);
+  if (!Number.isSafeInteger(value) || value < min || value > max) {
+    throw new InvalidInputError(
+      `${name} must be an integer in [${min}, ${max}]; received ${value}`
+    );
+  }
+  return value;
+}
+function assertMidiPitch(value, name = "MIDI pitch") {
+  return assertInteger(value, name, 0, 127);
+}
+function clampToMidi(value, name = "MIDI pitch") {
+  assertInteger(value, name);
+  return Math.min(127, Math.max(0, value));
+}
+function assertDegree(value, name = "degree") {
+  return assertInteger(value, name, 1, 1e3);
+}
+function assertFiniteSemitones(value, name = "semitones") {
+  return assertFiniteNumber(value, name);
+}
+function dropSilentNotes(events) {
+  return events.filter((event) => event !== void 0 && event.durationBeat > 0);
+}
+var soundingNotesOnly = dropSilentNotes;
+function assertOneOf(value, allowed, name) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new InvalidInputError(
+      `${name} must be one of ${allowed.join(", ")}; received ${JSON.stringify(value)}`
+    );
+  }
+  return value;
+}
+function assertPositiveInt(value, name, max = DEFAULT_GENERATION_BUDGET) {
+  return assertInteger(value, name, 1, max);
+}
+function assertRange(value, min, max, name) {
+  assertFiniteNumber(value, name);
+  if (value < min || value > max) {
+    throw new InvalidInputError(`${name} must be in [${min}, ${max}]; received ${value}`);
+  }
+  return value;
+}
+function assertGenerationBudget(estimated, name, limit = DEFAULT_GENERATION_BUDGET) {
+  const cap = _nullishCoalesce(limit, () => ( DEFAULT_GENERATION_BUDGET));
+  assertFiniteNumber(estimated, name);
+  assertPositiveInt(cap, `${name} limit`, Number.MAX_SAFE_INTEGER);
+  if (estimated < 0) {
+    throw new InvalidInputError(`${name} must not be negative; received ${estimated}`);
+  }
+  if (estimated > cap) {
+    throw new BudgetExceededError(
+      `${name} exceeds the generation budget ${cap}; received ${estimated}`
+    );
+  }
+  return estimated;
+}
+function assertTimeSignature(ts, name = "time signature") {
+  assertPositiveInt(ts.numerator, `${name}.numerator`);
+  assertPositiveInt(ts.denominator, `${name}.denominator`);
+  if (ts.grouping !== void 0) {
+    if (ts.grouping.length === 0) {
+      throw new InvalidInputError(`${name}.grouping must not be empty`);
+    }
+    let sum = 0;
+    for (let index = 0; index < ts.grouping.length; index += 1) {
+      sum += assertPositiveInt(_nullishCoalesce(ts.grouping[index], () => ( Number.NaN)), `${name}.grouping[${index}]`);
+    }
+    const pulses = isCompoundNumerator(ts.numerator) ? ts.numerator / 3 : ts.numerator;
+    if (sum !== pulses && sum !== ts.numerator) {
+      const accepted = pulses === ts.numerator ? `${pulses}` : `${pulses} (pulses) or ${ts.numerator} (units)`;
+      throw new InvalidInputError(`${name}.grouping must sum to ${accepted}; received ${sum}`);
+    }
+  }
+  return ts;
+}
+function assertMeterMap(meters, name = "meters") {
+  if (!Array.isArray(meters)) {
+    throw new InvalidInputError(`${name} must be an array; received ${typeof meters}`);
+  }
+  if (meters.length === 0) {
+    throw new InvalidInputError(`${name} must not be empty`);
+  }
+  let previous = Number.NEGATIVE_INFINITY;
+  for (let index = 0; index < meters.length; index += 1) {
+    const entry = meters[index];
+    if (entry === void 0) {
+      throw new InvalidInputError(`${name}[${index}] must be a meter change; received undefined`);
+    }
+    assertFiniteNumber(entry.startBeat, `${name}[${index}].startBeat`);
+    if (index > 0 && entry.startBeat <= previous) {
+      throw new InvalidInputError(
+        `${name}[${index}].startBeat must be greater than ${previous}; received ${entry.startBeat}`
+      );
+    }
+    previous = entry.startBeat;
+    assertTimeSignature(entry.ts, `${name}[${index}].ts`);
+  }
+  return meters;
+}
+function assertNoteEvent(event, name = "note event", options = {}) {
+  assertMidiPitch(event.pitch, `${name}.pitch`);
+  const minStartBeat = _nullishCoalesce(options.minStartBeat, () => ( -Number.MAX_SAFE_INTEGER));
+  assertFiniteNumber(minStartBeat, "minStartBeat");
+  assertRange(event.startBeat, minStartBeat, Number.MAX_SAFE_INTEGER, `${name}.startBeat`);
+  assertFiniteNumber(event.durationBeat, `${name}.durationBeat`);
+  if (!options.allowNonPositiveDuration && event.durationBeat <= 0) {
+    throw new InvalidInputError(
+      `${name}.durationBeat must be positive; received ${event.durationBeat}`
+    );
+  }
+  assertRange(
+    event.durationBeat,
+    -Number.MAX_SAFE_INTEGER,
+    Number.MAX_SAFE_INTEGER,
+    `${name}.durationBeat`
+  );
+  if (event.velocity !== void 0) {
+    assertRange(event.velocity, 0, 127, `${name}.velocity`);
+  }
+  return event;
+}
+function assertNoteEvents(events, name = "note events", options = {}) {
+  if (!Array.isArray(events)) {
+    throw new InvalidInputError(`${name} must be an array; received ${typeof events}`);
+  }
+  assertGenerationBudget(events.length, `${name} count`, options.budget);
+  for (let index = 0; index < events.length; index += 1) {
+    const event = events[index];
+    if (event === void 0) {
+      throw new InvalidInputError(`${name}[${index}] must be a note event; received undefined`);
+    }
+    assertNoteEvent(event, `${name}[${index}]`, options);
+  }
+  return events;
+}
+
+// src/core/pitch/naming.ts
+var NOTE_NAME_SYSTEMS = [
+  "english",
+  "german",
+  "japanese",
+  "italian",
+  "fixedDo"
+];
+var DETECTION_ORDER = ["english", "german", "japanese", "italian"];
+function tableOf(system) {
+  return system === "fixedDo" ? "italian" : system;
+}
+var ENGLISH_LETTERS = ["C", "D", "E", "F", "G", "A", "B"];
+var GERMAN_LETTERS = ["c", "d", "e", "f", "g", "a", "h"];
+var JAPANESE_LETTERS = ["\u30CF", "\u30CB", "\u30DB", "\u30D8", "\u30C8", "\u30A4", "\u30ED"];
+var ITALIAN_LETTERS = ["do", "re", "mi", "fa", "sol", "la", "si"];
+var GERMAN_ELIDING_LETTERS = [2, 5];
+var A_LETTER = 5;
+var B_LETTER = 6;
+var MODE_WORDS = {
+  english: { major: "major", minor: "minor" },
+  german: { major: "dur", minor: "moll" },
+  japanese: { major: "\u9577\u8ABF", minor: "\u77ED\u8ABF" },
+  italian: { major: "maggiore", minor: "minore" }
+};
+var JAPANESE_SHARP = "\u5B30";
+var JAPANESE_FLAT = "\u5909";
+var JAPANESE_DOUBLE = "\u91CD";
+var ITALIAN_SHARP = "diesis";
+var ITALIAN_FLAT = "bemolle";
+var ITALIAN_DOUBLE = "doppio";
+function normalize(text) {
+  return text.trim().replace(/\s+/g, " ");
+}
+function assertSystem(system) {
+  return assertOneOf(system, NOTE_NAME_SYSTEMS, "system");
+}
+var ENGLISH_PATTERN = /^([A-Ga-g])([#x]*|b*)(-?\d+)?$/;
+function parseEnglish(text) {
+  const match = text.match(ENGLISH_PATTERN);
+  if (match === null) {
+    return null;
+  }
+  const glyph = (_nullishCoalesce(match[1], () => ( ""))).toUpperCase();
+  const letter = ENGLISH_LETTERS.indexOf(glyph);
+  let alter = 0;
+  for (const ch of _nullishCoalesce(match[2], () => ( ""))) {
+    if (ch === "#") {
+      alter += 1;
+    } else if (ch === "x") {
+      alter += 2;
+    } else if (ch === "b") {
+      alter -= 1;
+    }
+  }
+  const note = { letter, alter };
+  if (match[3] !== void 0) {
+    note.octave = Number.parseInt(match[3], 10);
+  }
+  return note;
+}
+function formatEnglish(note) {
+  const glyph = _nullishCoalesce(ENGLISH_LETTERS[note.letter], () => ( "C"));
+  if (note.alter > 0) {
+    return `${glyph}${"#".repeat(note.alter)}`;
+  }
+  return note.alter < 0 ? `${glyph}${"b".repeat(-note.alter)}` : glyph;
+}
+function germanFlats(letter, suffix) {
+  let rest = suffix;
+  if (GERMAN_ELIDING_LETTERS.includes(letter) && rest.startsWith("s")) {
+    rest = rest.slice(1);
+  } else if (rest.startsWith("es")) {
+    rest = rest.slice(2);
+  } else {
+    return null;
+  }
+  let flats = 1;
+  while (rest.length > 0) {
+    if (rest.startsWith("es") || letter === A_LETTER && rest.startsWith("as")) {
+      rest = rest.slice(2);
+      flats += 1;
+    } else {
+      return null;
+    }
+  }
+  return flats;
+}
+function parseGerman(text) {
+  const lower = text.toLowerCase();
+  if (lower === "b") {
+    return { letter: B_LETTER, alter: -1 };
+  }
+  const letter = GERMAN_LETTERS.indexOf(lower.slice(0, 1));
+  if (letter < 0) {
+    return null;
+  }
+  const suffix = lower.slice(1);
+  if (suffix === "") {
+    return { letter, alter: 0 };
+  }
+  if (/^(?:is)+$/.test(suffix)) {
+    return { letter, alter: suffix.length / 2 };
+  }
+  const flats = germanFlats(letter, suffix);
+  return flats === null ? null : { letter, alter: -flats };
+}
+function formatGerman(note) {
+  const glyph = _nullishCoalesce(GERMAN_LETTERS[note.letter], () => ( "c"));
+  if (note.alter >= 0) {
+    return `${glyph}${"is".repeat(note.alter)}`;
+  }
+  const flats = -note.alter;
+  if (note.letter === B_LETTER) {
+    return flats === 1 ? "b" : `h${"es".repeat(flats)}`;
+  }
+  const first = GERMAN_ELIDING_LETTERS.includes(note.letter) ? `${glyph}s` : `${glyph}es`;
+  return `${first}${"es".repeat(flats - 1)}`;
+}
+function parseJapanese(text) {
+  let rest = text;
+  let alter = 0;
+  let direction = 0;
+  while (rest.length > 0) {
+    const doubled = rest.startsWith(JAPANESE_DOUBLE);
+    const mark = doubled ? rest.slice(1, 2) : rest.slice(0, 1);
+    const step = mark === JAPANESE_SHARP ? 1 : mark === JAPANESE_FLAT ? -1 : 0;
+    if (step === 0) {
+      break;
+    }
+    if (direction !== 0 && direction !== step) {
+      return null;
+    }
+    direction = step;
+    alter += doubled ? step * 2 : step;
+    rest = rest.slice(doubled ? 2 : 1);
+  }
+  const letter = JAPANESE_LETTERS.indexOf(rest);
+  return letter < 0 ? null : { letter, alter };
+}
+function formatJapanese(note) {
+  const glyph = _nullishCoalesce(JAPANESE_LETTERS[note.letter], () => ( "\u30CF"));
+  const marks = Math.abs(note.alter);
+  if (marks === 0) {
+    return glyph;
+  }
+  const mark = note.alter > 0 ? JAPANESE_SHARP : JAPANESE_FLAT;
+  return `${marks === 2 ? `${JAPANESE_DOUBLE}${mark}` : mark.repeat(marks)}${glyph}`;
+}
+function parseItalian(text) {
+  const words = text.toLowerCase().split(" ");
+  const letter = ITALIAN_LETTERS.indexOf(words[0]);
+  if (letter < 0) {
+    return null;
+  }
+  let alter = 0;
+  let direction = 0;
+  let doubled = false;
+  for (const word of words.slice(1)) {
+    if (word === ITALIAN_DOUBLE) {
+      if (doubled) {
+        return null;
+      }
+      doubled = true;
+      continue;
+    }
+    const step = word === ITALIAN_SHARP ? 1 : word === ITALIAN_FLAT ? -1 : 0;
+    if (step === 0 || direction !== 0 && direction !== step) {
+      return null;
+    }
+    direction = step;
+    alter += doubled ? step * 2 : step;
+    doubled = false;
+  }
+  return doubled ? null : { letter, alter };
+}
+function formatItalian(note) {
+  const glyph = _nullishCoalesce(ITALIAN_LETTERS[note.letter], () => ( "do"));
+  const marks = Math.abs(note.alter);
+  if (marks === 0) {
+    return glyph;
+  }
+  const word = note.alter > 0 ? ITALIAN_SHARP : ITALIAN_FLAT;
+  const accidental = marks === 2 ? `${ITALIAN_DOUBLE} ${word}` : Array.from({ length: marks }, () => word).join(" ");
+  return `${glyph} ${accidental}`;
+}
+function splitOctave(text) {
+  const match = text.match(/^(.*?)(-?\d+)$/);
+  if (match === null) {
+    return { name: text, octave: void 0 };
+  }
+  return { name: _nullishCoalesce(match[1], () => ( "")), octave: Number.parseInt(_nullishCoalesce(match[2], () => ( "0")), 10) };
+}
+function parseIn(text, system) {
+  const table = tableOf(system);
+  if (table === "english") {
+    return parseEnglish(text);
+  }
+  const { name, octave } = splitOctave(text);
+  const parser = table === "german" ? parseGerman : table === "japanese" ? parseJapanese : parseItalian;
+  const note = parser(name);
+  if (note === null) {
+    return null;
+  }
+  return octave === void 0 ? note : { ...note, octave };
+}
+function splitModeWord(text) {
+  const lower = text.toLowerCase();
+  let best;
+  for (const system of DETECTION_ORDER) {
+    for (const mode of ["major", "minor"]) {
+      const word = MODE_WORDS[system][mode];
+      if (lower.endsWith(word) && (best === void 0 || word.length > best.word.length)) {
+        best = { word, mode, system };
+      }
+    }
+  }
+  if (best === void 0) {
+    return { tonic: text, mode: void 0, system: void 0 };
+  }
+  return {
+    tonic: text.slice(0, text.length - best.word.length).replace(/[\s-]+$/, ""),
+    mode: best.mode,
+    system: best.system
+  };
+}
+function resolveSystem(text) {
+  const { tonic, system: wordSystem } = splitModeWord(text);
+  const accepted = DETECTION_ORDER.filter((system) => parseIn(tonic, system) !== null);
+  const first = accepted[0];
+  if (first === void 0) {
+    return null;
+  }
+  if (wordSystem === void 0) {
+    return first;
+  }
+  if (!accepted.includes(wordSystem)) {
+    throw new InvalidInputError(
+      `${JSON.stringify(text)} mixes note-name systems: ${JSON.stringify(tonic)} is ${accepted.join(" or ")} but its mode word is ${wordSystem}`
+    );
+  }
+  return wordSystem;
+}
+function detectNoteNameSystem(text) {
+  if (typeof text !== "string") {
+    throw new InvalidInputError(`name must be a string; received ${typeof text}`);
+  }
+  const system = resolveSystem(normalize(text));
+  if (system === null) {
+    throw new InvalidInputError(`no note-name system reads ${JSON.stringify(text)}`);
+  }
+  return system;
+}
+function readNoteName(text, opts) {
+  const name = normalize(text);
+  const system = _optionalChain([opts, 'optionalAccess', _5 => _5.system]) === void 0 ? resolveSystem(name) : assertSystem(opts.system);
+  const note = system === null ? null : parseIn(name, system);
+  if (note === null) {
+    throw new InvalidInputError(`Invalid note: ${text}`);
+  }
+  return note;
+}
+function writeNoteName(note, opts) {
+  const system = _optionalChain([opts, 'optionalAccess', _6 => _6.system]) === void 0 ? "english" : assertSystem(opts.system);
+  const table = tableOf(system);
+  const name = table === "german" ? formatGerman(note) : table === "japanese" ? formatJapanese(note) : table === "italian" ? formatItalian(note) : formatEnglish(note);
+  return note.octave === void 0 ? name : `${name}${note.octave}`;
+}
+function impliedMode(system, tonic) {
+  return tableOf(system) === "german" && /^[a-h]/.test(tonic) ? "minor" : "major";
+}
+function readKeyName(text, opts) {
+  const name = normalize(text);
+  const split = splitModeWord(name);
+  const system = _optionalChain([opts, 'optionalAccess', _7 => _7.system]) === void 0 ? resolveSystem(name) : assertSystem(opts.system);
+  if (system !== null && split.system !== void 0 && split.system !== tableOf(system)) {
+    throw new InvalidInputError(
+      `${JSON.stringify(text)} is not a ${system} key name: its mode word is ${split.system}`
+    );
+  }
+  const tonic = system === null ? null : parseIn(split.tonic, system);
+  if (tonic === null || system === null) {
+    throw new InvalidInputError(`Invalid key name: ${text}`);
+  }
+  if (tonic.octave !== void 0) {
+    throw new InvalidInputError(`a key name carries no octave; received ${JSON.stringify(text)}`);
+  }
+  return { tonic, mode: _nullishCoalesce(split.mode, () => ( impliedMode(system, split.tonic))) };
+}
+function writeKeyName(key, opts) {
+  const system = _optionalChain([opts, 'optionalAccess', _8 => _8.system]) === void 0 ? "english" : assertSystem(opts.system);
+  const table = tableOf(system);
+  const word = MODE_WORDS[table][key.mode];
+  const tonic = writeNoteName(key.tonic, { system });
+  if (table === "japanese") {
+    return `${tonic}${word}`;
+  }
+  if (table === "german") {
+    const cased = key.mode === "major" ? `${tonic.slice(0, 1).toUpperCase()}${tonic.slice(1)}` : tonic;
+    return `${cased} ${word}`;
+  }
+  return `${tonic} ${word}`;
+}
+
+// src/core/pitch/index.ts
+var LETTER_SEMITONES = [0, 2, 4, 5, 7, 9, 11];
+var MAX_ALTER = 6;
+function assertNote(note, name) {
+  assertInteger(note.letter, `${name}.letter`, 0, 6);
+  assertInteger(note.alter, `${name}.alter`, -MAX_ALTER, MAX_ALTER);
+  if (note.octave !== void 0) {
+    assertInteger(note.octave, `${name}.octave`, -100, 100);
+  }
+  return note;
+}
+function pitchClassOf(value) {
+  assertFiniteNumber(value, "pitch");
+  return (Math.round(value) % 12 + 12) % 12;
+}
+var mod12 = pitchClassOf;
+function diatonicLetterOf(value) {
+  assertFiniteNumber(value, "diatonic letter");
+  return (Math.round(value) % 7 + 7) % 7;
+}
+function naturalPitchClassOf(letter) {
+  return _nullishCoalesce(LETTER_SEMITONES[diatonicLetterOf(letter)], () => ( 0));
+}
+var mod7 = diatonicLetterOf;
+function parseNote(text, opts) {
+  return unwrapParse(tryParseNote(text, opts));
+}
+function tryParseNote(text, opts) {
+  try {
+    if (typeof text !== "string") {
+      throw new InvalidInputError(`note must be a string; received ${typeof text}`);
+    }
+    return { ok: true, value: assertNote(readNoteName(text, opts), `note ${text}`) };
+  } catch (error) {
+    return parseFailure(error);
+  }
+}
+function formatNote(note, opts) {
+  assertNote(note, "note");
+  return writeNoteName({ letter: mod7(note.letter), alter: note.alter, octave: note.octave }, opts);
+}
+function parseKeyName(text, opts) {
+  return unwrapParse(tryParseKeyName(text, opts));
+}
+function tryParseKeyName(text, opts) {
+  try {
+    if (typeof text !== "string") {
+      throw new InvalidInputError(`key name must be a string; received ${typeof text}`);
+    }
+    const key = readKeyName(text, opts);
+    assertNote(key.tonic, `key ${text}`);
+    return { ok: true, value: key };
+  } catch (error) {
+    return parseFailure(error);
+  }
+}
+function formatKeyName(key, opts) {
+  assertNote(key.tonic, "key.tonic");
+  const mode = assertOneOf(key.mode, ["major", "minor"], "key.mode");
+  return writeKeyName(
+    { tonic: { letter: mod7(key.tonic.letter), alter: key.tonic.alter }, mode },
+    opts
+  );
+}
+function noteToPitchClass(note) {
+  assertNote(note, "note");
+  const natural = _nullishCoalesce(LETTER_SEMITONES[mod7(note.letter)], () => ( 0));
+  return mod12(natural + note.alter);
+}
+function noteToMidi(note) {
+  assertNote(note, "note");
+  if (note.octave === void 0) {
+    throw new InvalidInputError("noteToMidi requires an octave");
+  }
+  const natural = _nullishCoalesce(LETTER_SEMITONES[mod7(note.letter)], () => ( 0));
+  return (note.octave + 1) * 12 + natural + note.alter;
+}
+var SPELLINGS = {
+  sharp: [
+    [0, 0],
+    [0, 1],
+    [1, 0],
+    [1, 1],
+    [2, 0],
+    [3, 0],
+    [3, 1],
+    [4, 0],
+    [4, 1],
+    [5, 0],
+    [5, 1],
+    [6, 0]
+  ],
+  flat: [
+    [0, 0],
+    [1, -1],
+    [1, 0],
+    [2, -1],
+    [2, 0],
+    [3, 0],
+    [4, -1],
+    [4, 0],
+    [5, -1],
+    [5, 0],
+    [6, -1],
+    [6, 0]
+  ]
+};
+var SPELLING_NAMES = Object.keys(SPELLINGS);
+function midiToNote(midi, spelling = "sharp") {
+  assertFiniteNumber(midi, "midi");
+  const side = assertOneOf(spelling, SPELLING_NAMES, "midi spelling");
+  const rounded = Math.round(midi);
+  const pc = mod12(rounded);
+  const octave = Math.floor(rounded / 12) - 1;
+  const entry = _nullishCoalesce(SPELLINGS[side][pc], () => ( [0, 0]));
+  return { letter: entry[0], alter: entry[1], octave };
+}
+var LETTER_STEPS_BY_SEMITONE = [0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6];
+function transposeNote(note, semitones, opts) {
+  if (!Number.isFinite(semitones)) {
+    throw new InvalidInputError(`semitones must be a finite number; received ${semitones}`);
+  }
+  const steps = Math.round(semitones);
+  if (_optionalChain([opts, 'optionalAccess', _9 => _9.spelling]) !== void 0) {
+    return note.octave === void 0 ? bareOf(midiToNote(60 + mod12(noteToPitchClass(note) + steps), opts.spelling)) : midiToNote(noteToMidi(note) + steps, opts.spelling);
+  }
+  const direction = steps < 0 ? -1 : 1;
+  const magnitude = Math.abs(steps);
+  const octaves = Math.floor(magnitude / 12);
+  const withinOctave = magnitude % 12;
+  const letterSteps = direction * ((_nullishCoalesce(LETTER_STEPS_BY_SEMITONE[withinOctave], () => ( 0))) + 7 * octaves);
+  const absoluteLetter = mod7(note.letter) + letterSteps;
+  const letter = mod7(absoluteLetter);
+  const natural = _nullishCoalesce(LETTER_SEMITONES[letter], () => ( 0));
+  if (note.octave === void 0) {
+    return { letter, alter: alterFor(natural, mod12(noteToPitchClass(note) + steps)) };
+  }
+  const octave = note.octave + Math.floor(absoluteLetter / 7);
+  return { letter, alter: noteToMidi(note) + steps - ((octave + 1) * 12 + natural), octave };
+}
+function bareOf(note) {
+  return { letter: note.letter, alter: note.alter };
+}
+function alterFor(natural, pc) {
+  const d = mod12(pc - natural);
+  return d > 6 ? d - 12 : d;
+}
+var SIMPLE_REFERENCE = [0, 0, 2, 4, 5, 7, 9, 11];
+function isPerfectNumber(simpleNumber) {
+  return simpleNumber === 1 || simpleNumber === 4 || simpleNumber === 5;
+}
+function qualityFromSpan(numberValue, semitones) {
+  const octaves = Math.floor((numberValue - 1) / 7);
+  const simple = numberValue - 7 * octaves;
+  const reference = (_nullishCoalesce(SIMPLE_REFERENCE[simple], () => ( 0))) + 12 * octaves;
+  const delta = semitones - reference;
+  const repeat = (glyph, count) => `${glyph}${glyph.repeat(Math.min(count, MAX_ALTER * 2) - 1)}`;
+  if (isPerfectNumber(simple)) {
+    if (delta === 0) {
+      return "P";
+    }
+    return delta > 0 ? repeat("A", delta) : repeat("d", -delta);
+  }
+  if (delta === 0) {
+    return "M";
+  }
+  if (delta === -1) {
+    return "m";
+  }
+  return delta > 0 ? repeat("A", delta) : repeat("d", -delta - 1);
+}
+var MAX_INTERVAL_NUMBER = 75;
+function intervalSemitones(numberValue, quality) {
+  assertInteger(numberValue, "interval number", 1, MAX_INTERVAL_NUMBER);
+  const octaves = Math.floor((numberValue - 1) / 7);
+  const simple = numberValue - 7 * octaves;
+  const reference = (_nullishCoalesce(SIMPLE_REFERENCE[simple], () => ( 0))) + 12 * octaves;
+  const perfect = isPerfectNumber(simple);
+  if (quality === "P" || quality === "M") {
+    if (perfect !== (quality === "P")) {
+      throw new InvalidInputError(
+        `an interval of ${numberValue} cannot be ${quality === "P" ? "perfect" : "major"}`
+      );
+    }
+    return reference;
+  }
+  if (quality === "m") {
+    if (perfect) {
+      throw new InvalidInputError(
+        `a perfect-class interval cannot be minor; received ${numberValue}`
+      );
+    }
+    return reference - 1;
+  }
+  if (/^A+$/.test(quality)) {
+    return reference + quality.length;
+  }
+  if (/^d+$/.test(quality)) {
+    if (numberValue === 1) {
+      throw new InvalidInputError(
+        `a unison cannot be diminished; a unison narrowed by a semitone descends, so name it '-${"A".repeat(quality.length)}1'`
+      );
+    }
+    return Math.abs(reference - quality.length - (perfect ? 0 : 1));
+  }
+  throw new InvalidInputError(`unknown interval quality ${JSON.stringify(quality)}`);
+}
+var INTERVAL_NAME_PATTERN = /^(-?)(P|M|m|A+|d+)(\d+)$/;
+function parseInterval(name) {
+  return unwrapParse(tryParseInterval(name));
+}
+function tryParseInterval(name) {
+  try {
+    const match = typeof name === "string" ? name.trim().match(INTERVAL_NAME_PATTERN) : null;
+    const quality = _optionalChain([match, 'optionalAccess', _10 => _10[2]]);
+    const numberValue = Number(_optionalChain([match, 'optionalAccess', _11 => _11[3]]));
+    if (quality === void 0 || !Number.isFinite(numberValue)) {
+      throw new InvalidInputError(
+        `interval must be a quality followed by a number, such as 'P5'; received ${JSON.stringify(name)}`
+      );
+    }
+    const span = intervalSemitones(numberValue, quality);
+    if (_optionalChain([match, 'optionalAccess', _12 => _12[1]]) !== "-") {
+      return { ok: true, value: { number: numberValue, quality, semitones: span } };
+    }
+    return {
+      ok: true,
+      value: { number: numberValue, quality, semitones: span === 0 ? 0 : -span, descending: true }
+    };
+  } catch (error) {
+    return parseFailure(error);
+  }
+}
+function isDescendingInterval(interval) {
+  if (interval.descending !== void 0) {
+    return interval.descending;
+  }
+  const span = Math.round(interval.semitones);
+  if (span < 0 && qualityFromSpan(interval.number, span) === interval.quality) {
+    return false;
+  }
+  return span < 0;
+}
+function normalizedInterval(data) {
+  assertInteger(data.number, "interval.number", 1);
+  assertFiniteNumber(data.semitones, "interval.semitones");
+  const expected = intervalSemitones(data.number, data.quality);
+  if (Math.abs(data.semitones) !== expected) {
+    throw new InvalidInputError(
+      `${data.quality}${data.number} spans ${expected} semitones; received ${data.semitones}`
+    );
+  }
+  const normalized = {
+    number: data.number,
+    quality: data.quality,
+    semitones: data.semitones
+  };
+  if (isDescendingInterval(data)) {
+    normalized.descending = true;
+  }
+  return normalized;
+}
+function toSpelledInterval(value) {
+  if (typeof value === "string") {
+    return parseInterval(value);
+  }
+  if (typeof value === "object" && value !== null) {
+    const data = "toJSON" in value && typeof value.toJSON === "function" ? value.toJSON() : value;
+    return normalizedInterval(data);
+  }
+  throw new InvalidInputError(
+    `interval must be a name or spelled interval data; received ${typeof value}`
+  );
+}
+function toNoteData(value) {
+  if (typeof value === "string") {
+    return parseNote(value);
+  }
+  if (typeof value === "number") {
+    return midiToNote(value);
+  }
+  if (typeof value === "object" && value !== null) {
+    const data = "toJSON" in value && typeof value.toJSON === "function" ? value.toJSON() : value;
+    const note = assertNote(data, "note");
+    return note.octave === void 0 ? { letter: note.letter, alter: note.alter } : { letter: note.letter, alter: note.alter, octave: note.octave };
+  }
+  throw new InvalidInputError(
+    `note must be a name, a MIDI number, or spelled note data; received ${typeof value}`
+  );
+}
+function transposeByInterval(note, interval) {
+  assertNote(note, "note");
+  assertInteger(interval.number, "interval.number", 1);
+  assertFiniteNumber(interval.semitones, "interval.semitones");
+  const letterSteps = (interval.number - 1) * (isDescendingInterval(interval) ? -1 : 1);
+  const absoluteLetter = mod7(note.letter) + letterSteps;
+  const letter = mod7(absoluteLetter);
+  const natural = _nullishCoalesce(LETTER_SEMITONES[letter], () => ( 0));
+  const steps = Math.round(interval.semitones);
+  if (note.octave === void 0) {
+    return { letter, alter: alterFor(natural, mod12(noteToPitchClass(note) + steps)) };
+  }
+  const octave = note.octave + Math.floor(absoluteLetter / 7);
+  return { letter, alter: noteToMidi(note) + steps - ((octave + 1) * 12 + natural), octave };
+}
+function diatonicIndex(note) {
+  return mod7(note.letter) + 7 * (_nullishCoalesce(note.octave, () => ( 0)));
+}
+function spelledInterval(a, b) {
+  assertNote(a, "a");
+  assertNote(b, "b");
+  if (a.octave === void 0 !== (b.octave === void 0)) {
+    throw new InvalidInputError(
+      "spelledInterval needs both notes to carry an octave or neither to; received one of each"
+    );
+  }
+  const octaved = a.octave !== void 0 && b.octave !== void 0;
+  let letterSteps;
+  let semitones;
+  if (octaved) {
+    letterSteps = diatonicIndex(b) - diatonicIndex(a);
+    semitones = noteToMidi(b) - noteToMidi(a);
+  } else {
+    letterSteps = mod7(b.letter - a.letter);
+    let rawSemis = mod12(noteToPitchClass(b) - noteToPitchClass(a));
+    const reference = _nullishCoalesce(SIMPLE_REFERENCE[letterSteps + 1], () => ( 0));
+    if (reference - rawSemis > 6) {
+      rawSemis += 12;
+    } else if (rawSemis - reference > 6) {
+      rawSemis -= 12;
+    }
+    semitones = rawSemis;
+  }
+  const absSteps = Math.abs(letterSteps);
+  const number = absSteps + 1;
+  const directedSpan = letterSteps === 0 ? Math.abs(semitones) : letterSteps > 0 ? semitones : -semitones;
+  const interval = {
+    number,
+    quality: qualityFromSpan(number, directedSpan),
+    semitones
+  };
+  if (letterSteps < 0 || letterSteps === 0 && semitones < 0) {
+    interval.descending = true;
+  }
+  return interval;
+}
+
+// src/core/interval/index.ts
+var ConsonanceClass = /* @__PURE__ */ ((ConsonanceClass2) => {
+  ConsonanceClass2[ConsonanceClass2["PerfectConsonance"] = 0] = "PerfectConsonance";
+  ConsonanceClass2[ConsonanceClass2["ImperfectConsonance"] = 1] = "ImperfectConsonance";
+  ConsonanceClass2[ConsonanceClass2["Dissonance"] = 2] = "Dissonance";
+  return ConsonanceClass2;
+})(ConsonanceClass || {});
+function simpleInterval(semitones) {
+  return pitchClassOf(Math.abs(semitones));
+}
+function classifyInterval(semitones, twoVoice = true) {
+  const pc = simpleInterval(semitones);
+  if (pc === 0 || pc === 7) {
+    return 0 /* PerfectConsonance */;
+  }
+  if (pc === 3 || pc === 4 || pc === 8 || pc === 9) {
+    return 1 /* ImperfectConsonance */;
+  }
+  if (pc === 5) {
+    return twoVoice ? 2 /* Dissonance */ : 1 /* ImperfectConsonance */;
+  }
+  return 2 /* Dissonance */;
+}
+function isPerfectInterval(semitones) {
+  const pc = simpleInterval(semitones);
+  return pc === 0 || pc === 7;
+}
+function isConsonantInterval(semitones, twoVoice = true) {
+  const pc = simpleInterval(semitones);
+  if (pc === 5) {
+    return !twoVoice;
+  }
+  return pc === 0 || pc === 3 || pc === 4 || pc === 7 || pc === 8 || pc === 9;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.parseFailure = parseFailure; exports.unwrapParse = unwrapParse; exports.InvalidInputError = InvalidInputError; exports.NoSolutionError = NoSolutionError; exports.BudgetExceededError = BudgetExceededError; exports.isLibcantusError = isLibcantusError; exports.isCompoundNumerator = isCompoundNumerator; exports.groupingSumOf = groupingSumOf; exports.isAdditiveReading = isAdditiveReading; exports.pulseCountOf = pulseCountOf; exports.pulseBeatsOf = pulseBeatsOf; exports.pulseGroupingOf = pulseGroupingOf; exports.barBeatsOf = barBeatsOf; exports.isMeterMap = isMeterMap; exports.entryIndexOf = entryIndexOf; exports.barStartOf = barStartOf; exports.barLengthOf = barLengthOf; exports.barIndexOf = barIndexOf; exports.beatOfBarIndex = beatOfBarIndex; exports.DEFAULT_GENERATION_BUDGET = DEFAULT_GENERATION_BUDGET; exports.assertFiniteNumber = assertFiniteNumber; exports.assertInteger = assertInteger; exports.assertMidiPitch = assertMidiPitch; exports.clampToMidi = clampToMidi; exports.assertDegree = assertDegree; exports.assertFiniteSemitones = assertFiniteSemitones; exports.dropSilentNotes = dropSilentNotes; exports.soundingNotesOnly = soundingNotesOnly; exports.assertOneOf = assertOneOf; exports.assertPositiveInt = assertPositiveInt; exports.assertRange = assertRange; exports.assertGenerationBudget = assertGenerationBudget; exports.assertTimeSignature = assertTimeSignature; exports.assertMeterMap = assertMeterMap; exports.assertNoteEvent = assertNoteEvent; exports.assertNoteEvents = assertNoteEvents; exports.detectNoteNameSystem = detectNoteNameSystem; exports.pitchClassOf = pitchClassOf; exports.diatonicLetterOf = diatonicLetterOf; exports.naturalPitchClassOf = naturalPitchClassOf; exports.parseNote = parseNote; exports.tryParseNote = tryParseNote; exports.formatNote = formatNote; exports.parseKeyName = parseKeyName; exports.tryParseKeyName = tryParseKeyName; exports.formatKeyName = formatKeyName; exports.noteToPitchClass = noteToPitchClass; exports.noteToMidi = noteToMidi; exports.midiToNote = midiToNote; exports.transposeNote = transposeNote; exports.intervalSemitones = intervalSemitones; exports.parseInterval = parseInterval; exports.tryParseInterval = tryParseInterval; exports.toSpelledInterval = toSpelledInterval; exports.toNoteData = toNoteData; exports.transposeByInterval = transposeByInterval; exports.spelledInterval = spelledInterval; exports.ConsonanceClass = ConsonanceClass; exports.classifyInterval = classifyInterval; exports.isPerfectInterval = isPerfectInterval; exports.isConsonantInterval = isConsonantInterval;
+//# sourceMappingURL=chunk-Q2WGKJNN.cjs.map