react-native-livechart 1.0.0

package/src/index.ts

@@ -0,0 +1,69 @@
+/**
+ * Public API — stable exports for `react-native-livechart` consumers.
+ *
+ * @remarks Conceptually inspired by [liveline](https://github.com/benjitaylor/liveline)
+ * (Benji Taylor) — live charts for React. This package is a separate React Native
+ * implementation on Skia and Reanimated, not a fork of the web library.
+ */
+
+// ── Components ───────────────────────────────────────────────────────────────
+
+import { LiveChart } from "./components/LiveChart";
+import { LiveChartSeries } from "./components/LiveChartSeries";
+import { LiveChartTransition } from "./components/LiveChartTransition";
+
+export { LiveChart, LiveChartSeries, LiveChartTransition };
+export type { LiveChartTransitionProps } from "./components/LiveChartTransition";
+
+// ── Utilities ────────────────────────────────────────────────────────────────
+
+export { formatTime, formatValue } from "./lib/format";
+export { MONO_FONT_FAMILY } from "./lib/monoFontFamily";
+
+// ── Optional hooks (degen / trade markers — see README) ───────────────────────
+
+export { useDegen } from "./hooks/useDegen";
+export { useTradeStream } from "./hooks/useTradeStream";
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export type {
+  BadgeConfig,
+  BadgeVariant,
+  CandlePoint,
+  ChartInsets,
+  DegenOptions,
+  DegenShakePayload,
+  FontConfig,
+  FontWeight,
+  GradientConfig,
+  GridStyleConfig,
+  LeftEdgeFadeConfig,
+  LegendConfig,
+  LegendStyle,
+  LineConfig,
+  LiveChartCoreProps,
+  LiveChartPalette,
+  LiveChartPoint,
+  LiveChartProps,
+  LiveChartSeriesProps,
+  Marker,
+  MarkerHoverEvent,
+  MarkerKind,
+  Momentum,
+  MomentumConfig,
+  MultiSeriesDotConfig,
+  PulseConfig,
+  ReferenceLine,
+  ScrubConfig,
+  ScrubPoint,
+  ScrubPointCore,
+  ScrubPointMulti,
+  ScrubSeriesValue,
+  SeriesConfig,
+  ThemeMode,
+  TradeEvent,
+  ValueLineConfig,
+  XAxisConfig,
+  YAxisConfig,
+} from "./types";

package/src/lib/format.ts

@@ -0,0 +1,36 @@
+/** Adaptive value formatter with compact suffixes. Worklet-safe. */
+export function formatValue(v: number): string {
+  "worklet";
+  const abs = Math.abs(v);
+  const sign = v < 0 ? "-" : "";
+  if (abs >= 1_000_000) {
+    const m = abs / 1_000_000;
+    return (
+      sign +
+      (m >= 100 ? m.toFixed(0) : m >= 10 ? m.toFixed(1) : m.toFixed(2)) +
+      "M"
+    );
+  }
+  if (abs >= 1_000) {
+    const k = abs / 1_000;
+    return (
+      sign +
+      (k >= 100 ? k.toFixed(0) : k >= 10 ? k.toFixed(1) : k.toFixed(2)) +
+      "K"
+    );
+  }
+  if (abs >= 100) return sign + abs.toFixed(1);
+  if (abs >= 1) return sign + abs.toFixed(2);
+  if (abs === 0) return "0";
+  return sign + abs.toPrecision(4);
+}
+
+/** HH:MM:SS time formatter. Worklet-safe. */
+export function formatTime(t: number): string {
+  "worklet";
+  const d = new Date(t * 1000);
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  return `${hh}:${mm}:${ss}`;
+}

package/src/lib/measureFontTextWidth.ts

@@ -0,0 +1,10 @@
+import type { SkFont } from "@shopify/react-native-skia";
+
+/**
+ * Horizontal layout width for `text` via Skia `measureText` (replaces deprecated `getTextWidth`).
+ * Marked worklet for use inside Reanimated `useDerivedValue`.
+ */
+export function measureFontTextWidth(font: SkFont, text: string): number {
+  "worklet";
+  return font.measureText(text).width;
+}

package/src/lib/monoFontFamily.ts

