@wenathlan/debonair 2.0.94 → 2.0.117

package/tests/familyurl.test.ts

@@ -0,0 +1,32 @@
+// # familyurl.test — the family link resolver of the root layer: the relative
+// sibling path the chrome builds for the other deploy units of the family,
+// runnable with the vitest runner:
+//   pnpm test
+// Every test watches the contract the family promises: the url always climbs
+// one level into the sibling folder, is slash-terminated, survives slugs
+// that arrive decorated with slashes and answers for every member of the
+// family.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { familyurl } from "../familyurl.ts";
+
+describe("familyurl", () => {
+  it("climbs one level and enters the sibling folder, slash-terminated", () => {
+    assert.equal(familyurl("cadria"), "../cadria/");
+  });
+
+  it("strips decorative slashes from the slug", () => {
+    assert.equal(familyurl("/cadria/"), "../cadria/");
+    assert.equal(familyurl("///cadria///"), "../cadria/");
+  });
+
+  it("answers for every deploy unit of the family", () => {
+    for (const slug of ["devthink", "cadria", "stealthhead", "foundry", "forge", "vault", "getry"]) {
+      assert.equal(familyurl(slug), `../${slug}/`);
+    }
+  });
+
+  it("keeps multi-segment slugs as the caller wrote them (minus the decoration)", () => {
+    assert.equal(familyurl("family/apps"), "../family/apps/");
+  });
+});

package/tests/fingerprint.test.ts

@@ -0,0 +1,61 @@
+// # fingerprint.test — the audio identity domain: the constellation is
+// deterministic, the landmarks fold into stable 32-bit hashes, the db
+// answers the right track by votes and stays null on an empty index.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { FingerprintDB, fingerprintOf, landmarksOf, peaksOfFrame } from "../fingerprint.ts";
+import { frameSpectrum } from "../spectrum.ts";
+
+/** Builds a deterministic tone mixture the tests analyze. */
+function tone(seedHz: number, seconds: number, sampleRate = 44100): number[] {
+  const out: number[] = [];
+  for (let i = 0; i < seconds * sampleRate; i++) {
+    const t = i / sampleRate;
+    out.push(0.5 * Math.sin(2 * Math.PI * seedHz * t) + 0.25 * Math.sin(2 * Math.PI * (seedHz * 2) * t));
+  }
+  return out;
+}
+
+describe("fingerprint — constellation", () => {
+  it("picks at most one peak per band and keeps them in-band", () => {
+    const sine = tone(220, 0.1);
+    const frame = frameSpectrum(sine.slice(0, 4096));
+    const peaks = peaksOfFrame(frame, 0);
+    assert.ok(peaks.length >= 1 && peaks.length <= 5);
+    for (const peak of peaks) assert.ok(peak.bin > 0 && peak.bin < frame.magnitudes.length);
+  });
+
+  it("answers identical landmarks for identical audio", () => {
+    const a = fingerprintOf(tone(330, 0.5), 44100);
+    const b = fingerprintOf(tone(330, 0.5), 44100);
+    assert.deepEqual(a, b);
+  });
+
+  it("folds pair lags into the hash without collisions on distinct pairs", () => {
+    const landmarks = landmarksOf([
+      { frame: 0, bin: 10 },
+      { frame: 4, bin: 40 },
+      { frame: 8, bin: 90 },
+    ]);
+    const hashes = new Set(landmarks.map((l) => l.hash));
+    assert.equal(hashes.size, landmarks.length);
+  });
+});
+
+describe("fingerprint — FingerprintDB", () => {
+  it("identifies the registered track by votes", () => {
+    const db = new FingerprintDB();
+    const track = fingerprintOf(tone(294, 0.6), 44100);
+    db.add("track-a", track);
+    const match = db.search(fingerprintOf(tone(294, 0.6), 44100));
+    assert.equal(match.trackId, "track-a");
+    assert.ok(match.score > 0);
+  });
+
+  it("answers a null track on an empty db", () => {
+    const db = new FingerprintDB();
+    const match = db.search(fingerprintOf(tone(294, 0.4), 44100));
+    assert.equal(match.trackId, null);
+    assert.equal(match.score, 0);
+  });
+});

package/tests/genrematrix.test.ts

