@libraz/libcantus 0.9.2 → 0.9.3

package/src/model/chord.ts

@@ -1,4 +1,4 @@
-import { detectChord, detectChordBest } from '../analyze/detect/index.js';
+import { type DetectChordOptions, detectChord, detectChordBest } from '../analyze/detect/index.js';
 import {
   analyzeChord,
   type BorrowedSource,
@@ -22,7 +22,7 @@ import {
   type ChordScaleMatch,
   chordScales,
 } from '../theory/chordscale/index.js';
-import { spellChord } from '../theory/spelling/index.js';
+import { spellChord, spellChordFromRoot, spellPitchClass } from '../theory/spelling/index.js';
 import { formatChordSymbol, parseChordSymbol } from '../theory/symbol/index.js';
 import {
   type StyledVoicingOptions,
@@ -33,7 +33,7 @@ import {
 import type { Key } from './key.js';
 import { Note } from './note.js';
 import { Progression } from './progression.js';
-import { mod12 } from './shared.js';
+import { mod12, spellPitchClassBare } from './shared.js';
 
 /**
  * Defensive copy of a plain chord.
@@ -85,7 +85,11 @@ export class Chord {
    * @param key Optional key context for analysis methods.
    */
   constructor(data: ChordData, key?: Key) {
-    this.#data = copyChord(data);
+    const copy = copyChord(data);
+    if (copy.rootSpelling === undefined && key !== undefined) {
+      copy.rootSpelling = spellPitchClass(copy.rootPc, key.tonic.data, key.scale);
+    }
+    this.#data = copy;
     this.#key = key;
   }
 
@@ -98,8 +102,13 @@ export class Chord {
    * @returns The chord (without key context).
    */
   static of(root: string | number, quality: ChordQuality, bass?: number): Chord {
-    const rootPc = typeof root === 'string' ? Note.of(root).pitchClass : root;
-    return new Chord(makeChord(rootPc, quality, bass));
+    if (typeof root === 'string') {
+      const rootNote = Note.of(root);
+      const data = makeChord(rootNote.pitchClass, quality, bass);
+      data.rootSpelling = { letter: rootNote.letter, alter: rootNote.alter };
+      return new Chord(data);
+    }
+    return new Chord(makeChord(root, quality, bass));
   }
 
   /**
@@ -129,8 +138,8 @@ export class Chord {
    * @param pitches MIDI pitches or bare pitch classes.
    * @returns Ranked chord interpretations (may be empty).
    */
-  static detect(pitches: number[]): Chord[] {
-    return detectChord(pitches).map(
+  static detect(pitches: number[], opts?: DetectChordOptions): Chord[] {
+    return detectChord(pitches, opts).map(
       (match) => new Chord(makeChord(match.rootPc, match.quality, match.bassPc)),
     );
   }
@@ -141,8 +150,8 @@ export class Chord {
    * @param pitches MIDI pitches or bare pitch classes.
    * @returns The top-ranked chord, or null when nothing matches.
    */
-  static detectBest(pitches: number[]): Chord | null {
-    const best = detectChordBest(pitches);
+  static detectBest(pitches: number[], opts?: DetectChordOptions): Chord | null {
+    const best = detectChordBest(pitches, opts);
     return best === null ? null : new Chord(best);
   }
 
@@ -320,8 +329,18 @@ export class Chord {
     const data = copyChord(this.#data);
     if (index === 0) {
       delete data.bassPc;
+      delete data.bassSpelling;
     } else {
       data.bassPc = mod12(this.#data.rootPc + (intervals[index] ?? 0));
+      const rootSpelling =
+        data.rootSpelling ??
+        (this.#key
+          ? spellPitchClass(data.rootPc, this.#key.tonic.data, this.#key.scale)
+          : spellPitchClassBare(data.rootPc, 'sharp'));
+      const bassSpelling = spellChordFromRoot(data, rootSpelling)[index];
+      if (bassSpelling !== undefined) {
+        data.bassSpelling = bassSpelling;
+      }
     }
     return new Chord(data, this.#key);
   }

package/src/theory/chord/index.ts

@@ -317,8 +317,10 @@ function classifySeventh(thirdIc: number, fifthIc: number, seventhIc: number): C
 function stackThirds(degree: number, key: KeyScale, size: 3 | 4): Chord {
   const tones = scaleTonesInDegreeOrder(key);
   const length = tones.length;
-  if (length === 0) {
-    return { rootPc: pitchClass(key.rootPc), quality: 'maj', intervals: [0, 4, 7] };
+  if (length !== 7) {
+    throw new Error(
+      `diatonic chord stacking requires a heptatonic scale (received ${length} tones)`,
+    );
   }
   const idx = (step: number) => (((degree + step) % length) + length) % length;
   const rootPc = tones[idx(0)] ?? pitchClass(key.rootPc);

package/src/theory/harmony/index.ts

@@ -1,4 +1,4 @@
-import type { Chord } from '../chord/index.js';
+import { type Chord, chordToneRole } from '../chord/index.js';
 
 /**
  * Harmonic role a pitch plays within a chord.
@@ -57,33 +57,18 @@ export type VoicedRole = {
 export function roleOf(pitch: number, chord: Chord, chordId = 0): VoicedRole {
   const interval = (((Math.trunc(pitch) - chord.rootPc) % 12) + 12) % 12;
   const tones = new Set(chord.intervals.map((i) => ((i % 12) + 12) % 12));
-  const hasHigherSeventh = tones.has(10) || tones.has(11);
   const hasThird = tones.has(3) || tones.has(4);
   const isSuspendedTone =
     !hasThird && ((interval === 5 && tones.has(5)) || (interval === 2 && tones.has(2)));
+  const chordRole = chordToneRole(pitch, chord);
   let role: HarmonyRole;
   let lock: LockLevel;
-  if (interval === 0) {
-    role = 'root';
-    lock = 'identity';
-  } else if (isSuspendedTone) {
+  if (isSuspendedTone) {
     role = 'third'; // suspended tone occupies the third's quality-defining slot
     lock = 'quality';
-  } else if (interval === 3 || interval === 4) {
-    role = 'third';
-    lock = 'quality';
-  } else if (interval === 6 || interval === 7 || interval === 8) {
-    role = 'fifth';
-    lock = 'voicing';
-  } else if (interval === 9 && tones.has(3) && tones.has(6) && !hasHigherSeventh) {
-    role = 'seventh'; // diminished seventh
-    lock = 'voicing';
-  } else if (interval === 9 && tones.has(9) && !hasHigherSeventh) {
-    role = 'sixth';
-    lock = 'voicing';
-  } else if (interval === 10 || interval === 11) {
-    role = 'seventh';
-    lock = 'voicing';
+  } else if (chordRole !== null) {
+    role = chordRole;
+    lock = chordRole === 'root' ? 'identity' : chordRole === 'third' ? 'quality' : 'voicing';
   } else {
     role = 'tension';
     lock = 'voicing';

package/src/theory/index.ts

@@ -2,7 +2,12 @@
  * Public API of the theory layer. Re-exports every theory-layer module;
  * also available from the package root.
  */
-export type { Chord as ChordData, ChordQuality } from './chord/index.js';
+export type {
+  Chord as ChordData,
+  ChordQuality,
+  ChordSpan,
+  PitchSpelling,
+} from './chord/index.js';
 export {
   chordFromDegree,
   chordPitchClasses,

package/src/theory/safety/index.ts

@@ -1,4 +1,9 @@
 import type { KeyScale } from '../../core/types.js';
+import {
+  assertFiniteNumber,
+  assertGenerationBudget,
+  assertInteger,
+} from '../../core/validation/index.js';
 import type { Chord } from '../chord/index.js';
 import { chordPitchClasses } from '../chord/index.js';
 import {
@@ -96,6 +101,36 @@ const SUGGESTION_WINDOW = 12;
 /** Maximum number of alternative pitches returned in `SafetyResult.suggestions`. */
 const MAX_SUGGESTIONS = 3;
 
+/** Canonical minimum verdict contributed by each non-informational reason. */
+const REASON_SEVERITY: ReadonlyArray<
+  readonly [flag: ReasonFlag, pop: NoteSafety, strict: NoteSafety]
+> = [
+  [ReasonFlag.Tension, NoteSafety.Warning, NoteSafety.Warning],
+  [ReasonFlag.AvoidNote, NoteSafety.Warning, NoteSafety.Dissonant],
+  [ReasonFlag.ScaleTone, NoteSafety.Warning, NoteSafety.Warning],
+  [ReasonFlag.NonScale, NoteSafety.Dissonant, NoteSafety.Dissonant],
+  [ReasonFlag.OutOfRange, NoteSafety.Warning, NoteSafety.Warning],
+  [ReasonFlag.Tritone, NoteSafety.Dissonant, NoteSafety.Dissonant],
+  [ReasonFlag.LargeLeap, NoteSafety.Warning, NoteSafety.Dissonant],
+  [ReasonFlag.VerticalDissonance, NoteSafety.Dissonant, NoteSafety.Dissonant],
+  [ReasonFlag.ParallelPerfect, NoteSafety.Warning, NoteSafety.Dissonant],
+  [ReasonFlag.HiddenParallel, NoteSafety.Warning, NoteSafety.Dissonant],
+  [ReasonFlag.VoiceCrossing, NoteSafety.Warning, NoteSafety.Dissonant],
+  [ReasonFlag.Suspension, NoteSafety.Dissonant, NoteSafety.Dissonant],
+  [ReasonFlag.NeedsResolution, NoteSafety.Warning, NoteSafety.Dissonant],
+];
+
+function minimumSafetyForReasons(reasons: number, profile: SafetyProfile): NoteSafety {
+  let minimum = NoteSafety.Safe;
+  const severityIndex = profile === 'strict' ? 2 : 1;
+  for (const entry of REASON_SEVERITY) {
+    if (reasons & entry[0]) {
+      minimum = Math.max(minimum, entry[severityIndex]) as NoteSafety;
+    }
+  }
+  return minimum;
+}
+
 function pitchClass(pitch: number): number {
   return ((Math.trunc(pitch) % 12) + 12) % 12;
 }
@@ -154,9 +189,30 @@ function stepResolution(pitch: number, chord: Chord): number | undefined {
  * @category Arrangement & Analysis
  */
 export function evaluateSafety(q: SafetyQuery): SafetyResult {
+  assertSafetyContext(q);
+  assertFiniteNumber(q.candidatePitch, 'candidatePitch');
   return evaluateInternal(q, true);
 }
 
+/** Validate all numeric context fields once at a public safety entry point. */
+function assertSafetyContext(q: Omit<SafetyQuery, 'candidatePitch'>): void {
+  if (q.prevPitch !== undefined) assertFiniteNumber(q.prevPitch, 'prevPitch');
+  if (q.vocalLow !== undefined) assertFiniteNumber(q.vocalLow, 'vocalLow');
+  if (q.vocalHigh !== undefined) assertFiniteNumber(q.vocalHigh, 'vocalHigh');
+  if (q.vocalLow !== undefined && q.vocalHigh !== undefined && q.vocalLow > q.vocalHigh) {
+    throw new RangeError('vocalLow must not exceed vocalHigh');
+  }
+  assertGenerationBudget(q.otherVoices.length, 'other voices');
+  for (let index = 0; index < q.otherVoices.length; index += 1) {
+    const voice = q.otherVoices[index];
+    if (!voice) continue;
+    assertFiniteNumber(voice.pitch, `otherVoices[${index}].pitch`);
+    if (voice.prevPitch !== undefined) {
+      assertFiniteNumber(voice.prevPitch, `otherVoices[${index}].prevPitch`);
+    }
+  }
+}
+
 /**
  * Core safety evaluation.
  *
@@ -239,9 +295,11 @@ function evaluateInternal(q: SafetyQuery, collectSuggestions: boolean): SafetyRe
     const pc = Math.abs(pitch - q.prevPitch) % 12;
     if (pc === 6) {
       reasons |= ReasonFlag.Tritone;
+      raise(NoteSafety.Dissonant);
     }
     if (isForbiddenMelodicLeap(q.prevPitch, pitch)) {
       reasons |= ReasonFlag.LargeLeap;
+      raise(parallelSeverity);
     }
     if (pc === 1) {
       reasons |= ReasonFlag.MinorSecond;
@@ -298,6 +356,12 @@ function evaluateInternal(q: SafetyQuery, collectSuggestions: boolean): SafetyRe
     }
   }
 
+  // Keep reason production and verdict policy as one invariant even when a new
+  // call path skips an earlier local `raise`: informational flags (ChordTone,
+  // MinorSecond, MajorSeventh) may coexist with Safe; every policy flag above
+  // contributes at least its table severity.
+  raise(minimumSafetyForReasons(reasons, q.profile));
+
   const result: SafetyResult = { safety: level, reasons, rationale: describe(reasons, q) };
   if (resolveTo !== undefined) {
     result.resolveTo = resolveTo;
@@ -382,6 +446,7 @@ function describe(reasons: number, q: SafetyQuery): string {
  * @param pitchLow Lowest MIDI pitch to consider (inclusive).
  * @param pitchHigh Highest MIDI pitch to consider (inclusive).
  * @returns Placeable pitches (non-dissonant), chord tones before others, each group descending.
+ * @throws If either bound is non-finite/non-integral, reversed, or exceeds the generation budget.
  * @example
  * ```ts
  * import { enumerateSafePitches, makeChord, majorKey } from '@libraz/libcantus';
@@ -399,11 +464,15 @@ export function enumerateSafePitches(
   pitchLow: number,
   pitchHigh: number,
 ): number[] {
+  assertSafetyContext(q);
   const chordTones: number[] = [];
   const others: number[] = [];
-  if (!Number.isFinite(pitchLow) || !Number.isFinite(pitchHigh)) {
-    return [];
+  assertInteger(pitchLow, 'pitchLow');
+  assertInteger(pitchHigh, 'pitchHigh');
+  if (pitchLow > pitchHigh) {
+    throw new RangeError(`pitchLow must not exceed pitchHigh; received ${pitchLow} > ${pitchHigh}`);
   }
+  assertGenerationBudget(pitchHigh - pitchLow + 1, 'safe pitch candidates');
   for (let pitch = pitchHigh; pitch >= pitchLow; pitch -= 1) {
     const result = evaluateInternal({ ...q, candidatePitch: pitch }, false);
     if (result.safety === NoteSafety.Dissonant) {

package/src/theory/spelling/index.ts

@@ -143,6 +143,74 @@ export function spellPitchClasses(pcs: number[], tonic: Note, key: KeyScale): No
   return pcs.map((pc) => spellPitchClass(pc, tonic, key));
 }
 
+/**
+ * Diatonic letter distance implied by a chord interval.
+ *
+ * Chord intervals are not merely pitch-class distances: 6 is a diminished
+ * fifth in the basic chord templates while 18 is an augmented eleventh, and 9
+ * is a diminished seventh in `dim7` but a sixth elsewhere. Keeping that
+ * distinction is what prevents functional chord tones from being respelled by
+ * their nearest key pitch (for example G# becoming Ab in E7).
+ */
+function chordLetterOffset(interval: number, chord: Chord): number {
+  switch (interval) {
+    case 0:
+    case 12:
+      return 0;
+    case 1:
+    case 2:
+    case 13:
+    case 14:
+      return 1;
+    case 3:
+    case 4:
+    case 15:
+    case 16:
+      return 2;
+    case 5:
+    case 17:
+    case 18:
+      return 3;
+    case 6:
+    case 7:
+    case 8:
+    case 19:
+      return 4;
+    case 9:
+      return chord.quality === 'dim7' ? 6 : 5;
+    case 20:
+    case 21:
+      return 5;
+    case 10:
+    case 11:
+    case 22:
+    case 23:
+      return 6;
+    default: {
+      // Unknown/custom interval data gets the nearest conventional diatonic
+      // distance. Public builders use the explicit cases above.
+      const octaves = Math.floor(Math.max(0, interval) / 12);
+      const simple = mod12(interval);
+      const simpleOffset = [0, 1, 1, 2, 2, 3, 4, 4, 4, 5, 6, 6][simple] ?? 0;
+      return octaves * 7 + simpleOffset;
+    }
+  }
+}
+
+/**
+ * Spell chord tones from an already chosen root spelling.
+ *
+ * This is exported for the model layer's inversion support; the package
+ * barrels intentionally expose the key-aware {@link spellChord} entry point.
+ */
+export function spellChordFromRoot(chord: Chord, root: Note): Note[] {
+  return chord.intervals.map((interval) => {
+    const letter = mod7(root.letter + chordLetterOffset(interval, chord));
+    const pc = mod12(chord.rootPc + interval);
+    return { letter, alter: alterFor(letter, pc) };
+  });
+}
+
 /**
  * Spell a chord's tones, in the chord's own (tertian) order, relative to a key.
  *
@@ -165,9 +233,8 @@ export function spellPitchClasses(pcs: number[], tonic: Note, key: KeyScale): No
  * @category Pitch & Intervals
  */
 export function spellChord(chord: Chord, tonic: Note, key: KeyScale): Note[] {
-  return chord.intervals.map((interval) =>
-    spellPitchClass(mod12(chord.rootPc + interval), tonic, key),
-  );
+  const root = spellPitchClass(chord.rootPc, tonic, key);
+  return spellChordFromRoot(chord, root);
 }
 
 /**

package/src/theory/voicing/satb.ts

@@ -1,3 +1,8 @@
+import {
+  assertFiniteNumber,
+  assertGenerationBudget,
+  assertPositiveInt,
+} from '../../core/validation/index.js';
 import type { Chord } from '../chord/index.js';
 import {
   DEFAULT_MAX_SPACING,
@@ -70,12 +75,23 @@ export function resolveRanges(opts?: VoicingOptions): VoiceRange[] {
     if (opts.ranges.length === 0) {
       throw new Error('ranges must contain at least one voice range');
     }
-    return opts.ranges.map((range) => ({ ...range }));
+    assertGenerationBudget(opts.ranges.length, 'voice ranges', 128);
+    return opts.ranges.map((range, index) => {
+      assertFiniteNumber(range.min, `ranges[${index}].min`);
+      assertFiniteNumber(range.max, `ranges[${index}].max`);
+      if (range.min > range.max) {
+        throw new RangeError(`ranges[${index}].min must not exceed max`);
+      }
+      assertGenerationBudget(
+        Math.floor(range.max) - Math.ceil(range.min) + 1,
+        `ranges[${index}] span`,
+        4096,
+      );
+      return { ...range };
+    });
   }
   const voices = opts?.voices ?? 4;
-  if (voices < 1) {
-    throw new Error('voices must be at least 1');
-  }
+  assertPositiveInt(voices, 'voices', 128);
   if (voices === 4) {
     return SATB_RANGES.map((range) => ({ ...range }));
   }
@@ -115,6 +131,8 @@ export function resolveRanges(opts?: VoicingOptions): VoiceRange[] {
 export function voiceChord(chord: Chord, opts?: VoicingOptions): number[] {
   const ranges = resolveRanges(opts);
   const maxSpacing = opts?.maxSpacing ?? DEFAULT_MAX_SPACING;
+  assertFiniteNumber(maxSpacing, 'maxSpacing');
+  if (maxSpacing < 0) throw new RangeError('maxSpacing must be non-negative');
   const candidates = enumerateVoicings(chord, ranges, maxSpacing);
   let best: number[] | undefined;
   let bestScore = Number.POSITIVE_INFINITY;
@@ -162,8 +180,11 @@ export function voiceChord(chord: Chord, opts?: VoicingOptions): number[] {
  * @category Voicing & Counterpoint
  */
 export function voiceProgression(chords: Chord[], opts?: VoicingOptions): number[][] {
+  assertGenerationBudget(chords.length * 4000, 'voiced progression search');
   const ranges = resolveRanges(opts);
   const maxSpacing = opts?.maxSpacing ?? DEFAULT_MAX_SPACING;
+  assertFiniteNumber(maxSpacing, 'maxSpacing');
+  if (maxSpacing < 0) throw new RangeError('maxSpacing must be non-negative');
   const result: number[][] = [];
   let prev: number[] | undefined;
   for (const chord of chords) {

package/src/theory/voicing/styled.ts

@@ -1,3 +1,4 @@
+import { assertFiniteNumber, assertInteger } from '../../core/validation/index.js';
 import type { Chord } from '../chord/index.js';
 import { chordToneRole } from '../chord/index.js';
 import { pitchClass } from './internal.js';
@@ -105,7 +106,12 @@ function nearestPc(target: number, pcs: number[]): number {
  */
 export function voiceChordStyled(chord: Chord, opts?: StyledVoicingOptions): number[] {
   const style = opts?.style ?? 'close';
-  const base = 12 * ((opts?.octave ?? DEFAULT_STYLE_OCTAVE) + 1);
+  const octave = opts?.octave ?? DEFAULT_STYLE_OCTAVE;
+  assertInteger(octave, 'styled voicing octave', -10, 10);
+  if (opts?.topNote !== undefined) {
+    assertFiniteNumber(opts.topNote, 'styled voicing topNote');
+  }
+  const base = 12 * (octave + 1);
   const rootPc = pitchClass(chord.rootPc);
   const bassPc = pitchClass(chord.bassPc ?? chord.rootPc);
   const omitRoot = style === 'rootless' || opts?.rootless === true;
@@ -130,12 +136,12 @@ export function voiceChordStyled(chord: Chord, opts?: StyledVoicingOptions): num
         : 'fifth';
     order = order.filter((_pc, i) => {
       const role = roles[i];
-      return role === 'root' || role === 'third' || role === guide;
+      return _pc === bassPc || role === 'root' || role === 'third' || role === guide;
     });
   }
 
   if (omitRoot) {
-    order = order.filter((pc) => pc !== rootPc);
+    order = order.filter((pc) => pc !== rootPc || (chord.bassPc !== undefined && pc === bassPc));
   }
 
   if (order.length === 0) {
@@ -172,5 +178,22 @@ export function voiceChordStyled(chord: Chord, opts?: StyledVoicingOptions): num
     stack[stack.length - 3] = (stack[stack.length - 3] ?? 0) - 12;
   }
 
+  // An explicit slash bass is a structural requirement, including when it is
+  // not a chord member. Drop voicings and top-note rotation may have moved a
+  // different tone below it, so lower the retained bass by octaves before the
+  // final sort. This gives the bass priority over a conflicting top-note hint.
+  if (chord.bassPc !== undefined) {
+    const bassIndexInStack = stack.findIndex((pitch) => pitchClass(pitch) === bassPc);
+    if (bassIndexInStack >= 0) {
+      const otherLowest = Math.min(
+        ...stack.filter((_pitch, index) => index !== bassIndexInStack),
+        Number.POSITIVE_INFINITY,
+      );
+      while ((stack[bassIndexInStack] ?? 0) >= otherLowest) {
+        stack[bassIndexInStack] = (stack[bassIndexInStack] ?? 0) - 12;
+      }
+    }
+  }
+
   return stack.sort((a, b) => a - b);
 }

package/dist/chunk-5HTNMQW4.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/analyze/timeline/index.ts","../src/analyze/arrange/internal.ts","../src/analyze/arrange/tension.ts","../src/analyze/voice/index.ts","../src/analyze/arrange/tracks.ts"],"sourcesContent":["import type { TimeSignature } from '../../core/meter/index.js';\nimport { beatsPerBar, metricWeight, parseTimeSignature } from '../../core/meter/index.js';\nimport type { KeyScale, NoteEvent } from '../../core/types.js';\nimport type { Chord, ChordSpan } from '../../theory/chord/index.js';\nimport { chordPitchClasses, makeChord } from '../../theory/chord/index.js';\nimport { isScaleTone, majorKey } from '../../theory/scale/index.js';\nimport type { ChordMatch } from '../detect/index.js';\nimport { detectChord, detectChordBest, detectKey } from '../detect/index.js';\nimport type { Cadence } from '../functional/index.js';\nimport { detectCadence } from '../functional/index.js';\n\n/**\n * A chord occupying a half-open beat span.\n *\n * @category Arrangement & Analysis\n */\nexport type ChordSegment = {\n  startBeat: number;\n  endBeat: number;\n  chord: Chord;\n};\n\n/**\n * A beat-indexed sequence of chord segments.\n *\n * @category Arrangement & Analysis\n */\nexport type ChordTimeline = {\n  /** The chord sounding at a beat, or null when no segment covers it. */\n  at: (beat: number) => Chord | null;\n  segments: ChordSegment[];\n};\n\n/**\n * Build a chord timeline from placed chords.\n *\n * Each chord spans from its `startBeat` to the next chord's `startBeat`; the last\n * chord runs to `totalBeats`. Segments with no positive length (from duplicate\n * onsets or a last chord at or past `totalBeats`) are dropped. `at(beat)` returns\n * the covering segment's chord, or null when the beat lies outside every segment.\n *\n * @param chords Placed chords in time order.\n * @param totalBeats End of the timeline in beats.\n * @returns A queryable chord timeline.\n * @category Arrangement & Analysis\n */\nexport function chordTimelineFromChords(chords: ChordSpan[], totalBeats: number): ChordTimeline {\n  const sorted = [...chords].sort((a, b) => a.startBeat - b.startBeat);\n  const segments: ChordSegment[] = sorted\n    .map((gc, i) => {\n      const next = sorted[i + 1];\n      const endBeat = Math.max(gc.startBeat, next ? next.startBeat : totalBeats);\n      return {\n        startBeat: gc.startBeat,\n        endBeat,\n        chord: makeChord(gc.rootPc, gc.quality, gc.bassPc),\n      };\n    })\n    .filter((seg) => seg.endBeat > seg.startBeat);\n\n  return { at: segmentLookup(segments), segments };\n}\n\n/** Build the `at(beat)` lookup over a segment list. */\nfunction segmentLookup(segments: ChordSegment[]): (beat: number) => Chord | null {\n  return (beat) => {\n    for (const seg of segments) {\n      if (beat >= seg.startBeat && beat < seg.endBeat) {\n        return seg.chord;\n      }\n    }\n    return null;\n  };\n}\n\nconst EPS = 1e-9;\n\n/** Fraction of the strongest pitch-class weight below which a pc is noise. */\nconst NOISE_THRESHOLD_RATIO = 0.2;\n\n/** Maximum number of pitch classes fed to chord detection per window. */\nconst MAX_DETECTION_PCS = 6;\n\n/** Number of top-weighted pitch classes tried in the detection fallback. */\nconst FALLBACK_PCS = 3;\n\n/** Confidence multiplier applied when the chosen chord match is inexact. */\nconst INEXACT_CONFIDENCE_FACTOR = 0.85;\n\n/** Score bonus for a match whose tones are all in the key. */\nconst DIATONIC_BONUS = 0.5;\n\n/** Score bonus for an exact match (no extra and no missing tones). */\nconst EXACT_BONUS = 0.5;\n\n/** Score penalty per extra or missing tone in a match. */\nconst MISMATCH_PENALTY = 0.3;\n\n/** Reduce a value to a pitch class in [0, 11]. */\nfunction pitchClass(value: number): number {\n  return ((Math.trunc(value) % 12) + 12) % 12;\n}\n\n/**\n * Options controlling {@link chordTimelineFromNotes}.\n *\n * @category Arrangement & Analysis\n */\nexport type ChordTimelineOptions = {\n  /** Key context; inferred from the notes with {@link detectKey} when omitted. */\n  key?: KeyScale;\n  /**\n   * Time signature used for metric accents; defaults to 4/4.\n   *\n   * @defaultValue `4/4`\n   */\n  ts?: TimeSignature;\n  /**\n   * Window length in beats per chord slot; defaults to one bar of `ts`.\n   *\n   * @defaultValue one bar of `ts`\n   */\n  harmonicRhythm?: number;\n  /**\n   * End of the analyzed span in beats; defaults to the end of the last note.\n   *\n   * @defaultValue the end of the last note\n   */\n  totalBeats?: number;\n};\n\n/**\n * The result of {@link chordTimelineFromNotes}.\n *\n * @category Arrangement & Analysis\n */\nexport type ChordTimelineResult = {\n  /** The inferred timeline, with adjacent identical chords merged. */\n  timeline: ChordTimeline;\n  /** The key used for the analysis (given or inferred). */\n  key: KeyScale;\n  /** One confidence value in [0, 1] per segment, in segment order. */\n  segmentConfidence: number[];\n};\n\n/** A window's inferred chord and its confidence, or null for an empty window. */\ntype WindowChord = {\n  chord: Chord;\n  confidence: number;\n};\n\n/**\n * Score a chord match against a window's pitch-class weights: a heavily\n * weighted root, in-key tones, and exactness all raise the score; extra or\n * missing tones lower it.\n */\nfunction scoreMatch(\n  match: ChordMatch,\n  weights: number[],\n  maxWeight: number,\n  key: KeyScale,\n): number {\n  const rootWeight = maxWeight > 0 ? (weights[match.rootPc] ?? 0) / maxWeight : 0;\n  const tones = chordPitchClasses(makeChord(match.rootPc, match.quality));\n  let score = rootWeight;\n  if (tones.every((pc) => isScaleTone(pc, key))) {\n    score += DIATONIC_BONUS;\n  }\n  if (match.exact) {\n    score += EXACT_BONUS;\n  }\n  score -= MISMATCH_PENALTY * (match.extraPcs.length + match.missingPcs.length);\n  return score;\n}\n\n/** Confidence of a chord for a window: chord-tone weight over total weight. */\nfunction chordConfidence(\n  chord: Chord,\n  weights: number[],\n  totalWeight: number,\n  exact: boolean,\n): number {\n  const tones = new Set(chordPitchClasses(chord));\n  let chordWeight = 0;\n  for (let pc = 0; pc < 12; pc += 1) {\n    if (tones.has(pc)) {\n      chordWeight += weights[pc] ?? 0;\n    }\n  }\n  const raw = totalWeight > 0 ? chordWeight / totalWeight : 0;\n  const confidence = Math.min(1, Math.max(0, raw));\n  return exact ? confidence : confidence * INEXACT_CONFIDENCE_FACTOR;\n}\n\n/**\n * Infer the chord sounding in one window from the notes overlapping it.\n *\n * Builds a pitch-class weight histogram (overlap duration x velocity x\n * metric-accent bonus for onsets inside the window), keeps the significantly\n * weighted pitch classes, and picks the best {@link detectChord} match by\n * root weight, key membership, and exactness.\n */\nfunction analyzeWindow(\n  notes: NoteEvent[],\n  windowStart: number,\n  windowEnd: number,\n  ts: TimeSignature,\n  key: KeyScale,\n): WindowChord | null {\n  const weights = new Array<number>(12).fill(0);\n  let lowestPitch = Number.POSITIVE_INFINITY;\n  for (const note of notes) {\n    const noteEnd = note.startBeat + note.durationBeat;\n    const overlap = Math.min(noteEnd, windowEnd) - Math.max(note.startBeat, windowStart);\n    if (overlap <= EPS) {\n      continue;\n    }\n    const velocityFactor = note.velocity !== undefined ? note.velocity / 127 : 1;\n    const onsetInWindow = note.startBeat >= windowStart - EPS && note.startBeat < windowEnd - EPS;\n    const accent = onsetInWindow ? 1 + metricWeight(note.startBeat, ts) / 3 : 1;\n    const pc = pitchClass(note.pitch);\n    weights[pc] = (weights[pc] ?? 0) + overlap * velocityFactor * accent;\n    if (note.pitch < lowestPitch) {\n      lowestPitch = note.pitch;\n    }\n  }\n  let totalWeight = 0;\n  let maxWeight = 0;\n  for (const w of weights) {\n    totalWeight += w;\n    maxWeight = Math.max(maxWeight, w);\n  }\n  if (totalWeight <= EPS) {\n    return null;\n  }\n\n  // Keep pitch classes with meaningful weight, strongest first.\n  const ranked = weights\n    .map((weight, pc) => ({ pc, weight }))\n    .filter(({ weight }) => weight > 0)\n    .sort((a, b) => b.weight - a.weight || a.pc - b.pc);\n  const selected = ranked\n    .filter(({ weight }) => weight >= maxWeight * NOISE_THRESHOLD_RATIO)\n    .slice(0, MAX_DETECTION_PCS)\n    .map(({ pc }) => pc);\n\n  // Feed detection with the window's true bass as the lowest pitch so inversion\n  // detection works; when the bass pc was filtered out as noise, anchor on the\n  // heaviest pc instead so no spurious inversion is reported.\n  const bassPc = pitchClass(lowestPitch);\n  const anchorPc = selected.includes(bassPc) ? bassPc : (selected[0] ?? bassPc);\n  const detectionPitches = selected.map((pc) => (pc === anchorPc ? pc : pc + 12));\n\n  const matches = detectChord(detectionPitches);\n  let bestMatch: ChordMatch | null = null;\n  let bestScore = Number.NEGATIVE_INFINITY;\n  for (const match of matches) {\n    const score = scoreMatch(match, weights, maxWeight, key);\n    if (score > bestScore) {\n      bestScore = score;\n      bestMatch = match;\n    }\n  }\n  if (bestMatch) {\n    const chord = makeChord(bestMatch.rootPc, bestMatch.quality, bestMatch.bassPc);\n    return { chord, confidence: chordConfidence(chord, weights, totalWeight, bestMatch.exact) };\n  }\n\n  // Fallback: retry on only the top-weighted pitch classes.\n  const fallback = detectChordBest(selected.slice(0, FALLBACK_PCS));\n  if (fallback) {\n    return { chord: fallback, confidence: chordConfidence(fallback, weights, totalWeight, false) };\n  }\n  return null;\n}\n\n/** Whether two chords are the same root, quality, and bass. */\nfunction sameChord(a: Chord, b: Chord): boolean {\n  return a.rootPc === b.rootPc && a.quality === b.quality && a.bassPc === b.bassPc;\n}\n\n/**\n * Infer a chord timeline from raw multi-track notes.\n *\n * The span `[0, totalBeats)` is sliced into `harmonicRhythm`-beat windows; each\n * window's chord is inferred from a pitch-class weight histogram of the notes\n * overlapping it (weight = overlap duration x velocity x metric-accent bonus\n * for onsets in the window). Adjacent windows carrying the identical chord are\n * merged into one segment; windows with no notes produce no segment, so\n * `at(beat)` returns null there. Each segment carries a confidence in [0, 1]:\n * the fraction of the window weight explained by chord tones, reduced when the\n * match is inexact, and duration-weighted across merged windows.\n *\n * Notes with a zero or negative duration never sound, so they are dropped at\n * ingest: they contribute to neither the key inference, the span, nor any\n * window's histogram.\n *\n * @param notes The notes to analyze (any number of tracks, flattened).\n * @param opts Analysis options; see {@link ChordTimelineOptions}.\n * @returns The inferred timeline, the key used, and per-segment confidences.\n * @throws If `harmonicRhythm` is not positive.\n * @example\n * ```ts\n * import { chordTimelineFromNotes } from '@libraz/libcantus';\n * const notes = [\n *   { pitch: 60, startBeat: 0, durationBeat: 2 }, // C\n *   { pitch: 64, startBeat: 0, durationBeat: 2 }, // E\n *   { pitch: 67, startBeat: 0, durationBeat: 2 }, // G\n * ];\n * const { timeline, key } = chordTimelineFromNotes(notes);\n * timeline.at(0); // the chord inferred over beat 0, or null\n * ```\n * @category Arrangement & Analysis\n */\nexport function chordTimelineFromNotes(\n  notes: NoteEvent[],\n  opts: ChordTimelineOptions = {},\n): ChordTimelineResult {\n  const ts = opts.ts ?? parseTimeSignature('4/4');\n  const harmonicRhythm = opts.harmonicRhythm ?? beatsPerBar(ts);\n  if (!(harmonicRhythm > 0)) {\n    throw new Error(`Invalid harmonic rhythm: ${harmonicRhythm}`);\n  }\n  // Zero/negative-length notes never sound; drop them before any inference.\n  const sounding = notes.filter((note) => note.durationBeat > 0);\n  const lastNoteEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);\n  const totalBeats = opts.totalBeats ?? lastNoteEnd;\n  const key = opts.key ?? detectKey(sounding.map((n) => n.pitch))[0]?.key ?? majorKey(0);\n\n  const segments: ChordSegment[] = [];\n  const segmentConfidence: number[] = [];\n  const windowCount = Math.max(0, Math.ceil(totalBeats / harmonicRhythm - EPS));\n  for (let i = 0; i < windowCount; i += 1) {\n    const start = i * harmonicRhythm;\n    const end = Math.min(start + harmonicRhythm, totalBeats);\n    const inferred = analyzeWindow(sounding, start, end, ts, key);\n    if (!inferred) {\n      continue;\n    }\n    const last = segments[segments.length - 1];\n    if (last && sameChord(last.chord, inferred.chord) && Math.abs(last.endBeat - start) < EPS) {\n      // Merge into the previous segment, blending confidence by duration.\n      const lastLength = last.endBeat - last.startBeat;\n      const length = end - start;\n      const lastConfidence = segmentConfidence[segmentConfidence.length - 1] ?? 0;\n      segmentConfidence[segmentConfidence.length - 1] =\n        (lastConfidence * lastLength + inferred.confidence * length) / (lastLength + length);\n      last.endBeat = end;\n    } else {\n      segments.push({ startBeat: start, endBeat: end, chord: inferred.chord });\n      segmentConfidence.push(inferred.confidence);\n    }\n  }\n\n  return {\n    timeline: { at: segmentLookup(segments), segments },\n    key,\n    segmentConfidence,\n  };\n}\n\n/**\n * A cadence found between two consecutive timeline segments.\n *\n * @category Arrangement & Analysis\n */\nexport type CadenceHit = {\n  /** The beat where the cadence arrives (the second chord's onset). */\n  atBeat: number;\n  type: Exclude<Cadence, null>;\n  from: Chord;\n  to: Chord;\n};\n\n/**\n * Find cadences between consecutive segments of a chord timeline.\n *\n * Each temporally adjacent segment pair is classified with\n * {@link detectCadence}; pairs forming no cadence are skipped. Segments\n * separated by a gap (a rest in the timeline) are not a chord-to-chord\n * progression, so they are never paired.\n *\n * @param timeline The chord timeline to scan.\n * @param key The prevailing key.\n * @returns The cadences found, in time order.\n * @example\n * ```ts\n * import { chordTimelineFromNotes, detectCadences } from '@libraz/libcantus';\n * const notes = [\n *   { pitch: 67, startBeat: 0, durationBeat: 4 }, // G, a dominant\n *   { pitch: 60, startBeat: 4, durationBeat: 4 }, // C, the tonic\n * ];\n * const { timeline, key } = chordTimelineFromNotes(notes);\n * const cadences = detectCadences(timeline, key);\n * ```\n * @category Arrangement & Analysis\n */\nexport function detectCadences(timeline: ChordTimeline, key: KeyScale): CadenceHit[] {\n  const hits: CadenceHit[] = [];\n  for (let i = 1; i < timeline.segments.length; i += 1) {\n    const prev = timeline.segments[i - 1];\n    const cur = timeline.segments[i];\n    if (!prev || !cur) {\n      continue;\n    }\n    if (Math.abs(cur.startBeat - prev.endBeat) > EPS) {\n      continue; // A rest separates the chords; no cadential motion across it.\n    }\n    const type = detectCadence(prev.chord, cur.chord, key);\n    if (type !== null) {\n      hits.push({ atBeat: cur.startBeat, type, from: prev.chord, to: cur.chord });\n    }\n  }\n  return hits;\n}\n","/**\n * Shared helpers for the arrangement-analysis modules: pooling every track's\n * sounding notes and partitioning a track into monophonic sub-voices, plus the\n * small geometric primitives both the track-role and tension passes rely on.\n */\n\nimport type { NoteEvent } from '../../core/types.js';\nimport type { VoiceNote } from '../voice/index.js';\nimport type { ArrangementTrack, TrackRole } from './tracks.js';\n\n/** Float tolerance for beat boundary comparisons. */\nexport const EPS = 1e-9;\n\n/** A note with the pitch that immediately preceded it in the same sub-voice. */\nexport type PreparedNote = {\n  pitch: number;\n  prevPitch?: number;\n  startBeat: number;\n  endBeat: number;\n};\n\n/** One monophonic sub-voice of a track: ordered notes plus sounding spans. */\nexport type PreparedVoice = {\n  /** The sub-voice's notes in time order, each with a stable id. */\n  voice: VoiceNote[];\n  /** The same notes as sounding spans, each carrying its predecessor's pitch. */\n  sounding: PreparedNote[];\n};\n\n/** A track prepared for analysis: resolved metadata plus monophonic sub-voices. */\nexport type PreparedTrack = {\n  name: string;\n  role: TrackRole;\n  /**\n   * The track's notes partitioned into monophonic sub-voices. Voice analysis\n   * assumes one note at a time, so a polyphonic track (e.g. a 'harmony' track\n   * playing block chords) is split here; a monophonic track yields exactly one\n   * sub-voice.\n   */\n  voices: PreparedVoice[];\n};\n\n/** Whether a sounding span `[start, end)` covers a beat. */\nexport function covers(note: PreparedNote, beat: number): boolean {\n  return beat >= note.startBeat - EPS && beat < note.endBeat - EPS;\n}\n\n/**\n * Every sounding note of every track pooled into one flat list. Zero- and\n * negative-length notes never sound, so they are dropped here (matching the\n * chord-inference ingest in the timeline module).\n */\nexport function poolNotes(tracks: ArrangementTrack[]): NoteEvent[] {\n  const notes: NoteEvent[] = [];\n  for (const track of tracks) {\n    for (const note of track.notes) {\n      if (note.durationBeat > 0) {\n        notes.push(note);\n      }\n    }\n  }\n  return notes;\n}\n\n/**\n * Split a track's ordered notes into monophonic sub-voices.\n *\n * Greedy lane assignment: each note joins the first sub-voice that is free at\n * its onset (its last note has ended), otherwise it opens a new sub-voice. A\n * monophonic track therefore stays a single sub-voice, while block chords fan\n * out into one sub-voice per simultaneous note, keeping every sub-voice's\n * note-to-note adjacency genuinely melodic.\n */\nfunction splitIntoSubVoices(ordered: VoiceNote[]): VoiceNote[][] {\n  const lanes: VoiceNote[][] = [];\n  for (const note of ordered) {\n    const lane = lanes.find((candidate) => {\n      const last = candidate[candidate.length - 1];\n      return last !== undefined && last.startBeat + last.durationBeat <= note.startBeat + EPS;\n    });\n    if (lane) {\n      lane.push(note);\n    } else {\n      lanes.push([note]);\n    }\n  }\n  return lanes;\n}\n\n/**\n * Resolve each track's metadata and derive its monophonic sub-voices.\n *\n * Notes are sorted by onset, then pitch, so ordering is deterministic, and ids\n * are assigned in that order. Zero- and negative-length notes never sound and\n * are dropped at ingest. Each track is then partitioned into monophonic\n * sub-voices (see {@link splitIntoSubVoices}); the predecessor pitch used for\n * suspension and parallel detection is the previous note of the same sub-voice,\n * never a simultaneous chord member.\n */\nexport function prepareTracks(tracks: ArrangementTrack[]): PreparedTrack[] {\n  let nextId = 0;\n  return tracks.map((track, index) => {\n    const ordered: VoiceNote[] = track.notes\n      .filter((note) => note.durationBeat > 0)\n      .sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch)\n      .map((note) => ({ ...note, id: nextId++ }));\n    const voices: PreparedVoice[] = splitIntoSubVoices(ordered).map((voice) => ({\n      voice,\n      sounding: voice.map((note, i) => {\n        const prev = i > 0 ? voice[i - 1] : undefined;\n        return {\n          pitch: note.pitch,\n          prevPitch: prev?.pitch,\n          startBeat: note.startBeat,\n          endBeat: note.startBeat + note.durationBeat,\n        };\n      }),\n    }));\n    return {\n      name: track.name ?? `track ${index + 1}`,\n      role: track.role ?? 'other',\n      voices,\n    };\n  });\n}\n","/**\n * Arrangement tension analysis: a coarse harmonic-tension curve sampled at\n * regular beats across a whole multi-track piece, combining the sounding\n * chord's harmonic function, the dissonance of the sounding notes, and their\n * registral span into a single normalized reading.\n */\n\nimport { isStrongBeat, parseTimeSignature, type TimeSignature } from '../../core/meter/index.js';\nimport type { KeyScale } from '../../core/types.js';\nimport { chordPitchClasses } from '../../theory/chord/index.js';\nimport { evaluateSafety, NoteSafety, type SafetyProfile } from '../../theory/safety/index.js';\nimport { functionOf } from '../functional/index.js';\nimport { type ChordTimeline, chordTimelineFromNotes } from '../timeline/index.js';\nimport { covers, EPS, type PreparedTrack, poolNotes, prepareTracks } from './internal.js';\nimport type { ArrangementOptions, ArrangementTrack } from './tracks.js';\n\n/**\n * A tension reading sampled at a beat.\n *\n * @category Arrangement & Analysis\n */\nexport type TensionPoint = {\n  beat: number;\n  /** Combined tension in [0, 1]. */\n  tension: number;\n};\n\n/** Tension contributed by the sounding chord's harmonic function. */\nconst FUNCTION_TENSION: Record<'tonic' | 'subdominant' | 'dominant', number> = {\n  tonic: 0,\n  subdominant: 0.5,\n  dominant: 1,\n};\n\n/** Weight of the harmonic-function term in the combined tension score. */\nconst FUNCTION_WEIGHT = 0.5;\n/** Weight of the non-chord-tone / dissonance term. */\nconst DISSONANCE_WEIGHT = 0.35;\n/** Weight of the registral-span term. */\nconst SPAN_WEIGHT = 0.15;\n/** Pitch span, in semitones, that saturates the span term. */\nconst SPAN_SATURATION = 24;\n\n/** Reduce a pitch to a pitch class in [0, 11]. */\nfunction pitchClass(pitch: number): number {\n  return ((Math.trunc(pitch) % 12) + 12) % 12;\n}\n\n/** Clamp a value into [0, 1]. */\nfunction clamp01(value: number): number {\n  return Math.min(1, Math.max(0, value));\n}\n\n/**\n * Sample the harmonic tension of an arrangement at regular beats.\n *\n * At each sample beat the tension combines three normalized terms:\n *  - the sounding chord's harmonic function (dominant `1`, subdominant `0.5`,\n *    tonic or no chord `0`), weighted {@link FUNCTION_WEIGHT};\n *  - the dissonance of the sounding notes — the larger of the share of sounding\n *    pitches that are not chord tones and the share that {@link evaluateSafety}\n *    rates {@link NoteSafety.Dissonant} — weighted {@link DISSONANCE_WEIGHT};\n *  - the registral span of the sounding notes, saturating at\n *    {@link SPAN_SATURATION} semitones, weighted {@link SPAN_WEIGHT}.\n *\n * The weighted sum is clamped to [0, 1]. The harmony is inferred from all tracks\n * pooled together, so the result is deterministic and self-contained.\n *\n * @param tracks The tracks to sample.\n * @param opts Analysis options plus an optional `step` (default one beat).\n * @returns One {@link TensionPoint} per sampled beat, in beat order.\n * @throws If `step` is not positive.\n * @example\n * ```ts\n * import { tensionCurve } from '@libraz/libcantus';\n * const notes = [{ pitch: 60, startBeat: 0, durationBeat: 4 }];\n * const curve = tensionCurve([{ notes }], { step: 1 });\n * curve; // one { beat, tension } sample per beat, in beat order\n * ```\n * @category Arrangement & Analysis\n */\nexport function tensionCurve(\n  tracks: ArrangementTrack[],\n  opts: ArrangementOptions & { step?: number } = {},\n): TensionPoint[] {\n  const ts = opts.ts ?? parseTimeSignature('4/4');\n  const profile: SafetyProfile = opts.profile ?? 'pop';\n  const step = opts.step ?? 1;\n  if (!(step > 0)) {\n    throw new Error(`Invalid tension sampling step: ${step}`);\n  }\n\n  const pooled = poolNotes(tracks);\n  const totalBeats = pooled.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);\n  const { timeline, key } = chordTimelineFromNotes(pooled, {\n    key: opts.key,\n    ts,\n    harmonicRhythm: opts.harmonicRhythm,\n  });\n\n  const prepared = prepareTracks(tracks);\n  const points: TensionPoint[] = [];\n  const sampleCount = Math.max(0, Math.ceil(totalBeats / step - EPS));\n  for (let i = 0; i < sampleCount; i += 1) {\n    const beat = i * step;\n    points.push({ beat, tension: sampleTension(prepared, timeline, key, ts, profile, beat) });\n  }\n  return points;\n}\n\n/** All sounding notes across every track at a beat, tagged with their track. */\nfunction allSounding(prepared: PreparedTrack[], beat: number): { pitch: number; track: number }[] {\n  const out: { pitch: number; track: number }[] = [];\n  for (let t = 0; t < prepared.length; t += 1) {\n    const track = prepared[t];\n    if (!track) {\n      continue;\n    }\n    for (const subVoice of track.voices) {\n      for (const note of subVoice.sounding) {\n        if (covers(note, beat)) {\n          out.push({ pitch: note.pitch, track: t });\n        }\n      }\n    }\n  }\n  return out;\n}\n\n/** Combine the harmonic, dissonance, and span terms at one sample beat. */\nfunction sampleTension(\n  prepared: PreparedTrack[],\n  timeline: ChordTimeline,\n  key: KeyScale,\n  ts: TimeSignature,\n  profile: SafetyProfile,\n  beat: number,\n): number {\n  const sounding = allSounding(prepared, beat);\n  if (sounding.length === 0) {\n    return 0;\n  }\n  const chord = timeline.at(beat);\n  const functionScore = chord ? FUNCTION_TENSION[functionOf(chord, key)] : 0;\n\n  const chordPcs = chord ? new Set(chordPitchClasses(chord)) : null;\n  const strongBeat = isStrongBeat(beat, ts);\n  let nonChord = 0;\n  let dissonant = 0;\n  for (let i = 0; i < sounding.length; i += 1) {\n    const voice = sounding[i];\n    if (!voice) {\n      continue;\n    }\n    // Non-chord-tone share only applies when a chord is sounding; at a timeline\n    // gap there is no reference harmony, so vertical dissonance alone drives the\n    // dissonance term (the chord function term is already 0 there).\n    if (chordPcs && !chordPcs.has(pitchClass(voice.pitch))) {\n      nonChord += 1;\n    }\n    const others = sounding.filter((_, j) => j !== i).map((s) => ({ pitch: s.pitch }));\n    const result = evaluateSafety({\n      profile,\n      candidatePitch: voice.pitch,\n      chord,\n      key,\n      otherVoices: others,\n      strongBeat,\n    });\n    if (result.safety === NoteSafety.Dissonant) {\n      dissonant += 1;\n    }\n  }\n  const dissonanceScore = Math.max(nonChord, dissonant) / sounding.length;\n\n  let low = Number.POSITIVE_INFINITY;\n  let high = Number.NEGATIVE_INFINITY;\n  for (const voice of sounding) {\n    low = Math.min(low, voice.pitch);\n    high = Math.max(high, voice.pitch);\n  }\n  const spanScore = Math.min(1, (high - low) / SPAN_SATURATION);\n\n  return clamp01(\n    FUNCTION_WEIGHT * functionScore + DISSONANCE_WEIGHT * dissonanceScore + SPAN_WEIGHT * spanScore,\n  );\n}\n","import type { KeyScale, NoteEvent } from '../../core/types.js';\nimport type { Chord } from '../../theory/chord/index.js';\nimport { chordPitchClasses, chordToneRole } from '../../theory/chord/index.js';\nimport {\n  createsVerticalDissonance,\n  isLeadingToneResolution,\n} from '../../theory/counterpoint/index.js';\nimport type { VoiceSnapshot } from '../../theory/safety/index.js';\n\n/**\n * A theory annotation attached to a note.\n *\n * @category Arrangement & Analysis\n */\nexport type TheoryLabel =\n  | { kind: 'chordTone'; role: 'root' | 'third' | 'fifth' | 'sixth' | 'seventh' }\n  | { kind: 'tension'; degree: 9 | 11 | 13 }\n  | { kind: 'avoid' }\n  | { kind: 'passing' }\n  | { kind: 'neighbor' }\n  | { kind: 'suspension'; type: 'sus4-3' | 'sus7-6' | 'sus9-8' | 'sus2-3'; resolveTo: number }\n  | { kind: 'anticipation' }\n  | { kind: 'escape' }\n  | { kind: 'needsResolution'; resolveTo: number }\n  | { kind: 'leadingTone'; resolveTo: number };\n\n/**\n * A note with its theory labels and a short rationale.\n *\n * @category Arrangement & Analysis\n */\nexport type AnalyzedNote = {\n  noteId: number;\n  labels: TheoryLabel[];\n  rationale?: string;\n};\n\n/**\n * A single note in a monophonic voice: a {@link NoteEvent} with a stable id.\n *\n * @category Arrangement & Analysis\n */\nexport type VoiceNote = NoteEvent & { id: number };\n\n/** Float tolerance for beat comparisons. */\nconst EPS = 1e-9;\n\nfunction pitchClass(pitch: number): number {\n  return ((Math.trunc(pitch) % 12) + 12) % 12;\n}\n\nfunction intervalAboveRoot(pitch: number, chord: Chord): number {\n  return (((pitchClass(pitch) - pitchClass(chord.rootPc)) % 12) + 12) % 12;\n}\n\n/**\n * Interval class of a pitch above the actual sounding bass.\n *\n * Suspension figures (4-3, 7-6, 9-8) are named for the interval above the bass,\n * not the chord root, so this prefers the lowest pitch among the other sounding\n * voices when one lies below the note. Without a lower sounding voice it falls\n * back to the chord's bass pitch class (or root in root position).\n */\nfunction intervalAboveBass(pitch: number, others: VoiceSnapshot[], chord: Chord): number {\n  let bass = Number.POSITIVE_INFINITY;\n  for (const ov of others) {\n    bass = Math.min(bass, ov.pitch);\n  }\n  if (Number.isFinite(bass) && bass < pitch) {\n    return (((pitch - bass) % 12) + 12) % 12;\n  }\n  const ref = chord.bassPc ?? chord.rootPc;\n  return (((pitchClass(pitch) - pitchClass(ref)) % 12) + 12) % 12;\n}\n\n/**\n * Map an interval class above the root to its extended-tension scale degree:\n * a flat/natural ninth (1 or 2) to 9, an eleventh (5 or 6) to 11, and a\n * thirteenth (8 or 9) to 13.\n */\nfunction tensionDegree(ic: number): 9 | 11 | 13 {\n  if (ic === 1 || ic === 2) {\n    return 9;\n  }\n  if (ic === 5 || ic === 6) {\n    return 11;\n  }\n  return 13;\n}\n\nfunction isChordMember(pitch: number, chord: Chord | null): boolean {\n  return chord ? chordPitchClasses(chord).includes(pitchClass(pitch)) : false;\n}\n\nfunction isStep(a: number, b: number): boolean {\n  const d = Math.abs(a - b);\n  return d === 1 || d === 2;\n}\n\n/**\n * Classify a suspension figure from the interval class above the sounding bass\n * (`ic`) and the resolution direction (`delta`, positive when resolving upward).\n */\nfunction suspensionType(ic: number, delta: number): TheoryLabel & { kind: 'suspension' } {\n  let type: 'sus4-3' | 'sus7-6' | 'sus9-8' | 'sus2-3';\n  if (delta > 0) {\n    type = 'sus2-3';\n  } else if (ic === 2) {\n    type = 'sus9-8';\n  } else if (ic === 10 || ic === 11) {\n    type = 'sus7-6';\n  } else {\n    type = 'sus4-3';\n  }\n  return { kind: 'suspension', type, resolveTo: 0 };\n}\n\nfunction stepResolution(pitch: number, chord: Chord): number | undefined {\n  for (let delta = 1; delta <= 2; delta += 1) {\n    if (isChordMember(pitch - delta, chord)) {\n      return pitch - delta;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Label every note of a voice with its theory roles.\n *\n * Each note is classified against the chord sounding at its beat. Chord tones\n * get a role label; non-chord tones are matched, in order, as suspensions\n * (prepared by an identical consonant pitch and resolving by step), passing\n * tones, neighbors, anticipations, and escape tones, then fall back to tension,\n * avoid, or an unresolved-dissonance label. Leading-tone resolutions are noted\n * additionally.\n *\n * The voice is expected to be monophonic (one note at a time). Notes sharing an\n * onset are treated as simultaneous cluster members, not melodic neighbors, so\n * they receive no melodic labels (suspension, passing, neighbor, anticipation,\n * escape) — only harmonic ones. Callers with truly polyphonic material should\n * split it into monophonic sub-voices first, as `analyzeArrangement` does.\n *\n * @param voice The monophonic voice, in time order.\n * @param chordAtBeat Chord sounding at a given beat, or null.\n * @param key Key context for leading-tone detection.\n * @param otherVoicesAtBeat Other sounding voices at a given beat.\n * @returns One annotation per input note.\n * @example\n * ```ts\n * import { analyzeVoice, makeChord, majorKey } from '@libraz/libcantus';\n * const voice = [\n *   { id: 0, pitch: 60, startBeat: 0, durationBeat: 1 },\n *   { id: 1, pitch: 62, startBeat: 1, durationBeat: 1 },\n *   { id: 2, pitch: 64, startBeat: 2, durationBeat: 1 },\n * ];\n * const cMajor = makeChord(0, 'maj');\n * const labels = analyzeVoice(voice, () => cMajor, majorKey(0), () => []);\n * labels; // one AnalyzedNote per input note, in the same order\n * ```\n * @category Arrangement & Analysis\n */\nexport function analyzeVoice(\n  voice: VoiceNote[],\n  chordAtBeat: (beat: number) => Chord | null,\n  key: KeyScale,\n  otherVoicesAtBeat: (beat: number) => VoiceSnapshot[],\n): AnalyzedNote[] {\n  const result: AnalyzedNote[] = [];\n\n  for (let i = 0; i < voice.length; i += 1) {\n    const note = voice[i];\n    if (!note) {\n      continue;\n    }\n    const prevNote = i > 0 ? voice[i - 1] : undefined;\n    const nextNote = i + 1 < voice.length ? voice[i + 1] : undefined;\n    // A neighboring note sharing this note's onset is a simultaneous cluster\n    // member, not a melodic predecessor/successor; treating it as one would\n    // fabricate passing/suspension figures, so it is dropped here.\n    const prev =\n      prevNote !== undefined && prevNote.startBeat < note.startBeat - EPS ? prevNote : undefined;\n    const next =\n      nextNote !== undefined && nextNote.startBeat > note.startBeat + EPS ? nextNote : undefined;\n    const chord = chordAtBeat(note.startBeat);\n    const labels: TheoryLabel[] = [];\n    const member = isChordMember(note.pitch, chord);\n    let handled = false;\n\n    if (chord && member) {\n      const role = chordToneRole(note.pitch, chord);\n      if (role) {\n        labels.push({ kind: 'chordTone', role });\n      } else {\n        const ic = intervalAboveRoot(note.pitch, chord);\n        labels.push({ kind: 'tension', degree: tensionDegree(ic) });\n      }\n      handled = true;\n    }\n\n    if (!handled && chord && prev && next) {\n      const prevChord = chordAtBeat(prev.startBeat);\n      const prepared = prev.pitch === note.pitch && isChordMember(prev.pitch, prevChord);\n      const resolves = isStep(next.pitch, note.pitch);\n      const others = otherVoicesAtBeat(note.startBeat);\n      const verticallyDissonant = others.some((ov) =>\n        createsVerticalDissonance(note.pitch, ov.pitch, true),\n      );\n      if (prepared && verticallyDissonant && resolves) {\n        const ic = intervalAboveBass(note.pitch, others, chord);\n        const sus = suspensionType(ic, next.pitch - note.pitch);\n        sus.resolveTo = next.pitch;\n        labels.push(sus);\n        handled = true;\n      }\n    }\n\n    if (!handled && chord && prev && next) {\n      const prevMember = isChordMember(prev.pitch, chordAtBeat(prev.startBeat));\n      const nextMember = isChordMember(next.pitch, chordAtBeat(next.startBeat));\n      const up = note.pitch - prev.pitch > 0;\n      const contInto = next.pitch - note.pitch > 0;\n      const sameDir = note.pitch !== prev.pitch && next.pitch !== note.pitch && up === contInto;\n      if (\n        prevMember &&\n        nextMember &&\n        !member &&\n        isStep(note.pitch, prev.pitch) &&\n        isStep(next.pitch, note.pitch) &&\n        sameDir\n      ) {\n        labels.push({ kind: 'passing' });\n        handled = true;\n      }\n    }\n\n    if (\n      !handled &&\n      chord &&\n      prev &&\n      next &&\n      !member &&\n      prev.pitch === next.pitch &&\n      isChordMember(prev.pitch, chordAtBeat(prev.startBeat)) &&\n      isStep(note.pitch, prev.pitch)\n    ) {\n      labels.push({ kind: 'neighbor' });\n      handled = true;\n    }\n\n    if (!handled && chord && next && !member && note.pitch === next.pitch) {\n      const nextChord = chordAtBeat(next.startBeat);\n      if (isChordMember(next.pitch, nextChord)) {\n        labels.push({ kind: 'anticipation' });\n        handled = true;\n      }\n    }\n\n    if (!handled && chord && prev && next && !member) {\n      const prevMember = isChordMember(prev.pitch, chordAtBeat(prev.startBeat));\n      const nextMember = isChordMember(next.pitch, chordAtBeat(next.startBeat));\n      const stepFromPrev = isStep(note.pitch, prev.pitch);\n      const leapToNext = Math.abs(next.pitch - note.pitch) >= 3;\n      const opposite = note.pitch - prev.pitch > 0 !== next.pitch - note.pitch > 0;\n      if (prevMember && nextMember && stepFromPrev && leapToNext && opposite) {\n        labels.push({ kind: 'escape' });\n        handled = true;\n      }\n    }\n\n    if (!handled && chord && !member) {\n      const ic = intervalAboveRoot(note.pitch, chord);\n      const isTension = ic === 2 || ic === 5 || ic === 9;\n      const avoid =\n        (ic === 5 && chord.intervals.includes(4) && !chord.intervals.includes(5)) ||\n        (ic === 11 && chord.intervals.includes(4) && chord.intervals.includes(10));\n      if (avoid) {\n        labels.push({ kind: 'avoid' });\n        const resolveTo = stepResolution(note.pitch, chord);\n        if (resolveTo !== undefined) {\n          labels.push({ kind: 'needsResolution', resolveTo });\n        }\n      } else if (isTension) {\n        labels.push({ kind: 'tension', degree: tensionDegree(ic) });\n      } else {\n        const resolveTo = stepResolution(note.pitch, chord);\n        if (resolveTo !== undefined) {\n          labels.push({ kind: 'needsResolution', resolveTo });\n        }\n      }\n    }\n\n    if (next && isLeadingToneResolution(note.pitch, next.pitch, key)) {\n      labels.push({ kind: 'leadingTone', resolveTo: next.pitch });\n    }\n\n    result.push({ noteId: note.id, labels, rationale: describe(labels) });\n  }\n\n  return result;\n}\n\n/** Build a short rationale from a note's primary label. */\nfunction describe(labels: TheoryLabel[]): string {\n  const primary = labels[0];\n  if (!primary) {\n    return 'Unclassified note';\n  }\n  switch (primary.kind) {\n    case 'chordTone':\n      return `Chord ${primary.role}`;\n    case 'tension':\n      return `${primary.degree}th tension`;\n    case 'avoid':\n      return 'Avoid note';\n    case 'passing':\n      return 'Passing tone between chord tones';\n    case 'neighbor':\n      return 'Neighbor tone';\n    case 'suspension':\n      return `Suspension (${primary.type})`;\n    case 'anticipation':\n      return 'Anticipation of the next chord';\n    case 'escape':\n      return 'Escape tone';\n    case 'needsResolution':\n      return 'Unresolved dissonance';\n    case 'leadingTone':\n      return 'Leading tone resolving to the tonic';\n  }\n}\n","/**\n * Arrangement track-role analysis: a single harmony is inferred from every\n * track's notes pooled together, each track is then analysed against that shared\n * harmony, and notes that clash with the sounding chord are collected as\n * conflicts.\n */\n\nimport { isStrongBeat, parseTimeSignature, type TimeSignature } from '../../core/meter/index.js';\nimport type { KeyScale, NoteEvent } from '../../core/types.js';\nimport {\n  evaluateSafety,\n  NoteSafety,\n  type SafetyProfile,\n  type VoiceSnapshot,\n} from '../../theory/safety/index.js';\nimport {\n  type CadenceHit,\n  type ChordTimeline,\n  chordTimelineFromNotes,\n  detectCadences,\n} from '../timeline/index.js';\nimport { type AnalyzedNote, analyzeVoice, type VoiceNote } from '../voice/index.js';\nimport { covers, EPS, type PreparedTrack, poolNotes, prepareTracks } from './internal.js';\n\n/**\n * The musical role a track plays in the arrangement.\n *\n * @category Arrangement & Analysis\n */\nexport type TrackRole = 'melody' | 'harmony' | 'bass' | 'other';\n\n/**\n * One input track: its notes plus optional name and role.\n *\n * @category Arrangement & Analysis\n */\nexport type ArrangementTrack = {\n  name?: string;\n  role?: TrackRole;\n  notes: NoteEvent[];\n};\n\n/**\n * A track after analysis: its resolved name, role, and per-note annotations.\n *\n * @category Arrangement & Analysis\n */\nexport type TrackAnalysis = {\n  name: string;\n  role: TrackRole;\n  /** One {@link AnalyzedNote} per note, labelled against the inferred chords. */\n  notes: AnalyzedNote[];\n};\n\n/**\n * A note that clashes with the harmony sounding beneath it.\n *\n * @category Arrangement & Analysis\n */\nexport type Conflict = {\n  beat: number;\n  trackName: string;\n  pitch: number;\n  /** The clash severity: {@link NoteSafety.Warning} or {@link NoteSafety.Dissonant}. */\n  safety: NoteSafety;\n  /** {@link import('../safety/index.js').SafetyResult.reasons} bitmask. */\n  reasons: number;\n  rationale?: string;\n};\n\n/**\n * The full result of {@link analyzeArrangement}.\n *\n * @category Arrangement & Analysis\n */\nexport type ArrangementAnalysis = {\n  key: KeyScale;\n  timeline: ChordTimeline;\n  segmentConfidence: number[];\n  cadences: CadenceHit[];\n  tracks: TrackAnalysis[];\n  /** Notes clashing with the sounding harmony, worst severity first. */\n  conflicts: Conflict[];\n};\n\n/**\n * Options controlling {@link analyzeArrangement} and {@link tensionCurve}.\n *\n * @category Arrangement & Analysis\n */\nexport type ArrangementOptions = {\n  /** Key context; inferred from the pooled notes when omitted. */\n  key?: KeyScale;\n  /**\n   * Time signature; defaults to 4/4.\n   *\n   * @defaultValue `4/4`\n   */\n  ts?: TimeSignature;\n  /**\n   * Chord-slot length in beats; defaults to one bar of `ts`.\n   *\n   * @defaultValue one bar of `ts`\n   */\n  harmonicRhythm?: number;\n  /**\n   * Safety profile used for conflict detection; defaults to `pop`.\n   *\n   * @defaultValue `'pop'`\n   */\n  profile?: SafetyProfile;\n};\n\n/**\n * Sounding pitches of every sub-voice at a beat, excluding one sub-voice.\n *\n * Only the sub-voice under analysis is excluded — sibling sub-voices of the\n * same track are included, so dissonant clusters inside a single polyphonic\n * track are still detected.\n */\nfunction otherVoicesSounding(\n  prepared: PreparedTrack[],\n  excludeTrack: number,\n  excludeVoice: number,\n  beat: number,\n): VoiceSnapshot[] {\n  const out: VoiceSnapshot[] = [];\n  for (let t = 0; t < prepared.length; t += 1) {\n    const track = prepared[t];\n    if (!track) {\n      continue;\n    }\n    for (let v = 0; v < track.voices.length; v += 1) {\n      if (t === excludeTrack && v === excludeVoice) {\n        continue;\n      }\n      const subVoice = track.voices[v];\n      if (!subVoice) {\n        continue;\n      }\n      for (const note of subVoice.sounding) {\n        if (!covers(note, beat)) {\n          continue;\n        }\n        const snap: VoiceSnapshot = { pitch: note.pitch };\n        if (note.prevPitch !== undefined) {\n          snap.prevPitch = note.prevPitch;\n        }\n        out.push(snap);\n      }\n    }\n  }\n  return out;\n}\n\n/**\n * The beats at which a note must be checked against the harmony: its onset,\n * plus the onset of every later chord segment the note sustains across. Each\n * crossed segment is visited exactly once (at its own start), so a boundary\n * beat is never evaluated twice for the same note.\n */\nfunction evaluationBeats(note: VoiceNote, timeline: ChordTimeline): number[] {\n  const noteEnd = note.startBeat + note.durationBeat;\n  const beats = [note.startBeat];\n  for (const segment of timeline.segments) {\n    if (segment.startBeat > note.startBeat + EPS && segment.startBeat < noteEnd - EPS) {\n      beats.push(segment.startBeat);\n    }\n  }\n  return beats;\n}\n\n/**\n * Analyse a whole arrangement against a single inferred harmony.\n *\n * The chord timeline and key are inferred from the pooled notes of every track\n * (see {@link chordTimelineFromNotes}); pooling all voices is robust even when\n * roles are absent or a track doubles the harmony, so it is preferred over\n * deriving the harmony from a subset. Zero- and negative-length notes never\n * sound, so they are dropped at ingest and appear in neither the annotations\n * nor the conflicts.\n *\n * Voice analysis assumes one monophonic voice at a time, so each track is\n * first partitioned into monophonic sub-voices (a polyphonic block-chord track\n * fans out into one sub-voice per simultaneous note; a monophonic track is\n * unaffected). Each sub-voice is labelled note-by-note against the harmony\n * with {@link analyzeVoice}, seeing every other sub-voice — including siblings\n * within the same track — as its accompaniment. Every note is then re-checked\n * with {@link evaluateSafety} at its onset and again at each chord change it\n * sustains across, so a held note that clashes with a later chord is caught:\n * evaluations that are not {@link NoteSafety.Safe} become conflicts, one per\n * clashing beat, sorted worst severity first and then by beat.\n *\n * @param tracks The tracks to analyse.\n * @param opts Analysis options; see {@link ArrangementOptions}.\n * @returns The inferred harmony, per-track annotations, cadences, and conflicts.\n * @example\n * ```ts\n * import { analyzeArrangement } from '@libraz/libcantus';\n * const melody = [\n *   { pitch: 60, startBeat: 0, durationBeat: 2 },\n *   { pitch: 67, startBeat: 2, durationBeat: 2 },\n * ];\n * const { key, conflicts } = analyzeArrangement([{ role: 'melody', notes: melody }]);\n * conflicts; // notes clashing with the inferred harmony, worst severity first\n * ```\n * @category Arrangement & Analysis\n */\nexport function analyzeArrangement(\n  tracks: ArrangementTrack[],\n  opts: ArrangementOptions = {},\n): ArrangementAnalysis {\n  const ts = opts.ts ?? parseTimeSignature('4/4');\n  const profile: SafetyProfile = opts.profile ?? 'pop';\n  const pooled = poolNotes(tracks);\n\n  const { timeline, key, segmentConfidence } = chordTimelineFromNotes(pooled, {\n    key: opts.key,\n    ts,\n    harmonicRhythm: opts.harmonicRhythm,\n  });\n  const cadences = detectCadences(timeline, key);\n  const prepared = prepareTracks(tracks);\n\n  const trackAnalyses: TrackAnalysis[] = [];\n  const conflicts: Conflict[] = [];\n\n  for (let t = 0; t < prepared.length; t += 1) {\n    const track = prepared[t];\n    if (!track) {\n      continue;\n    }\n    const notes: AnalyzedNote[] = [];\n    for (let v = 0; v < track.voices.length; v += 1) {\n      const subVoice = track.voices[v];\n      if (!subVoice) {\n        continue;\n      }\n      notes.push(\n        ...analyzeVoice(subVoice.voice, timeline.at, key, (beat) =>\n          otherVoicesSounding(prepared, t, v, beat),\n        ),\n      );\n\n      for (const note of subVoice.voice) {\n        for (const beat of evaluationBeats(note, timeline)) {\n          const result = evaluateSafety({\n            profile,\n            candidatePitch: note.pitch,\n            chord: timeline.at(beat),\n            key,\n            otherVoices: otherVoicesSounding(prepared, t, v, beat),\n            strongBeat: isStrongBeat(beat, ts),\n          });\n          if (result.safety !== NoteSafety.Safe) {\n            const conflict: Conflict = {\n              beat,\n              trackName: track.name,\n              pitch: note.pitch,\n              safety: result.safety,\n              reasons: result.reasons,\n            };\n            if (result.rationale !== undefined) {\n              conflict.rationale = result.rationale;\n            }\n            conflicts.push(conflict);\n          }\n        }\n      }\n    }\n    // Sub-voice results interleave; restore the track's onset-then-pitch order.\n    notes.sort((a, b) => a.noteId - b.noteId);\n    trackAnalyses.push({ name: track.name, role: track.role, notes });\n  }\n\n  conflicts.sort((a, b) => b.safety - a.safety || a.beat - b.beat);\n\n  return { key, timeline, segmentConfidence, cadences, tracks: trackAnalyses, conflicts };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CO,SAAS,wBAAwB,QAAqB,YAAmC;AAC9F,QAAM,SAAS,CAAC,GAAG,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,YAAY,EAAE,SAAS;AACnE,QAAM,WAA2B,OAC9B,IAAI,CAAC,IAAI,MAAM;AACd,UAAM,OAAO,OAAO,IAAI,CAAC;AACzB,UAAM,UAAU,KAAK,IAAI,GAAG,WAAW,OAAO,KAAK,YAAY,UAAU;AACzE,WAAO;AAAA,MACL,WAAW,GAAG;AAAA,MACd;AAAA,MACA,OAAO,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM;AAAA,IACnD;AAAA,EACF,CAAC,EACA,OAAO,CAAC,QAAQ,IAAI,UAAU,IAAI,SAAS;AAE9C,SAAO,EAAE,IAAI,cAAc,QAAQ,GAAG,SAAS;AACjD;AAGA,SAAS,cAAc,UAA0D;AAC/E,SAAO,CAAC,SAAS;AACf,eAAW,OAAO,UAAU;AAC1B,UAAI,QAAQ,IAAI,aAAa,OAAO,IAAI,SAAS;AAC/C,eAAO,IAAI;AAAA,MACb;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACF;AAEA,IAAM,MAAM;AAGZ,IAAM,wBAAwB;AAG9B,IAAM,oBAAoB;AAG1B,IAAM,eAAe;AAGrB,IAAM,4BAA4B;AAGlC,IAAM,iBAAiB;AAGvB,IAAM,cAAc;AAGpB,IAAM,mBAAmB;AAGzB,SAAS,WAAW,OAAuB;AACzC,UAAS,KAAK,MAAM,KAAK,IAAI,KAAM,MAAM;AAC3C;AAuDA,SAAS,WACP,OACA,SACA,WACA,KACQ;AACR,QAAM,aAAa,YAAY,KAAK,QAAQ,MAAM,MAAM,KAAK,KAAK,YAAY;AAC9E,QAAM,QAAQ,kBAAkB,UAAU,MAAM,QAAQ,MAAM,OAAO,CAAC;AACtE,MAAI,QAAQ;AACZ,MAAI,MAAM,MAAM,CAAC,OAAO,YAAY,IAAI,GAAG,CAAC,GAAG;AAC7C,aAAS;AAAA,EACX;AACA,MAAI,MAAM,OAAO;AACf,aAAS;AAAA,EACX;AACA,WAAS,oBAAoB,MAAM,SAAS,SAAS,MAAM,WAAW;AACtE,SAAO;AACT;AAGA,SAAS,gBACP,OACA,SACA,aACA,OACQ;AACR,QAAM,QAAQ,IAAI,IAAI,kBAAkB,KAAK,CAAC;AAC9C,MAAI,cAAc;AAClB,WAAS,KAAK,GAAG,KAAK,IAAI,MAAM,GAAG;AACjC,QAAI,MAAM,IAAI,EAAE,GAAG;AACjB,qBAAe,QAAQ,EAAE,KAAK;AAAA,IAChC;AAAA,EACF;AACA,QAAM,MAAM,cAAc,IAAI,cAAc,cAAc;AAC1D,QAAM,aAAa,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,GAAG,CAAC;AAC/C,SAAO,QAAQ,aAAa,aAAa;AAC3C;AAUA,SAAS,cACP,OACA,aACA,WACA,IACA,KACoB;AACpB,QAAM,UAAU,IAAI,MAAc,EAAE,EAAE,KAAK,CAAC;AAC5C,MAAI,cAAc,OAAO;AACzB,aAAW,QAAQ,OAAO;AACxB,UAAM,UAAU,KAAK,YAAY,KAAK;AACtC,UAAM,UAAU,KAAK,IAAI,SAAS,SAAS,IAAI,KAAK,IAAI,KAAK,WAAW,WAAW;AACnF,QAAI,WAAW,KAAK;AAClB;AAAA,IACF;AACA,UAAM,iBAAiB,KAAK,aAAa,SAAY,KAAK,WAAW,MAAM;AAC3E,UAAM,gBAAgB,KAAK,aAAa,cAAc,OAAO,KAAK,YAAY,YAAY;AAC1F,UAAM,SAAS,gBAAgB,IAAI,aAAa,KAAK,WAAW,EAAE,IAAI,IAAI;AAC1E,UAAM,KAAK,WAAW,KAAK,KAAK;AAChC,YAAQ,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,UAAU,iBAAiB;AAC9D,QAAI,KAAK,QAAQ,aAAa;AAC5B,oBAAc,KAAK;AAAA,IACrB;AAAA,EACF;AACA,MAAI,cAAc;AAClB,MAAI,YAAY;AAChB,aAAW,KAAK,SAAS;AACvB,mBAAe;AACf,gBAAY,KAAK,IAAI,WAAW,CAAC;AAAA,EACnC;AACA,MAAI,eAAe,KAAK;AACtB,WAAO;AAAA,EACT;AAGA,QAAM,SAAS,QACZ,IAAI,CAAC,QAAQ,QAAQ,EAAE,IAAI,OAAO,EAAE,EACpC,OAAO,CAAC,EAAE,OAAO,MAAM,SAAS,CAAC,EACjC,KAAK,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE;AACpD,QAAM,WAAW,OACd,OAAO,CAAC,EAAE,OAAO,MAAM,UAAU,YAAY,qBAAqB,EAClE,MAAM,GAAG,iBAAiB,EAC1B,IAAI,CAAC,EAAE,GAAG,MAAM,EAAE;AAKrB,QAAM,SAAS,WAAW,WAAW;AACrC,QAAM,WAAW,SAAS,SAAS,MAAM,IAAI,SAAU,SAAS,CAAC,KAAK;AACtE,QAAM,mBAAmB,SAAS,IAAI,CAAC,OAAQ,OAAO,WAAW,KAAK,KAAK,EAAG;AAE9E,QAAM,UAAU,YAAY,gBAAgB;AAC5C,MAAI,YAA+B;AACnC,MAAI,YAAY,OAAO;AACvB,aAAW,SAAS,SAAS;AAC3B,UAAM,QAAQ,WAAW,OAAO,SAAS,WAAW,GAAG;AACvD,QAAI,QAAQ,WAAW;AACrB,kBAAY;AACZ,kBAAY;AAAA,IACd;AAAA,EACF;AACA,MAAI,WAAW;AACb,UAAM,QAAQ,UAAU,UAAU,QAAQ,UAAU,SAAS,UAAU,MAAM;AAC7E,WAAO,EAAE,OAAO,YAAY,gBAAgB,OAAO,SAAS,aAAa,UAAU,KAAK,EAAE;AAAA,EAC5F;AAGA,QAAM,WAAW,gBAAgB,SAAS,MAAM,GAAG,YAAY,CAAC;AAChE,MAAI,UAAU;AACZ,WAAO,EAAE,OAAO,UAAU,YAAY,gBAAgB,UAAU,SAAS,aAAa,KAAK,EAAE;AAAA,EAC/F;AACA,SAAO;AACT;AAGA,SAAS,UAAU,GAAU,GAAmB;AAC9C,SAAO,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE;AAC5E;AAmCO,SAAS,uBACd,OACA,OAA6B,CAAC,GACT;AACrB,QAAM,KAAK,KAAK,MAAM,mBAAmB,KAAK;AAC9C,QAAM,iBAAiB,KAAK,kBAAkB,YAAY,EAAE;AAC5D,MAAI,EAAE,iBAAiB,IAAI;AACzB,UAAM,IAAI,MAAM,4BAA4B,cAAc,EAAE;AAAA,EAC9D;AAEA,QAAM,WAAW,MAAM,OAAO,CAAC,SAAS,KAAK,eAAe,CAAC;AAC7D,QAAM,cAAc,SAAS,OAAO,CAAC,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,YAAY,EAAE,YAAY,GAAG,CAAC;AAC9F,QAAM,aAAa,KAAK,cAAc;AACtC,QAAM,MAAM,KAAK,OAAO,UAAU,SAAS,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,OAAO,SAAS,CAAC;AAErF,QAAM,WAA2B,CAAC;AAClC,QAAM,oBAA8B,CAAC;AACrC,QAAM,cAAc,KAAK,IAAI,GAAG,KAAK,KAAK,aAAa,iBAAiB,GAAG,CAAC;AAC5E,WAAS,IAAI,GAAG,IAAI,aAAa,KAAK,GAAG;AACvC,UAAM,QAAQ,IAAI;AAClB,UAAM,MAAM,KAAK,IAAI,QAAQ,gBAAgB,UAAU;AACvD,UAAM,WAAW,cAAc,UAAU,OAAO,KAAK,IAAI,GAAG;AAC5D,QAAI,CAAC,UAAU;AACb;AAAA,IACF;AACA,UAAM,OAAO,SAAS,SAAS,SAAS,CAAC;AACzC,QAAI,QAAQ,UAAU,KAAK,OAAO,SAAS,KAAK,KAAK,KAAK,IAAI,KAAK,UAAU,KAAK,IAAI,KAAK;AAEzF,YAAM,aAAa,KAAK,UAAU,KAAK;AACvC,YAAM,SAAS,MAAM;AACrB,YAAM,iBAAiB,kBAAkB,kBAAkB,SAAS,CAAC,KAAK;AAC1E,wBAAkB,kBAAkB,SAAS,CAAC,KAC3C,iBAAiB,aAAa,SAAS,aAAa,WAAW,aAAa;AAC/E,WAAK,UAAU;AAAA,IACjB,OAAO;AACL,eAAS,KAAK,EAAE,WAAW,OAAO,SAAS,KAAK,OAAO,SAAS,MAAM,CAAC;AACvE,wBAAkB,KAAK,SAAS,UAAU;AAAA,IAC5C;AAAA,EACF;AAEA,SAAO;AAAA,IACL,UAAU,EAAE,IAAI,cAAc,QAAQ,GAAG,SAAS;AAAA,IAClD;AAAA,IACA;AAAA,EACF;AACF;AAsCO,SAAS,eAAe,UAAyB,KAA6B;AACnF,QAAM,OAAqB,CAAC;AAC5B,WAAS,IAAI,GAAG,IAAI,SAAS,SAAS,QAAQ,KAAK,GAAG;AACpD,UAAM,OAAO,SAAS,SAAS,IAAI,CAAC;AACpC,UAAM,MAAM,SAAS,SAAS,CAAC;AAC/B,QAAI,CAAC,QAAQ,CAAC,KAAK;AACjB;AAAA,IACF;AACA,QAAI,KAAK,IAAI,IAAI,YAAY,KAAK,OAAO,IAAI,KAAK;AAChD;AAAA,IACF;AACA,UAAM,OAAO,cAAc,KAAK,OAAO,IAAI,OAAO,GAAG;AACrD,QAAI,SAAS,MAAM;AACjB,WAAK,KAAK,EAAE,QAAQ,IAAI,WAAW,MAAM,MAAM,KAAK,OAAO,IAAI,IAAI,MAAM,CAAC;AAAA,IAC5E;AAAA,EACF;AACA,SAAO;AACT;;;ACnZO,IAAMA,OAAM;AAgCZ,SAAS,OAAO,MAAoB,MAAuB;AAChE,SAAO,QAAQ,KAAK,YAAYA,QAAO,OAAO,KAAK,UAAUA;AAC/D;AAOO,SAAS,UAAU,QAAyC;AACjE,QAAM,QAAqB,CAAC;AAC5B,aAAW,SAAS,QAAQ;AAC1B,eAAW,QAAQ,MAAM,OAAO;AAC9B,UAAI,KAAK,eAAe,GAAG;AACzB,cAAM,KAAK,IAAI;AAAA,MACjB;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAWA,SAAS,mBAAmB,SAAqC;AAC/D,QAAM,QAAuB,CAAC;AAC9B,aAAW,QAAQ,SAAS;AAC1B,UAAM,OAAO,MAAM,KAAK,CAAC,cAAc;AACrC,YAAM,OAAO,UAAU,UAAU,SAAS,CAAC;AAC3C,aAAO,SAAS,UAAa,KAAK,YAAY,KAAK,gBAAgB,KAAK,YAAYA;AAAA,IACtF,CAAC;AACD,QAAI,MAAM;AACR,WAAK,KAAK,IAAI;AAAA,IAChB,OAAO;AACL,YAAM,KAAK,CAAC,IAAI,CAAC;AAAA,IACnB;AAAA,EACF;AACA,SAAO;AACT;AAYO,SAAS,cAAc,QAA6C;AACzE,MAAI,SAAS;AACb,SAAO,OAAO,IAAI,CAAC,OAAO,UAAU;AAClC,UAAM,UAAuB,MAAM,MAChC,OAAO,CAAC,SAAS,KAAK,eAAe,CAAC,EACtC,KAAK,CAAC,GAAG,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,KAAK,EAC7D,IAAI,CAAC,UAAU,EAAE,GAAG,MAAM,IAAI,SAAS,EAAE;AAC5C,UAAM,SAA0B,mBAAmB,OAAO,EAAE,IAAI,CAAC,WAAW;AAAA,MAC1E;AAAA,MACA,UAAU,MAAM,IAAI,CAAC,MAAM,MAAM;AAC/B,cAAM,OAAO,IAAI,IAAI,MAAM,IAAI,CAAC,IAAI;AACpC,eAAO;AAAA,UACL,OAAO,KAAK;AAAA,UACZ,WAAW,MAAM;AAAA,UACjB,WAAW,KAAK;AAAA,UAChB,SAAS,KAAK,YAAY,KAAK;AAAA,QACjC;AAAA,MACF,CAAC;AAAA,IACH,EAAE;AACF,WAAO;AAAA,MACL,MAAM,MAAM,QAAQ,SAAS,QAAQ,CAAC;AAAA,MACtC,MAAM,MAAM,QAAQ;AAAA,MACpB;AAAA,IACF;AAAA,EACF,CAAC;AACH;;;AChGA,IAAM,mBAAyE;AAAA,EAC7E,OAAO;AAAA,EACP,aAAa;AAAA,EACb,UAAU;AACZ;AAGA,IAAM,kBAAkB;AAExB,IAAM,oBAAoB;AAE1B,IAAM,cAAc;AAEpB,IAAM,kBAAkB;AAGxB,SAASC,YAAW,OAAuB;AACzC,UAAS,KAAK,MAAM,KAAK,IAAI,KAAM,MAAM;AAC3C;AAGA,SAAS,QAAQ,OAAuB;AACtC,SAAO,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,KAAK,CAAC;AACvC;AA8BO,SAAS,aACd,QACA,OAA+C,CAAC,GAChC;AAChB,QAAM,KAAK,KAAK,MAAM,mBAAmB,KAAK;AAC9C,QAAM,UAAyB,KAAK,WAAW;AAC/C,QAAM,OAAO,KAAK,QAAQ;AAC1B,MAAI,EAAE,OAAO,IAAI;AACf,UAAM,IAAI,MAAM,kCAAkC,IAAI,EAAE;AAAA,EAC1D;AAEA,QAAM,SAAS,UAAU,MAAM;AAC/B,QAAM,aAAa,OAAO,OAAO,CAAC,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,YAAY,EAAE,YAAY,GAAG,CAAC;AAC3F,QAAM,EAAE,UAAU,IAAI,IAAI,uBAAuB,QAAQ;AAAA,IACvD,KAAK,KAAK;AAAA,IACV;AAAA,IACA,gBAAgB,KAAK;AAAA,EACvB,CAAC;AAED,QAAM,WAAW,cAAc,MAAM;AACrC,QAAM,SAAyB,CAAC;AAChC,QAAM,cAAc,KAAK,IAAI,GAAG,KAAK,KAAK,aAAa,OAAOC,IAAG,CAAC;AAClE,WAAS,IAAI,GAAG,IAAI,aAAa,KAAK,GAAG;AACvC,UAAM,OAAO,IAAI;AACjB,WAAO,KAAK,EAAE,MAAM,SAAS,cAAc,UAAU,UAAU,KAAK,IAAI,SAAS,IAAI,EAAE,CAAC;AAAA,EAC1F;AACA,SAAO;AACT;AAGA,SAAS,YAAY,UAA2B,MAAkD;AAChG,QAAM,MAA0C,CAAC;AACjD,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK,GAAG;AAC3C,UAAM,QAAQ,SAAS,CAAC;AACxB,QAAI,CAAC,OAAO;AACV;AAAA,IACF;AACA,eAAW,YAAY,MAAM,QAAQ;AACnC,iBAAW,QAAQ,SAAS,UAAU;AACpC,YAAI,OAAO,MAAM,IAAI,GAAG;AACtB,cAAI,KAAK,EAAE,OAAO,KAAK,OAAO,OAAO,EAAE,CAAC;AAAA,QAC1C;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAGA,SAAS,cACP,UACA,UACA,KACA,IACA,SACA,MACQ;AACR,QAAM,WAAW,YAAY,UAAU,IAAI;AAC3C,MAAI,SAAS,WAAW,GAAG;AACzB,WAAO;AAAA,EACT;AACA,QAAM,QAAQ,SAAS,GAAG,IAAI;AAC9B,QAAM,gBAAgB,QAAQ,iBAAiB,WAAW,OAAO,GAAG,CAAC,IAAI;AAEzE,QAAM,WAAW,QAAQ,IAAI,IAAI,kBAAkB,KAAK,CAAC,IAAI;AAC7D,QAAM,aAAa,aAAa,MAAM,EAAE;AACxC,MAAI,WAAW;AACf,MAAI,YAAY;AAChB,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK,GAAG;AAC3C,UAAM,QAAQ,SAAS,CAAC;AACxB,QAAI,CAAC,OAAO;AACV;AAAA,IACF;AAIA,QAAI,YAAY,CAAC,SAAS,IAAID,YAAW,MAAM,KAAK,CAAC,GAAG;AACtD,kBAAY;AAAA,IACd;AACA,UAAM,SAAS,SAAS,OAAO,CAAC,GAAG,MAAM,MAAM,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE;AACjF,UAAM,SAAS,eAAe;AAAA,MAC5B;AAAA,MACA,gBAAgB,MAAM;AAAA,MACtB;AAAA,MACA;AAAA,MACA,aAAa;AAAA,MACb;AAAA,IACF,CAAC;AACD,QAAI,OAAO,8BAAiC;AAC1C,mBAAa;AAAA,IACf;AAAA,EACF;AACA,QAAM,kBAAkB,KAAK,IAAI,UAAU,SAAS,IAAI,SAAS;AAEjE,MAAI,MAAM,OAAO;AACjB,MAAI,OAAO,OAAO;AAClB,aAAW,SAAS,UAAU;AAC5B,UAAM,KAAK,IAAI,KAAK,MAAM,KAAK;AAC/B,WAAO,KAAK,IAAI,MAAM,MAAM,KAAK;AAAA,EACnC;AACA,QAAM,YAAY,KAAK,IAAI,IAAI,OAAO,OAAO,eAAe;AAE5D,SAAO;AAAA,IACL,kBAAkB,gBAAgB,oBAAoB,kBAAkB,cAAc;AAAA,EACxF;AACF;;;AC7IA,IAAME,OAAM;AAEZ,SAASC,YAAW,OAAuB;AACzC,UAAS,KAAK,MAAM,KAAK,IAAI,KAAM,MAAM;AAC3C;AAEA,SAAS,kBAAkB,OAAe,OAAsB;AAC9D,WAAUA,YAAW,KAAK,IAAIA,YAAW,MAAM,MAAM,KAAK,KAAM,MAAM;AACxE;AAUA,SAAS,kBAAkB,OAAe,QAAyB,OAAsB;AACvF,MAAI,OAAO,OAAO;AAClB,aAAW,MAAM,QAAQ;AACvB,WAAO,KAAK,IAAI,MAAM,GAAG,KAAK;AAAA,EAChC;AACA,MAAI,OAAO,SAAS,IAAI,KAAK,OAAO,OAAO;AACzC,aAAU,QAAQ,QAAQ,KAAM,MAAM;AAAA,EACxC;AACA,QAAM,MAAM,MAAM,UAAU,MAAM;AAClC,WAAUA,YAAW,KAAK,IAAIA,YAAW,GAAG,KAAK,KAAM,MAAM;AAC/D;AAOA,SAAS,cAAc,IAAyB;AAC9C,MAAI,OAAO,KAAK,OAAO,GAAG;AACxB,WAAO;AAAA,EACT;AACA,MAAI,OAAO,KAAK,OAAO,GAAG;AACxB,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,SAAS,cAAc,OAAe,OAA8B;AAClE,SAAO,QAAQ,kBAAkB,KAAK,EAAE,SAASA,YAAW,KAAK,CAAC,IAAI;AACxE;AAEA,SAAS,OAAO,GAAW,GAAoB;AAC7C,QAAM,IAAI,KAAK,IAAI,IAAI,CAAC;AACxB,SAAO,MAAM,KAAK,MAAM;AAC1B;AAMA,SAAS,eAAe,IAAY,OAAqD;AACvF,MAAI;AACJ,MAAI,QAAQ,GAAG;AACb,WAAO;AAAA,EACT,WAAW,OAAO,GAAG;AACnB,WAAO;AAAA,EACT,WAAW,OAAO,MAAM,OAAO,IAAI;AACjC,WAAO;AAAA,EACT,OAAO;AACL,WAAO;AAAA,EACT;AACA,SAAO,EAAE,MAAM,cAAc,MAAM,WAAW,EAAE;AAClD;AAEA,SAAS,eAAe,OAAe,OAAkC;AACvE,WAAS,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG;AAC1C,QAAI,cAAc,QAAQ,OAAO,KAAK,GAAG;AACvC,aAAO,QAAQ;AAAA,IACjB;AAAA,EACF;AACA,SAAO;AACT;AAqCO,SAAS,aACd,OACA,aACA,KACA,mBACgB;AAChB,QAAM,SAAyB,CAAC;AAEhC,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;AACxC,UAAM,OAAO,MAAM,CAAC;AACpB,QAAI,CAAC,MAAM;AACT;AAAA,IACF;AACA,UAAM,WAAW,IAAI,IAAI,MAAM,IAAI,CAAC,IAAI;AACxC,UAAM,WAAW,IAAI,IAAI,MAAM,SAAS,MAAM,IAAI,CAAC,IAAI;AAIvD,UAAM,OACJ,aAAa,UAAa,SAAS,YAAY,KAAK,YAAYD,OAAM,WAAW;AACnF,UAAM,OACJ,aAAa,UAAa,SAAS,YAAY,KAAK,YAAYA,OAAM,WAAW;AACnF,UAAM,QAAQ,YAAY,KAAK,SAAS;AACxC,UAAM,SAAwB,CAAC;AAC/B,UAAM,SAAS,cAAc,KAAK,OAAO,KAAK;AAC9C,QAAI,UAAU;AAEd,QAAI,SAAS,QAAQ;AACnB,YAAM,OAAO,cAAc,KAAK,OAAO,KAAK;AAC5C,UAAI,MAAM;AACR,eAAO,KAAK,EAAE,MAAM,aAAa,KAAK,CAAC;AAAA,MACzC,OAAO;AACL,cAAM,KAAK,kBAAkB,KAAK,OAAO,KAAK;AAC9C,eAAO,KAAK,EAAE,MAAM,WAAW,QAAQ,cAAc,EAAE,EAAE,CAAC;AAAA,MAC5D;AACA,gBAAU;AAAA,IACZ;AAEA,QAAI,CAAC,WAAW,SAAS,QAAQ,MAAM;AACrC,YAAM,YAAY,YAAY,KAAK,SAAS;AAC5C,YAAM,WAAW,KAAK,UAAU,KAAK,SAAS,cAAc,KAAK,OAAO,SAAS;AACjF,YAAM,WAAW,OAAO,KAAK,OAAO,KAAK,KAAK;AAC9C,YAAM,SAAS,kBAAkB,KAAK,SAAS;AAC/C,YAAM,sBAAsB,OAAO;AAAA,QAAK,CAAC,OACvC,0BAA0B,KAAK,OAAO,GAAG,OAAO,IAAI;AAAA,MACtD;AACA,UAAI,YAAY,uBAAuB,UAAU;AAC/C,cAAM,KAAK,kBAAkB,KAAK,OAAO,QAAQ,KAAK;AACtD,cAAM,MAAM,eAAe,IAAI,KAAK,QAAQ,KAAK,KAAK;AACtD,YAAI,YAAY,KAAK;AACrB,eAAO,KAAK,GAAG;AACf,kBAAU;AAAA,MACZ;AAAA,IACF;AAEA,QAAI,CAAC,WAAW,SAAS,QAAQ,MAAM;AACrC,YAAM,aAAa,cAAc,KAAK,OAAO,YAAY,KAAK,SAAS,CAAC;AACxE,YAAM,aAAa,cAAc,KAAK,OAAO,YAAY,KAAK,SAAS,CAAC;AACxE,YAAM,KAAK,KAAK,QAAQ,KAAK,QAAQ;AACrC,YAAM,WAAW,KAAK,QAAQ,KAAK,QAAQ;AAC3C,YAAM,UAAU,KAAK,UAAU,KAAK,SAAS,KAAK,UAAU,KAAK,SAAS,OAAO;AACjF,UACE,cACA,cACA,CAAC,UACD,OAAO,KAAK,OAAO,KAAK,KAAK,KAC7B,OAAO,KAAK,OAAO,KAAK,KAAK,KAC7B,SACA;AACA,eAAO,KAAK,EAAE,MAAM,UAAU,CAAC;AAC/B,kBAAU;AAAA,MACZ;AAAA,IACF;AAEA,QACE,CAAC,WACD,SACA,QACA,QACA,CAAC,UACD,KAAK,UAAU,KAAK,SACpB,cAAc,KAAK,OAAO,YAAY,KAAK,SAAS,CAAC,KACrD,OAAO,KAAK,OAAO,KAAK,KAAK,GAC7B;AACA,aAAO,KAAK,EAAE,MAAM,WAAW,CAAC;AAChC,gBAAU;AAAA,IACZ;AAEA,QAAI,CAAC,WAAW,SAAS,QAAQ,CAAC,UAAU,KAAK,UAAU,KAAK,OAAO;AACrE,YAAM,YAAY,YAAY,KAAK,SAAS;AAC5C,UAAI,cAAc,KAAK,OAAO,SAAS,GAAG;AACxC,eAAO,KAAK,EAAE,MAAM,eAAe,CAAC;AACpC,kBAAU;AAAA,MACZ;AAAA,IACF;AAEA,QAAI,CAAC,WAAW,SAAS,QAAQ,QAAQ,CAAC,QAAQ;AAChD,YAAM,aAAa,cAAc,KAAK,OAAO,YAAY,KAAK,SAAS,CAAC;AACxE,YAAM,aAAa,cAAc,KAAK,OAAO,YAAY,KAAK,SAAS,CAAC;AACxE,YAAM,eAAe,OAAO,KAAK,OAAO,KAAK,KAAK;AAClD,YAAM,aAAa,KAAK,IAAI,KAAK,QAAQ,KAAK,KAAK,KAAK;AACxD,YAAM,WAAW,KAAK,QAAQ,KAAK,QAAQ,MAAM,KAAK,QAAQ,KAAK,QAAQ;AAC3E,UAAI,cAAc,cAAc,gBAAgB,cAAc,UAAU;AACtE,eAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,kBAAU;AAAA,MACZ;AAAA,IACF;AAEA,QAAI,CAAC,WAAW,SAAS,CAAC,QAAQ;AAChC,YAAM,KAAK,kBAAkB,KAAK,OAAO,KAAK;AAC9C,YAAM,YAAY,OAAO,KAAK,OAAO,KAAK,OAAO;AACjD,YAAM,QACH,OAAO,KAAK,MAAM,UAAU,SAAS,CAAC,KAAK,CAAC,MAAM,UAAU,SAAS,CAAC,KACtE,OAAO,MAAM,MAAM,UAAU,SAAS,CAAC,KAAK,MAAM,UAAU,SAAS,EAAE;AAC1E,UAAI,OAAO;AACT,eAAO,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC7B,cAAM,YAAY,eAAe,KAAK,OAAO,KAAK;AAClD,YAAI,cAAc,QAAW;AAC3B,iBAAO,KAAK,EAAE,MAAM,mBAAmB,UAAU,CAAC;AAAA,QACpD;AAAA,MACF,WAAW,WAAW;AACpB,eAAO,KAAK,EAAE,MAAM,WAAW,QAAQ,cAAc,EAAE,EAAE,CAAC;AAAA,MAC5D,OAAO;AACL,cAAM,YAAY,eAAe,KAAK,OAAO,KAAK;AAClD,YAAI,cAAc,QAAW;AAC3B,iBAAO,KAAK,EAAE,MAAM,mBAAmB,UAAU,CAAC;AAAA,QACpD;AAAA,MACF;AAAA,IACF;AAEA,QAAI,QAAQ,wBAAwB,KAAK,OAAO,KAAK,OAAO,GAAG,GAAG;AAChE,aAAO,KAAK,EAAE,MAAM,eAAe,WAAW,KAAK,MAAM,CAAC;AAAA,IAC5D;AAEA,WAAO,KAAK,EAAE,QAAQ,KAAK,IAAI,QAAQ,WAAW,SAAS,MAAM,EAAE,CAAC;AAAA,EACtE;AAEA,SAAO;AACT;AAGA,SAAS,SAAS,QAA+B;AAC/C,QAAM,UAAU,OAAO,CAAC;AACxB,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AACA,UAAQ,QAAQ,MAAM;AAAA,IACpB,KAAK;AACH,aAAO,SAAS,QAAQ,IAAI;AAAA,IAC9B,KAAK;AACH,aAAO,GAAG,QAAQ,MAAM;AAAA,IAC1B,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO,eAAe,QAAQ,IAAI;AAAA,IACpC,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,EACX;AACF;;;ACjNA,SAAS,oBACP,UACA,cACA,cACA,MACiB;AACjB,QAAM,MAAuB,CAAC;AAC9B,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK,GAAG;AAC3C,UAAM,QAAQ,SAAS,CAAC;AACxB,QAAI,CAAC,OAAO;AACV;AAAA,IACF;AACA,aAAS,IAAI,GAAG,IAAI,MAAM,OAAO,QAAQ,KAAK,GAAG;AAC/C,UAAI,MAAM,gBAAgB,MAAM,cAAc;AAC5C;AAAA,MACF;AACA,YAAM,WAAW,MAAM,OAAO,CAAC;AAC/B,UAAI,CAAC,UAAU;AACb;AAAA,MACF;AACA,iBAAW,QAAQ,SAAS,UAAU;AACpC,YAAI,CAAC,OAAO,MAAM,IAAI,GAAG;AACvB;AAAA,QACF;AACA,cAAM,OAAsB,EAAE,OAAO,KAAK,MAAM;AAChD,YAAI,KAAK,cAAc,QAAW;AAChC,eAAK,YAAY,KAAK;AAAA,QACxB;AACA,YAAI,KAAK,IAAI;AAAA,MACf;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAQA,SAAS,gBAAgB,MAAiB,UAAmC;AAC3E,QAAM,UAAU,KAAK,YAAY,KAAK;AACtC,QAAM,QAAQ,CAAC,KAAK,SAAS;AAC7B,aAAW,WAAW,SAAS,UAAU;AACvC,QAAI,QAAQ,YAAY,KAAK,YAAYE,QAAO,QAAQ,YAAY,UAAUA,MAAK;AACjF,YAAM,KAAK,QAAQ,SAAS;AAAA,IAC9B;AAAA,EACF;AACA,SAAO;AACT;AAsCO,SAAS,mBACd,QACA,OAA2B,CAAC,GACP;AACrB,QAAM,KAAK,KAAK,MAAM,mBAAmB,KAAK;AAC9C,QAAM,UAAyB,KAAK,WAAW;AAC/C,QAAM,SAAS,UAAU,MAAM;AAE/B,QAAM,EAAE,UAAU,KAAK,kBAAkB,IAAI,uBAAuB,QAAQ;AAAA,IAC1E,KAAK,KAAK;AAAA,IACV;AAAA,IACA,gBAAgB,KAAK;AAAA,EACvB,CAAC;AACD,QAAM,WAAW,eAAe,UAAU,GAAG;AAC7C,QAAM,WAAW,cAAc,MAAM;AAErC,QAAM,gBAAiC,CAAC;AACxC,QAAM,YAAwB,CAAC;AAE/B,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK,GAAG;AAC3C,UAAM,QAAQ,SAAS,CAAC;AACxB,QAAI,CAAC,OAAO;AACV;AAAA,IACF;AACA,UAAM,QAAwB,CAAC;AAC/B,aAAS,IAAI,GAAG,IAAI,MAAM,OAAO,QAAQ,KAAK,GAAG;AAC/C,YAAM,WAAW,MAAM,OAAO,CAAC;AAC/B,UAAI,CAAC,UAAU;AACb;AAAA,MACF;AACA,YAAM;AAAA,QACJ,GAAG;AAAA,UAAa,SAAS;AAAA,UAAO,SAAS;AAAA,UAAI;AAAA,UAAK,CAAC,SACjD,oBAAoB,UAAU,GAAG,GAAG,IAAI;AAAA,QAC1C;AAAA,MACF;AAEA,iBAAW,QAAQ,SAAS,OAAO;AACjC,mBAAW,QAAQ,gBAAgB,MAAM,QAAQ,GAAG;AAClD,gBAAM,SAAS,eAAe;AAAA,YAC5B;AAAA,YACA,gBAAgB,KAAK;AAAA,YACrB,OAAO,SAAS,GAAG,IAAI;AAAA,YACvB;AAAA,YACA,aAAa,oBAAoB,UAAU,GAAG,GAAG,IAAI;AAAA,YACrD,YAAY,aAAa,MAAM,EAAE;AAAA,UACnC,CAAC;AACD,cAAI,OAAO,yBAA4B;AACrC,kBAAM,WAAqB;AAAA,cACzB;AAAA,cACA,WAAW,MAAM;AAAA,cACjB,OAAO,KAAK;AAAA,cACZ,QAAQ,OAAO;AAAA,cACf,SAAS,OAAO;AAAA,YAClB;AACA,gBAAI,OAAO,cAAc,QAAW;AAClC,uBAAS,YAAY,OAAO;AAAA,YAC9B;AACA,sBAAU,KAAK,QAAQ;AAAA,UACzB;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,UAAM,KAAK,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,MAAM;AACxC,kBAAc,KAAK,EAAE,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,CAAC;AAAA,EAClE;AAEA,YAAU,KAAK,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI;AAE/D,SAAO,EAAE,KAAK,UAAU,mBAAmB,UAAU,QAAQ,eAAe,UAAU;AACxF;","names":["EPS","pitchClass","EPS","EPS","pitchClass","EPS"]}