@@ -0,0 +1,8 @@
+import { Platform } from "react-native";
+
+/**
+ * React Native `Text` / navigation title styles: iOS has no generic "monospace"
+ * family (unlike web/CSS). Menlo is the system monospace on Apple platforms.
+ */
+export const MONO_FONT_FAMILY =
+  Platform.select({ ios: "Menlo", default: "monospace" }) ?? "monospace";

package/src/math/color.ts

@@ -0,0 +1,31 @@
+/** Parse hex color (#rgb or #rrggbb) to [r, g, b]. Worklet-safe (no regex). */
+export function hexToRgb(hex: string): [number, number, number] {
+  "worklet";
+  // Fallback to neutral grey if hex is unparseable
+  let r = 128;
+  let g = 128;
+  let b = 128;
+  if (hex.length === 4) {
+    r = parseInt(hex[1] + hex[1], 16);
+    g = parseInt(hex[2] + hex[2], 16);
+    b = parseInt(hex[3] + hex[3], 16);
+  } else if (hex.length >= 7) {
+    r = parseInt(hex.slice(1, 3), 16);
+    g = parseInt(hex.slice(3, 5), 16);
+    b = parseInt(hex.slice(5, 7), 16);
+  }
+  return [r, g, b];
+}
+
+/** Interpolate between two RGB triples. Returns `rgb(r,g,b)` string. */
+export function lerpColor(
+  a: [number, number, number],
+  b: [number, number, number],
+  t: number,
+): string {
+  "worklet";
+  const r = Math.round(a[0] + (b[0] - a[0]) * t);
+  const g = Math.round(a[1] + (b[1] - a[1]) * t);
+  const bl = Math.round(a[2] + (b[2] - a[2]) * t);
+  return `rgb(${r},${g},${bl})`;
+}

package/src/math/degenTick.ts

