@libraz/libcantus 0.9.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libraz/libcantus",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Pure-TypeScript music-theory and composition primitives (intervals, scales, chords).",
   "type": "module",
   "license": "Apache-2.0",
@@ -58,6 +58,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
+    "docs": "typedoc",
     "prepare": "[ -d node_modules/typescript ] && tsup || true",
     "prepublishOnly": "yarn build"
   },
@@ -65,6 +66,10 @@
     "@biomejs/biome": "2.5.2",
     "@vitest/coverage-v8": "4.1.9",
     "tsup": "8.5.1",
+    "typedoc": "0.28.20",
+    "typedoc-material-theme": "1.4.1",
+    "typedoc-plugin-extras": "4.0.1",
+    "typedoc-plugin-mdn-links": "5.1.1",
     "typescript": "6.0.3",
     "vitest": "4.1.9"
   }

package/src/analysis/index.ts

@@ -4,7 +4,11 @@ import { createsVerticalDissonance, isLeadingToneResolution } from '../counterpo
 import type { VoiceSnapshot } from '../safety/index.js';
 import type { KeyScale, NoteEvent } from '../types.js';
 
-/** A theory annotation attached to a note. */
+/**
+ * A theory annotation attached to a note.
+ *
+ * @category Arrangement & Analysis
+ */
 export type TheoryLabel =
   | { kind: 'chordTone'; role: 'root' | 'third' | 'fifth' | 'sixth' | 'seventh' }
   | { kind: 'tension'; degree: 9 | 11 | 13 }
@@ -17,16 +21,27 @@ export type TheoryLabel =
   | { kind: 'needsResolution'; resolveTo: number }
   | { kind: 'leadingTone'; resolveTo: number };
 
-/** A note with its theory labels and a short rationale. */
+/**
+ * A note with its theory labels and a short rationale.
+ *
+ * @category Arrangement & Analysis
+ */
 export type AnalyzedNote = {
   noteId: number;
   labels: TheoryLabel[];
   rationale?: string;
 };
 
-/** A single note in a monophonic voice: a {@link NoteEvent} with a stable id. */
+/**
+ * A single note in a monophonic voice: a {@link NoteEvent} with a stable id.
+ *
+ * @category Arrangement & Analysis
+ */
 export type VoiceNote = NoteEvent & { id: number };
 
+/** Float tolerance for beat comparisons. */
+const EPS = 1e-9;
+
 function pitchClass(pitch: number): number {
   return ((Math.trunc(pitch) % 12) + 12) % 12;
 }
@@ -35,6 +50,26 @@ function intervalAboveRoot(pitch: number, chord: Chord): number {
   return (((pitchClass(pitch) - pitchClass(chord.rootPc)) % 12) + 12) % 12;
 }
 