@@ -0,0 +1,116 @@
+// # genrematrix.test — honest unit tests for the style dictionary (the
+// fifteen entries, their bpm windows and loudness targets, the family,
+// progression and scale references, the seeded bpm pick, the free-text
+// genre match and the whole-matrix validation), runnable with the vitest
+// runner:
+//   pnpm test
+// Every fixture is the matrix table itself — no randomness beyond the
+// engine's mulberry32 driven by fixed seeds.
+import { describe, expect, it } from "vitest";
+import { GENRES, genreById, matchGenre, pickBpm, validateMatrix } from "../genrematrix.ts";
+import { PROGRESSION_IDS } from "../harmonyengine.ts";
+import { SCALE_NAMES } from "../musictheory.ts";
+import { FAMILY_NAMES } from "../rhythmgrammar.ts";
+
+describe("the matrix table", () => {
+  it("holds the fifteen documented genres", () => {
+    expect(GENRES.length).toBe(15);
+  });
+
+  it("carries unique lowercase ids", () => {
+    const ids = GENRES.map((genre) => genre.id);
+    expect(new Set(ids).size).toBe(15);
+    for (const id of ids) {
+      expect(id.length > 0).toBe(true);
+      expect(id, `${id} stays lowercase`).toBe(id.toLowerCase());
+      expect(/^[a-z][a-z0-9-]*$/.test(id), `${id} is a stable token`).toBe(true);
+    }
+  });
+
+  it("references real rhythmgrammar families", () => {
+    for (const genre of GENRES)
+      expect(FAMILY_NAMES.includes(genre.pattern), `${genre.id} -> ${genre.pattern}`).toBe(true);
+  });
+
+  it("references real progression sets, known scales and a legal swing", () => {
+    for (const genre of GENRES) {
+      expect(PROGRESSION_IDS.includes(genre.progressions), `${genre.id} -> ${genre.progressions}`).toBe(true);
+      expect(genre.scales.length > 0, `${genre.id} biases a scale`).toBe(true);
+      for (const scale of genre.scales) expect(SCALE_NAMES.includes(scale), `${genre.id}: ${scale}`).toBe(true);
+      expect(genre.swing >= 0.5 && genre.swing <= 0.75, `${genre.id} swing ${genre.swing}`).toBe(true);
+    }
+  });
+
+  it("keeps every bpm window inside the 40-220 band with a default inside it", () => {
+    for (const genre of GENRES) {
+      expect(genre.bpmin < genre.bpmax, `${genre.id} window opens`).toBe(true);
+      expect(genre.bpmin >= 40 && genre.bpmax <= 220, `${genre.id} window [${genre.bpmin}, ${genre.bpmax}]`).toBe(true);
+      expect(genre.bpm >= genre.bpmin && genre.bpm <= genre.bpmax, `${genre.id} default bpm ${genre.bpm}`).toBe(true);
+    }
+  });
+
+  it("masters inside the documented loudness band", () => {
+    for (const genre of GENRES) {
+      expect(Number.isFinite(genre.lufs), `${genre.id} lufs is a number`).toBe(true);
+      expect(genre.lufs >= -16 && genre.lufs <= -6, `${genre.id} lufs ${genre.lufs}`).toBe(true);
+    }
+    expect(genreById("ambient")?.lufs).toBe(-16);
+    expect(genreById("hyperpop")?.lufs).toBe(-7);
+  });
+
+  it("tags non-empty timbre hints on every genre", () => {
+    for (const genre of GENRES) {
+      expect(genre.timbre.length > 0, `${genre.id} carries timbre`).toBe(true);
+      for (const tag of genre.timbre) expect(tag.length > 0, `${genre.id}: "${tag}"`).toBe(true);
+    }
+  });
+});
+
+describe("lookups", () => {
+  it("answers genreById with the entry or nothing", () => {
+    expect(genreById("trap")).toBe(GENRES[0]);
+    expect(genreById("trap")?.label).toBe("Trap");
+    expect(genreById("rude-trap")?.pattern).toBe("trap");
+    expect(genreById("no-such-genre")).toBeUndefined();
+  });
+});
+
+describe("seeded bpm pick", () => {
+  it("replays the same bpm for the same seed, always inside the window", () => {
+    for (const genre of GENRES) {
+      expect(pickBpm(genre, "demo")).toBe(pickBpm(genre, "demo"));
+      const bpm = pickBpm(genre, "seed-a");
+      expect(Number.isInteger(bpm), `${genre.id} picks an integer`).toBe(true);
+      expect(bpm >= genre.bpmin && bpm <= genre.bpmax, `${genre.id} bpm ${bpm}`).toBe(true);
+    }
+  });
+
+  it("varies with the seed while staying inside the window", () => {
+    const trap = GENRES[0];
+    const picks = new Set(["one", "two", "three", "four", "five"].map((seed) => pickBpm(trap, seed)));
+    expect(picks.size > 1, "different seeds move the pick").toBe(true);
+    for (const bpm of picks) expect(bpm >= trap.bpmin && bpm <= trap.bpmax).toBe(true);
+  });
+});
+
+describe("free-text match", () => {
+  it("matches by label, alias and timbre tags", () => {
+    expect(matchGenre("Trap")?.id).toBe("trap");
+    expect(matchGenre("Drum & Bass")?.id).toBe("dnb");
+    expect(matchGenre("lo-fi")?.id).toBe("lofi");
+    expect(matchGenre("808 sub")?.id).toBe("trap");
+  });
+
+  it("scores free text and answers nothing on a miss", () => {
+    expect(matchGenre("make me a drill beat")?.id).toBe("drill");
+    expect(matchGenre("hyperpop glitch")?.id).toBe("hyperpop");
+    expect(matchGenre("zzz qqq wibble")).toBeUndefined();
+    expect(matchGenre("")).toBeUndefined();
+  });
+});
+
+describe("matrix validation", () => {
+  it("clears the matrix against the sibling tables", () => {
+    expect(validateMatrix()).toEqual([]);
+  });
+});