@@ -0,0 +1,151 @@
+/**
+ * Particle system for "degen" momentum bursts.
+ *
+ * Particles live in a packed `Float64Array` ring buffer.  Each slot occupies
+ * `DEGEN_STRIDE` (7) contiguous floats:
+ *
+ * | offset | field      | description                          |
+ * | ------ | ---------- | ------------------------------------ |
+ * |   0    | x          | current x position (px)              |
+ * |   1    | y          | current y position (px)              |
+ * |   2    | vx         | velocity x (px/s)                    |
+ * |   3    | vy         | velocity y (px/s)                    |
+ * |   4    | t0         | spawn timestamp (seconds)            |
+ * |   5    | active     | 1 = alive, 0 = expired               |
+ * |   6    | size       | particle radius (px, pre-scaled)     |
+ * |   7    | colorIndex | index into the renderer's color list |
+ *
+ * All functions are worklet-safe for UI-thread execution.
+ */
+import { DEGEN_STRIDE } from "../constants";
+
+/** Deterministic pseudo-random hash for reproducible particle variation. */
+export function hash(a: number, b: number): number {
+  "worklet";
+  const x = Math.sin(a * 12.9898 + b * 78.233) * 43758.5453;
+  return x - Math.floor(x);
+}
+
+export interface SpawnParams {
+  /** Origin x — center of the burst (px). */
+  ox: number;
+  /** Origin y — center of the burst (px). */
+  oy: number;
+  /** Scale multiplier applied to speed and size. */
+  sc: number;
+  /** Number of particles to spawn in this burst. */
+  burst: number;
+  /** Central emission angle (radians). */
+  baseAngle: number;
+  /** Angular spread around `baseAngle` (radians). */
+  spread: number;
+  /** Horizontal position jitter (±half, px). */
+  jx: number;
+  /** Vertical position jitter (±half, px). */
+  jy: number;
+  /** Minimum initial speed (px/s, before `sc`). */
+  sMin: number;
+  /** Maximum initial speed (px/s, before `sc`). */
+  sMax: number;
+  /** Minimum particle radius (px, before `sc`). */
+  szMin: number;
+  /** Maximum particle radius (px, before `sc`). */
+  szMax: number;
+  /** Current timestamp (seconds). */
+  now: number;
+  /** Ring-buffer rotation index for slot allocation. */
+  baseRot: number;
+  /** Total number of slots in the ring buffer. */
+  slots: number;
+  /**
+   * Color list index written to every particle in this burst. Use a fixed value
+   * (e.g. a series index) to color the whole burst uniformly, or `-1` to cycle
+   * the renderer's color list per particle (the particle's loop index is stored).
+   * Defaults to `-1`.
+   */
+  colorIndex?: number;
+}
+
+/** Write `p.burst` particles into the ring buffer starting at `p.baseRot`. Returns the next rotation index. */
+export function spawnBurst(buf: Float64Array, p: SpawnParams): number {
+  "worklet";
+  const stride = DEGEN_STRIDE;
+  const rot = p.baseRot;
+  const colorIndex = p.colorIndex ?? -1;
+  for (let k = 0; k < p.burst; k++) {
+    const slot = (rot + k) % p.slots;
+    const b = slot * stride;
+    const angle = p.baseAngle + (hash(k, p.now * 1000) - 0.5) * p.spread;
+    const speed =
+      (p.sMin + hash(k + 100, p.now * 1000) * (p.sMax - p.sMin)) * p.sc;
+    buf[b + 0] = p.ox + (hash(k + 200, p.now * 1000) - 0.5) * p.jx;
+    buf[b + 1] = p.oy + (hash(k + 300, p.now * 1000) - 0.5) * p.jy;
+    buf[b + 2] = Math.cos(angle) * speed;
+    buf[b + 3] = Math.sin(angle) * speed;
+    buf[b + 4] = p.now;
+    buf[b + 5] = 1;
+    buf[b + 6] =
+      (p.szMin + hash(k + 400, p.now * 1000) * (p.szMax - p.szMin)) * p.sc;
+    // Fixed index colors the whole burst; -1 cycles per particle via k.
+    buf[b + 7] = colorIndex < 0 ? k : colorIndex;
+  }
+  return (rot + p.burst) % p.slots;
+}
+
+export interface ShakeResult {
+  x: number;
+  y: number;
+  active: boolean;
+}
+
+/** Compute screen-shake displacement with exponential decay envelope. */
+export function computeShake(
+  elapsed: number,
+  dur: number,
+  sc: number,
+  sint: number,
+): ShakeResult {
+  "worklet";
+  if (elapsed >= dur) return { x: 0, y: 0, active: false };
+  const amp = 10 * sc * sint;
+  const tail = 1 - elapsed / dur;
+  const env = Math.exp(-elapsed * 10) * tail;
+  return {
+    x: Math.sin(elapsed * 88) * amp * env,
+    y: Math.cos(elapsed * 71) * amp * env * 0.92,
+    active: true,
+  };
+}
+
+/**
+ * Advance all particles by `dtSec`: apply velocity, drag, and expire particles older than `burstDur`.
+ * Returns the number of particles still alive after the tick, so callers can skip per-frame
+ * repaint work (bumping `packRevision`) when the field is empty.
+ */
+export function tickParticles(
+  buf: Float64Array,
+  slots: number,
+  now: number,
+  burstDur: number,
+  drag: number,
+  dtSec: number,
+): number {
+  "worklet";
+  const stride = DEGEN_STRIDE;
+  let active = 0;
+  for (let i = 0; i < slots; i++) {
+    const b = i * stride;
+    if (buf[b + 5] < 0.5) continue;
+    const t0 = buf[b + 4];
+    if (now - t0 > burstDur) {
+      buf[b + 5] = 0;
+      continue;
+    }
+    buf[b + 0] += buf[b + 2] * dtSec;
+    buf[b + 1] += buf[b + 3] * dtSec;
+    buf[b + 2] *= drag;
+    buf[b + 3] *= drag;
+    active++;
+  }
+  return active;
+}

package/src/math/interpolate.ts

