insomni-plot 0.1.0-alpha.0

package/src/stats/index.d.ts

@@ -0,0 +1,200 @@
+export { confidenceBand, linearFit, loessFit, polyFit, type ConfidenceBandOptions, type ConfidenceBandPoint, type LoessOptions, type RegressionFit, } from "./regression.ts";
+export { rollingWindow, type RollingAxis, type RollingPoint, type RollingStatistic, type RollingStatisticKind, type RollingWindow, type RollingWindowOptions, } from "./rolling-window.ts";
+export type QuantileMethod = "type-7" | "type-1";
+/**
+ * Quantile of an already-sorted ascending numeric array.
+ *
+ * - `"type-7"` (default): R's default — linear interpolation between order
+ *   stats with `h = (n - 1) * p`. The quantile method most users expect.
+ * - `"type-1"`: inverse-of-empirical-CDF (step function). No interpolation.
+ *
+ * Returns `NaN` for empty input. Clamps `p` to `[0, 1]`.
+ */
+export declare function quantile(sorted: readonly number[], p: number, method?: QuantileMethod): number;
+export type WhiskerRule = number | "minmax";
+export interface BoxStats {
+    /** Sample size (after filtering non-finite). */
+    n: number;
+    /** Smallest value in the sample. */
+    min: number;
+    /** Lower whisker endpoint (clamped to data range). */
+    lowerWhisker: number;
+    q1: number;
+    median: number;
+    q3: number;
+    /** Upper whisker endpoint (clamped to data range). */
+    upperWhisker: number;
+    /** Largest value in the sample. */
+    max: number;
+    /** Q3 − Q1. */
+    iqr: number;
+    /** Values strictly outside the whiskers. Order preserves input order. */
+    outliers: number[];
+    /** Mean of the sample. Useful as an annotation; not used for box geometry. */
+    mean: number;
+}
+export interface BoxStatsOptions {
+    /**
+     * Whisker rule.
+     *
+     * - A number `k` (default `1.5`) — Tukey-style: whiskers extend to the most
+     *   extreme value within `k * IQR` of Q1/Q3. Anything beyond is an outlier.
+     * - `"minmax"` — whiskers extend to the data min/max; no outliers.
+     */
+    whisker?: WhiskerRule;
+    quantile?: QuantileMethod;
+}
+/**
+ * Compute Tukey-style box statistics. Filters non-finite inputs.
+ *
+ * Returns `null` for empty input — caller decides how to render `n=0`.
+ * For `n=1`, every quartile equals the single value and `outliers` is empty.
+ */
+export declare function boxStats(values: readonly number[], options?: BoxStatsOptions): BoxStats | null;
+export type KdeKernel = "gaussian" | "epanechnikov";
+export type KdeBandwidth = number | "silverman" | "scott";
+export interface KdeOptions {
+    /** Number of evaluation points. Default `64`, capped to `512`. */
+    gridSize?: number;
+    /**
+     * Either a positive number (fixed bandwidth in data units) or a rule:
+     * - `"silverman"` (default) — `1.06 · scale · n^(-1/5)` with the robust
+     *   scale `min(σ, IQR/1.34)`. Less sensitive to heavy tails / skew.
+     * - `"scott"` — `1.06 · σ · n^(-1/5)` using the plain standard deviation
+     *   (no IQR robustification). Wider on skewed/heavy-tailed samples.
+     */
+    bandwidth?: KdeBandwidth;
+    kernel?: KdeKernel;
+    /**
+     * Evaluate over `[min, max]` of the sample (`true`, default) or pad outward
+     * by ~3 bandwidths so density tails reach near-zero (`false`).
+     */
+    trim?: boolean;
+    /** Override the evaluation domain. Bypasses `trim`. */
+    domain?: readonly [number, number];
+}
+export interface KdeResult {
+    /** Evaluation grid (length `gridSize`). */
+    x: number[];
+    /** Density at each grid point (length `gridSize`). */
+    y: number[];
+    /** Resolved bandwidth in data units. */
+    bandwidth: number;
+}
+/**
+ * Kernel density estimate.
+ *
+ * Returns `null` for empty input. For all-equal samples falls back to a tiny
+ * bandwidth so callers don't divide by zero — the result is a narrow spike.
+ */
+export declare function kde(values: readonly number[], options?: KdeOptions): KdeResult | null;
+/**
+ * Group an iterable into a `Map` keyed by `key(item)`. Insertion order
+ * preserved per key; the map's key order is the order of first occurrence.
+ */
+export declare function groupBy<T, K>(items: Iterable<T>, key: (item: T, index: number) => K): Map<K, T[]>;
+export type BinRule = "sturges" | "scott" | "fd" | "rice";
+export type BinClosed = "left" | "right";
+export interface BinBreaksOptions {
+    /** Explicit bin count. Ignored if `binwidth` or `breaks` is set. */
+    bins?: number;
+    /** Explicit bin width in data units. Beats `bins` and `rule`. */
+    binwidth?: number;
+    /** Fully explicit edge array — bypasses rules entirely. */
+    breaks?: readonly number[];
+    /**
+     * Rule used to pick a bin count when neither `bins`, `binwidth`, nor
+     * `breaks` is provided.
+     *
+     * - `"sturges"` (default) — `⌈log₂ n⌉ + 1`. R / ggplot default.
+     * - `"rice"` — `⌈2 · n^(1/3)⌉`. Slightly higher resolution.
+     * - `"scott"` — `3.49 σ n^(-1/3)` width. Good for roughly normal data.
+     * - `"fd"` — Freedman-Diaconis `2 · IQR · n^(-1/3)` width. Robust on skew.
+     */
+    rule?: BinRule;
+    /** Clip edges to this. Default = `[min, max]` of data. */
+    domain?: readonly [number, number];
+    /** Round outer edges + step to nice numbers. Default `true`. */
+    nice?: boolean;
+}
+export interface BinResult {
+    /** Inclusive lower edge for `closed: "left"` (the default). */
+    x0: number;
+    /** Exclusive upper edge for `closed: "left"`, except the final bin. */
+    x1: number;
+    /** Number of input values that fell in this bin. */
+    count: number;
+    /** `count / (n · width)`. Sums to 1 across all bins (∑ density · width). */
+    density: number;
+}
+/**
+ * How a histogram bin's `count` is converted into a y-axis value:
+ * - `"count"` / `"frequency"`: raw `count`
+ * - `"density"`: `count / (n · width)` — area sums to 1
+ * - `"proportion"`: `count / n` — values sum to 1
+ */
+export type HistogramMeasure = "count" | "density" | "proportion" | "frequency";
+/**
+ * Convert a `BinResult` to its measured value under `measure`. `n` is the
+ * total sample count for the histogram (or per-group total for stacked /
+ * faceted cases) — used to normalise `density` and `proportion`.
+ */
+export declare function histogramMeasureValue(bin: BinResult, n: number, measure: HistogramMeasure): number;
+export interface BinOptions extends BinBreaksOptions {
+    /**
+     * Edge-closure convention. With `"left"` (default) bins are `[x0, x1)` and
+     * the final bin includes the max as `[x_{k-1}, x_k]`. With `"right"` the
+     * first bin is `[x_0, x_1]` and the rest are `(x_i, x_{i+1}]`.
+     */
+    closed?: BinClosed;
+}
+/**
+ * Compute bin edges for the given data. Returns an array of length
+ * `binCount + 1` describing the boundaries of each bin from left to right.
+ *
+ * Resolution order (highest precedence first): explicit `breaks` → `binwidth`
+ * → `bins` → `rule` (default `"sturges"`).
+ *
+ * Returns `[]` for empty / all-non-finite input.
+ */
+export declare function binBreaks(values: readonly number[], options?: BinBreaksOptions): number[];
+/**
+ * Bin a numeric sample into a sorted array of `BinResult`. Filters non-finite.
+ *
+ * Bins are half-open `[x0, x1)` by default (`closed: "left"`); the last bin
+ * is closed on both ends so the maximum value is counted. With
+ * `closed: "right"` the first bin is closed on both ends and the rest are
+ * `(x0, x1]`.
+ *
+ * Values strictly outside the resolved domain are dropped.
+ */
+export declare function bin(values: readonly number[], options?: BinOptions): BinResult[];
+/**
+ * Assign already-resolved values into known bin edges. Useful when the caller
+ * has computed `breaks` once across multiple groups (so per-group histograms
+ * align horizontally).
+ */
+export declare function binWithBreaks(values: readonly number[], breaks: readonly number[], closed?: BinClosed): BinResult[];
+export interface BinByOptions extends BinOptions {
+    /**
+     * Use one shared edge array for every group (default `true`) so per-group
+     * histograms align horizontally for stack/dodge/overlay. With `false`, each
+     * group computes its own breaks against its own data.
+     */
+    sharedBreaks?: boolean;
+}
+export interface BinByResult<K> {
+    breaks: number[];
+    groups: Map<K, BinResult[]>;
+}
+/**
+ * Bin a flat numeric array partitioned by key. Group iteration order matches
+ * first-occurrence order in the input.
+ */
+export declare function binBy<K>(values: readonly number[], keys: readonly K[], options?: BinByOptions): BinByResult<K>;
+/**
+ * Deterministic uniform jitter offsets in `[-width/2, +width/2]`. Same
+ * `(seed, count)` pair always produces the same sequence — important so that
+ * jittered overlay points don't dance between renders.
+ */
+export declare function jitter(seed: number, count: number, width: number): number[];