package/tests/harmonyengine.test.ts

@@ -0,0 +1,204 @@
+// # harmonyengine.test — honest unit tests for the progression grammar
+// (progression sets, seeded generator, tension curve, cadence detection,
+// reharmonisation passes), runnable with the vitest runner:
+//   pnpm test
+// The only randomness is the engine's own mulberry32 driven by fixed seeds.
+import { describe, expect, it } from "vitest";
+import {
+  type Chord,
+  detectCadence,
+  generateProgression,
+  hashSeed,
+  type Key,
+  mulberry32,
+  PROGRESSION_IDS,
+  PROGRESSION_SETS,
+  pickProgression,
+  reharmonizeDiatonic,
+  reharmonizeRelative,
+  tensionOf,
+} from "../harmonyengine.ts";
+import { chordSymbol, parseChord, parseRoman, scalePcs } from "../musictheory.ts";
+
+const C = { tonic: 0, mode: "major" } as const;
+const Am = { tonic: 9, mode: "aeolian" } as const;
+
+/** Parses a lead-sheet symbol and asserts the landing (the non-null guard the suite pins). */
+const chord = (token: string): Chord => {
+  const parsed = parseChord(token);
+  expect(parsed, `${token} parses`).toBeTruthy();
+  return parsed as Chord;
+};
+
+/** Parses a roman numeral against a key and asserts the landing. */
+const roman = (token: string, key: Key): Chord => {
+  const parsed = parseRoman(token, key);
+  expect(parsed, `${token} parses`).toBeTruthy();
+  return parsed as Chord;
+};
+
+describe("seeded randomness", () => {
+  it("folds a seed string into one uint32, deterministically", () => {
+    expect(hashSeed("42")).toBe(hashSeed("42"));
+    expect(hashSeed("42")).not.toBe(hashSeed("43"));
+    expect(hashSeed(""), "the FNV offset basis").toBe(0x811c9dc5);
+    expect(Number.isInteger(hashSeed("katexis")) && hashSeed("katexis") >= 0).toBe(true);
+  });
+
+  it("runs the same mulberry32 sequence for the same seed", () => {
+    const a = mulberry32(hashSeed("seed"));
+    const b = mulberry32(hashSeed("seed"));
+    const c = mulberry32(hashSeed("other"));
+    const first = [a(), a(), a()];
+    expect(first).toEqual([b(), b(), b()]);
+    expect(first.every((v) => v >= 0 && v < 1)).toBe(true);
+    expect(first).not.toEqual([c(), c(), c()]);
+  });
+});
+
+describe("progression sets", () => {
+  it("documents the nine style families", () => {
+    expect([...PROGRESSION_IDS].sort()).toEqual(
+      ["ambient", "dnb", "drill", "house", "jazz", "lofi", "pop", "techno", "trap"].sort(),
+    );
+    for (const id of PROGRESSION_IDS) {
+      const spec = PROGRESSION_SETS[id];
+      expect(spec.mode === "major" || spec.mode === "minor", `${id} names a mode`).toBe(true);
+      expect(spec.loops.length >= 2, `${id} carries loops`).toBe(true);
+      expect(spec.moods.length >= 2, `${id} carries moods`).toBe(true);
+    }
+  });
+
+  it("parses every numeral of every loop in the set's home mode", () => {
+    for (const id of PROGRESSION_IDS) {
+      const spec = PROGRESSION_SETS[id];
+      const key: Key = spec.mode === "major" ? { tonic: 0, mode: "major" } : { tonic: 9, mode: "aeolian" };
+      for (const loop of spec.loops) {
+        for (const token of loop.split("-")) {
+          const parsed = roman(token, key);
+          if (!/^[b#]/.test(token))
+            expect(scalePcs(key).includes(parsed.root), `${id}: ${token} roots inside the scale`).toBe(true);
+        }
+      }
+    }
+  });
+});
+
+describe("progression generator", () => {
+  it("plays the same chords for the same seed, key and mood", () => {
+    const a = generateProgression({ seed: "demo", key: C, mood: "bright radio", bars: 8 });
+    const b = generateProgression({ seed: "demo", key: C, mood: "bright radio", bars: 8 });
+    expect(a).toEqual(b);
+    expect(
+      a.map((e) => e.symbol),
+      "the pop set cycles I-V-vi-IV",
+    ).toEqual(["C", "G", "Am", "F", "C", "G", "Am", "F"]);
+  });
+
+  it("varies with the seed and honours the bar count", () => {
+    const symbols = (seed: string) =>
+      generateProgression({ seed, key: C, mood: "bright", bars: 4 }).map((e) => e.symbol);
+    const variants = new Set(["one", "two", "three", "four"].map(symbols));
+    expect(variants.size > 1, "different seeds move the pick").toBe(true);
+    const nine = generateProgression({ seed: "demo", key: C, mood: "bright", bars: 9 });
+    expect(nine.length).toBe(9);
+    expect(nine.map((e) => e.bar)).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8]);
+    expect(nine[8].symbol, "the loop wraps onto the ninth bar").toBe(nine[0].symbol);
+  });
+
+  it("routes moods to the documented sets", () => {
+    const trapKey = pickProgression(Am, "dark hard 808 night", mulberry32(1));
+    expect(PROGRESSION_IDS.find((id) => PROGRESSION_SETS[id] === trapKey)).toBe("trap");
+    const lofiKey = pickProgression(C, "chill study tape", mulberry32(1));
+    expect(PROGRESSION_IDS.find((id) => PROGRESSION_SETS[id] === lofiKey)).toBe("lofi");
+    const fallback = pickProgression(Am, "", mulberry32(1));
+    expect(fallback.mode, "a minor key with no mood still lands on a minor-mode set").toBe("minor");
+  });
+
+  it("keeps every tension inside the unit band", () => {
+    for (const seed of ["a", "b", "c", "d"]) {
+      const events = generateProgression({ seed, key: Am, mood: "dark", bars: 8 });
+      for (const event of events) {
+        expect(Number.isFinite(event.tension)).toBe(true);
+        expect(event.tension >= 0 && event.tension <= 1, `tension ${event.tension}`).toBe(true);
+      }
+    }
+  });
+});
+
+describe("tension curve", () => {
+  it("weights the functional degrees and quality extensions", () => {
+    expect(tensionOf(chord("C"), C), "the tonic rests").toBeLessThan(0.2);
+    expect(tensionOf(chord("G7"), C), "the dominant pulls").toBeGreaterThan(tensionOf(chord("C"), C));
+    expect(tensionOf(chord("G7"), C), "the seventh bites").toBeGreaterThan(tensionOf(chord("G"), C));
+    expect(tensionOf(chord("Bdim7"), C), "alterations never relax the degree").toBeGreaterThanOrEqual(
+      tensionOf(chord("Bdim"), C),
+    );
+    expect(tensionOf(chord("Cmaj7"), C), "maj7 softens").toBeLessThan(tensionOf(chord("C"), C) + 1e-9);
+    expect(tensionOf(chord("Db7"), C), "a chromatic root sits at 0.7 plus the seventh").toBeCloseTo(0.75, 9);
+    expect(
+      tensionOf(chord("G7"), Am),
+      "the same chord weighs by its degree in the key: VII in minor, V in major",
+    ).toBeGreaterThan(tensionOf(chord("G7"), C));
+  });
+});
+
+describe("cadence detection", () => {
+  it("answers the documented table", () => {
+    expect(detectCadence([chord("G7"), chord("C")], C)).toBe("perfect");
+    expect(detectCadence([chord("G"), chord("C")], C)).toBe("authentic");
+    expect(detectCadence([chord("F"), chord("C")], C)).toBe("plagal");
+    expect(detectCadence([chord("Dm"), chord("G")], C)).toBe("half");
+    expect(detectCadence([chord("G"), chord("Am")], C)).toBe("deceptive");
+    expect(detectCadence([chord("Dm"), chord("E")], Am), "iv -> V in a minor key").toBe("phrygian");
+    expect(detectCadence([chord("C"), chord("Dm"), chord("G")], C), "only the last pair counts").toBe("half");
+  });
+
+  it("answers none for short, chromatic or non-cadential pairs", () => {
+    expect(detectCadence([chord("C")], C)).toBe("none");
+    expect(detectCadence([chord("Db"), chord("C")], C), "chromatic roots stay silent").toBe("none");
+    expect(detectCadence([chord("C"), chord("Dm")], C)).toBe("none");
+    expect(detectCadence([chord("Dm"), chord("G"), chord("Am")], Am), "vii-less minor pairs").toBe("none");
+  });
+});
+
+describe("reharmonisation passes", () => {
+  it("substitutes along the documented third relations, seeded", () => {
+    const base = [chord("C"), chord("Dm"), chord("G"), chord("F"), chord("Db7")];
+    expect(reharmonizeDiatonic(base, C, mulberry32(7), 0).map(chordSymbol), "probability 0 keeps everything").toEqual([
+      "C",
+      "Dm",
+      "G",
+      "F",
+      "C#7",
+    ]);
+    const all = reharmonizeDiatonic(base, C, mulberry32(1), 1).map(chordSymbol);
+    expect(all, "probability 1 swaps every diatonic partner, chromatic roots stay").toEqual([
+      "Am",
+      "F",
+      "Em",
+      "Dm",
+      "C#7",
+    ]);
+    const once = reharmonizeDiatonic(base, C, mulberry32(11), 0.5);
+    const again = reharmonizeDiatonic(base, C, mulberry32(11), 0.5);
+    expect(once, "the same rng seed replays the same pass").toEqual(again);
+  });
+
+  it("swaps a major key to its relative minor, notes untouched", () => {
+    const loop = [chord("C"), chord("G"), chord("Am"), chord("F")];
+    const swap = reharmonizeRelative(loop, C);
+    expect(swap.key).toEqual({ tonic: 9, mode: "aeolian" });
+    expect(swap.numerals).toEqual(["III", "VII", "i", "VI"]);
+    for (let i = 0; i < loop.length; i++) {
+      const back = roman(swap.numerals[i] ?? "", swap.key);
+      expect(chordSymbol(back), "every chord keeps its notes").toBe(chordSymbol(loop[i]));
+    }
+  });
+
+  it("swaps a minor key back to its relative major", () => {
+    const swap = reharmonizeRelative([chord("Am"), chord("F")], Am);
+    expect(swap.key).toEqual({ tonic: 0, mode: "major" });
+    expect(swap.numerals).toEqual(["vi", "IV"]);
+  });
+});