@@ -0,0 +1,32 @@
+import type { LiveChartPoint } from "../types";
+
+/**
+ * Binary search to find interpolated value at a given time.
+ * Returns null if time is outside data range.
+ */
+export function interpolateAtTime(
+  points: LiveChartPoint[],
+  time: number,
+): number | null {
+  "worklet";
+  if (points.length === 0) return null;
+  if (time <= points[0].time) return points[0].value;
+  if (time >= points[points.length - 1].time)
+    return points[points.length - 1].value;
+
+  let lo = 0;
+  let hi = points.length - 1;
+  while (hi - lo > 1) {
+    const mid = (lo + hi) >> 1;
+    if (points[mid].time <= time) lo = mid;
+    else hi = mid;
+  }
+
+  const p1 = points[lo];
+  const p2 = points[hi];
+  const dt = p2.time - p1.time;
+  /* istanbul ignore next -- unreachable with sorted keys: duplicate times collapse to the last index with time <= t, so p1/p2 always have distinct times unless clamps fire first */
+  if (dt === 0) return p1.value;
+  const t = (time - p1.time) / dt;
+  return p1.value + (p2.value - p1.value) * t;
+}

package/src/math/intervals.ts

@@ -0,0 +1,17 @@
+/** Pick a nice time interval in seconds for time axis labels. */
+export function niceTimeInterval(windowSecs: number): number {
+  "worklet";
+  if (windowSecs <= 15) return 2;
+  if (windowSecs <= 30) return 5;
+  if (windowSecs <= 60) return 10;
+  if (windowSecs <= 120) return 15;
+  if (windowSecs <= 300) return 30;
+  if (windowSecs <= 600) return 60;
+  if (windowSecs <= 1800) return 300;
+  if (windowSecs <= 3600) return 600;
+  if (windowSecs <= 14400) return 1800;
+  if (windowSecs <= 43200) return 3600;
+  if (windowSecs <= 86400) return 7200;
+  if (windowSecs <= 604800) return 86400;
+  return 604800;
+}

package/src/math/lerp.ts

@@ -0,0 +1,17 @@
+import { MS_PER_FRAME_60FPS } from "../constants";
+
+/**
+ * Frame-rate-independent exponential lerp.
+ * `speed` is the fraction approached per frame at 60fps.
+ * At lower frame rates, dt is larger so we approach more per frame.
+ */
+export function lerp(
+  current: number,
+  target: number,
+  speed: number,
+  dt = MS_PER_FRAME_60FPS,
+): number {
+  "worklet";
+  const factor = 1 - Math.pow(1 - speed, dt / MS_PER_FRAME_60FPS);
+  return current + (target - current) * factor;
+}

package/src/math/markers.ts

