@libraz/libcantus 0.9.2 → 0.9.4

package/dist/{chunk-GQKN5KDT.js → chunk-GQSGS2N4.js}

@@ -5,20 +5,20 @@ import {
   functionOf,
   isDiatonic,
   parallelKey
-} from "./chunk-LN7ZZMD2.js";
+} from "./chunk-KMHOICIY.js";
 import {
   chordPitchClasses,
   diatonicTriad,
   makeChord,
   scaleTonesInDegreeOrder
-} from "./chunk-7Y7WF64D.js";
+} from "./chunk-D2FAJBYL.js";
+import {
+  pitchClassOf
+} from "./chunk-XEBG3G53.js";
 
 // src/generate/reharmony/index.ts
-function mod12(n) {
-  return (n % 12 + 12) % 12;
-}
 function hasInterval(chord, semitone) {
-  return chord.intervals.some((iv) => mod12(iv) === semitone);
+  return chord.intervals.some((iv) => pitchClassOf(iv) === semitone);
 }
 function isDominantType(chord) {
   return hasInterval(chord, 4) && hasInterval(chord, 10);
@@ -28,15 +28,24 @@ function isStableTarget(chord) {
   const hasThird = hasInterval(chord, 3) || hasInterval(chord, 4);
   return hasFifth && hasThird && !isDominantType(chord);
 }
-function triadPitchClasses(chord) {
-  const third = hasInterval(chord, 4) ? 4 : hasInterval(chord, 3) ? 3 : 4;
-  const fifth = hasInterval(chord, 8) ? 8 : hasInterval(chord, 6) ? 6 : 7;
-  return [mod12(chord.rootPc), mod12(chord.rootPc + third), mod12(chord.rootPc + fifth)];
-}
 function commonToneCount(a, b) {
   const set = new Set(b);
   return a.filter((pc) => set.has(pc)).length;
 }
+function triadQualityOf(chord) {
+  const semis = new Set(chord.intervals.map((interval) => pitchClassOf(interval)));
+  const hasThird = semis.has(4) ? "maj" : semis.has(3) ? "min" : void 0;
+  if (hasThird === void 0) {
+    return chord.quality;
+  }
+  if (semis.has(6) && !semis.has(7)) {
+    return hasThird === "min" ? "dim" : "majb5";
+  }
+  if (semis.has(8) && !semis.has(7)) {
+    return "aug";
+  }
+  return hasThird;
+}
 function diatonicTriadsOf(key) {
   const degrees = scaleTonesInDegreeOrder(key).length;
   const triads = [];
@@ -46,24 +55,24 @@ function diatonicTriadsOf(key) {
   return triads;
 }
 function sameChord(a, b) {
-  return mod12(a.rootPc) === mod12(b.rootPc) && a.quality === b.quality;
+  return pitchClassOf(a.rootPc) === pitchClassOf(b.rootPc) && a.quality === b.quality;
 }
 var THIRD_OFFSETS = [3, 4, 8, 9];
 function substituteChord(chord, key, opts) {
-  const original = triadPitchClasses(chord);
+  const originalTriad = chordPitchClasses(makeChord(chord.rootPc, triadQualityOf(chord)));
   const candidates = [];
   if (isDominantType(chord)) {
-    candidates.push({ chord: makeChord(mod12(chord.rootPc + 6), "dom7"), type: "tritone" });
+    candidates.push({ chord: makeChord(pitchClassOf(chord.rootPc + 6), "dom7"), type: "tritone" });
   }
   if (isStableTarget(chord)) {
     candidates.push({
-      chord: makeChord(mod12(chord.rootPc + 7), "dom7"),
-      type: "secondary-dominant"
+      chord: makeChord(pitchClassOf(chord.rootPc + 7), "dom7"),
+      type: "secondaryDominant"
     });
   }
   for (const triad of diatonicTriadsOf(key)) {
-    const offset = mod12(triad.rootPc - chord.rootPc);
-    if (THIRD_OFFSETS.includes(offset) && commonToneCount(original, chordPitchClasses(triad)) === 2) {
+    const offset = pitchClassOf(triad.rootPc - chord.rootPc);
+    if (THIRD_OFFSETS.includes(offset) && commonToneCount(originalTriad, chordPitchClasses(triad)) === 2) {
       candidates.push({ chord: triad, type: "relative" });
     }
   }
@@ -75,20 +84,20 @@ function substituteChord(chord, key, opts) {
   }
   for (const offset of THIRD_OFFSETS) {
     for (const quality of ["maj", "min"]) {
-      const mediant = makeChord(mod12(chord.rootPc + offset), quality);
-      if (commonToneCount(original, chordPitchClasses(mediant)) === 1 && !isDiatonic(mediant, key)) {
-        candidates.push({ chord: mediant, type: "chromatic-mediant" });
+      const mediant = makeChord(pitchClassOf(chord.rootPc + offset), quality);
+      if (commonToneCount(originalTriad, chordPitchClasses(mediant)) === 1 && !isDiatonic(mediant, key)) {
+        candidates.push({ chord: mediant, type: "chromaticMediant" });
       }
     }
   }
-  const melodyPcs = opts?.melodyPcs?.map(mod12);
+  const melodyPcs = opts?.melodyPcs?.map(pitchClassOf);
   const seen = /* @__PURE__ */ new Set();
   const results = [];
   for (const candidate of candidates) {
     if (sameChord(candidate.chord, chord)) {
       continue;
     }
-    const dedupeKey = `${mod12(candidate.chord.rootPc)}:${candidate.chord.quality}`;
+    const dedupeKey = `${pitchClassOf(candidate.chord.rootPc)}:${candidate.chord.quality}`;
     if (seen.has(dedupeKey)) {
       continue;
     }
@@ -102,7 +111,12 @@ function substituteChord(chord, key, opts) {
     results.push({
       chord: candidate.chord,
       type: candidate.type,
-      roman: chordToRoman(candidate.chord, key),
+      // A secondary dominant is named as the applied chord it is, so the
+      // numeral re-parses to the chord that was proposed rather than to a
+      // chromatic chord on the same root.
+      roman: chordToRoman(candidate.chord, key, {
+        applied: candidate.type === "secondaryDominant"
+      }),
       function: functionOf(candidate.chord, key)
     });
   }
@@ -112,7 +126,7 @@ function modalInterchangePalette(key) {
   const palette = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (chord) => {
-    const dedupeKey = `${mod12(chord.rootPc)}:${chord.quality}`;
+    const dedupeKey = `${pitchClassOf(chord.rootPc)}:${chord.quality}`;
     if (seen.has(dedupeKey)) {
       return;
     }
@@ -128,15 +142,15 @@ function modalInterchangePalette(key) {
       add(triad);
     }
   }
-  const neapolitan = makeChord(mod12(key.rootPc + 1), "maj");
+  const neapolitan = makeChord(pitchClassOf(key.rootPc + 1), "maj");
   if (!isDiatonic(neapolitan, key)) {
     add(neapolitan);
   }
   return palette;
 }
 function negativeHarmonyMirror(chord, key) {
-  const tonic = mod12(key.rootPc);
-  const mirror = (p) => mod12(2 * tonic + 7 - p);
+  const tonic = pitchClassOf(key.rootPc);
+  const mirror = (p) => pitchClassOf(2 * tonic + 7 - p);
   const pcs = chordPitchClasses(chord).map(mirror);
   const bassPc = chord.bassPc !== void 0 ? mirror(chord.bassPc) : void 0;
   const pitches = bassPc !== void 0 ? [bassPc - 12, ...pcs] : pcs;
@@ -156,4 +170,4 @@ export {
   modalInterchangePalette,
   negativeHarmonyMirror
 };
-//# sourceMappingURL=chunk-GQKN5KDT.js.map
+//# sourceMappingURL=chunk-GQSGS2N4.js.map

package/dist/chunk-GQSGS2N4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/generate/reharmony/index.ts"],"sourcesContent":["/**\n * Reharmonization: chord substitution, modal-interchange palettes, and negative\n * harmony. These transforms take an existing chord (or a key) and propose\n * alternative harmonies that preserve a chosen relationship — a shared function,\n * a common tone, a tonicizing dominant, or a reflection across the key axis.\n *\n * Roots are pitch classes (0..11); no spelled key signature is required.\n */\n\nimport { detectChordBest } from '../../analyze/detect/index.js';\nimport {\n  type BorrowedSource,\n  borrowedSource,\n  chordToRoman,\n  functionOf,\n  type HarmonicFunction,\n  isDiatonic,\n  parallelKey,\n} from '../../analyze/functional/index.js';\nimport { pitchClassOf as mod12 } from '../../core/pitch/index.js';\nimport type { KeyScale } from '../../core/types.js';\nimport {\n  type Chord,\n  type ChordQuality,\n  chordPitchClasses,\n  diatonicTriad,\n  makeChord,\n} from '../../theory/chord/index.js';\nimport { scaleTonesInDegreeOrder } from '../../theory/scale/index.js';\n\n/**\n * The kind of substitution relationship a candidate realizes.\n *\n * @category Reharmonization\n */\nexport type SubstitutionType =\n  | 'tritone'\n  | 'relative'\n  | 'borrowed'\n  | 'chromaticMediant'\n  | 'secondaryDominant';\n\n/**\n * A proposed chord substitution with its relationship, numeral, and function.\n *\n * @category Reharmonization\n */\nexport type Substitution = {\n  chord: Chord;\n  type: SubstitutionType;\n  roman: string;\n  function: HarmonicFunction;\n};\n\n/**\n * Options controlling which substitutions {@link substituteChord} returns.\n *\n * @category Reharmonization\n */\nexport type SubstituteOptions = {\n  /**\n   * Melody pitch classes that must remain chord tones. When given, only\n   * substitutions whose pitch classes contain every listed pitch class are\n   * kept, so the melody stays consonant against the new harmony.\n   */\n  melodyPcs?: number[];\n};\n\n/** Whether the chord's template carries a given interval (mod 12). */\nfunction hasInterval(chord: Chord, semitone: number): boolean {\n  return chord.intervals.some((iv) => mod12(iv) === semitone);\n}\n\n/** Whether a chord is a dominant type: a major third with a minor seventh. */\nfunction isDominantType(chord: Chord): boolean {\n  return hasInterval(chord, 4) && hasInterval(chord, 10);\n}\n\n/**\n * A chord that can be tonicized: it has a perfect fifth and a third but is not\n * itself a dominant seventh (which is an unstable, tonicizing sonority rather\n * than a stable target).\n */\nfunction isStableTarget(chord: Chord): boolean {\n  const hasFifth = hasInterval(chord, 7);\n  const hasThird = hasInterval(chord, 3) || hasInterval(chord, 4);\n  return hasFifth && hasThird && !isDominantType(chord);\n}\n\n/** Count the pitch classes shared between two pitch-class sets. */\nfunction commonToneCount(a: number[], b: number[]): number {\n  const set = new Set(b);\n  return a.filter((pc) => set.has(pc)).length;\n}\n\n/** The plain triad quality underlying a chord's own quality. */\nfunction triadQualityOf(chord: Chord): ChordQuality {\n  const semis = new Set(chord.intervals.map((interval) => mod12(interval)));\n  const hasThird = semis.has(4) ? 'maj' : semis.has(3) ? 'min' : undefined;\n  if (hasThird === undefined) {\n    return chord.quality; // sus, power, and other non-tertian chords stand alone\n  }\n  if (semis.has(6) && !semis.has(7)) {\n    return hasThird === 'min' ? 'dim' : 'majb5';\n  }\n  if (semis.has(8) && !semis.has(7)) {\n    return 'aug';\n  }\n  return hasThird;\n}\n\n/** The diatonic triads of a key, one per scale degree. */\nfunction diatonicTriadsOf(key: KeyScale): Chord[] {\n  const degrees = scaleTonesInDegreeOrder(key).length;\n  const triads: Chord[] = [];\n  for (let degree = 0; degree < degrees; degree += 1) {\n    triads.push(diatonicTriad(degree, key));\n  }\n  return triads;\n}\n\n/** Whether two chords share the same root pitch class and quality. */\nfunction sameChord(a: Chord, b: Chord): boolean {\n  return mod12(a.rootPc) === mod12(b.rootPc) && a.quality === b.quality;\n}\n\n/** Root offsets (semitones) that form a third above or below a root. */\nconst THIRD_OFFSETS = [3, 4, 8, 9] as const;\n\n/**\n * Propose substitutions for a chord within a key.\n *\n * Candidates are generated by several relationships and deduplicated against the\n * original chord and each other:\n *\n * - `tritone`: for a dominant-type chord, the dominant seventh a tritone away.\n * - `secondaryDominant`: for a stable target, the dominant seventh a fifth\n *   above its root (tonicizing it).\n * - `relative`: a diatonic triad a third away that shares two common tones.\n * - `borrowed`: a triad from the parallel mode with the same harmonic function.\n * - `chromaticMediant`: a major/minor triad a third away sharing one common\n *   tone.\n *\n * Each result carries its Roman numeral and harmonic function in `key`. When\n * `opts.melodyPcs` is given, only substitutions whose pitch classes contain all\n * of those pitch classes are returned.\n *\n * @param chord The chord to reharmonize.\n * @param key The prevailing key.\n * @param opts Optional melody-preservation constraint.\n * @returns The deduplicated substitution candidates.\n * @example\n * ```ts\n * import { substituteChord, makeChord, majorKey } from '@libraz/libcantus';\n * const subs = substituteChord(makeChord(7, 'dom7'), majorKey(0));\n * // includes the tritone sub Db7 (rootPc 1, quality 'dom7')\n * ```\n * @category Reharmonization\n */\nexport function substituteChord(\n  chord: Chord,\n  key: KeyScale,\n  opts?: SubstituteOptions,\n): Substitution[] {\n  // The relative test counts common tones against the chord's triad, not its\n  // full pitch-class set: an exact count of two would otherwise be decided by\n  // how many tensions the input carries, so C proposes both Em and Am while\n  // Cmaj7 proposes only Am — penalising the candidate that overlaps *more*.\n  const originalTriad = chordPitchClasses(makeChord(chord.rootPc, triadQualityOf(chord)));\n  const candidates: { chord: Chord; type: SubstitutionType }[] = [];\n\n  // Tritone substitution: only for dominant-type chords.\n  if (isDominantType(chord)) {\n    candidates.push({ chord: makeChord(mod12(chord.rootPc + 6), 'dom7'), type: 'tritone' });\n  }\n\n  // Secondary dominant: the V7 tonicizing a stable target.\n  if (isStableTarget(chord)) {\n    candidates.push({\n      chord: makeChord(mod12(chord.rootPc + 7), 'dom7'),\n      type: 'secondaryDominant',\n    });\n  }\n\n  // Relative: a diatonic triad a third away sharing two common tones.\n  for (const triad of diatonicTriadsOf(key)) {\n    const offset = mod12(triad.rootPc - chord.rootPc);\n    if (\n      (THIRD_OFFSETS as readonly number[]).includes(offset) &&\n      commonToneCount(originalTriad, chordPitchClasses(triad)) === 2\n    ) {\n      candidates.push({ chord: triad, type: 'relative' });\n    }\n  }\n\n  // Borrowed: a parallel-mode triad sharing the original's harmonic function.\n  const targetFunction = functionOf(chord, key);\n  for (const triad of diatonicTriadsOf(parallelKey(key))) {\n    if (functionOf(triad, key) === targetFunction && !isDiatonic(triad, key)) {\n      candidates.push({ chord: triad, type: 'borrowed' });\n    }\n  }\n\n  // Chromatic mediants: major/minor triads a third away sharing one common tone.\n  for (const offset of THIRD_OFFSETS) {\n    for (const quality of ['maj', 'min'] as const) {\n      const mediant = makeChord(mod12(chord.rootPc + offset), quality);\n      if (\n        commonToneCount(originalTriad, chordPitchClasses(mediant)) === 1 &&\n        !isDiatonic(mediant, key)\n      ) {\n        candidates.push({ chord: mediant, type: 'chromaticMediant' });\n      }\n    }\n  }\n\n  const melodyPcs = opts?.melodyPcs?.map(mod12);\n  const seen = new Set<string>();\n  const results: Substitution[] = [];\n  for (const candidate of candidates) {\n    if (sameChord(candidate.chord, chord)) {\n      continue;\n    }\n    const dedupeKey = `${mod12(candidate.chord.rootPc)}:${candidate.chord.quality}`;\n    if (seen.has(dedupeKey)) {\n      continue;\n    }\n    seen.add(dedupeKey);\n    if (melodyPcs !== undefined) {\n      const pcs = new Set(chordPitchClasses(candidate.chord));\n      if (!melodyPcs.every((pc) => pcs.has(pc))) {\n        continue;\n      }\n    }\n    results.push({\n      chord: candidate.chord,\n      type: candidate.type,\n      // A secondary dominant is named as the applied chord it is, so the\n      // numeral re-parses to the chord that was proposed rather than to a\n      // chromatic chord on the same root.\n      roman: chordToRoman(candidate.chord, key, {\n        applied: candidate.type === 'secondaryDominant',\n      }),\n      function: functionOf(candidate.chord, key),\n    });\n  }\n  return results;\n}\n\n/**\n * A borrowed chord in the modal-interchange palette of a key.\n *\n * @category Reharmonization\n */\nexport type BorrowedChord = {\n  chord: Chord;\n  roman: string;\n  source: BorrowedSource;\n};\n\n/**\n * The modal-interchange palette of a key.\n *\n * Lists the diatonic triads of the {@link parallelKey} that are not diatonic to\n * `key` (the classic borrowed chords such as `iv`, `bVI`, and `bVII` in a major\n * key), plus the Neapolitan (a major triad on the flat second degree). Each\n * carries its Roman numeral and {@link borrowedSource} relative to `key`.\n *\n * @param key The prevailing key.\n * @returns The borrowed-chord palette.\n * @category Reharmonization\n */\nexport function modalInterchangePalette(key: KeyScale): BorrowedChord[] {\n  const palette: BorrowedChord[] = [];\n  const seen = new Set<string>();\n  const add = (chord: Chord) => {\n    const dedupeKey = `${mod12(chord.rootPc)}:${chord.quality}`;\n    if (seen.has(dedupeKey)) {\n      return;\n    }\n    seen.add(dedupeKey);\n    palette.push({\n      chord,\n      roman: chordToRoman(chord, key),\n      source: borrowedSource(chord, key),\n    });\n  };\n\n  for (const triad of diatonicTriadsOf(parallelKey(key))) {\n    if (!isDiatonic(triad, key)) {\n      add(triad);\n    }\n  }\n  // The Neapolitan (major triad on b2) sits outside both parallel modes, so it\n  // is added explicitly — unless b2 is already diatonic (e.g. in a Phrygian key,\n  // where it is a native chord rather than a borrowing).\n  const neapolitan = makeChord(mod12(key.rootPc + 1), 'maj');\n  if (!isDiatonic(neapolitan, key)) {\n    add(neapolitan);\n  }\n  return palette;\n}\n\n/**\n * Reflect a chord across the tonic–dominant axis of a key (negative harmony).\n *\n * Every pitch class `p` maps to `(2*T + 7 - p) mod 12`, where `T` is the key\n * tonic — the reflection that swaps the tonic with the dominant. The mirrored\n * pitch classes (including the bass, if set) are reassembled into a chord by\n * {@link detectChordBest}; when no chord is recognized, the mirrored root and\n * the original quality are used as a fallback.\n *\n * @param chord The chord to reflect.\n * @param key The prevailing key.\n * @returns The negative-harmony counterpart of the chord.\n * @example\n * ```ts\n * import { negativeHarmonyMirror, makeChord, majorKey } from '@libraz/libcantus';\n * negativeHarmonyMirror(makeChord(7, 'maj'), majorKey(0));\n * // G major reflected across C's axis => F minor (rootPc 5, quality 'min')\n * ```\n * @category Reharmonization\n */\nexport function negativeHarmonyMirror(chord: Chord, key: KeyScale): Chord {\n  const tonic = mod12(key.rootPc);\n  const mirror = (p: number) => mod12(2 * tonic + 7 - p);\n  const pcs = chordPitchClasses(chord).map(mirror);\n  const bassPc = chord.bassPc !== undefined ? mirror(chord.bassPc) : undefined;\n  // Place the mirrored bass an octave below so it is recognized as the lowest\n  // note and preserved through detection.\n  const pitches = bassPc !== undefined ? [bassPc - 12, ...pcs] : pcs;\n  const detected = detectChordBest(pitches);\n  if (detected) {\n    // Without an input bass the mirrored tones are octave-less, so detection may\n    // read the lowest pitch class as a slash bass and report a spurious\n    // inversion. Restore the recognized chord to root position in that case.\n    if (bassPc === undefined && detected.bassPc !== undefined) {\n      return makeChord(detected.rootPc, detected.quality);\n    }\n    return detected;\n  }\n  const quality: ChordQuality = chord.quality;\n  return makeChord(mirror(chord.rootPc), quality, bassPc);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-HKGYCQ34.js

@@ -0,0 +1,53 @@
+import {
+  InvalidInputError,
+  assertFiniteNumber,
+  assertInteger,
+  assertRange
+} from "./chunk-XEBG3G53.js";
+
+// 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 {
+  createRng
+};
+//# sourceMappingURL=chunk-HKGYCQ34.js.map

package/dist/chunk-HKGYCQ34.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/random/index.ts"],"sourcesContent":["/**\n * Deterministic seeded pseudo-random number generation shared across the\n * generative modules (rhythm, drums, bass, groove, counter-melody). A single\n * mulberry32 core exposes the small set of samplers those modules need; given a\n * seed the stream is fully reproducible.\n */\n\nimport { InvalidInputError } from '../errors/index.js';\nimport { assertFiniteNumber, assertInteger, assertRange } from '../validation/index.js';\n\n/**\n * A deterministic PRNG with the sampling helpers the generators need.\n *\n * @category Utilities\n */\nexport type Rng = {\n  /** Next float in [0, 1). */\n  next: () => number;\n  /** True with probability `p`. */\n  prob: (p: number) => boolean;\n  /** Integer in the inclusive range [lo, hi]. */\n  range: (lo: number, hi: number) => number;\n  /** Float in [lo, hi). */\n  float: (lo: number, hi: number) => number;\n};\n\n/**\n * Create a seeded PRNG (mulberry32) exposing the shared samplers.\n *\n * @param seed The 32-bit seed; the same seed always yields the same stream.\n * @returns The seeded generator.\n * @example\n * ```ts\n * import { createRng } from '@libraz/libcantus';\n * const rng = createRng(42);\n * rng.next(); // deterministic float in [0, 1)\n * rng.range(1, 6); // deterministic integer in [1, 6]\n * ```\n * @category Utilities\n */\nexport function createRng(seed: number): Rng {\n  // The state is 32 bits, so a wider or fractional seed would be truncated —\n  // silently mapping distinct seeds onto one sequence.\n  assertInteger(seed, 'seed', 0, 0xffffffff);\n  let state = seed >>> 0;\n  const next = () => {\n    state = (state + 0x6d2b79f5) >>> 0;\n    let t = state;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n  return {\n    next,\n    prob: (p) => {\n      // Validate first: a draw consumed by a rejected call shifts the stream,\n      // so a caller who catches the error gets a different sequence than one\n      // who never made the call.\n      assertRange(p, 0, 1, 'probability');\n      return next() < p;\n    },\n    range: (lo, hi) => {\n      assertInteger(lo, 'range lower bound');\n      assertInteger(hi, 'range upper bound');\n      if (lo > hi) {\n        throw new InvalidInputError(\n          `range lower bound must not exceed upper bound; received ${lo} > ${hi}`,\n        );\n      }\n      assertInteger(hi - lo, 'range span', 0);\n      return lo + Math.floor(next() * (hi - lo + 1));\n    },\n    float: (lo, hi) => {\n      assertFiniteNumber(lo, 'float lower bound');\n      assertFiniteNumber(hi, 'float upper bound');\n      if (lo > hi) {\n        throw new InvalidInputError(\n          `float lower bound must not exceed upper bound; received ${lo} > ${hi}`,\n        );\n      }\n      assertFiniteNumber(hi - lo, 'float span');\n      return lo + next() * (hi - lo);\n    },\n  };\n}\n"],"mappings":";;;;;;;;AAwCO,SAAS,UAAU,MAAmB;AAG3C,gBAAc,MAAM,QAAQ,GAAG,UAAU;AACzC,MAAI,QAAQ,SAAS;AACrB,QAAM,OAAO,MAAM;AACjB,YAAS,QAAQ,eAAgB;AACjC,QAAI,IAAI;AACR,QAAI,KAAK,KAAK,IAAK,MAAM,IAAK,IAAI,CAAC;AACnC,SAAK,IAAI,KAAK,KAAK,IAAK,MAAM,GAAI,IAAI,EAAE;AACxC,aAAS,IAAK,MAAM,QAAS,KAAK;AAAA,EACpC;AACA,SAAO;AAAA,IACL;AAAA,IACA,MAAM,CAAC,MAAM;AAIX,kBAAY,GAAG,GAAG,GAAG,aAAa;AAClC,aAAO,KAAK,IAAI;AAAA,IAClB;AAAA,IACA,OAAO,CAAC,IAAI,OAAO;AACjB,oBAAc,IAAI,mBAAmB;AACrC,oBAAc,IAAI,mBAAmB;AACrC,UAAI,KAAK,IAAI;AACX,cAAM,IAAI;AAAA,UACR,2DAA2D,EAAE,MAAM,EAAE;AAAA,QACvE;AAAA,MACF;AACA,oBAAc,KAAK,IAAI,cAAc,CAAC;AACtC,aAAO,KAAK,KAAK,MAAM,KAAK,KAAK,KAAK,KAAK,EAAE;AAAA,IAC/C;AAAA,IACA,OAAO,CAAC,IAAI,OAAO;AACjB,yBAAmB,IAAI,mBAAmB;AAC1C,yBAAmB,IAAI,mBAAmB;AAC1C,UAAI,KAAK,IAAI;AACX,cAAM,IAAI;AAAA,UACR,2DAA2D,EAAE,MAAM,EAAE;AAAA,QACvE;AAAA,MACF;AACA,yBAAmB,KAAK,IAAI,YAAY;AACxC,aAAO,KAAK,KAAK,KAAK,KAAK;AAAA,IAC7B;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-I24MV65U.js

@@ -0,0 +1,106 @@
+import {
+  InvalidInputError,
+  assertFiniteNumber,
+  assertInteger,
+  assertPositiveInt,
+  assertRange
+} from "./chunk-XEBG3G53.js";
+
+// src/core/tuning/index.ts
+var TWELVE_TET = Object.freeze({ refStep: 69, refFreq: 440, divisions: 12 });
+function assertTuning(tuning) {
+  assertFiniteNumber(tuning.refStep, "tuning.refStep");
+  assertRange(tuning.refFreq, Number.MIN_VALUE, Number.MAX_VALUE, "tuning.refFreq");
+  assertPositiveInt(tuning.divisions, "tuning.divisions");
+  return tuning;
+}
+function edo(n, refFreq = 440, refStep = 69) {
+  assertPositiveInt(n, "EDO divisions");
+  assertRange(refFreq, Number.MIN_VALUE, Number.MAX_VALUE, "reference frequency");
+  assertFiniteNumber(refStep, "reference step");
+  return { refStep, refFreq, divisions: n };
+}
+function frequencyOf(step, tuning = TWELVE_TET) {
+  assertFiniteNumber(step, "step");
+  assertTuning(tuning);
+  const result = tuning.refFreq * 2 ** ((step - tuning.refStep) / tuning.divisions);
+  return assertRange(result, Number.MIN_VALUE, Number.MAX_VALUE, "frequency result");
+}
+function nearestStep(freq, tuning = TWELVE_TET) {
+  assertRange(freq, Number.MIN_VALUE, Number.MAX_VALUE, "frequency");
+  assertTuning(tuning);
+  return Math.round(tuning.refStep + tuning.divisions * Math.log2(freq / tuning.refFreq));
+}
+function stepOf(freq, tuning = TWELVE_TET) {
+  assertRange(freq, Number.MIN_VALUE, Number.MAX_VALUE, "frequency");
+  assertTuning(tuning);
+  return tuning.refStep + tuning.divisions * Math.log2(freq / tuning.refFreq);
+}
+function centsFromNearestStep(freq, tuning = TWELVE_TET) {
+  const exact = stepOf(freq, tuning);
+  return centsOfSteps(exact - Math.round(exact), tuning);
+}
+function stepsOfCents(cents, tuning = TWELVE_TET) {
+  assertFiniteNumber(cents, "cents");
+  assertTuning(tuning);
+  return assertFiniteNumber(cents * tuning.divisions / 1200, "steps result");
+}
+function centsToRatio(cents) {
+  assertFiniteNumber(cents, "cents");
+  return 2 ** (cents / 1200);
+}
+function centsBetweenFreq(a, b) {
+  assertRange(a, Number.MIN_VALUE, Number.MAX_VALUE, "first frequency");
+  assertRange(b, Number.MIN_VALUE, Number.MAX_VALUE, "second frequency");
+  return 1200 * (Math.log2(b) - Math.log2(a));
+}
+function centsOfSteps(steps, tuning = TWELVE_TET) {
+  assertFiniteNumber(steps, "steps");
+  assertTuning(tuning);
+  return assertFiniteNumber(steps * 1200 / tuning.divisions, "cents result");
+}
+function ratioToCents(numerator, denominator) {
+  assertRange(numerator, Number.MIN_VALUE, Number.MAX_VALUE, "ratio numerator");
+  assertRange(denominator, Number.MIN_VALUE, Number.MAX_VALUE, "ratio denominator");
+  return 1200 * (Math.log2(numerator) - Math.log2(denominator));
+}
+var JUST_RATIOS = Object.freeze({
+  0: [1, 1],
+  1: [16, 15],
+  2: [9, 8],
+  3: [6, 5],
+  4: [5, 4],
+  5: [4, 3],
+  6: [45, 32],
+  7: [3, 2],
+  8: [8, 5],
+  9: [5, 3],
+  10: [9, 5],
+  11: [15, 8],
+  12: [2, 1]
+});
+function justDeviationCents(semitoneClass) {
+  assertInteger(semitoneClass, "semitone class", 0, 12);
+  const ratio = JUST_RATIOS[semitoneClass];
+  if (!ratio) {
+    throw new InvalidInputError(`semitone class has no just ratio: ${semitoneClass}`);
+  }
+  return ratioToCents(ratio[0], ratio[1]) - semitoneClass * 100;
+}
+
+export {
+  TWELVE_TET,
+  edo,
+  frequencyOf,
+  nearestStep,
+  stepOf,
+  centsFromNearestStep,
+  stepsOfCents,
+  centsToRatio,
+  centsBetweenFreq,
+  centsOfSteps,
+  ratioToCents,
+  JUST_RATIOS,
+  justDeviationCents
+};
+//# sourceMappingURL=chunk-I24MV65U.js.map

package/dist/chunk-I24MV65U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/tuning/index.ts"],"sourcesContent":["/**\n * Tuning and microtonality: frequency conversion, cents, arbitrary equal\n * temperaments (EDO), and just-intonation ratios.\n *\n * The rest of the library reasons in twelve-tone pitch classes, which is a\n * deliberate scope choice for tonal theory. This module is the escape hatch for\n * anyone who needs actual frequencies, cents, non-12 equal temperaments, or the\n * acoustic (just) tuning behind the tempered intervals.\n */\n\nimport { InvalidInputError } from '../errors/index.js';\nimport {\n  assertFiniteNumber,\n  assertInteger,\n  assertPositiveInt,\n  assertRange,\n} from '../validation/index.js';\n\n/**\n * An equal-tempered tuning: a reference pitch and a number of equal divisions of\n * the octave. With `divisions === 12` a step index is an ordinary MIDI number.\n *\n * @category Pitch & Intervals\n */\nexport type Tuning = {\n  /** Step index (MIDI number when `divisions` is 12) whose frequency is `refFreq`. */\n  readonly refStep: number;\n  /** Frequency in Hz of `refStep`. */\n  readonly refFreq: number;\n  /** Equal divisions of the octave (12 standard; e.g. 19 or 31 for microtonal). */\n  readonly divisions: number;\n};\n\n/**\n * Standard twelve-tone equal temperament, A4 (MIDI 69) = 440 Hz.\n *\n * @category Pitch & Intervals\n */\nexport const TWELVE_TET: Tuning = Object.freeze({ refStep: 69, refFreq: 440, divisions: 12 });\n\nfunction assertTuning(tuning: Tuning): Tuning {\n  assertFiniteNumber(tuning.refStep, 'tuning.refStep');\n  assertRange(tuning.refFreq, Number.MIN_VALUE, Number.MAX_VALUE, 'tuning.refFreq');\n  assertPositiveInt(tuning.divisions, 'tuning.divisions');\n  return tuning;\n}\n\n/**\n * Build an equal temperament with `n` divisions of the octave.\n *\n * @param n Divisions of the octave (e.g. 19, 24, 31).\n * @param refFreq Reference frequency in Hz (default 440).\n * @param refStep Step index of the reference (default 69).\n * @returns The tuning.\n * @example\n * ```ts\n * import { edo, frequencyOf } from '@libraz/libcantus';\n * const et19 = edo(19); // { refStep: 69, refFreq: 440, divisions: 19 }\n * frequencyOf(70, et19); // one 19-EDO step above A4\n * ```\n * @category Pitch & Intervals\n */\nexport function edo(n: number, refFreq = 440, refStep = 69): Tuning {\n  assertPositiveInt(n, 'EDO divisions');\n  assertRange(refFreq, Number.MIN_VALUE, Number.MAX_VALUE, 'reference frequency');\n  assertFiniteNumber(refStep, 'reference step');\n  return { refStep, refFreq, divisions: n };\n}\n\n/**\n * Frequency in Hz of a step index under a tuning.\n *\n * @param step Step index (a MIDI number under 12-EDO).\n * @param tuning The tuning (default 12-TET).\n * @returns The frequency in Hz.\n * @example\n * ```ts\n * import { frequencyOf } from '@libraz/libcantus';\n * frequencyOf(69); // 440 (A4 in 12-TET)\n * frequencyOf(60); // middle C in Hz\n * ```\n * @category Pitch & Intervals\n */\nexport function frequencyOf(step: number, tuning: Tuning = TWELVE_TET): number {\n  assertFiniteNumber(step, 'step');\n  assertTuning(tuning);\n  const result = tuning.refFreq * 2 ** ((step - tuning.refStep) / tuning.divisions);\n  return assertRange(result, Number.MIN_VALUE, Number.MAX_VALUE, 'frequency result');\n}\n\n/**\n * Nearest step index to a frequency under a tuning (the inverse of\n * {@link frequencyOf}, rounded).\n *\n * @param freq Frequency in Hz.\n * @param tuning The tuning (default 12-TET).\n * @returns The nearest step index.\n * @category Pitch & Intervals\n */\nexport function nearestStep(freq: number, tuning: Tuning = TWELVE_TET): number {\n  assertRange(freq, Number.MIN_VALUE, Number.MAX_VALUE, 'frequency');\n  assertTuning(tuning);\n  return Math.round(tuning.refStep + tuning.divisions * Math.log2(freq / tuning.refFreq));\n}\n\n/**\n * Step index of a frequency under a tuning, unrounded.\n *\n * The exact inverse of {@link frequencyOf}. {@link nearestStep} rounds it,\n * which discards how far off the pitch actually is — the figure a tuner\n * display, a pitch-bend amount, or an intonation check is built on.\n *\n * @param freq Frequency in Hz.\n * @param tuning The tuning (default 12-TET).\n * @returns The fractional step index.\n * @example\n * ```ts\n * import { stepOf } from '@libraz/libcantus';\n * stepOf(442); // slightly above 69, the step for A440\n * ```\n * @category Pitch & Intervals\n */\nexport function stepOf(freq: number, tuning: Tuning = TWELVE_TET): number {\n  assertRange(freq, Number.MIN_VALUE, Number.MAX_VALUE, 'frequency');\n  assertTuning(tuning);\n  return tuning.refStep + tuning.divisions * Math.log2(freq / tuning.refFreq);\n}\n\n/**\n * How far a frequency sits from its nearest step, in cents.\n *\n * Positive means sharp of the step, negative flat.\n *\n * @param freq Frequency in Hz.\n * @param tuning The tuning (default 12-TET).\n * @returns The signed deviation in cents.\n * @example\n * ```ts\n * import { centsFromNearestStep } from '@libraz/libcantus';\n * Math.round(centsFromNearestStep(442)); // 8\n * ```\n * @category Pitch & Intervals\n */\nexport function centsFromNearestStep(freq: number, tuning: Tuning = TWELVE_TET): number {\n  const exact = stepOf(freq, tuning);\n  return centsOfSteps(exact - Math.round(exact), tuning);\n}\n\n/**\n * Steps spanned by an interval in cents, unrounded — the inverse of\n * {@link centsOfSteps}.\n *\n * @param cents The interval in cents.\n * @param tuning The tuning (default 12-TET).\n * @returns The fractional step count.\n * @category Pitch & Intervals\n */\nexport function stepsOfCents(cents: number, tuning: Tuning = TWELVE_TET): number {\n  assertFiniteNumber(cents, 'cents');\n  assertTuning(tuning);\n  return assertFiniteNumber((cents * tuning.divisions) / 1200, 'steps result');\n}\n\n/**\n * The frequency ratio an interval in cents spans — the inverse of\n * {@link ratioToCents}.\n *\n * Multiply a frequency by this to move it by that many cents, which is how a\n * cents offset (a pitch-bend spec, a tuning table entry) is applied.\n *\n * @param cents The interval in cents.\n * @returns The frequency ratio.\n * @example\n * ```ts\n * import { centsToRatio } from '@libraz/libcantus';\n * 440 * centsToRatio(14); // A440 raised by 14 cents\n * ```\n * @category Pitch & Intervals\n */\nexport function centsToRatio(cents: number): number {\n  assertFiniteNumber(cents, 'cents');\n  return 2 ** (cents / 1200);\n}\n\n/**\n * Interval in cents between two frequencies.\n *\n * @param a Lower/first frequency in Hz.\n * @param b Upper/second frequency in Hz.\n * @returns Cents from `a` to `b` (negative if `b` is lower).\n * @category Pitch & Intervals\n */\nexport function centsBetweenFreq(a: number, b: number): number {\n  assertRange(a, Number.MIN_VALUE, Number.MAX_VALUE, 'first frequency');\n  assertRange(b, Number.MIN_VALUE, Number.MAX_VALUE, 'second frequency');\n  return 1200 * (Math.log2(b) - Math.log2(a));\n}\n\n/**\n * Cents spanned by a number of equal-temperament steps.\n *\n * @param steps Number of steps.\n * @param tuning The tuning (default 12-TET).\n * @returns The cents.\n * @category Pitch & Intervals\n */\nexport function centsOfSteps(steps: number, tuning: Tuning = TWELVE_TET): number {\n  assertFiniteNumber(steps, 'steps');\n  assertTuning(tuning);\n  return assertFiniteNumber((steps * 1200) / tuning.divisions, 'cents result');\n}\n\n/**\n * Cents of a frequency ratio, e.g. `ratioToCents(3, 2)` ≈ 701.955 for the just\n * perfect fifth.\n *\n * @param numerator Ratio numerator.\n * @param denominator Ratio denominator.\n * @returns The interval in cents.\n * @category Pitch & Intervals\n */\nexport function ratioToCents(numerator: number, denominator: number): number {\n  assertRange(numerator, Number.MIN_VALUE, Number.MAX_VALUE, 'ratio numerator');\n  assertRange(denominator, Number.MIN_VALUE, Number.MAX_VALUE, 'ratio denominator');\n  return 1200 * (Math.log2(numerator) - Math.log2(denominator));\n}\n\n/**\n * Five-limit just-intonation ratios for the twelve interval classes above a\n * unison, indexed by semitone class (0..12).\n *\n * @category Pitch & Intervals\n */\nexport const JUST_RATIOS: Readonly<Record<number, readonly [number, number]>> = Object.freeze({\n  0: [1, 1],\n  1: [16, 15],\n  2: [9, 8],\n  3: [6, 5],\n  4: [5, 4],\n  5: [4, 3],\n  6: [45, 32],\n  7: [3, 2],\n  8: [8, 5],\n  9: [5, 3],\n  10: [9, 5],\n  11: [15, 8],\n  12: [2, 1],\n});\n\n/**\n * Cents by which a five-limit just interval departs from its 12-TET tempering\n * (positive means the just interval is wider).\n *\n * @param semitoneClass Semitone class in [0, 12].\n * @returns The deviation in cents.\n * @throws If `semitoneClass` is not an integer in [0, 12].\n * @category Pitch & Intervals\n */\nexport function justDeviationCents(semitoneClass: number): number {\n  assertInteger(semitoneClass, 'semitone class', 0, 12);\n  const ratio = JUST_RATIOS[semitoneClass];\n  if (!ratio) {\n    throw new InvalidInputError(`semitone class has no just ratio: ${semitoneClass}`);\n  }\n  return ratioToCents(ratio[0], ratio[1]) - semitoneClass * 100;\n}\n"],"mappings":"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","names":[]}