@libraz/libcantus 1.0.1 → 1.2.0

package/dist/{chunk-Q2WGKJNN.cjs → chunk-S5BKZZGM.cjs}

@@ -40,8 +40,24 @@ function isLibcantusError(value) {
   return code === "INVALID_INPUT" || code === "NO_SOLUTION" || code === "BUDGET_EXCEEDED";
 }
 
+// src/core/instrument/articulation.ts
+var ARTICULATIONS = Object.freeze([
+  "accent",
+  "ghost",
+  "staccato",
+  "legato",
+  "slide",
+  "hammer",
+  "mute",
+  "flam",
+  "drag",
+  "roll",
+  "choke",
+  "open"
+]);
+
 // src/core/meter/internal.ts
-var EPS = 1e-9;
+var BEAT_EPS = 1e-9;
 function unitBeatsOf(ts) {
   return 4 / ts.denominator;
 }
@@ -96,86 +112,195 @@ function barBeatsOf(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;
+function copyTimeSignature(ts) {
+  return ts.grouping === void 0 ? { numerator: ts.numerator, denominator: ts.denominator } : { numerator: ts.numerator, denominator: ts.denominator, grouping: [...ts.grouping] };
+}
+function copyMeterMap(map) {
+  const copy = new Array(map.length);
+  for (let i = 0; i < map.length; i += 1) {
+    const entry = map[i];
+    copy[i] = entry === void 0 ? { startBeat: 0, ts: { numerator: 4, denominator: 4 } } : { startBeat: entry.startBeat, ts: copyTimeSignature(entry.ts) };
   }
+  return copy;
+}
+function copyMeterData(data) {
+  return isMeterMap(data) ? copyMeterMap(data) : copyTimeSignature(data);
+}
+var INDEX_CACHE = /* @__PURE__ */ new WeakMap();
+var readMap;
+var readIndex;
+function rememberRead(map, index) {
+  readMap = map;
+  readIndex = index;
   return index;
 }
-function barsBeforeEntry(map, index) {
+function sameSignature(ts, snapshot) {
+  if (typeof ts !== "object" || ts === null) {
+    return false;
+  }
+  if (ts.numerator !== snapshot.numerator || ts.denominator !== snapshot.denominator) {
+    return false;
+  }
+  const grouping = ts.grouping;
+  const was = snapshot.grouping;
+  if (grouping === void 0 || was === void 0) {
+    return grouping === was;
+  }
+  if (grouping.length !== was.length) {
+    return false;
+  }
+  for (let i = 0; i < was.length; i += 1) {
+    if (grouping[i] !== was[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function describesMap(index, map) {
+  if (index.startBeats.length !== map.length) {
+    return false;
+  }
+  for (let i = 0; i < map.length; i += 1) {
+    const entry = map[i];
+    const signature = index.signatures[i];
+    if (entry === void 0 || entry === null || signature === void 0 || entry.startBeat !== index.startBeats[i] || !sameSignature(entry.ts, signature)) {
+      return false;
+    }
+  }
+  return true;
+}
+function buildMeterIndex(map, validated) {
+  const startBeats = new Array(map.length);
+  const signatures = new Array(map.length);
+  const barAnchors = new Array(map.length);
+  const barBeats = new Array(map.length);
+  const barsBefore = new Array(map.length);
   let bars = 0;
-  for (let i = 0; i < index; i += 1) {
+  for (let i = 0; i < map.length; i += 1) {
     const entry = map[i];
+    const startBeat = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _ => _.startBeat]), () => ( 0));
+    const barLen = entry === void 0 ? 0 : barBeatsOf(entry.ts);
+    const anchor = i === 0 ? 0 : startBeat;
+    startBeats[i] = startBeat;
+    signatures[i] = entry === void 0 ? { numerator: 4, denominator: 4 } : copyTimeSignature(entry.ts);
+    barAnchors[i] = anchor;
+    barBeats[i] = barLen;
+    barsBefore[i] = bars;
     const next = map[i + 1];
-    if (entry === void 0 || next === void 0) {
-      break;
+    if (next !== void 0 && barLen > 0) {
+      bars += Math.max(1, Math.ceil((next.startBeat - anchor) / barLen - BEAT_EPS));
+    }
+  }
+  const index = { startBeats, signatures, barAnchors, barBeats, barsBefore, validated };
+  INDEX_CACHE.set(map, index);
+  return rememberRead(map, index);
+}
+function meterIndexOf(map) {
+  if (readMap === map && readIndex !== void 0) {
+    return readIndex;
+  }
+  const cached = INDEX_CACHE.get(map);
+  return cached !== void 0 && describesMap(cached, map) ? rememberRead(map, cached) : buildMeterIndex(map, false);
+}
+function isValidatedMeterMap(map) {
+  const cached = INDEX_CACHE.get(map);
+  if (_optionalChain([cached, 'optionalAccess', _2 => _2.validated]) !== true || !describesMap(cached, map)) {
+    return false;
+  }
+  rememberRead(map, cached);
+  return true;
+}
+function rememberValidatedMeterMap(map) {
+  buildMeterIndex(map, true);
+}
+function lastAtOrBefore(keys, value) {
+  let low = 1;
+  let high = keys.length - 1;
+  let index = 0;
+  while (low <= high) {
+    const mid = low + high >>> 1;
+    if ((_nullishCoalesce(keys[mid], () => ( Number.POSITIVE_INFINITY))) <= value) {
+      index = mid;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
     }
-    bars += Math.max(1, Math.ceil((next.startBeat - entry.startBeat) / barBeatsOf(entry.ts) - EPS));
   }
-  return bars;
+  return index;
+}
+function entryIndexOf(map, beat) {
+  return lastAtOrBefore(meterIndexOf(map).startBeats, beat + BEAT_EPS);
 }
 function barStartOf(map, beat) {
-  const entry = map[entryIndexOf(map, beat)];
-  if (entry === void 0) {
+  const index = meterIndexOf(map);
+  const at = lastAtOrBefore(index.startBeats, beat + BEAT_EPS);
+  const anchor = index.barAnchors[at];
+  const barLen = index.barBeats[at];
+  if (anchor === void 0 || barLen === void 0 || barLen === 0) {
     return 0;
   }
-  const barLen = barBeatsOf(entry.ts);
-  return entry.startBeat + Math.floor((beat - entry.startBeat) / barLen + EPS) * barLen;
+  return anchor + Math.floor((beat - anchor) / barLen + BEAT_EPS) * barLen;
 }
 function barLengthOf(map, beat) {
-  const index = entryIndexOf(map, beat);
-  const entry = map[index];
-  if (entry === void 0) {
+  const index = meterIndexOf(map);
+  const at = lastAtOrBefore(index.startBeats, beat + BEAT_EPS);
+  const full = index.barBeats[at];
+  if (full === void 0) {
     return 0;
   }
-  const full = barBeatsOf(entry.ts);
-  const next = _optionalChain([map, 'access', _3 => _3[index + 1], 'optionalAccess', _4 => _4.startBeat]);
+  const next = index.startBeats[at + 1];
   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) {
+  const index = meterIndexOf(map);
+  const at = lastAtOrBefore(index.startBeats, beat + BEAT_EPS);
+  const anchor = index.barAnchors[at];
+  const barLen = index.barBeats[at];
+  if (anchor === void 0 || barLen === void 0 || barLen === 0) {
     return 0;
   }
-  const barLen = barBeatsOf(entry.ts);
-  return barsBeforeEntry(map, index) + Math.floor((beat - entry.startBeat) / barLen + EPS);
+  return (_nullishCoalesce(index.barsBefore[at], () => ( 0))) + Math.floor((beat - anchor) / barLen + BEAT_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;
+  const index = meterIndexOf(map);
+  const at = lastAtOrBefore(index.barsBefore, barIndex);
+  const anchor = index.barAnchors[at];
+  const barLen = index.barBeats[at];
+  if (anchor === void 0 || barLen === void 0) {
+    return 0;
   }
-  return 0;
+  return anchor + (barIndex - (_nullishCoalesce(index.barsBefore[at], () => ( 0)))) * barLen;
 }
 
 // src/core/validation/index.ts
 var DEFAULT_GENERATION_BUDGET = 1e6;
+var MAX_METER_CHANGES = 1e5;
+var MAX_ECHOED_LENGTH = 64;
+function describeRejected(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value !== "string") {
+    return typeof value;
+  }
+  return value.length <= MAX_ECHOED_LENGTH ? JSON.stringify(value) : `${JSON.stringify(value.slice(0, MAX_ECHOED_LENGTH))} (truncated from ${value.length} characters)`;
+}
 function assertFiniteNumber(value, name) {
   if (!Number.isFinite(value)) {
     throw new InvalidInputError(`${name} must be finite; received ${value}`);
   }
   return value;
 }
+function assertBounds(min, max, name) {
+  if (!Number.isFinite(min) || !Number.isFinite(max)) {
+    throw new InvalidInputError(
+      `${name} must be bounded by finite numbers; received [${describeRejected(min)}, ${describeRejected(max)}]`
+    );
+  }
+}
 function assertInteger(value, name, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
   assertFiniteNumber(value, name);
+  assertBounds(min, max, name);
   if (!Number.isSafeInteger(value) || value < min || value > max) {
     throw new InvalidInputError(
       `${name} must be an integer in [${min}, ${max}]; received ${value}`
@@ -186,6 +311,9 @@ function assertInteger(value, name, min = Number.MIN_SAFE_INTEGER, max = Number.
 function assertMidiPitch(value, name = "MIDI pitch") {
   return assertInteger(value, name, 0, 127);
 }
+function assertPitchClass(value, name = "pitch class") {
+  return assertInteger(value, name, 0, 11);
+}
 function clampToMidi(value, name = "MIDI pitch") {
   assertInteger(value, name);
   return Math.min(127, Math.max(0, value));
@@ -197,13 +325,43 @@ function assertFiniteSemitones(value, name = "semitones") {
   return assertFiniteNumber(value, name);
 }
 function dropSilentNotes(events) {
-  return events.filter((event) => event !== void 0 && event.durationBeat > 0);
+  return assertArray(events, "events").filter(
+    (event) => event !== void 0 && event !== null && event.durationBeat > 0
+  );
 }
 var soundingNotesOnly = dropSilentNotes;
+function assertArray(value, name) {
+  if (!Array.isArray(value)) {
+    throw new InvalidInputError(`${name} must be an array; received ${describeRejected(value)}`);
+  }
+  return value;
+}
+function assertRecord(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new InvalidInputError(`${name} must be an object; received ${describeRejected(value)}`);
+  }
+  return value;
+}
+function assertOptions(value, name = "options") {
+  return value === void 0 ? {} : assertRecord(value, name);
+}
+function assertFlag(value, name) {
+  if (typeof value !== "boolean") {
+    throw new InvalidInputError(`${name} must be a boolean; received ${describeRejected(value)}`);
+  }
+  return value;
+}
+function assertFunction(value, name) {
+  if (typeof value !== "function") {
+    throw new InvalidInputError(`${name} must be a function; received ${describeRejected(value)}`);
+  }
+  return value;
+}
 function assertOneOf(value, allowed, name) {
-  if (typeof value !== "string" || !allowed.includes(value)) {
+  const names = assertArray(allowed, `${name} allowed values`);
+  if (typeof value !== "string" || !names.includes(value)) {
     throw new InvalidInputError(
-      `${name} must be one of ${allowed.join(", ")}; received ${JSON.stringify(value)}`
+      `${name} must be one of ${names.join(", ")}; received ${describeRejected(value)}`
     );
   }
   return value;
@@ -213,13 +371,14 @@ function assertPositiveInt(value, name, max = DEFAULT_GENERATION_BUDGET) {
 }
 function assertRange(value, min, max, name) {
   assertFiniteNumber(value, name);
+  assertBounds(min, max, 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));
+  const cap = limit === void 0 ? DEFAULT_GENERATION_BUDGET : limit;
   assertFiniteNumber(estimated, name);
   assertPositiveInt(cap, `${name} limit`, Number.MAX_SAFE_INTEGER);
   if (estimated < 0) {
@@ -232,10 +391,31 @@ function assertGenerationBudget(estimated, name, limit = DEFAULT_GENERATION_BUDG
   }
   return estimated;
 }
+function assertTableSize(rows, columns, name, budget) {
+  assertFiniteNumber(rows, `${name} rows`);
+  assertFiniteNumber(columns, `${name} columns`);
+  return assertGenerationBudget(rows * columns, name, budget);
+}
+function allocateCandidateTable(rows, columns, name, budget) {
+  return new Float64Array(assertTableSize(rows, columns, name, budget));
+}
+function allocateChoiceTable(rows, columns, name, budget) {
+  return new Int32Array(assertTableSize(rows, columns, name, budget));
+}
 function assertTimeSignature(ts, name = "time signature") {
+  if (typeof ts !== "object" || ts === null) {
+    throw new InvalidInputError(
+      `${name} must be a time signature; received ${describeRejected(ts)}`
+    );
+  }
   assertPositiveInt(ts.numerator, `${name}.numerator`);
   assertPositiveInt(ts.denominator, `${name}.denominator`);
   if (ts.grouping !== void 0) {
+    if (!Array.isArray(ts.grouping)) {
+      throw new InvalidInputError(
+        `${name}.grouping must be an array of group lengths; received ${describeRejected(ts.grouping)}`
+      );
+    }
     if (ts.grouping.length === 0) {
       throw new InvalidInputError(`${name}.grouping must not be empty`);
     }
@@ -258,11 +438,17 @@ function assertMeterMap(meters, name = "meters") {
   if (meters.length === 0) {
     throw new InvalidInputError(`${name} must not be empty`);
   }
+  assertGenerationBudget(meters.length, `${name} count`, MAX_METER_CHANGES);
+  if (isValidatedMeterMap(meters)) {
+    return meters;
+  }
   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`);
+    if (typeof entry !== "object" || entry === null) {
+      throw new InvalidInputError(
+        `${name}[${index}] must be a meter change; received ${describeRejected(entry)}`
+      );
     }
     assertFiniteNumber(entry.startBeat, `${name}[${index}].startBeat`);
     if (index > 0 && entry.startBeat <= previous) {
@@ -273,15 +459,22 @@ function assertMeterMap(meters, name = "meters") {
     previous = entry.startBeat;
     assertTimeSignature(entry.ts, `${name}[${index}].ts`);
   }
+  rememberValidatedMeterMap(meters);
   return meters;
 }
 function assertNoteEvent(event, name = "note event", options = {}) {
+  const asked = assertOptions(options, `${name} options`);
+  if (typeof event !== "object" || event === null) {
+    throw new InvalidInputError(
+      `${name} must be a note event; received ${describeRejected(event)}`
+    );
+  }
   assertMidiPitch(event.pitch, `${name}.pitch`);
-  const minStartBeat = _nullishCoalesce(options.minStartBeat, () => ( -Number.MAX_SAFE_INTEGER));
+  const minStartBeat = _nullishCoalesce(asked.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) {
+  if (!asked.allowNonPositiveDuration && event.durationBeat <= 0) {
     throw new InvalidInputError(
       `${name}.durationBeat must be positive; received ${event.durationBeat}`
     );
@@ -293,21 +486,27 @@ function assertNoteEvent(event, name = "note event", options = {}) {
     `${name}.durationBeat`
   );
   if (event.velocity !== void 0) {
-    assertRange(event.velocity, 0, 127, `${name}.velocity`);
+    assertInteger(event.velocity, `${name}.velocity`, 0, 127);
+  }
+  if (event.articulation !== void 0) {
+    assertOneOf(event.articulation, ARTICULATIONS, `${name}.articulation`);
   }
   return event;
 }
 function assertNoteEvents(events, name = "note events", options = {}) {
+  const asked = assertOptions(options, `${name} options`);
   if (!Array.isArray(events)) {
     throw new InvalidInputError(`${name} must be an array; received ${typeof events}`);
   }
-  assertGenerationBudget(events.length, `${name} count`, options.budget);
+  assertGenerationBudget(events.length, `${name} count`, asked.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`);
+    if (typeof event !== "object" || event === null) {
+      throw new InvalidInputError(
+        `${name}[${index}] must be a note event; received ${describeRejected(event)}`
+      );
     }
-    assertNoteEvent(event, `${name}[${index}]`, options);
+    assertNoteEvent(event, `${name}[${index}]`, asked);
   }
   return events;
 }
@@ -343,6 +542,30 @@ var JAPANESE_DOUBLE = "\u91CD";
 var ITALIAN_SHARP = "diesis";
 var ITALIAN_FLAT = "bemolle";
 var ITALIAN_DOUBLE = "doppio";
+var MAX_NAME_ACCIDENTALS = 2;
+function longestGlyph(glyphs) {
+  return Math.max(...glyphs.map((glyph) => glyph.length));
+}
+var MAX_LETTER_LENGTH = {
+  english: longestGlyph(ENGLISH_LETTERS),
+  german: longestGlyph(GERMAN_LETTERS),
+  japanese: longestGlyph(JAPANESE_LETTERS),
+  italian: longestGlyph(ITALIAN_LETTERS)
+};
+var MAX_ACCIDENTAL_LENGTH = {
+  /** `#`, `x` and `b`. */
+  english: 1,
+  /** The `-is` and `-es` affixes, whose first mark may elide to a bare `s`. */
+  german: 2,
+  /** 嬰 and 変; 重 stands in for the second mark of a double, not beside it. */
+  japanese: 1,
+  /** A space and the accidental word; `doppio` covers two marks in one word. */
+  italian: 1 + Math.max(ITALIAN_SHARP.length, ITALIAN_FLAT.length)
+};
+function maxNoteNameLength(system) {
+  const table = tableOf(assertSystem(system));
+  return MAX_LETTER_LENGTH[table] + MAX_NAME_ACCIDENTALS * MAX_ACCIDENTAL_LENGTH[table];
+}
 function normalize(text) {
   return text.trim().replace(/\s+/g, " ");
 }
@@ -498,12 +721,19 @@ function formatItalian(note) {
   const accidental = marks === 2 ? `${ITALIAN_DOUBLE} ${word}` : Array.from({ length: marks }, () => word).join(" ");
   return `${glyph} ${accidental}`;
 }
+function isDigit(ch) {
+  return ch >= "0" && ch <= "9";
+}
 function splitOctave(text) {
-  const match = text.match(/^(.*?)(-?\d+)$/);
-  if (match === null) {
+  let start = text.length;
+  while (start > 0 && isDigit(text.charAt(start - 1))) {
+    start -= 1;
+  }
+  if (start === text.length) {
     return { name: text, octave: void 0 };
   }
-  return { name: _nullishCoalesce(match[1], () => ( "")), octave: Number.parseInt(_nullishCoalesce(match[2], () => ( "0")), 10) };
+  const signed = start > 0 && text.charAt(start - 1) === "-" ? start - 1 : start;
+  return { name: text.slice(0, signed), octave: Number.parseInt(text.slice(signed), 10) };
 }
 function parseIn(text, system) {
   const table = tableOf(system);
@@ -518,6 +748,13 @@ function parseIn(text, system) {
   }
   return octave === void 0 ? note : { ...note, octave };
 }
+function trimSeparators(text) {
+  let end = text.length;
+  while (end > 0 && /[\s-]/.test(text.charAt(end - 1))) {
+    end -= 1;
+  }
+  return text.slice(0, end);
+}
 function splitModeWord(text) {
   const lower = text.toLowerCase();
   let best;
@@ -533,27 +770,31 @@ function splitModeWord(text) {
     return { tonic: text, mode: void 0, system: void 0 };
   }
   return {
-    tonic: text.slice(0, text.length - best.word.length).replace(/[\s-]+$/, ""),
+    tonic: trimSeparators(text.slice(0, text.length - best.word.length)),
     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) {
+  if (wordSystem === void 0) {
+    for (const system of DETECTION_ORDER) {
+      if (parseIn(tonic, system) !== null) {
+        return system;
+      }
+    }
     return null;
   }
-  if (wordSystem === void 0) {
-    return first;
+  if (parseIn(tonic, wordSystem) !== null) {
+    return wordSystem;
   }
-  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}`
-    );
+  const accepted = DETECTION_ORDER.filter((system) => parseIn(tonic, system) !== null);
+  if (accepted.length === 0) {
+    return null;
   }
-  return wordSystem;
+  throw new InvalidInputError(
+    `${describeRejected(text)} mixes note-name systems: ${describeRejected(tonic)} is ${accepted.join(" or ")} but its mode word is ${wordSystem}`
+  );
 }
 function detectNoteNameSystem(text) {
   if (typeof text !== "string") {
@@ -561,21 +802,23 @@ function detectNoteNameSystem(text) {
   }
   const system = resolveSystem(normalize(text));
   if (system === null) {
-    throw new InvalidInputError(`no note-name system reads ${JSON.stringify(text)}`);
+    throw new InvalidInputError(`no note-name system reads ${describeRejected(text)}`);
   }
   return system;
 }
 function readNoteName(text, opts) {
+  const asked = assertOptions(opts, "opts");
   const name = normalize(text);
-  const system = _optionalChain([opts, 'optionalAccess', _5 => _5.system]) === void 0 ? resolveSystem(name) : assertSystem(opts.system);
+  const system = asked.system === void 0 ? resolveSystem(name) : assertSystem(asked.system);
   const note = system === null ? null : parseIn(name, system);
   if (note === null) {
-    throw new InvalidInputError(`Invalid note: ${text}`);
+    throw new InvalidInputError(`Invalid note: ${describeRejected(text)}`);
   }
   return note;
 }
 function writeNoteName(note, opts) {
-  const system = _optionalChain([opts, 'optionalAccess', _6 => _6.system]) === void 0 ? "english" : assertSystem(opts.system);
+  const asked = assertOptions(opts, "opts");
+  const system = asked.system === void 0 ? "english" : assertSystem(asked.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}`;
@@ -585,24 +828,26 @@ function impliedMode(system, tonic) {
 }
 function readKeyName(text, opts) {
   const name = normalize(text);
+  const asked = assertOptions(opts, "opts");
   const split = splitModeWord(name);
-  const system = _optionalChain([opts, 'optionalAccess', _7 => _7.system]) === void 0 ? resolveSystem(name) : assertSystem(opts.system);
+  const system = asked.system === void 0 ? resolveSystem(name) : assertSystem(asked.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}`
+      `${describeRejected(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}`);
+    throw new InvalidInputError(`Invalid key name: ${describeRejected(text)}`);
   }
   if (tonic.octave !== void 0) {
-    throw new InvalidInputError(`a key name carries no octave; received ${JSON.stringify(text)}`);
+    throw new InvalidInputError(`a key name carries no octave; received ${describeRejected(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 asked = assertOptions(opts, "opts");
+  const system = asked.system === void 0 ? "english" : assertSystem(asked.system);
   const table = tableOf(system);
   const word = MODE_WORDS[table][key.mode];
   const tonic = writeNoteName(key.tonic, { system });
@@ -619,11 +864,13 @@ function writeKeyName(key, opts) {
 // src/core/pitch/index.ts
 var LETTER_SEMITONES = [0, 2, 4, 5, 7, 9, 11];
 var MAX_ALTER = 6;
+var MAX_OCTAVE = 100;
 function assertNote(note, name) {
+  assertRecord(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);
+    assertInteger(note.octave, `${name}.octave`, -MAX_OCTAVE, MAX_OCTAVE);
   }
   return note;
 }
@@ -644,11 +891,12 @@ function parseNote(text, opts) {
   return unwrapParse(tryParseNote(text, opts));
 }
 function tryParseNote(text, opts) {
+  const asked = assertOptions(opts, "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}`) };
+    return { ok: true, value: assertNote(readNoteName(text, asked), `note ${text}`) };
   } catch (error) {
     return parseFailure(error);
   }
@@ -661,11 +909,12 @@ function parseKeyName(text, opts) {
   return unwrapParse(tryParseKeyName(text, opts));
 }
 function tryParseKeyName(text, opts) {
+  const asked = assertOptions(opts, "opts");
   try {
     if (typeof text !== "string") {
       throw new InvalidInputError(`key name must be a string; received ${typeof text}`);
     }
-    const key = readKeyName(text, opts);
+    const key = readKeyName(text, asked);
     assertNote(key.tonic, `key ${text}`);
     return { ok: true, value: key };
   } catch (error) {
@@ -673,10 +922,11 @@ function tryParseKeyName(text, opts) {
   }
 }
 function formatKeyName(key, opts) {
-  assertNote(key.tonic, "key.tonic");
-  const mode = assertOneOf(key.mode, ["major", "minor"], "key.mode");
+  const named = assertRecord(key, "key");
+  assertNote(named.tonic, "key.tonic");
+  const mode = assertOneOf(named.mode, ["major", "minor"], "key.mode");
   return writeKeyName(
-    { tonic: { letter: mod7(key.tonic.letter), alter: key.tonic.alter }, mode },
+    { tonic: { letter: mod7(named.tonic.letter), alter: named.tonic.alter }, mode },
     opts
   );
 }
@@ -735,12 +985,14 @@ function midiToNote(midi, spelling = "sharp") {
 }
 var LETTER_STEPS_BY_SEMITONE = [0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6];
 function transposeNote(note, semitones, opts) {
+  assertNote(note, "note");
+  const asked = assertOptions(opts, "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);
+  if (asked.spelling !== void 0) {
+    return note.octave === void 0 ? bareOf(midiToNote(60 + mod12(noteToPitchClass(note) + steps), asked.spelling)) : midiToNote(noteToMidi(note) + steps, asked.spelling);
   }
   const direction = steps < 0 ? -1 : 1;
   const magnitude = Math.abs(steps);
@@ -751,10 +1003,16 @@ function transposeNote(note, semitones, opts) {
   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)) };
+    return assertNote(
+      { letter, alter: alterFor(natural, mod12(noteToPitchClass(note) + steps)) },
+      "transposed note"
+    );
   }
   const octave = note.octave + Math.floor(absoluteLetter / 7);
-  return { letter, alter: noteToMidi(note) + steps - ((octave + 1) * 12 + natural), octave };
+  return assertNote(
+    { letter, alter: noteToMidi(note) + steps - ((octave + 1) * 12 + natural), octave },
+    "transposed note"
+  );
 }
 function bareOf(note) {
   return { letter: note.letter, alter: note.alter };
@@ -787,7 +1045,7 @@ function qualityFromSpan(numberValue, semitones) {
   }
   return delta > 0 ? repeat("A", delta) : repeat("d", -delta - 1);
 }
-var MAX_INTERVAL_NUMBER = 75;
+var MAX_INTERVAL_NUMBER = 7 * (2 * MAX_OCTAVE) + 6 + 1;
 function intervalSemitones(numberValue, quality) {
   assertInteger(numberValue, "interval number", 1, MAX_INTERVAL_NUMBER);
   const octaves = Math.floor((numberValue - 1) / 7);
@@ -819,9 +1077,9 @@ function intervalSemitones(numberValue, quality) {
         `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));
+    return reference - quality.length - (perfect ? 0 : 1);
   }
-  throw new InvalidInputError(`unknown interval quality ${JSON.stringify(quality)}`);
+  throw new InvalidInputError(`unknown interval quality ${describeRejected(quality)}`);
 }
 var INTERVAL_NAME_PATTERN = /^(-?)(P|M|m|A+|d+)(\d+)$/;
 function parseInterval(name) {
@@ -830,16 +1088,19 @@ function parseInterval(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]]));
+    const quality = _optionalChain([match, 'optionalAccess', _3 => _3[2]]);
+    const numberValue = Number(_optionalChain([match, 'optionalAccess', _4 => _4[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)}`
+        `interval must be a quality followed by a number, such as 'P5'; received ${describeRejected(name)}`
       );
     }
     const span = intervalSemitones(numberValue, quality);
-    if (_optionalChain([match, 'optionalAccess', _12 => _12[1]]) !== "-") {
-      return { ok: true, value: { number: numberValue, quality, semitones: span } };
+    if (_optionalChain([match, 'optionalAccess', _5 => _5[1]]) !== "-") {
+      return {
+        ok: true,
+        value: { number: numberValue, quality, semitones: span, descending: false }
+      };
     }
     return {
       ok: true,
@@ -854,29 +1115,26 @@ function isDescendingInterval(interval) {
     return interval.descending;
   }
   const span = Math.round(interval.semitones);
-  if (span < 0 && qualityFromSpan(interval.number, span) === interval.quality) {
-    return false;
+  if (qualityFromSpan(interval.number, span) === interval.quality) {
+    return interval.number === 1 && span < 0;
   }
-  return span < 0;
+  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) {
+  if (Math.abs(data.semitones) !== Math.abs(expected)) {
     throw new InvalidInputError(
       `${data.quality}${data.number} spans ${expected} semitones; received ${data.semitones}`
     );
   }
-  const normalized = {
+  return {
     number: data.number,
     quality: data.quality,
-    semitones: data.semitones
+    semitones: data.semitones,
+    descending: isDescendingInterval(data)
   };
-  if (isDescendingInterval(data)) {
-    normalized.descending = true;
-  }
-  return normalized;
 }
 function toSpelledInterval(value) {
   if (typeof value === "string") {
@@ -895,7 +1153,7 @@ function toNoteData(value) {
     return parseNote(value);
   }
   if (typeof value === "number") {
-    return midiToNote(value);
+    return midiToNote(assertMidiPitch(value, "note"));
   }
   if (typeof value === "object" && value !== null) {
     const data = "toJSON" in value && typeof value.toJSON === "function" ? value.toJSON() : value;
@@ -906,9 +1164,10 @@ function toNoteData(value) {
     `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);
+function transposeByInterval(given, named) {
+  const note = toNoteData(given);
+  const interval = toSpelledInterval(named);
+  assertInteger(interval.number, "interval.number", 1, MAX_INTERVAL_NUMBER);
   assertFiniteNumber(interval.semitones, "interval.semitones");
   const letterSteps = (interval.number - 1) * (isDescendingInterval(interval) ? -1 : 1);
   const absoluteLetter = mod7(note.letter) + letterSteps;
@@ -916,10 +1175,16 @@ function transposeByInterval(note, interval) {
   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)) };
+    return assertNote(
+      { letter, alter: alterFor(natural, mod12(noteToPitchClass(note) + steps)) },
+      "transposed note"
+    );
   }
   const octave = note.octave + Math.floor(absoluteLetter / 7);
-  return { letter, alter: noteToMidi(note) + steps - ((octave + 1) * 12 + natural), octave };
+  return assertNote(
+    { letter, alter: noteToMidi(note) + steps - ((octave + 1) * 12 + natural), octave },
+    "transposed note"
+  );
 }
 function diatonicIndex(note) {
   return mod7(note.letter) + 7 * (_nullishCoalesce(note.octave, () => ( 0)));
@@ -952,15 +1217,12 @@ function spelledInterval(a, b) {
   const absSteps = Math.abs(letterSteps);
   const number = absSteps + 1;
   const directedSpan = letterSteps === 0 ? Math.abs(semitones) : letterSteps > 0 ? semitones : -semitones;
-  const interval = {
+  return {
     number,
     quality: qualityFromSpan(number, directedSpan),
-    semitones
+    semitones,
+    descending: letterSteps < 0 || letterSteps === 0 && semitones < 0
   };
-  if (letterSteps < 0 || letterSteps === 0 && semitones < 0) {
-    interval.descending = true;
-  }
-  return interval;
 }
 
 // src/core/interval/index.ts
@@ -970,10 +1232,13 @@ var ConsonanceClass = /* @__PURE__ */ ((ConsonanceClass2) => {
   ConsonanceClass2[ConsonanceClass2["Dissonance"] = 2] = "Dissonance";
   return ConsonanceClass2;
 })(ConsonanceClass || {});
+Object.freeze(ConsonanceClass);
 function simpleInterval(semitones) {
+  assertFiniteSemitones(semitones);
   return pitchClassOf(Math.abs(semitones));
 }
 function classifyInterval(semitones, twoVoice = true) {
+  assertFlag(twoVoice, "twoVoice");
   const pc = simpleInterval(semitones);
   if (pc === 0 || pc === 7) {
     return 0 /* PerfectConsonance */;
@@ -991,6 +1256,7 @@ function isPerfectInterval(semitones) {
   return pc === 0 || pc === 7;
 }
 function isConsonantInterval(semitones, twoVoice = true) {
+  assertFlag(twoVoice, "twoVoice");
   const pc = simpleInterval(semitones);
   if (pc === 5) {
     return !twoVoice;
@@ -998,6 +1264,316 @@ function isConsonantInterval(semitones, twoVoice = true) {
   return pc === 0 || pc === 3 || pc === 4 || pc === 7 || pc === 8 || pc === 9;
 }
 
+// src/core/meter/index.ts
+function toMeterData(value, name = "meter") {
+  return copyMeterData(readMeterData(value, name));
+}
+function readMeterData(value, name = "meter") {
+  if (typeof value === "string") {
+    const parsed = tryParseTimeSignature(value);
+    if (parsed.ok) {
+      return parsed.value;
+    }
+    throw new InvalidInputError(`${name} must name a time signature; ${parsed.error.message}`);
+  }
+  if (typeof value === "object" && value !== null) {
+    const data = !Array.isArray(value) && "toJSON" in value && typeof value.toJSON === "function" ? value.toJSON() : value;
+    if (isMeterMap(data)) {
+      return assertMeterMap(data, name);
+    }
+    if (typeof data === "object" && data !== null && "numerator" in data) {
+      return assertTimeSignature(data, name);
+    }
+  }
+  throw new InvalidInputError(
+    `${name} must be a time signature, a meter map, or a signature name; received ${describeRejected(value)}`
+  );
+}
+function readSignature(value, name) {
+  const resolved = readMeterData(value, name);
+  return isMeterMap(resolved) ? meterAtChecked(0, resolved) : resolved;
+}
+var DEFAULT_TS = Object.freeze({ numerator: 4, denominator: 4 });
+var MAX_CHANGE_DIVISIONS = 16;
+function isMultiple(value, unit) {
+  if (unit === 0) {
+    return false;
+  }
+  const ratio = value / unit;
+  return Math.abs(ratio - Math.round(ratio)) < BEAT_EPS;
+}
+function parseTimeSignature(text) {
+  return unwrapParse(tryParseTimeSignature(text));
+}
+function tryParseTimeSignature(text) {
+  try {
+    if (typeof text !== "string") {
+      throw new InvalidInputError(`time signature must be a string; received ${typeof text}`);
+    }
+    return { ok: true, value: readTimeSignature(text) };
+  } catch (error) {
+    return parseFailure(error);
+  }
+}
+function readTimeSignature(text) {
+  const match = /^\s*((?:\d+\s*\+\s*)*\d+)\s*\/\s*(\d+)\s*$/.exec(text);
+  if (!match) {
+    throw new InvalidInputError(`Invalid time signature: ${text}`);
+  }
+  const groupTokens = (_nullishCoalesce(match[1], () => ( ""))).split("+").map((token) => Number.parseInt(token.trim(), 10));
+  const numerator = groupTokens.reduce((sum, value) => sum + value, 0);
+  const denominator = Number.parseInt(_nullishCoalesce(match[2], () => ( "")), 10);
+  if (!Number.isSafeInteger(numerator) || !Number.isSafeInteger(denominator) || numerator <= 0 || denominator <= 0) {
+    throw new InvalidInputError(`Invalid time signature: ${text}`);
+  }
+  const ts = groupTokens.length > 1 ? { numerator, denominator, grouping: groupTokens } : { numerator, denominator };
+  return assertTimeSignature(ts, `time signature ${text}`);
+}
+function formatTimeSignature(ts, opts = {}) {
+  const asked = assertOptions(opts, "opts");
+  const signature = readSignature(ts, "ts");
+  const grouping = signature.grouping;
+  if (asked.grouping === true && grouping !== void 0) {
+    if (groupingSumOf(signature) === signature.numerator) {
+      return `${grouping.join("+")}/${signature.denominator}`;
+    }
+    const pulseGrouping = pulseGroupingOf(signature);
+    if (pulseGrouping !== void 0 && !isUniformGrouping(pulseGrouping)) {
+      throw new InvalidInputError(
+        `ts carries a grouping no signature text can spell: ${grouping.join("+")} counted in the pulses of ${signature.numerator}/${signature.denominator}. Format it without the grouping to name the bar it is written in.`
+      );
+    }
+  }
+  return `${signature.numerator}/${signature.denominator}`;
+}
+function isCompound(ts) {
+  const signature = readSignature(ts, "ts");
+  return isCompoundNumerator(signature.numerator) && !isAdditiveReading(signature);
+}
+function beatsPerBar(ts) {
+  return barBeatsOf(readSignature(ts, "ts"));
+}
+function meterAt(beatInQuarters, meter) {
+  assertFiniteNumber(beatInQuarters, "beat");
+  return copyTimeSignature(meterAtChecked(beatInQuarters, readMeterData(meter)));
+}
+function meterAtChecked(beatInQuarters, meter) {
+  if (!isMeterMap(meter)) {
+    return meter;
+  }
+  const ts = _optionalChain([meter, 'access', _6 => _6[entryIndexOf(meter, beatInQuarters)], 'optionalAccess', _7 => _7.ts]);
+  if (ts === void 0) {
+    throw new InvalidInputError(
+      `meters names no time signature in force at beat ${beatInQuarters}; a meter map must stay a non-empty run of changes while it is being read`
+    );
+  }
+  return ts;
+}
+function barStartBeat(beatInQuarters, meter) {
+  assertFiniteNumber(beatInQuarters, "beat");
+  return barStartChecked(beatInQuarters, readMeterData(meter));
+}
+function barStartChecked(beatInQuarters, meter) {
+  if (isMeterMap(meter)) {
+    return barStartOf(meter, beatInQuarters);
+  }
+  const barLen = barBeatsOf(meter);
+  return Math.floor(beatInQuarters / barLen + BEAT_EPS) * barLen;
+}
+function barIndexAt(beatInQuarters, meter) {
+  assertFiniteNumber(beatInQuarters, "beat");
+  return barIndexChecked(beatInQuarters, readMeterData(meter));
+}
+function barIndexChecked(beatInQuarters, meter) {
+  if (isMeterMap(meter)) {
+    return barIndexOf(meter, beatInQuarters);
+  }
+  return Math.floor(beatInQuarters / barBeatsOf(meter) + BEAT_EPS);
+}
+function beatsPerBarAt(beatInQuarters, meter) {
+  assertFiniteNumber(beatInQuarters, "beat");
+  const data = readMeterData(meter);
+  return isMeterMap(data) ? barLengthOf(data, beatInQuarters) : barBeatsOf(meterAt(beatInQuarters, meter));
+}
+function resolveMeters(opts, name = "meters") {
+  assertRecord(opts, `${name} options`);
+  if (opts.ts !== void 0 && opts.meters !== void 0) {
+    throw new InvalidInputError(
+      `${name} and ts name the same thing; give one or the other, not both`
+    );
+  }
+  for (const [field, value] of [
+    ["meters", opts.meters],
+    ["ts", opts.ts]
+  ]) {
+    if (value === null) {
+      throw new InvalidInputError(
+        `${field === "meters" ? name : "ts"} must name a meter, not null`
+      );
+    }
+  }
+  const given = _nullishCoalesce(opts.meters, () => ( opts.ts));
+  if (given === void 0) {
+    return [{ startBeat: 0, ts: copyTimeSignature(DEFAULT_TS) }];
+  }
+  const resolved = toMeterData(given, opts.meters !== void 0 ? name : "ts");
+  return isMeterMap(resolved) ? resolved : [{ startBeat: 0, ts: resolved }];
+}
+function pulsesPerBar(ts) {
+  return pulseCountOf(readSignature(ts, "ts"));
+}
+function isGroupHead(grouping, pulseIndex) {
+  let acc = 0;
+  for (const g of grouping) {
+    if (acc === pulseIndex) {
+      return true;
+    }
+    acc += g;
+  }
+  return false;
+}
+function isUniformGrouping(grouping) {
+  return grouping.every((entry) => entry === grouping[0]);
+}
+function beatToBarPosition(beatInQuarters, meter) {
+  assertFiniteNumber(beatInQuarters, "beat");
+  return barPositionChecked(beatInQuarters, readMeterData(meter));
+}
+function barPositionChecked(beatInQuarters, meter) {
+  return {
+    bar: barIndexChecked(beatInQuarters, meter),
+    beat: beatInQuarters - barStartChecked(beatInQuarters, meter)
+  };
+}
+function pulseBeats(ts) {
+  return pulseBeatsOf(readSignature(ts, "ts"));
+}
+function barPositionToPulse(pos, meter) {
+  const position = assertRecord(pos, "position");
+  assertInteger(position.bar, "position.bar");
+  assertFiniteNumber(position.beat, "position.beat");
+  return pulseChecked(position, readMeterData(meter));
+}
+function pulseChecked(pos, meter) {
+  return pos.beat / pulseBeatsOf(meterAtBarChecked(pos.bar, meter)) + 1;
+}
+function meterAtBarChecked(bar, meter) {
+  if (!isMeterMap(meter)) {
+    return meter;
+  }
+  assertFiniteNumber(bar, "position.bar");
+  return meterAtChecked(beatOfBarIndex(meter, bar), meter);
+}
+function formatBarPosition(beatInQuarters, meter, decimals = 2) {
+  assertInteger(decimals, "decimals", 0, 100);
+  assertFiniteNumber(beatInQuarters, "beat");
+  const resolved = readMeterData(meter);
+  const position = barPositionChecked(beatInQuarters, resolved);
+  const ts = meterAtChecked(beatInQuarters, resolved);
+  const pulse = pulseChecked(position, ts);
+  const rounded = Number(pulse.toFixed(decimals));
+  const barLength = isMeterMap(resolved) ? barLengthOf(resolved, beatInQuarters) : barBeatsOf(resolved);
+  const pulsesInBar = Math.ceil(barLength / pulseBeatsOf(ts) - BEAT_EPS);
+  if (rounded >= pulsesInBar + 1) {
+    return `${barIndexChecked(barStartChecked(beatInQuarters, resolved) + barLength, resolved) + 1}.1`;
+  }
+  const wholePulse = Math.floor(rounded);
+  const fraction = Number((rounded - wholePulse).toFixed(decimals));
+  return fraction === 0 ? `${position.bar + 1}.${wholePulse}` : `${position.bar + 1}.${wholePulse}+${fraction}`;
+}
+function barPositionToBeat(pos, meter) {
+  const position = assertRecord(pos, "bar position");
+  assertInteger(position.bar, "bar position bar");
+  assertFiniteNumber(position.beat, "bar position beat");
+  const resolved = readMeterData(meter);
+  if (isMeterMap(resolved)) {
+    return beatOfBarIndex(resolved, position.bar) + position.beat;
+  }
+  return position.bar * barBeatsOf(resolved) + position.beat;
+}
+function metricWeight(beatInQuarters, meter) {
+  assertFiniteNumber(beatInQuarters, "beat");
+  const resolved = readMeterData(meter);
+  const ts = meterAtChecked(beatInQuarters, resolved);
+  const beat = beatInQuarters - barStartChecked(beatInQuarters, resolved);
+  const pulse = pulseBeatsOf(ts);
+  if (!isMultiple(beat, pulse)) {
+    return 0;
+  }
+  const pulses = pulseCountOf(ts);
+  const pulseIndex = Math.round(beat / pulse) % pulses;
+  if (pulseIndex === 0) {
+    return 3;
+  }
+  const grouping = pulseGroupingOf(ts);
+  if (grouping !== void 0 && (isAdditiveReading(ts) || !isUniformGrouping(grouping))) {
+    return isGroupHead(grouping, pulseIndex) ? 2 : 1;
+  }
+  if (pulses % 2 === 0 && pulseIndex === pulses / 2) {
+    return 2;
+  }
+  return 1;
+}
+function metricGridUnit(meter) {
+  const resolved = readMeterData(meter);
+  if (!isMeterMap(resolved)) {
+    return pulseBeatsOf(resolved);
+  }
+  let unit = 0;
+  for (const change of resolved) {
+    unit = commonStep(unit, pulseBeatsOf(change.ts));
+  }
+  if (unit <= 0) {
+    return pulseBeatsOf(DEFAULT_TS);
+  }
+  const origin = _nullishCoalesce(_optionalChain([resolved, 'access', _8 => _8[0], 'optionalAccess', _9 => _9.startBeat]), () => ( 0));
+  let onChanges = unit;
+  for (const change of resolved) {
+    onChanges = commonStep(onChanges, Math.abs(change.startBeat - origin));
+  }
+  return onChanges * MAX_CHANGE_DIVISIONS >= unit - BEAT_EPS ? onChanges : unit;
+}
+function commonStep(a, b) {
+  let longer = Math.max(a, b);
+  let shorter = Math.min(a, b);
+  for (let i = 0; i < 8 && shorter > BEAT_EPS; i += 1) {
+    const remainder = longer - Math.floor(longer / shorter + BEAT_EPS) * shorter;
+    longer = shorter;
+    shorter = remainder > BEAT_EPS ? remainder : 0;
+  }
+  const smallest = a > 0 && b > 0 ? Math.min(a, b) : Math.max(a, b);
+  return longer > BEAT_EPS && longer <= smallest + BEAT_EPS ? longer : smallest;
+}
+function isStrongBeat(beatInQuarters, meter) {
+  return metricWeight(beatInQuarters, meter) >= 2;
+}
+function tuplet(totalBeats, count) {
+  assertRange(totalBeats, 0, Number.MAX_SAFE_INTEGER, "tuplet total beats");
+  assertPositiveInt(count, "tuplet count");
+  return new Array(count).fill(totalBeats / count);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -1060,5 +1636,5 @@ function isConsonantInterval(semitones, twoVoice = true) {
 
 
 
-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
+exports.parseFailure = parseFailure; exports.unwrapParse = unwrapParse; exports.InvalidInputError = InvalidInputError; exports.NoSolutionError = NoSolutionError; exports.BudgetExceededError = BudgetExceededError; exports.isLibcantusError = isLibcantusError; exports.ARTICULATIONS = ARTICULATIONS; exports.BEAT_EPS = BEAT_EPS; exports.DEFAULT_GENERATION_BUDGET = DEFAULT_GENERATION_BUDGET; exports.describeRejected = describeRejected; exports.assertFiniteNumber = assertFiniteNumber; exports.assertInteger = assertInteger; exports.assertMidiPitch = assertMidiPitch; exports.assertPitchClass = assertPitchClass; exports.clampToMidi = clampToMidi; exports.assertDegree = assertDegree; exports.assertFiniteSemitones = assertFiniteSemitones; exports.dropSilentNotes = dropSilentNotes; exports.soundingNotesOnly = soundingNotesOnly; exports.assertArray = assertArray; exports.assertRecord = assertRecord; exports.assertOptions = assertOptions; exports.assertFlag = assertFlag; exports.assertFunction = assertFunction; exports.assertOneOf = assertOneOf; exports.assertPositiveInt = assertPositiveInt; exports.assertRange = assertRange; exports.assertGenerationBudget = assertGenerationBudget; exports.allocateCandidateTable = allocateCandidateTable; exports.allocateChoiceTable = allocateChoiceTable; exports.assertTimeSignature = assertTimeSignature; exports.assertMeterMap = assertMeterMap; exports.assertNoteEvent = assertNoteEvent; exports.assertNoteEvents = assertNoteEvents; exports.MAX_NAME_ACCIDENTALS = MAX_NAME_ACCIDENTALS; exports.maxNoteNameLength = maxNoteNameLength; 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; exports.toMeterData = toMeterData; exports.parseTimeSignature = parseTimeSignature; exports.tryParseTimeSignature = tryParseTimeSignature; exports.formatTimeSignature = formatTimeSignature; exports.isCompound = isCompound; exports.beatsPerBar = beatsPerBar; exports.meterAt = meterAt; exports.barStartBeat = barStartBeat; exports.barIndexAt = barIndexAt; exports.beatsPerBarAt = beatsPerBarAt; exports.resolveMeters = resolveMeters; exports.pulsesPerBar = pulsesPerBar; exports.beatToBarPosition = beatToBarPosition; exports.pulseBeats = pulseBeats; exports.barPositionToPulse = barPositionToPulse; exports.formatBarPosition = formatBarPosition; exports.barPositionToBeat = barPositionToBeat; exports.metricWeight = metricWeight; exports.metricGridUnit = metricGridUnit; exports.isStrongBeat = isStrongBeat; exports.tuplet = tuplet;
+//# sourceMappingURL=chunk-S5BKZZGM.cjs.map