@@ -0,0 +1,175 @@
+import type { LiveChartPoint, Marker, SeriesConfig } from "../types";
+import { splineValueAtTime } from "./spline";
+
+/** Screen-space position for one marker, index-aligned with the marker array. */
+export interface ProjectedMarker {
+  x: number;
+  y: number;
+  visible: boolean;
+}
+
+export interface ProjectMarkersOpts {
+  canvasWidth: number;
+  canvasHeight: number;
+  padTop: number;
+  padBottom: number;
+  padLeft: number;
+  padRight: number;
+  timestamp: number;
+  displayWindow: number;
+  displayMin: number;
+  displayMax: number;
+  /** Multi-series data, used to anchor markers by `seriesId`. */
+  series?: SeriesConfig[];
+  /** Single-series line data; anchors markers that omit `value` (and `seriesId`). */
+  lineData?: LiveChartPoint[];
+}
+
+/** How far off-chart (px) a marker may sit before it is culled. */
+const CULL_MARGIN = 24;
+
+/**
+ * Project one marker (given its primitive anchor fields) into `target`,
+ * without allocation. Primitives only, so per-glyph worklet closures don't
+ * capture the full `Marker` (which may carry non-serializable `data`/`image`).
+ */
+function projectInto(
+  time: number,
+  value: number | undefined,
+  seriesId: string | undefined,
+  opts: ProjectMarkersOpts,
+  target: ProjectedMarker,
+): void {
+  "worklet";
+  const w = opts.canvasWidth;
+  const h = opts.canvasHeight;
+  const chartLeft = opts.padLeft;
+  const chartRight = w - opts.padRight;
+  const chartW = chartRight - chartLeft;
+  const chartTop = opts.padTop;
+  const chartBottom = h - opts.padBottom;
+  const chartH = chartBottom - chartTop;
+  const valRange = opts.displayMax - opts.displayMin;
+  if (
+    w === 0 ||
+    h === 0 ||
+    chartW <= 0 ||
+    opts.displayWindow <= 0 ||
+    valRange <= 0
+  ) {
+    target.visible = false;
+    return;
+  }
+  let v: number | null = null;
+  if (value !== undefined) {
+    v = value;
+  } else if (seriesId !== undefined && opts.series) {
+    for (let j = 0; j < opts.series.length; j++) {
+      if (opts.series[j].id === seriesId) {
+        // Evaluate the rendered spline (not the linear chord) so the glyph sits
+        // exactly on the curve between data points.
+        v = splineValueAtTime(opts.series[j].data, time);
+        break;
+      }
+    }
+  } else if (opts.lineData) {
+    // Single-series anchor: omit `value` to pin the marker to the line at `time`
+    // (on the rendered spline curve, not the linear chord between points).
+    v = splineValueAtTime(opts.lineData, time);
+  }
+  if (v === null) {
+    target.visible = false;
+    return;
+  }
+  const winStart = opts.timestamp - opts.displayWindow;
+  const x = chartLeft + ((time - winStart) / opts.displayWindow) * chartW;
+  const y = chartTop + ((opts.displayMax - v) / valRange) * chartH;
+  target.x = x;
+  target.y = y;
+  target.visible =
+    x >= chartLeft - CULL_MARGIN &&
+    x <= chartRight + CULL_MARGIN &&
+    y >= chartTop - CULL_MARGIN &&
+    y <= chartBottom + CULL_MARGIN;
+}
+
+/**
+ * Project markers to screen positions, mutating `out` in place (reused buffer).
+ * y comes from `value` (absolute) or, failing that, from interpolating the
+ * `seriesId` series' data at the marker's time. Returns `out`.
+ */
+export function projectMarkers(
+  markers: Marker[],
+  out: ProjectedMarker[],
+  opts: ProjectMarkersOpts,
+): ProjectedMarker[] {
+  "worklet";
+  out.length = markers.length;
+  for (let i = 0; i < markers.length; i++) {
+    let cur = out[i];
+    if (!cur) {
+      cur = { x: 0, y: 0, visible: false };
+      out[i] = cur;
+    }
+    const m = markers[i];
+    projectInto(m.time, m.value, m.seriesId, opts, cur);
+  }
+  return out;
+}
+
+/**
+ * Project a single marker by its anchor fields, returning a fresh
+ * `ProjectedMarker`. Used per-glyph at render so each glyph owns its position
+ * (no shared index buffer → no flicker when the marker array reorders).
+ */
+export function projectPoint(
+  time: number,
+  value: number | undefined,
+  seriesId: string | undefined,
+  opts: ProjectMarkersOpts,
+): ProjectedMarker {
+  "worklet";
+  const target: ProjectedMarker = { x: 0, y: 0, visible: false };
+  projectInto(time, value, seriesId, opts, target);
+  return target;
+}
+
+/** Stable signature over marker id / kind / color / icon / size / image-presence
+ *  (snapshot sync, not per-tick). */
+export function markersSignature(markers: Marker[]): string {
+  "worklet";
+  let out = "";
+  for (let i = 0; i < markers.length; i++) {
+    if (i > 0) out += "\x1e";
+    const m = markers[i];
+    out += `${m.id}\x1f${m.kind}\x1f${m.color ?? ""}\x1f${m.icon ?? ""}\x1f${m.size ?? ""}\x1f${m.image ? 1 : 0}`;
+  }
+  return out;
+}
+
+/**
+ * Index of the nearest visible marker within `radius` px of `(x, y)`, or `-1`.
+ * Ties resolve to the later index (drawn on top).
+ */
+export function nearestMarkerIndex(
+  positions: ProjectedMarker[],
+  x: number,
+  y: number,
+  radius: number,
+): number {
+  "worklet";
+  let best = -1;
+  let bestD = radius * radius;
+  for (let i = 0; i < positions.length; i++) {
+    const p = positions[i];
+    if (!p.visible) continue;
+    const dx = p.x - x;
+    const dy = p.y - y;
+    const d = dx * dx + dy * dy;
+    if (d <= bestD) {
+      bestD = d;
+      best = i;
+    }
+  }
+  return best;
+}

package/src/math/momentum.ts

