@libraz/libcantus 0.9.4 → 1.0.0

package/dist/chunk-FVSI36UV.js

@@ -0,0 +1,690 @@
+import {
+  InvalidInputError,
+  assertFiniteNumber,
+  assertInteger,
+  assertNoteEvents,
+  assertRange
+} from "./chunk-VTI6FOLB.js";
+
+// src/core/instrument/articulation.ts
+var ARTICULATIONS = Object.freeze([
+  "accent",
+  "ghost",
+  "staccato",
+  "legato",
+  "slide",
+  "hammer",
+  "mute",
+  "flam",
+  "drag",
+  "roll",
+  "choke",
+  "open"
+]);
+
+// src/core/instrument/profile.ts
+var LIMBS = Object.freeze(["rightHand", "leftHand", "rightFoot", "leftFoot"]);
+function toInstrumentProfile(value, name = "instrument") {
+  if (typeof value !== "object" || value === null) {
+    throw new InvalidInputError(`${name} must be an instrument profile; received ${typeof value}`);
+  }
+  const data = "toJSON" in value && typeof value.toJSON === "function" ? value.toJSON() : value;
+  const kind = data?.kind;
+  if (kind !== "stringed" && kind !== "percussion") {
+    throw new InvalidInputError(
+      `${name} must be a stringed or percussion profile; received kind ${String(kind)}`
+    );
+  }
+  assertProfile(data);
+  return data;
+}
+function toStringedProfile(value, name = "instrument") {
+  const profile = toInstrumentProfile(value, name);
+  if (profile.kind !== "stringed") {
+    throw new InvalidInputError(
+      `${name} must be a stringed instrument; ${profile.name} has no strings`
+    );
+  }
+  return profile;
+}
+function assertProfile(profile) {
+  if (profile.kind === "stringed") {
+    if (profile.tuning.length === 0) {
+      throw new InvalidInputError(`${profile.name} must have at least one string`);
+    }
+    if (!Number.isInteger(profile.frets) || profile.frets < 0) {
+      throw new InvalidInputError(`${profile.name} frets must be a non-negative integer`);
+    }
+    return;
+  }
+  if (Object.keys(profile.reach).length === 0) {
+    throw new InvalidInputError(`${profile.name} must have at least one voice within reach`);
+  }
+}
+function reachOf(profile, pitch) {
+  if (pitch === void 0) {
+    return [];
+  }
+  return (profile.reach[pitch] ?? []).filter((limb) => profile.limbs.includes(limb));
+}
+function instrumentRange(profile) {
+  assertProfile(profile);
+  if (profile.kind === "stringed") {
+    let low2 = Number.POSITIVE_INFINITY;
+    let high2 = Number.NEGATIVE_INFINITY;
+    for (const open of profile.tuning) {
+      low2 = Math.min(low2, open);
+      high2 = Math.max(high2, open + profile.frets);
+    }
+    return { low: low2, high: high2 };
+  }
+  let low = Number.POSITIVE_INFINITY;
+  let high = Number.NEGATIVE_INFINITY;
+  for (const key of Object.keys(profile.reach)) {
+    const pitch = Number(key);
+    if (reachOf(profile, pitch).length === 0) {
+      continue;
+    }
+    low = Math.min(low, pitch);
+    high = Math.max(high, pitch);
+  }
+  return { low, high };
+}
+function canSound(profile, pitch) {
+  assertProfile(profile);
+  if (profile.kind === "stringed") {
+    return profile.tuning.some((open) => pitch >= open && pitch - open <= profile.frets);
+  }
+  return reachOf(profile, pitch).length > 0;
+}
+function fingeringsFor(profile, pitch) {
+  assertProfile(profile);
+  const out = [];
+  for (let string = 0; string < profile.tuning.length; string += 1) {
+    const open = profile.tuning[string];
+    if (open === void 0) {
+      continue;
+    }
+    const fret = pitch - open;
+    if (fret >= 0 && fret <= profile.frets) {
+      out.push({ string, fret });
+    }
+  }
+  return out;
+}
+function foldIntoRange(pitch, profile) {
+  if (canSound(profile, pitch)) {
+    return pitch;
+  }
+  const { low, high } = instrumentRange(profile);
+  for (let candidate = pitch + 12; candidate <= high; candidate += 12) {
+    if (canSound(profile, candidate)) {
+      return candidate;
+    }
+  }
+  for (let candidate = pitch - 12; candidate >= low; candidate -= 12) {
+    if (canSound(profile, candidate)) {
+      return candidate;
+    }
+  }
+  return pitch;
+}
+
+// src/core/instrument/playability.ts
+var REFERENCE_BPM = 120;
+var MAX_FRET_SHIFT_PER_SECOND = 100;
+var MIN_LIMB_STROKE_SECONDS = 0.06;
+var DIFFICULTY_SCALE = 12;
+var MIN_DIFFICULTY = 1;
+var MAX_DIFFICULTY = 5;
+var STRING_CROSSING_COST = 2;
+var ONSET_GRID = 128;
+var EPS = 1e-9;
+function playability(notes, profile, bpm) {
+  assertNoteEvents(notes, "playability notes", { allowNonPositiveDuration: true });
+  if (bpm !== void 0) {
+    assertRange(bpm, Number.MIN_VALUE, 1e3, "playability bpm");
+  }
+  const order = notes.map((_, index) => index).sort((a, b) => {
+    const left = notes[a];
+    const right = notes[b];
+    if (!left || !right) {
+      return a - b;
+    }
+    return left.startBeat - right.startBeat || left.pitch - right.pitch || a - b;
+  });
+  const state = {
+    notes,
+    order,
+    placements: notes.map((_, index) => ({ note: index })),
+    issues: [],
+    movement: 0,
+    secondsPerBeat: bpm === void 0 ? void 0 : 60 / bpm
+  };
+  checkExistence(state, profile);
+  if (profile.kind === "stringed") {
+    placeOnNeck(state, profile);
+  } else {
+    placeOnKit(state, profile);
+  }
+  return {
+    difficulty: difficultyOf(state, bpm),
+    issues: state.issues,
+    placements: state.placements
+  };
+}
+function checkExistence(state, profile) {
+  for (const index of state.order) {
+    const note = state.notes[index];
+    if (!note) {
+      continue;
+    }
+    if (!canSound(profile, note.pitch)) {
+      state.issues.push({
+        type: "noteOutOfRange",
+        layer: 1,
+        notes: [index],
+        startBeat: note.startBeat,
+        impossible: true,
+        message: `${profile.name} cannot sound MIDI ${note.pitch}`
+      });
+    }
+    const articulation = note.articulation;
+    if (articulation !== void 0 && !profile.articulations.includes(articulation)) {
+      state.issues.push({
+        type: "articulationUnavailable",
+        layer: 1,
+        notes: [index],
+        startBeat: note.startBeat,
+        impossible: true,
+        message: `${profile.name} cannot play ${articulation}`
+      });
+    }
+  }
+}
+function soundingGroups(state) {
+  const groups = [];
+  let active = [];
+  let cursor = 0;
+  let previousKey = Number.NaN;
+  for (const index of state.order) {
+    const note = state.notes[index];
+    if (!note) {
+      continue;
+    }
+    const key = Math.round(note.startBeat * ONSET_GRID);
+    if (key === previousKey) {
+      continue;
+    }
+    previousKey = key;
+    const at = note.startBeat;
+    active = active.filter((member) => {
+      const held = state.notes[member];
+      return held !== void 0 && held.startBeat + held.durationBeat > at + EPS;
+    });
+    while (cursor < state.order.length) {
+      const candidateIndex = state.order[cursor];
+      const candidate = candidateIndex === void 0 ? void 0 : state.notes[candidateIndex];
+      if (!candidate || candidate.startBeat > at + EPS) {
+        break;
+      }
+      if (candidateIndex !== void 0 && candidate.startBeat + candidate.durationBeat > at + EPS) {
+        active.push(candidateIndex);
+      }
+      cursor += 1;
+    }
+    groups.push({ startBeat: at, members: [...active] });
+  }
+  return groups;
+}
+function placeOnNeck(state, profile) {
+  const stringFreeAt = profile.tuning.map(() => Number.NEGATIVE_INFINITY);
+  const stringHeldBy = profile.tuning.map(() => void 0);
+  let previous;
+  let previousIndex;
+  for (const index of state.order) {
+    const note = state.notes[index];
+    const placement = state.placements[index];
+    if (!note || !placement) {
+      continue;
+    }
+    const candidates = fingeringsFor(profile, note.pitch);
+    if (candidates.length === 0) {
+      continue;
+    }
+    const free = candidates.filter(
+      (candidate) => (stringFreeAt[candidate.string] ?? 0) <= note.startBeat + EPS
+    );
+    if (free.length === 0) {
+      const blocked = candidates.map((candidate) => stringHeldBy[candidate.string]).filter((held) => held !== void 0);
+      state.issues.push({
+        type: "stringConflict",
+        layer: 2,
+        notes: [.../* @__PURE__ */ new Set([...blocked, index])].sort((a, b) => a - b),
+        startBeat: note.startBeat,
+        impossible: true,
+        message: `MIDI ${note.pitch} needs a string already sounding on ${profile.name}`
+      });
+    }
+    const pool = free.length > 0 ? free : candidates;
+    const chosen = pool.reduce(
+      (best, candidate) => fingeringCost(candidate, previous) < fingeringCost(best, previous) ? candidate : best
+    );
+    placement.fingering = chosen;
+    stringFreeAt[chosen.string] = note.startBeat + note.durationBeat;
+    stringHeldBy[chosen.string] = index;
+    state.movement += 1;
+    if (previous) {
+      state.movement += Math.abs(chosen.fret - previous.fret) + Math.abs(chosen.string - previous.string);
+      checkShiftSpeed(state, profile, previousIndex, index, previous, chosen);
+    }
+    previous = chosen;
+    previousIndex = index;
+  }
+  for (const group of soundingGroups(state)) {
+    checkStretch(state, profile, group);
+    checkPolyphony(state, profile, group);
+  }
+}
+function fingeringCost(candidate, previous) {
+  if (!previous) {
+    return candidate.fret + candidate.string / 100;
+  }
+  return Math.abs(candidate.fret - previous.fret) + STRING_CROSSING_COST * Math.abs(candidate.string - previous.string) + candidate.string / 100;
+}
+function checkShiftSpeed(state, profile, fromIndex, toIndex, from, to) {
+  const secondsPerBeat = state.secondsPerBeat;
+  if (secondsPerBeat === void 0 || fromIndex === void 0) {
+    return;
+  }
+  const previousNote = state.notes[fromIndex];
+  const note = state.notes[toIndex];
+  if (!previousNote || !note) {
+    return;
+  }
+  const seconds = (note.startBeat - previousNote.startBeat) * secondsPerBeat;
+  const shift = Math.abs(to.fret - from.fret);
+  if (seconds <= EPS || shift === 0) {
+    return;
+  }
+  if (shift / seconds > MAX_FRET_SHIFT_PER_SECOND) {
+    state.issues.push({
+      type: "tooFast",
+      layer: 3,
+      notes: [fromIndex, toIndex].sort((a, b) => a - b),
+      startBeat: note.startBeat,
+      impossible: false,
+      message: `a ${shift}-fret shift in ${seconds.toFixed(3)}s is beyond ${profile.name}`
+    });
+  }
+}
+function checkStretch(state, profile, group) {
+  const frets = group.members.map((member) => state.placements[member]?.fingering).filter(
+    (fingering) => fingering !== void 0 && fingering.fret > 0
+  ).map((fingering) => fingering.fret);
+  if (frets.length < 2) {
+    return;
+  }
+  const span = Math.max(...frets) - Math.min(...frets);
+  if (span > profile.maxStretch) {
+    state.issues.push({
+      type: "stretchTooWide",
+      layer: 2,
+      notes: [...group.members].sort((a, b) => a - b),
+      startBeat: group.startBeat,
+      impossible: true,
+      message: `a ${span}-fret stretch exceeds the ${profile.maxStretch} frets one hand spans on ${profile.name}`
+    });
+  }
+}
+function checkPolyphony(state, profile, group) {
+  if (group.members.length <= profile.polyphony) {
+    return;
+  }
+  state.issues.push({
+    type: "polyphonyExceeded",
+    layer: 2,
+    notes: [...group.members].sort((a, b) => a - b),
+    startBeat: group.startBeat,
+    impossible: true,
+    message: `${group.members.length} notes sound at once; ${profile.name} has ${profile.polyphony}`
+  });
+}
+function placeOnKit(state, profile) {
+  const limbForVoice = /* @__PURE__ */ new Map();
+  const lastStroke = /* @__PURE__ */ new Map();
+  for (const group of onsetGroups(state)) {
+    const taken = /* @__PURE__ */ new Set();
+    let conflicted = false;
+    const members = [...group.members].sort((a, b) => {
+      const left = reachOf(profile, state.notes[a]?.pitch);
+      const right = reachOf(profile, state.notes[b]?.pitch);
+      return left.length - right.length || a - b;
+    });
+    for (const index of members) {
+      const note = state.notes[index];
+      const placement = state.placements[index];
+      if (!note || !placement) {
+        continue;
+      }
+      const candidates = reachOf(profile, note.pitch);
+      if (candidates.length === 0) {
+        continue;
+      }
+      const preferred = limbForVoice.get(note.pitch);
+      const free = candidates.filter((limb) => !taken.has(limb));
+      const chosen = free.length === 0 ? candidates[0] : preferred !== void 0 && free.includes(preferred) ? preferred : free[0];
+      if (free.length === 0) {
+        conflicted = true;
+      }
+      if (chosen === void 0) {
+        continue;
+      }
+      taken.add(chosen);
+      placement.limb = chosen;
+      limbForVoice.set(note.pitch, chosen);
+      state.movement += 1;
+      const previousIndex = lastStroke.get(chosen);
+      if (previousIndex !== void 0) {
+        const previousNote = state.notes[previousIndex];
+        if (previousNote && previousNote.pitch !== note.pitch) {
+          state.movement += 1;
+        }
+        checkStrokeSpeed(state, profile, previousIndex, index, chosen);
+      }
+      lastStroke.set(chosen, index);
+    }
+    if (conflicted) {
+      state.issues.push({
+        type: "limbConflict",
+        layer: 2,
+        notes: [...group.members].sort((a, b) => a - b),
+        startBeat: group.startBeat,
+        impossible: true,
+        message: `${group.members.length} simultaneous strokes cannot be shared among the limbs of ${profile.name}`
+      });
+    } else {
+      checkPolyphony(state, profile, group);
+    }
+  }
+}
+function checkStrokeSpeed(state, profile, fromIndex, toIndex, limb) {
+  const secondsPerBeat = state.secondsPerBeat;
+  if (secondsPerBeat === void 0) {
+    return;
+  }
+  const previousNote = state.notes[fromIndex];
+  const note = state.notes[toIndex];
+  if (!previousNote || !note) {
+    return;
+  }
+  const seconds = (note.startBeat - previousNote.startBeat) * secondsPerBeat;
+  if (seconds <= EPS || seconds >= MIN_LIMB_STROKE_SECONDS) {
+    return;
+  }
+  state.issues.push({
+    type: "tooFast",
+    layer: 3,
+    notes: [fromIndex, toIndex].sort((a, b) => a - b),
+    startBeat: note.startBeat,
+    impossible: false,
+    message: `${limb} strikes twice ${seconds.toFixed(3)}s apart on ${profile.name}`
+  });
+}
+function onsetGroups(state) {
+  const groups = [];
+  let key = Number.NaN;
+  let current;
+  for (const index of state.order) {
+    const note = state.notes[index];
+    if (!note) {
+      continue;
+    }
+    const onsetKey = Math.round(note.startBeat * ONSET_GRID);
+    if (!current || onsetKey !== key) {
+      current = { startBeat: note.startBeat, members: [] };
+      groups.push(current);
+      key = onsetKey;
+    }
+    current.members.push(index);
+  }
+  return groups;
+}
+function difficultyOf(state, bpm) {
+  let first = Number.POSITIVE_INFINITY;
+  let last = Number.NEGATIVE_INFINITY;
+  for (const note of state.notes) {
+    if (!note) {
+      continue;
+    }
+    first = Math.min(first, note.startBeat);
+    last = Math.max(last, note.startBeat + Math.max(0, note.durationBeat));
+  }
+  const spanBeats = last - first;
+  if (!Number.isFinite(spanBeats) || spanBeats <= EPS) {
+    return MIN_DIFFICULTY;
+  }
+  const seconds = spanBeats * 60 / (bpm ?? REFERENCE_BPM);
+  const rate = state.movement / seconds;
+  const scaled = MIN_DIFFICULTY + (MAX_DIFFICULTY - MIN_DIFFICULTY) * (1 - Math.exp(-rate / DIFFICULTY_SCALE));
+  return Math.round(scaled * 1e4) / 1e4;
+}
+
+// src/core/instrument/profiles.ts
+var STRINGED_ARTICULATIONS = Object.freeze([
+  "accent",
+  "ghost",
+  "staccato",
+  "legato",
+  "slide",
+  "hammer",
+  "mute",
+  "open"
+]);
+var BASS_4_STRING = Object.freeze({
+  kind: "stringed",
+  name: "4-string bass",
+  tuning: Object.freeze([28, 33, 38, 43]),
+  frets: 24,
+  maxStretch: 4,
+  articulations: STRINGED_ARTICULATIONS,
+  polyphony: 4
+});
+var BASS_5_STRING = Object.freeze({
+  kind: "stringed",
+  name: "5-string bass",
+  tuning: Object.freeze([23, 28, 33, 38, 43]),
+  frets: 24,
+  maxStretch: 4,
+  articulations: STRINGED_ARTICULATIONS,
+  polyphony: 5
+});
+var GUITAR_STANDARD = Object.freeze({
+  kind: "stringed",
+  name: "guitar",
+  tuning: Object.freeze([40, 45, 50, 55, 59, 64]),
+  frets: 24,
+  maxStretch: 5,
+  articulations: STRINGED_ARTICULATIONS,
+  polyphony: 6
+});
+var GUITAR_DROP_D = Object.freeze({
+  kind: "stringed",
+  name: "guitar (drop D)",
+  tuning: Object.freeze([38, 45, 50, 55, 59, 64]),
+  frets: 24,
+  maxStretch: 5,
+  articulations: STRINGED_ARTICULATIONS,
+  polyphony: 6
+});
+
+// src/core/random/internal.ts
+var UINT32_RANGE = 4294967296;
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+var DOMAIN_SEED = 1;
+var DOMAIN_POSITION = 2;
+var TAG_STRING = 1;
+var TAG_NUMBER = 2;
+var numberBytes = new DataView(new ArrayBuffer(8));
+function absorb(hash, byte) {
+  return Math.imul(hash ^ byte & 255, FNV_PRIME) >>> 0;
+}
+function absorbUint32(hash, value) {
+  let next = hash;
+  for (let shift = 0; shift < 32; shift += 8) {
+    next = absorb(next, value >>> shift & 255);
+  }
+  return next;
+}
+function fmix32(value) {
+  let mixed = value >>> 0;
+  mixed ^= mixed >>> 16;
+  mixed = Math.imul(mixed, 2246822507);
+  mixed ^= mixed >>> 13;
+  mixed = Math.imul(mixed, 3266489909);
+  mixed ^= mixed >>> 16;
+  return mixed >>> 0;
+}
+function absorbSegment(hash, segment, index) {
+  if (typeof segment === "string") {
+    let next = absorb(hash, TAG_STRING);
+    next = absorbUint32(next, segment.length);
+    for (let i = 0; i < segment.length; i += 1) {
+      const unit = segment.charCodeAt(i);
+      next = absorb(next, unit & 255);
+      next = absorb(next, unit >>> 8 & 255);
+    }
+    return next;
+  }
+  if (typeof segment === "number") {
+    assertFiniteNumber(segment, `seed path segment ${index}`);
+    numberBytes.setFloat64(0, segment === 0 ? 0 : segment, true);
+    let next = absorb(hash, TAG_NUMBER);
+    for (let i = 0; i < 8; i += 1) {
+      next = absorb(next, numberBytes.getUint8(i));
+    }
+    return next;
+  }
+  throw new InvalidInputError(
+    `seed path segment ${index} must be a string or a number; received ${typeof segment}`
+  );
+}
+function hashPath(domain, root, path) {
+  let hash = absorb(FNV_OFFSET_BASIS, domain);
+  hash = absorbUint32(hash, root);
+  for (let index = 0; index < path.length; index += 1) {
+    const segment = path[index];
+    if (segment === void 0) {
+      throw new InvalidInputError(
+        `seed path segment ${index} must be a string or a number; received undefined`
+      );
+    }
+    hash = absorbSegment(hash, segment, index);
+  }
+  return fmix32(hash);
+}
+
+// src/core/random/positional.ts
+function createPositionalRng(seed) {
+  assertInteger(seed, "seed", 0, 4294967295);
+  return {
+    at: (...path) => hashPath(DOMAIN_POSITION, seed, path) / UINT32_RANGE
+  };
+}
+function includeAt(rng, complexity, ...path) {
+  assertRange(complexity, 0, 1, "complexity");
+  const draw = rng.at(...path);
+  if (!(draw >= 0 && draw < 1)) {
+    throw new InvalidInputError(`positional draw must be in [0, 1); received ${draw}`);
+  }
+  return draw < complexity;
+}
+
+// src/core/random/seed.ts
+function deriveSeed(root, ...path) {
+  assertInteger(root, "root seed", 0, 4294967295);
+  return hashPath(DOMAIN_SEED, root, path);
+}
+
+// src/core/random/version.ts
+var ALGORITHM_VERSION = 1;
+var MIN_ALGORITHM_VERSION = 1;
+function resolveAlgorithmVersion(requested) {
+  if (requested === void 0) {
+    return ALGORITHM_VERSION;
+  }
+  assertInteger(requested, "algorithm version");
+  if (requested < MIN_ALGORITHM_VERSION || requested > ALGORITHM_VERSION) {
+    throw new InvalidInputError(
+      `algorithm version ${requested} is not produced by this build; supported versions are ${MIN_ALGORITHM_VERSION}..${ALGORITHM_VERSION}`
+    );
+  }
+  return requested;
+}
+
+// src/core/random/index.ts
+function createRng(seed) {
+  assertInteger(seed, "seed", 0, 4294967295);
+  let state = seed >>> 0;
+  const next = () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+  return {
+    next,
+    prob: (p) => {
+      assertRange(p, 0, 1, "probability");
+      return next() < p;
+    },
+    range: (lo, hi) => {
+      assertInteger(lo, "range lower bound");
+      assertInteger(hi, "range upper bound");
+      if (lo > hi) {
+        throw new InvalidInputError(
+          `range lower bound must not exceed upper bound; received ${lo} > ${hi}`
+        );
+      }
+      assertInteger(hi - lo, "range span", 0);
+      return lo + Math.floor(next() * (hi - lo + 1));
+    },
+    float: (lo, hi) => {
+      assertFiniteNumber(lo, "float lower bound");
+      assertFiniteNumber(hi, "float upper bound");
+      if (lo > hi) {
+        throw new InvalidInputError(
+          `float lower bound must not exceed upper bound; received ${lo} > ${hi}`
+        );
+      }
+      assertFiniteNumber(hi - lo, "float span");
+      return lo + next() * (hi - lo);
+    }
+  };
+}
+
+export {
+  ARTICULATIONS,
+  LIMBS,
+  toInstrumentProfile,
+  toStringedProfile,
+  instrumentRange,
+  canSound,
+  fingeringsFor,
+  foldIntoRange,
+  playability,
+  BASS_4_STRING,
+  BASS_5_STRING,
+  GUITAR_STANDARD,
+  GUITAR_DROP_D,
+  createPositionalRng,
+  includeAt,
+  deriveSeed,
+  ALGORITHM_VERSION,
+  MIN_ALGORITHM_VERSION,
+  resolveAlgorithmVersion,
+  createRng
+};
+//# sourceMappingURL=chunk-FVSI36UV.js.map