package/tests/katexis.test.ts

@@ -0,0 +1,97 @@
+// # katexis.test — the pure helper contract of the katexis engine root,
+// runnable with vitest:
+//   pnpm vitest run tests/katexis.test.ts
+// Every test watches the promises the helpers make: the tone maps stay
+// total (every status answers a tone, every tone answers its class
+// suffix), the mastering spec rides the documented loudness targets, the
+// fader readout always spells one decimal with the dB unit, the track name
+// keeps the first four words with the trailing punctuation trimmed, and
+// the filter answers every row untouched on an empty query. The random
+// draws only face their documented bounds (six-digit seed, 2:00-3:59).
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import {
+  deriveSeed,
+  estimateDuration,
+  filterTracks,
+  formatDb,
+  genreByLabel,
+  type LibraryTrackRow,
+  MASTERING,
+  PROMPT_MAX_LENGTH,
+  statusTone,
+  toneClass,
+  trackNameFromPrompt,
+} from "../katexis.ts";
+
+describe("katexis tones", () => {
+  it("maps every library status to a badge tone", () => {
+    assert.equal(statusTone("ready"), "success");
+    assert.equal(statusTone("rendering"), "warning");
+    assert.equal(statusTone("draft"), "info");
+  });
+  it("answers the class suffix per tone and empty for the default", () => {
+    assert.equal(toneClass("default"), "");
+    assert.equal(toneClass("success"), " success");
+    assert.equal(toneClass("error"), " error");
+    assert.equal(toneClass("warning"), " warning");
+    assert.equal(toneClass("info"), " info");
+  });
+});
+
+describe("katexis spec", () => {
+  it("pins the mastering targets the engine documents", () => {
+    assert.equal(MASTERING.sampleRateHz, 48000);
+    assert.equal(MASTERING.truePeakDbtp, -1);
+    assert.equal(MASTERING.loudnessStandard, "BS.1770-4");
+    assert.deepEqual(MASTERING.platformTargetsLufs, { spotify: -14, apple: -16, beatport: -9 });
+    assert.equal(PROMPT_MAX_LENGTH, 280);
+  });
+});
+
+describe("katexis helpers", () => {
+  it("formats fader readouts with one decimal and the unit", () => {
+    assert.equal(formatDb(-4), "-4.0 dB");
+    assert.equal(formatDb(-12.25), "-12.3 dB");
+    assert.equal(formatDb(0), "0.0 dB");
+  });
+  it("draws the seed inside the six-digit band", () => {
+    for (let i = 0; i < 200; i++) {
+      const seed = deriveSeed();
+      assert.ok(seed >= 100000 && seed <= 999999);
+      assert.equal(Number.isInteger(seed), true);
+    }
+  });
+  it("keeps the estimate inside the 2:00-3:59 band", () => {
+    for (let i = 0; i < 200; i++) {
+      const estimate = estimateDuration();
+      assert.match(estimate, /^[23]:\d{2}$/);
+    }
+  });
+  it("builds the track name from the first four words, punctuation trimmed", () => {
+    assert.equal(trackNameFromPrompt("  midnight   harbor run. longer tail "), "Midnight harbor run. longer");
+    assert.equal(trackNameFromPrompt("deep, dark; brassy!"), "Deep, dark; brassy");
+    assert.equal(trackNameFromPrompt("solo"), "Solo");
+  });
+  it("finds a genre by its exact label", () => {
+    const genres = [
+      { id: "techno", label: "Techno" },
+      { id: "jazz", label: "Jazz" },
+    ];
+    assert.deepEqual(genreByLabel(genres, "Jazz"), { id: "jazz", label: "Jazz" });
+    assert.equal(genreByLabel(genres, "jazz"), undefined);
+    assert.equal(genreByLabel(genres, "Ambient"), undefined);
+  });
+  it("filters rows over name, genre and status, empty query copies all", () => {
+    const rows: LibraryTrackRow[] = [
+      { name: "Midnight Harbor", genre: "Techno", status: "ready", duration: "2:40" },
+      { name: "Brass Dusk", genre: "Jazz", status: "draft", duration: "3:05" },
+    ];
+    assert.equal(filterTracks(rows, "").length, 2);
+    assert.deepEqual(filterTracks(rows, ""), rows);
+    assert.equal(filterTracks(rows, "techno").length, 1);
+    assert.equal(filterTracks(rows, "READY").length, 1);
+    assert.equal(filterTracks(rows, "harbor")[0]?.name, "Midnight Harbor");
+    assert.equal(filterTracks(rows, "nope").length, 0);
+  });
+});