@@ -0,0 +1,38 @@
+import type { LiveChartPoint, Momentum } from "../types";
+
+/**
+ * Auto-detect momentum from recent data points.
+ * Uses the full lookback window for threshold calculation
+ * but only the last 5 points for active velocity.
+ */
+export function detectMomentum(
+  points: LiveChartPoint[],
+  lookback = 20,
+  threshold = 0.12,
+): Momentum {
+  "worklet";
+  if (points.length < 5) return "flat";
+
+  const start = Math.max(0, points.length - lookback);
+
+  let min = Infinity;
+  let max = -Infinity;
+  for (let i = start; i < points.length; i++) {
+    const v = points[i].value;
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  const range = max - min;
+  if (range === 0) return "flat";
+
+  const tailStart = Math.max(start, points.length - 5);
+  const first = points[tailStart].value;
+  const last = points[points.length - 1].value;
+  const delta = last - first;
+
+  const absThreshold = range * threshold;
+
+  if (delta > absThreshold) return "up";
+  if (delta < -absThreshold) return "down";
+  return "flat";
+}

package/src/math/pickCandle.ts

@@ -0,0 +1,42 @@
+import type { CandlePoint } from "../types";
+
+/**
+ * Find the candle whose time bucket contains `time`.
+ * Each candle spans [candle.time, candle.time + candleWidthSecs).
+ * Includes the live candle if it overlaps. Returns null if no match.
+ */
+export function pickCandleAtTime(
+  candles: CandlePoint[],
+  liveCandle: CandlePoint | null,
+  time: number,
+  candleWidthSecs: number,
+): CandlePoint | null {
+  "worklet";
+  if (
+    liveCandle &&
+    time >= liveCandle.time &&
+    time < liveCandle.time + candleWidthSecs
+  ) {
+    return liveCandle;
+  }
+
+  if (candles.length === 0) return null;
+
+  // Binary search: find the last candle with time <= scrub time
+  let lo = 0;
+  let hi = candles.length - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    if (candles[mid].time <= time) lo = mid + 1;
+    else hi = mid - 1;
+  }
+  // hi is now the index of the last candle with time <= time
+  if (hi < 0) return null;
+
+  const c = candles[hi];
+  if (time >= c.time && time < c.time + candleWidthSecs) {
+    return c;
+  }
+
+  return null;
+}

package/src/math/range.ts

@@ -0,0 +1,54 @@
+import type { LiveChartPoint } from "../types";
+
+/**
+ * Compute visible Y range from data points + current value.
+ * Returns { min, max } with margin applied.
+ */
+export function computeRange(
+  visible: LiveChartPoint[],
+  currentValue: number,
+  referenceValue?: number,
+  exaggerate?: boolean,
+  nonNegative?: boolean,
+  maxValue?: number,
+): { min: number; max: number } {
+  "worklet";
+  let targetMin = Infinity;
+  let targetMax = -Infinity;
+
+  for (let i = 0; i < visible.length; i++) {
+    const v = visible[i].value;
+    if (v < targetMin) targetMin = v;
+    if (v > targetMax) targetMax = v;
+  }
+
+  if (currentValue < targetMin) targetMin = currentValue;
+  if (currentValue > targetMax) targetMax = currentValue;
+
+  if (referenceValue !== undefined) {
+    if (referenceValue < targetMin) targetMin = referenceValue;
+    if (referenceValue > targetMax) targetMax = referenceValue;
+  }
+
+  const rawRange = targetMax - targetMin;
+  // marginFactor: breathing room above/below the data (tight for exaggerate mode)
+  const marginFactor = exaggerate ? 0.01 : 0.12;
+  // minRange: prevents the chart from collapsing to a flat line on tiny movements
+  const minRange =
+    rawRange * (exaggerate ? 0.02 : 0.1) || (exaggerate ? 0.04 : 0.4);
+
+  if (rawRange < minRange) {
+    const mid = (targetMin + targetMax) / 2;
+    targetMin = mid - minRange / 2;
+    targetMax = mid + minRange / 2;
+  } else {
+    const margin = rawRange * marginFactor;
+    targetMin -= margin;
+    targetMax += margin;
+  }
+
+  if (nonNegative && targetMin < 0) targetMin = 0;
+  if (maxValue !== undefined && targetMax > maxValue) targetMax = maxValue;
+
+  return { min: targetMin, max: targetMax };
+}