package/src/stats/index.test.ts

@@ -0,0 +1,349 @@
+import { describe, expect, test } from "vite-plus/test";
+
+import {
+  bin,
+  binBreaks,
+  binBy,
+  binWithBreaks,
+  boxStats,
+  groupBy,
+  jitter,
+  kde,
+  quantile,
+} from "./index.ts";
+
+// ============ Fixtures ============
+const fixture = {
+  // 11 evenly-spaced values 0..10 — quartiles fall on integers under type-7.
+  evenlySpaced: () => Array.from({ length: 11 }, (_, i) => i),
+  // Skewed sample with two outliers above 1.5 * IQR.
+  withOutliers: () => [1, 2, 2, 3, 3, 3, 4, 4, 5, 12, 18],
+  bimodal: () => [
+    ...Array.from({ length: 30 }, (_, i) => 0.2 + i * 0.01),
+    ...Array.from({ length: 30 }, (_, i) => 0.8 + i * 0.01),
+  ],
+};
+
+describe("quantile", () => {
+  test("type-7 matches R defaults on evenly-spaced data", () => {
+    const sorted = fixture.evenlySpaced();
+    expect(quantile(sorted, 0.0)).toBe(0);
+    expect(quantile(sorted, 0.25)).toBe(2.5);
+    expect(quantile(sorted, 0.5)).toBe(5);
+    expect(quantile(sorted, 0.75)).toBe(7.5);
+    expect(quantile(sorted, 1.0)).toBe(10);
+  });
+
+  test("type-1 returns order-statistics without interpolation", () => {
+    const sorted = fixture.evenlySpaced();
+    expect(quantile(sorted, 0.5, "type-1")).toBe(5);
+    expect(quantile(sorted, 0.25, "type-1")).toBe(2);
+  });
+
+  test("clamps p to [0, 1]", () => {
+    const sorted = [10, 20, 30];
+    expect(quantile(sorted, -1)).toBe(10);
+    expect(quantile(sorted, 2)).toBe(30);
+  });
+
+  test("returns NaN on empty input and the value itself for n=1", () => {
+    expect(Number.isNaN(quantile([], 0.5))).toBe(true);
+    expect(quantile([42], 0.5)).toBe(42);
+  });
+});
+
+describe("boxStats", () => {
+  test("computes Tukey stats and isolates outliers via 1.5 * IQR", () => {
+    const stats = boxStats(fixture.withOutliers())!;
+    expect(stats.n).toBe(11);
+    expect(stats.median).toBe(3);
+    expect(stats.q1).toBe(2.5);
+    expect(stats.q3).toBe(4.5);
+    expect(stats.iqr).toBe(2);
+    // Upper fence = 4.5 + 1.5*2 = 7.5 → 12 and 18 are outliers.
+    expect(stats.outliers).toEqual([12, 18]);
+    // Whiskers clamp to the most extreme inlier.
+    expect(stats.upperWhisker).toBe(5);
+    expect(stats.lowerWhisker).toBe(1);
+  });
+
+  test("'minmax' rule extends whiskers to data extremes with no outliers", () => {
+    const stats = boxStats(fixture.withOutliers(), { whisker: "minmax" })!;
+    expect(stats.lowerWhisker).toBe(1);
+    expect(stats.upperWhisker).toBe(18);
+    expect(stats.outliers).toEqual([]);
+  });
+
+  test("returns null on empty after filtering non-finite", () => {
+    expect(boxStats([])).toBe(null);
+    expect(boxStats([Number.NaN, Number.POSITIVE_INFINITY])).toBe(null);
+  });
+
+  test("collapses to the single value for n=1", () => {
+    const stats = boxStats([7])!;
+    expect(stats.n).toBe(1);
+    expect(stats.q1).toBe(7);
+    expect(stats.median).toBe(7);
+    expect(stats.q3).toBe(7);
+    expect(stats.iqr).toBe(0);
+    expect(stats.outliers).toEqual([]);
+  });
+
+  test("handles all-equal samples with IQR 0 and no outliers", () => {
+    const stats = boxStats([5, 5, 5, 5])!;
+    expect(stats.iqr).toBe(0);
+    expect(stats.outliers).toEqual([]);
+    expect(stats.lowerWhisker).toBe(5);
+    expect(stats.upperWhisker).toBe(5);
+  });
+});
+
+describe("kde", () => {
+  test("returns gridSize evaluation points across the data range", () => {
+    const result = kde(fixture.bimodal(), { gridSize: 32 })!;
+    expect(result.x).toHaveLength(32);
+    expect(result.y).toHaveLength(32);
+    expect(result.bandwidth).toBeGreaterThan(0);
+    // Trim default → grid spans the data extent exactly.
+    const finite = fixture.bimodal();
+    const min = Math.min(...finite);
+    const max = Math.max(...finite);
+    expect(result.x[0]).toBeCloseTo(min, 8);
+    expect(result.x[31]).toBeCloseTo(max, 8);
+  });
+
+  test("density integrates to roughly 1.0 (trapezoidal)", () => {
+    const result = kde(fixture.bimodal(), { gridSize: 256, trim: false })!;
+    let area = 0;
+    for (let i = 1; i < result.x.length; i++) {
+      const dx = result.x[i]! - result.x[i - 1]!;
+      area += 0.5 * (result.y[i]! + result.y[i - 1]!) * dx;
+    }
+    // Wide grid (3σ pad) catches most of the mass; ~1 with kernel & boundary slack.
+    expect(area).toBeGreaterThan(0.95);
+    expect(area).toBeLessThan(1.05);
+  });
+
+  test("falls back to a tiny bandwidth on all-equal samples without throwing", () => {
+    const result = kde([3, 3, 3, 3], { gridSize: 8 })!;
+    expect(result.bandwidth).toBeGreaterThan(0);
+    expect(result.y.every((v) => Number.isFinite(v))).toBe(true);
+  });
+
+  test("'scott' differs from 'silverman' on heavy-tailed data and matches 1.06 σ n^(-1/5)", () => {
+    // Skewed/heavy-tailed: IQR/1.34 ≈ 1.49 < σ, so the robust scale Silverman
+    // uses diverges from Scott's plain standard deviation.
+    const sample = fixture.withOutliers();
+
+    const scott = kde(sample, { bandwidth: "scott" })!;
+    const silverman = kde(sample, { bandwidth: "silverman" })!;
+
+    // The two rules must NOT coincide here.
+    expect(scott.bandwidth).not.toBeCloseTo(silverman.bandwidth, 8);
+    // Robust scale (min(σ, IQR/1.34)) ⇒ Silverman is the narrower of the two.
+    expect(silverman.bandwidth).toBeLessThan(scott.bandwidth);
+
+    // Hand-computed Scott: 1.06 · σ · n^(-1/5) with the sample (n-1) stddev.
+    const n = sample.length;
+    const mean = sample.reduce((s, v) => s + v, 0) / n;
+    const variance = sample.reduce((s, v) => s + (v - mean) ** 2, 0) / (n - 1);
+    const sd = Math.sqrt(variance);
+    const expected = 1.06 * sd * n ** (-1 / 5);
+    expect(scott.bandwidth).toBeCloseTo(expected, 10);
+  });
+
+  test("'scott' and 'silverman' coincide when σ ≤ IQR/1.34", () => {
+    // Evenly-spaced 0..10: σ ≈ 3.32, IQR/1.34 ≈ 3.73, so min(σ, IQR/1.34) = σ
+    // and the robust scale equals the plain stddev — both rules agree.
+    const sample = fixture.evenlySpaced();
+    const scott = kde(sample, { bandwidth: "scott" })!;
+    const silverman = kde(sample, { bandwidth: "silverman" })!;
+    expect(scott.bandwidth).toBeCloseTo(silverman.bandwidth, 10);
+  });
+
+  test("returns null on empty input", () => {
+    expect(kde([])).toBe(null);
+  });
+});
+
+describe("groupBy", () => {
+  test("preserves insertion order both in keys and within buckets", () => {
+    const items = [
+      { k: "a", v: 1 },
+      { k: "b", v: 2 },
+      { k: "a", v: 3 },
+      { k: "c", v: 4 },
+      { k: "b", v: 5 },
+    ];
+    const grouped = groupBy(items, (item) => item.k);
+    expect([...grouped.keys()]).toEqual(["a", "b", "c"]);
+    expect(grouped.get("a")!.map((i) => i.v)).toEqual([1, 3]);
+    expect(grouped.get("b")!.map((i) => i.v)).toEqual([2, 5]);
+  });
+});
+
+describe("binBreaks", () => {
+  test("explicit `breaks` short-circuits all rules", () => {
+    const breaks = binBreaks([0, 1, 2, 3], { breaks: [-1, 0, 1, 2, 3, 4] });
+    expect(breaks).toEqual([-1, 0, 1, 2, 3, 4]);
+  });
+
+  test("`binwidth` produces nice-aligned edges by default", () => {
+    const breaks = binBreaks([0.3, 1.7, 4.2, 7.9], { binwidth: 1 });
+    expect(breaks[0]).toBe(0);
+    expect(breaks[breaks.length - 1]).toBe(8);
+    expect(breaks).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8]);
+  });
+
+  test("`binwidth` with `nice: false` lands on raw min/max", () => {
+    const breaks = binBreaks([0.3, 7.9], { binwidth: 1, nice: false });
+    expect(breaks[0]).toBeCloseTo(0.3, 12);
+    expect(breaks.length).toBeGreaterThan(1);
+  });
+
+  test("`bins` with `nice: false` divides domain evenly", () => {
+    const breaks = binBreaks([0, 10], { bins: 4, nice: false });
+    expect(breaks).toEqual([0, 2.5, 5, 7.5, 10]);
+  });
+
+  test("Sturges rule yields ⌈log2 n⌉ + 1 bins (default)", () => {
+    // n=8 → log2 8 = 3 → 4 bins
+    const breaks = binBreaks([1, 2, 3, 4, 5, 6, 7, 8], { nice: false });
+    expect(breaks.length - 1).toBe(4);
+  });
+
+  test("returns `[]` for empty / non-finite input", () => {
+    expect(binBreaks([])).toEqual([]);
+    expect(binBreaks([Number.NaN, Number.POSITIVE_INFINITY])).toEqual([]);
+  });
+
+  test("`domain` clips edges and `nice: false` honors exact bounds", () => {
+    const breaks = binBreaks([0, 1, 2, 3, 4, 5], {
+      bins: 5,
+      domain: [0, 5],
+      nice: false,
+    });
+    expect(breaks).toEqual([0, 1, 2, 3, 4, 5]);
+  });
+});
+
+describe("bin", () => {
+  test("`closed: 'left'` is half-open and includes the max in the last bin", () => {
+    const result = bin([0, 0.5, 1, 1.5, 2, 2.5, 3], {
+      breaks: [0, 1, 2, 3],
+      closed: "left",
+    });
+    expect(result).toHaveLength(3);
+    expect(result.map((b) => b.count)).toEqual([2, 2, 3]);
+  });
+
+  test("`closed: 'right'` includes the min in the first bin", () => {
+    const result = bin([0, 0.5, 1, 1.5, 2, 2.5, 3], {
+      breaks: [0, 1, 2, 3],
+      closed: "right",
+    });
+    // 0 → bin0 (special), 0.5 → bin0, 1.0 → bin0 ((0,1]),
+    // 1.5 → bin1, 2.0 → bin1, 2.5 → bin2, 3.0 → bin2.
+    expect(result.map((b) => b.count)).toEqual([3, 2, 2]);
+  });
+
+  test("density integrates to 1 across bins", () => {
+    const result = bin([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], { bins: 5, nice: false });
+    let area = 0;
+    for (const b of result) area += b.density * (b.x1 - b.x0);
+    expect(area).toBeCloseTo(1, 8);
+  });
+
+  test("drops values strictly outside `domain`", () => {
+    const result = bin([-5, 0, 5, 10, 15], {
+      breaks: [0, 5, 10],
+      closed: "left",
+    });
+    // -5 dropped; 0 → bin0; 5 → bin1; 10 → bin1 (closed at top); 15 dropped.
+    expect(result.map((b) => b.count)).toEqual([1, 2]);
+  });
+
+  test("returns `[]` for empty input", () => {
+    expect(bin([])).toEqual([]);
+  });
+
+  test("collapses to a single padded bin for all-equal values", () => {
+    const result = bin([7, 7, 7]);
+    expect(result).toHaveLength(1);
+    expect(result[0]!.count).toBe(3);
+  });
+
+  test("filters non-finite values silently", () => {
+    const result = bin([1, 2, Number.NaN, 3, Number.POSITIVE_INFINITY], {
+      breaks: [0, 1, 2, 3, 4],
+    });
+    expect(result.map((b) => b.count)).toEqual([0, 1, 1, 1]);
+  });
+});
+
+describe("binWithBreaks", () => {
+  test("counts against caller-provided edges without recomputing", () => {
+    const result = binWithBreaks([0.5, 1.5, 1.5, 2.5], [0, 1, 2, 3]);
+    expect(result.map((b) => b.count)).toEqual([1, 2, 1]);
+  });
+});
+
+describe("binBy", () => {
+  test("uses shared edges so groups align horizontally", () => {
+    const values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    const keys = ["a", "a", "a", "a", "a", "b", "b", "b", "b", "b"] as const;
+    const { breaks, groups } = binBy(values, keys, { bins: 5, nice: false });
+    expect(breaks.length).toBe(6);
+    expect(groups.size).toBe(2);
+    const a = groups.get("a")!;
+    const b = groups.get("b")!;
+    expect(a).toHaveLength(5);
+    expect(b).toHaveLength(5);
+    // Each group's edges line up.
+    for (let i = 0; i < a.length; i++) {
+      expect(a[i]!.x0).toBe(b[i]!.x0);
+      expect(a[i]!.x1).toBe(b[i]!.x1);
+    }
+    // Per-group totals match the input partition.
+    const sum = (xs: { count: number }[]) => xs.reduce((s, x) => s + x.count, 0);
+    expect(sum(a)).toBe(5);
+    expect(sum(b)).toBe(5);
+  });
+
+  test("preserves insertion order in groups", () => {
+    const { groups } = binBy([1, 2, 3], ["b", "a", "b"] as const, { bins: 2, nice: false });
+    expect([...groups.keys()]).toEqual(["b", "a"]);
+  });
+
+  test("`sharedBreaks: false` lets each group bin independently", () => {
+    const { groups } = binBy(
+      [0, 1, 2, 100, 200, 300],
+      ["lo", "lo", "lo", "hi", "hi", "hi"] as const,
+      { bins: 3, nice: false, sharedBreaks: false },
+    );
+    const lo = groups.get("lo")!;
+    const hi = groups.get("hi")!;
+    expect(lo[0]!.x0).toBe(0);
+    expect(lo[lo.length - 1]!.x1).toBe(2);
+    expect(hi[0]!.x0).toBe(100);
+    expect(hi[hi.length - 1]!.x1).toBe(300);
+  });
+});
+
+describe("jitter", () => {
+  test("is deterministic for the same seed", () => {
+    const a = jitter(42, 16, 1);
+    const b = jitter(42, 16, 1);
+    expect(a).toEqual(b);
+  });
+
+  test("differs across seeds and stays within [-w/2, w/2]", () => {
+    const a = jitter(1, 32, 4);
+    const b = jitter(2, 32, 4);
+    expect(a).not.toEqual(b);
+    for (const v of a) {
+      expect(v).toBeGreaterThanOrEqual(-2);
+      expect(v).toBeLessThanOrEqual(2);
+    }
+  });
+});