+/**
+ * Interval class of a pitch above the actual sounding bass.
+ *
+ * Suspension figures (4-3, 7-6, 9-8) are named for the interval above the bass,
+ * not the chord root, so this prefers the lowest pitch among the other sounding
+ * voices when one lies below the note. Without a lower sounding voice it falls
+ * back to the chord's bass pitch class (or root in root position).
+ */
+function intervalAboveBass(pitch: number, others: VoiceSnapshot[], chord: Chord): number {
+  let bass = Number.POSITIVE_INFINITY;
+  for (const ov of others) {
+    bass = Math.min(bass, ov.pitch);
+  }
+  if (Number.isFinite(bass) && bass < pitch) {
+    return (((pitch - bass) % 12) + 12) % 12;
+  }
+  const ref = chord.bassPc ?? chord.rootPc;
+  return (((pitchClass(pitch) - pitchClass(ref)) % 12) + 12) % 12;
+}
+
 /**
  * Map an interval class above the root to its extended-tension scale degree:
  * a flat/natural ninth (1 or 2) to 9, an eleventh (5 or 6) to 11, and a
@@ -59,6 +94,10 @@ function isStep(a: number, b: number): boolean {
   return d === 1 || d === 2;
 }
 
+/**
+ * Classify a suspension figure from the interval class above the sounding bass
+ * (`ic`) and the resolution direction (`delta`, positive when resolving upward).
+ */
 function suspensionType(ic: number, delta: number): TheoryLabel & { kind: 'suspension' } {
   let type: 'sus4-3' | 'sus7-6' | 'sus9-8' | 'sus2-3';
   if (delta > 0) {
@@ -92,11 +131,30 @@ function stepResolution(pitch: number, chord: Chord): number | undefined {
  * avoid, or an unresolved-dissonance label. Leading-tone resolutions are noted
  * additionally.
  *
+ * The voice is expected to be monophonic (one note at a time). Notes sharing an
+ * onset are treated as simultaneous cluster members, not melodic neighbors, so
+ * they receive no melodic labels (suspension, passing, neighbor, anticipation,
+ * escape) — only harmonic ones. Callers with truly polyphonic material should
+ * split it into monophonic sub-voices first, as `analyzeArrangement` does.
+ *
  * @param voice The monophonic voice, in time order.
  * @param chordAtBeat Chord sounding at a given beat, or null.
  * @param key Key context for leading-tone detection.
  * @param otherVoicesAtBeat Other sounding voices at a given beat.
  * @returns One annotation per input note.
+ * @example
+ * ```ts
+ * import { analyzeVoice, makeChord, majorKey } from '@libraz/libcantus';
+ * const voice = [
+ *   { id: 0, pitch: 60, startBeat: 0, durationBeat: 1 },
+ *   { id: 1, pitch: 62, startBeat: 1, durationBeat: 1 },
+ *   { id: 2, pitch: 64, startBeat: 2, durationBeat: 1 },
+ * ];
+ * const cMajor = makeChord(0, 'maj');
+ * const labels = analyzeVoice(voice, () => cMajor, majorKey(0), () => []);
+ * labels; // one AnalyzedNote per input note, in the same order
+ * ```
+ * @category Arrangement & Analysis
  */
 export function analyzeVoice(
   voice: VoiceNote[],
@@ -111,8 +169,15 @@ export function analyzeVoice(
     if (!note) {
       continue;
     }
-    const prev = i > 0 ? voice[i - 1] : undefined;
-    const next = i + 1 < voice.length ? voice[i + 1] : undefined;
+    const prevNote = i > 0 ? voice[i - 1] : undefined;
+    const nextNote = i + 1 < voice.length ? voice[i + 1] : undefined;
+    // A neighboring note sharing this note's onset is a simultaneous cluster
+    // member, not a melodic predecessor/successor; treating it as one would
+    // fabricate passing/suspension figures, so it is dropped here.
+    const prev =
+      prevNote !== undefined && prevNote.startBeat < note.startBeat - EPS ? prevNote : undefined;
+    const next =
+      nextNote !== undefined && nextNote.startBeat > note.startBeat + EPS ? nextNote : undefined;
     const chord = chordAtBeat(note.startBeat);
     const labels: TheoryLabel[] = [];
     const member = isChordMember(note.pitch, chord);
@@ -133,11 +198,12 @@ export function analyzeVoice(
       const prevChord = chordAtBeat(prev.startBeat);
       const prepared = prev.pitch === note.pitch && isChordMember(prev.pitch, prevChord);
       const resolves = isStep(next.pitch, note.pitch);
-      const verticallyDissonant = otherVoicesAtBeat(note.startBeat).some((ov) =>
+      const others = otherVoicesAtBeat(note.startBeat);
+      const verticallyDissonant = others.some((ov) =>
         createsVerticalDissonance(note.pitch, ov.pitch, true),
       );
       if (prepared && verticallyDissonant && resolves) {
-        const ic = intervalAboveRoot(note.pitch, chord);
+        const ic = intervalAboveBass(note.pitch, others, chord);
         const sus = suspensionType(ic, next.pitch - note.pitch);
         sus.resolveTo = next.pitch;
         labels.push(sus);

package/src/arrange/index.ts

@@ -29,17 +29,29 @@ import type { KeyScale, NoteEvent } from '../types.js';
 /** Float tolerance for beat boundary comparisons. */
 const EPS = 1e-9;
 
-/** The musical role a track plays in the arrangement. */
+/**
+ * The musical role a track plays in the arrangement.
+ *
+ * @category Arrangement & Analysis
+ */
 export type TrackRole = 'melody' | 'harmony' | 'bass' | 'other';
 
-/** One input track: its notes plus optional name and role. */
+/**
+ * One input track: its notes plus optional name and role.
+ *
+ * @category Arrangement & Analysis
+ */
 export type ArrangementTrack = {
   name?: string;
   role?: TrackRole;
   notes: NoteEvent[];
 };
 
-/** A track after analysis: its resolved name, role, and per-note annotations. */
+/**
+ * A track after analysis: its resolved name, role, and per-note annotations.
+ *
+ * @category Arrangement & Analysis
+ */
 export type TrackAnalysis = {
   name: string;
   role: TrackRole;
@@ -47,7 +59,11 @@ export type TrackAnalysis = {
   notes: AnalyzedNote[];
 };
 
-/** A note that clashes with the harmony sounding beneath it. */
+/**
+ * A note that clashes with the harmony sounding beneath it.
+ *
+ * @category Arrangement & Analysis
+ */
 export type Conflict = {
   beat: number;
   trackName: string;
@@ -59,7 +75,11 @@ export type Conflict = {
   rationale?: string;
 };
 
-/** The full result of {@link analyzeArrangement}. */
+/**
+ * The full result of {@link analyzeArrangement}.
+ *
+ * @category Arrangement & Analysis
+ */
 export type ArrangementAnalysis = {
   key: KeyScale;
   timeline: ChordTimeline;
@@ -70,19 +90,35 @@ export type ArrangementAnalysis = {
   conflicts: Conflict[];
 };
 
-/** Options controlling {@link analyzeArrangement} and {@link tensionCurve}. */
+/**
+ * Options controlling {@link analyzeArrangement} and {@link tensionCurve}.
+ *
+ * @category Arrangement & Analysis
+ */
 export type ArrangementOptions = {
   /** Key context; inferred from the pooled notes when omitted. */
   key?: KeyScale;
-  /** Time signature; defaults to 4/4. */
+  /**
+   * Time signature; defaults to 4/4.
+   *
+   * @defaultValue `4/4`
+   */
   ts?: TimeSignature;
-  /** Chord-slot length in beats; defaults to one bar of `ts`. */
+  /**
+   * Chord-slot length in beats; defaults to one bar of `ts`.
+   *
+   * @defaultValue one bar of `ts`
+   */
   harmonicRhythm?: number;
-  /** Safety profile used for conflict detection; defaults to `pop`. */
+  /**
+   * Safety profile used for conflict detection; defaults to `pop`.
+   *
+   * @defaultValue `'pop'`
+   */
   profile?: SafetyProfile;
 };
 
-/** A note with the pitch that immediately preceded it in the same track. */
+/** A note with the pitch that immediately preceded it in the same sub-voice. */
 type PreparedNote = {
   pitch: number;
   prevPitch?: number;
@@ -90,16 +126,27 @@ type PreparedNote = {
   endBeat: number;
 };
 
-/** A track prepared for analysis: resolved metadata plus derived note views. */
-type PreparedTrack = {
-  name: string;
-  role: TrackRole;
-  /** The track's notes in time order, each with a stable id. */
+/** One monophonic sub-voice of a track: ordered notes plus sounding spans. */
+type PreparedVoice = {
+  /** The sub-voice's notes in time order, each with a stable id. */
   voice: VoiceNote[];
   /** The same notes as sounding spans, each carrying its predecessor's pitch. */
   sounding: PreparedNote[];
 };
 
+/** A track prepared for analysis: resolved metadata plus monophonic sub-voices. */
+type PreparedTrack = {
+  name: string;
+  role: TrackRole;
+  /**
+   * The track's notes partitioned into monophonic sub-voices. Voice analysis
+   * assumes one note at a time, so a polyphonic track (e.g. a 'harmony' track
+   * playing block chords) is split here; a monophonic track yields exactly one
+   * sub-voice.
+   */
+  voices: PreparedVoice[];
+};
+
 /** Reduce a pitch to a pitch class in [0, 11]. */
 function pitchClass(pitch: number): number {
   return ((Math.trunc(pitch) % 12) + 12) % 12;
@@ -110,91 +157,179 @@ function covers(note: PreparedNote, beat: number): boolean {
   return beat >= note.startBeat - EPS && beat < note.endBeat - EPS;
 }
 
-/** Every note of every track pooled into one flat list. */
+/**
+ * Every sounding note of every track pooled into one flat list. Zero- and
+ * negative-length notes never sound, so they are dropped here (matching the
+ * chord-inference ingest in the timeline module).
+ */
 function poolNotes(tracks: ArrangementTrack[]): NoteEvent[] {
   const notes: NoteEvent[] = [];
   for (const track of tracks) {
     for (const note of track.notes) {
-      notes.push(note);
+      if (note.durationBeat > 0) {
+        notes.push(note);
+      }
     }
   }
   return notes;
 }
 
 /**
- * Resolve each track's metadata and derive its ordered voice and sounding spans.
+ * Split a track's ordered notes into monophonic sub-voices.
  *
- * Notes are sorted by onset, then pitch, so ordering is deterministic; the
- * predecessor pitch used for suspension and parallel detection is simply the
- * previous note in that order.
+ * Greedy lane assignment: each note joins the first sub-voice that is free at
+ * its onset (its last note has ended), otherwise it opens a new sub-voice. A
+ * monophonic track therefore stays a single sub-voice, while block chords fan
+ * out into one sub-voice per simultaneous note, keeping every sub-voice's
+ * note-to-note adjacency genuinely melodic.
+ */
+function splitIntoSubVoices(ordered: VoiceNote[]): VoiceNote[][] {
+  const lanes: VoiceNote[][] = [];
+  for (const note of ordered) {
+    const lane = lanes.find((candidate) => {
+      const last = candidate[candidate.length - 1];
+      return last !== undefined && last.startBeat + last.durationBeat <= note.startBeat + EPS;
+    });
+    if (lane) {
+      lane.push(note);
+    } else {
+      lanes.push([note]);
+    }
+  }
+  return lanes;
+}
+
+/**
+ * Resolve each track's metadata and derive its monophonic sub-voices.
+ *
+ * Notes are sorted by onset, then pitch, so ordering is deterministic, and ids
+ * are assigned in that order. Zero- and negative-length notes never sound and
+ * are dropped at ingest. Each track is then partitioned into monophonic
+ * sub-voices (see {@link splitIntoSubVoices}); the predecessor pitch used for
+ * suspension and parallel detection is the previous note of the same sub-voice,
+ * never a simultaneous chord member.
  */
 function prepareTracks(tracks: ArrangementTrack[]): PreparedTrack[] {
   let nextId = 0;
   return tracks.map((track, index) => {
-    const ordered = [...track.notes].sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch);
-    const voice: VoiceNote[] = ordered.map((note) => ({ ...note, id: nextId++ }));
-    const sounding: PreparedNote[] = ordered.map((note, i) => {
-      const prev = i > 0 ? ordered[i - 1] : undefined;
-      return {
-        pitch: note.pitch,
-        prevPitch: prev?.pitch,
-        startBeat: note.startBeat,
-        endBeat: note.startBeat + note.durationBeat,
-      };
-    });
+    const ordered: VoiceNote[] = track.notes
+      .filter((note) => note.durationBeat > 0)
+      .sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch)
+      .map((note) => ({ ...note, id: nextId++ }));
+    const voices: PreparedVoice[] = splitIntoSubVoices(ordered).map((voice) => ({
+      voice,
+      sounding: voice.map((note, i) => {
+        const prev = i > 0 ? voice[i - 1] : undefined;
+        return {
+          pitch: note.pitch,
+          prevPitch: prev?.pitch,
+          startBeat: note.startBeat,
+          endBeat: note.startBeat + note.durationBeat,
+        };
+      }),
+    }));
     return {
       name: track.name ?? `track ${index + 1}`,
       role: track.role ?? 'other',
-      voice,
-      sounding,
+      voices,
     };
   });
 }
 
-/** Sounding pitches of every track except `excludeIndex` at a beat. */
+/**
+ * Sounding pitches of every sub-voice at a beat, excluding one sub-voice.
+ *
+ * Only the sub-voice under analysis is excluded — sibling sub-voices of the
+ * same track are included, so dissonant clusters inside a single polyphonic
+ * track are still detected.
+ */
 function otherVoicesSounding(
   prepared: PreparedTrack[],
-  excludeIndex: number,
+  excludeTrack: number,
+  excludeVoice: number,
   beat: number,
 ): VoiceSnapshot[] {
   const out: VoiceSnapshot[] = [];
   for (let t = 0; t < prepared.length; t += 1) {
-    if (t === excludeIndex) {
-      continue;
-    }
     const track = prepared[t];
     if (!track) {
       continue;
     }
-    for (const note of track.sounding) {
-      if (!covers(note, beat)) {
+    for (let v = 0; v < track.voices.length; v += 1) {
+      if (t === excludeTrack && v === excludeVoice) {
+        continue;
+      }
+      const subVoice = track.voices[v];
+      if (!subVoice) {
         continue;
       }
-      const snap: VoiceSnapshot = { pitch: note.pitch };
-      if (note.prevPitch !== undefined) {
-        snap.prevPitch = note.prevPitch;
+      for (const note of subVoice.sounding) {
+        if (!covers(note, beat)) {
+          continue;
+        }
+        const snap: VoiceSnapshot = { pitch: note.pitch };
+        if (note.prevPitch !== undefined) {
+          snap.prevPitch = note.prevPitch;
+        }
+        out.push(snap);
       }
-      out.push(snap);
     }
   }
   return out;
 }
 
+/**
+ * The beats at which a note must be checked against the harmony: its onset,
+ * plus the onset of every later chord segment the note sustains across. Each
+ * crossed segment is visited exactly once (at its own start), so a boundary
+ * beat is never evaluated twice for the same note.
+ */
+function evaluationBeats(note: VoiceNote, timeline: ChordTimeline): number[] {
+  const noteEnd = note.startBeat + note.durationBeat;
+  const beats = [note.startBeat];
+  for (const segment of timeline.segments) {
+    if (segment.startBeat > note.startBeat + EPS && segment.startBeat < noteEnd - EPS) {
+      beats.push(segment.startBeat);
+    }
+  }
+  return beats;
+}
+
 /**
  * Analyse a whole arrangement against a single inferred harmony.
  *
  * The chord timeline and key are inferred from the pooled notes of every track
  * (see {@link chordTimelineFromNotes}); pooling all voices is robust even when
  * roles are absent or a track doubles the harmony, so it is preferred over
- * deriving the harmony from a subset. Each track is then labelled note-by-note
- * against that harmony with {@link analyzeVoice}, seeing the other tracks as its
- * accompaniment, and every note is re-checked with {@link evaluateSafety}: those
- * that are not {@link NoteSafety.Safe} against the sounding chord become
- * conflicts, sorted worst severity first and then by beat.
+ * deriving the harmony from a subset. Zero- and negative-length notes never
+ * sound, so they are dropped at ingest and appear in neither the annotations
+ * nor the conflicts.
+ *
+ * Voice analysis assumes one monophonic voice at a time, so each track is
+ * first partitioned into monophonic sub-voices (a polyphonic block-chord track
+ * fans out into one sub-voice per simultaneous note; a monophonic track is
+ * unaffected). Each sub-voice is labelled note-by-note against the harmony
+ * with {@link analyzeVoice}, seeing every other sub-voice — including siblings
+ * within the same track — as its accompaniment. Every note is then re-checked
+ * with {@link evaluateSafety} at its onset and again at each chord change it
+ * sustains across, so a held note that clashes with a later chord is caught:
+ * evaluations that are not {@link NoteSafety.Safe} become conflicts, one per
+ * clashing beat, sorted worst severity first and then by beat.
  *
  * @param tracks The tracks to analyse.
  * @param opts Analysis options; see {@link ArrangementOptions}.
  * @returns The inferred harmony, per-track annotations, cadences, and conflicts.
+ * @example
+ * ```ts
+ * import { analyzeArrangement } from '@libraz/libcantus';
+ * const melody = [
+ *   { pitch: 60, startBeat: 0, durationBeat: 2 },
+ *   { pitch: 67, startBeat: 2, durationBeat: 2 },
+ * ];
+ * const { key, conflicts } = analyzeArrangement([{ role: 'melody', notes: melody }]);
+ * conflicts; // notes clashing with the inferred harmony, worst severity first
+ * ```
+ * @category Arrangement & Analysis
  */
 export function analyzeArrangement(
   tracks: ArrangementTrack[],
@@ -220,34 +355,47 @@ export function analyzeArrangement(
     if (!track) {
       continue;
     }
-    const notes = analyzeVoice(track.voice, timeline.at, key, (beat) =>
-      otherVoicesSounding(prepared, t, beat),
-    );
-    trackAnalyses.push({ name: track.name, role: track.role, notes });
-
-    for (const note of track.voice) {
-      const result = evaluateSafety({
-        profile,
-        candidatePitch: note.pitch,
-        chord: timeline.at(note.startBeat),
-        key,
-        otherVoices: otherVoicesSounding(prepared, t, note.startBeat),
-        strongBeat: isStrongBeat(note.startBeat, ts),
-      });
-      if (result.safety !== NoteSafety.Safe) {
-        const conflict: Conflict = {
-          beat: note.startBeat,
-          trackName: track.name,
-          pitch: note.pitch,
-          safety: result.safety,
-          reasons: result.reasons,
-        };
-        if (result.rationale !== undefined) {
-          conflict.rationale = result.rationale;
+    const notes: AnalyzedNote[] = [];
+    for (let v = 0; v < track.voices.length; v += 1) {
+      const subVoice = track.voices[v];
+      if (!subVoice) {
+        continue;
+      }
+      notes.push(
+        ...analyzeVoice(subVoice.voice, timeline.at, key, (beat) =>
+          otherVoicesSounding(prepared, t, v, beat),
+        ),
+      );
+
+      for (const note of subVoice.voice) {
+        for (const beat of evaluationBeats(note, timeline)) {
+          const result = evaluateSafety({
+            profile,
+            candidatePitch: note.pitch,
+            chord: timeline.at(beat),
+            key,
+            otherVoices: otherVoicesSounding(prepared, t, v, beat),
+            strongBeat: isStrongBeat(beat, ts),
+          });
+          if (result.safety !== NoteSafety.Safe) {
+            const conflict: Conflict = {
+              beat,
+              trackName: track.name,
+              pitch: note.pitch,
+              safety: result.safety,
+              reasons: result.reasons,
+            };
+            if (result.rationale !== undefined) {
+              conflict.rationale = result.rationale;
+            }
+            conflicts.push(conflict);
+          }
         }
-        conflicts.push(conflict);
       }
     }
+    // Sub-voice results interleave; restore the track's onset-then-pitch order.
+    notes.sort((a, b) => a.noteId - b.noteId);
+    trackAnalyses.push({ name: track.name, role: track.role, notes });
   }
 
   conflicts.sort((a, b) => b.safety - a.safety || a.beat - b.beat);
@@ -255,7 +403,11 @@ export function analyzeArrangement(
   return { key, timeline, segmentConfidence, cadences, tracks: trackAnalyses, conflicts };
 }
 
-/** A tension reading sampled at a beat. */
+/**
+ * A tension reading sampled at a beat.
+ *
+ * @category Arrangement & Analysis
+ */
 export type TensionPoint = {
   beat: number;
   /** Combined tension in [0, 1]. */
@@ -302,6 +454,14 @@ function clamp01(value: number): number {
  * @param opts Analysis options plus an optional `step` (default one beat).
  * @returns One {@link TensionPoint} per sampled beat, in beat order.
  * @throws If `step` is not positive.
+ * @example
+ * ```ts
+ * import { tensionCurve } from '@libraz/libcantus';
+ * const notes = [{ pitch: 60, startBeat: 0, durationBeat: 4 }];
+ * const curve = tensionCurve([{ notes }], { step: 1 });
+ * curve; // one { beat, tension } sample per beat, in beat order
+ * ```
+ * @category Arrangement & Analysis
  */
 export function tensionCurve(
   tracks: ArrangementTrack[],
@@ -340,9 +500,11 @@ function allSounding(prepared: PreparedTrack[], beat: number): { pitch: number;
     if (!track) {
       continue;
     }
-    for (const note of track.sounding) {
-      if (covers(note, beat)) {
-        out.push({ pitch: note.pitch, track: t });
+    for (const subVoice of track.voices) {
+      for (const note of subVoice.sounding) {
+        if (covers(note, beat)) {
+          out.push({ pitch: note.pitch, track: t });
+        }
       }
     }
   }