tokmon 0.28.2 → 0.28.4

package/dist/chunk-TN6V7XSL.js

@@ -0,0 +1,512 @@
+#!/usr/bin/env node
+import {
+  PROVIDERS,
+  PROVIDER_ORDER,
+  identityFromIdToken,
+  readClaudeIdentity,
+  readJson
+} from "./chunk-CFKUZCMB.js";
+import {
+  containsEmail,
+  expandHome,
+  redactEmail,
+  slugify
+} from "./chunk-HNWEJ6MS.js";
+
+// src/accounts.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { homedir } from "os";
+import { basename, join as join2, resolve } from "path";
+
+// src/providers/codex/identity.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+function codexAuthPaths(homeDir) {
+  return [join(homeDir, ".codex", "auth.json"), join(homeDir, "auth.json")];
+}
+function readCodexIdentity(homeDir) {
+  for (const path of codexAuthPaths(homeDir)) {
+    try {
+      const parsed = JSON.parse(readFileSync(path, "utf-8"));
+      const { email, displayName, payload } = identityFromIdToken(parsed?.tokens?.id_token);
+      if (!payload) continue;
+      return { email, displayName };
+    } catch {
+    }
+  }
+  return {};
+}
+
+// src/accounts.ts
+function accountKey(providerId, homeDir) {
+  return `${providerId}:${homeDir ? resolve(expandHome(homeDir)) : homedir()}`;
+}
+function uniqueId(base, used) {
+  let id = slugify(base) || "account";
+  if (!used.has(id)) {
+    used.add(id);
+    return id;
+  }
+  for (let i = 2; i < 1e3; i++) {
+    const next = `${id}_${i}`;
+    if (!used.has(next)) {
+      used.add(next);
+      return next;
+    }
+  }
+  id = `${id}_${Date.now()}`;
+  used.add(id);
+  return id;
+}
+function hasClaudeState(homeDir) {
+  return existsSync(join2(homeDir, ".claude.json")) || existsSync(join2(homeDir, ".claude", ".credentials.json")) || existsSync(join2(homeDir, ".claude", "projects")) || existsSync(join2(homeDir, ".config", "claude", ".credentials.json")) || existsSync(join2(homeDir, ".config", "claude", "projects"));
+}
+function candidateAlternateHomes(prefix) {
+  const home = homedir();
+  let entries;
+  try {
+    entries = readdirSync(home);
+  } catch {
+    return [];
+  }
+  const out = [];
+  const pattern = new RegExp(`^\\.${prefix}[_-]`);
+  for (const name of entries) {
+    if (!pattern.test(name)) continue;
+    const path = join2(home, name);
+    try {
+      if (!statSync(path).isDirectory()) continue;
+      out.push(path);
+    } catch {
+    }
+  }
+  return out.sort();
+}
+function labelForClaudeHome(homeDir) {
+  const identity = readClaudeIdentity(homeDir);
+  if (identity.email) return `Claude ${identity.email}`;
+  if (identity.displayName) return `Claude ${identity.displayName}`;
+  const raw = basename(homeDir).replace(/^\.claude[_-]?/, "").replace(/[_-]+/g, " ").trim();
+  return raw ? `Claude ${raw}` : "Claude";
+}
+function hasCodexAuth(homeDir) {
+  for (const path of codexAuthPaths(homeDir)) {
+    try {
+      const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+      const accessToken = parsed?.tokens?.access_token;
+      if (typeof accessToken === "string" && accessToken.trim()) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function labelForCodexHome(homeDir) {
+  const identity = readCodexIdentity(homeDir);
+  if (identity.email) return `Codex ${identity.email}`;
+  if (identity.displayName) return `Codex ${identity.displayName}`;
+  const raw = basename(homeDir).replace(/^\.codex[_-]?/, "").replace(/[_-]+/g, " ").trim();
+  return raw ? `Codex ${raw}` : "Codex";
+}
+function discoverClaudeAccounts(usedIds) {
+  const provider = PROVIDERS.claude;
+  const out = [];
+  for (const homeDir of candidateAlternateHomes("claude")) {
+    if (!hasClaudeState(homeDir)) continue;
+    const suffix = basename(homeDir).replace(/^\.claude[_-]?/, "") || basename(homeDir);
+    out.push({
+      id: uniqueId(`claude_${suffix}`, usedIds),
+      providerId: "claude",
+      name: labelForClaudeHome(homeDir),
+      color: provider.color,
+      homeDir
+    });
+  }
+  return out;
+}
+function discoverCodexAccounts(usedIds) {
+  const provider = PROVIDERS.codex;
+  const out = [];
+  for (const homeDir of candidateAlternateHomes("codex")) {
+    if (!hasCodexAuth(homeDir)) continue;
+    const suffix = basename(homeDir).replace(/^\.codex[_-]?/, "") || basename(homeDir);
+    out.push({
+      id: uniqueId(`codex_${suffix}`, usedIds),
+      providerId: "codex",
+      name: labelForCodexHome(homeDir),
+      color: provider.color,
+      homeDir
+    });
+  }
+  return out;
+}
+function discoverProviderAccounts(providerId, usedIds) {
+  if (providerId === "claude") return discoverClaudeAccounts(usedIds);
+  if (providerId === "codex") return discoverCodexAccounts(usedIds);
+  return [];
+}
+function buildAccounts(config, detected) {
+  const out = [];
+  const usedIds = new Set(config.accounts.map((a) => a.id));
+  const seenKeys = /* @__PURE__ */ new Set();
+  const excludedKeys = new Set(
+    config.accountDetection.excludedAccounts.map((ref) => accountKey(ref.providerId, ref.homeDir))
+  );
+  const add = (account) => {
+    const key = accountKey(account.providerId, account.homeDir);
+    if (seenKeys.has(key)) return;
+    seenKeys.add(key);
+    out.push(account);
+  };
+  for (const pid of PROVIDER_ORDER) {
+    if (config.disabledProviders.includes(pid)) continue;
+    const provider = PROVIDERS[pid];
+    const configured = config.accounts.filter((a) => a.providerId === pid);
+    for (const a of configured) {
+      add({
+        id: a.id,
+        providerId: pid,
+        name: a.name,
+        color: a.color || provider.color,
+        homeDir: a.homeDir && a.homeDir !== "~" ? expandHome(a.homeDir) : void 0
+      });
+    }
+    if (!config.accountDetection.enabled || config.accountDetection.disabledProviders.includes(pid)) continue;
+    const discovered = discoverProviderAccounts(pid, usedIds);
+    if (detected.includes(pid)) {
+      const account = { id: pid, providerId: pid, name: provider.name, color: provider.color, homeDir: void 0 };
+      if (!excludedKeys.has(accountKey(pid))) add(account);
+    }
+    for (const account of discovered) {
+      if (excludedKeys.has(accountKey(account.providerId, account.homeDir))) continue;
+      add(account);
+    }
+  }
+  return out;
+}
+function accountsByProvider(accounts) {
+  const groups = [];
+  for (const pid of PROVIDER_ORDER) {
+    const list = accounts.filter((a) => a.providerId === pid);
+    if (list.length > 0) groups.push({ provider: pid, accounts: list });
+  }
+  return groups;
+}
+
+// src/shared/colors.ts
+var FALLBACK_HEX = "#8d9090";
+var NAMED_HEX = {
+  green: "#6caa71",
+  greenBright: "#79be7e",
+  cyan: "#7ccbcd",
+  cyanBright: "#84dde0",
+  blue: "#6d96b4",
+  blueBright: "#67b5ed",
+  magenta: "#bd7bcd",
+  magentaBright: "#d389e5",
+  yellow: "#c4ac62",
+  yellowBright: "#d9c074",
+  red: "#b45648",
+  redBright: "#cf6a5a",
+  white: "#dee5eb",
+  whiteBright: "#f3f5f5",
+  gray: FALLBACK_HEX,
+  grey: FALLBACK_HEX
+};
+var PROVIDER_HEX = {
+  claude: NAMED_HEX.green,
+  codex: NAMED_HEX.cyan,
+  cursor: NAMED_HEX.magenta,
+  copilot: NAMED_HEX.white,
+  pi: NAMED_HEX.blue,
+  opencode: NAMED_HEX.yellow,
+  antigravity: NAMED_HEX.red,
+  gemini: NAMED_HEX.greenBright,
+  grok: NAMED_HEX.yellowBright
+};
+function namedHex(name) {
+  if (!name) return FALLBACK_HEX;
+  if (name.startsWith("#")) return name;
+  return NAMED_HEX[name] ?? FALLBACK_HEX;
+}
+function colorHex(accountColor, providerColorName) {
+  if (accountColor) {
+    if (accountColor.startsWith("#")) return accountColor;
+    const named = NAMED_HEX[accountColor];
+    if (named) return named;
+  }
+  return namedHex(providerColorName);
+}
+var MODEL_PALETTE = [
+  "#00d7ff",
+  "#00d787",
+  "#e6b450",
+  "#d75f87",
+  "#5f87ff",
+  "#af87ff",
+  "#5fd7a7",
+  "#ff8787",
+  "#d7af5f",
+  "#87d7ff",
+  "#d787d7",
+  "#9ee493",
+  "#ffb454",
+  "#7aa2f7",
+  "#bb9af7"
+];
+var modelColorCache = /* @__PURE__ */ new Map();
+function modelColor(name) {
+  const cached = modelColorCache.get(name);
+  if (cached) return cached;
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) hash = hash * 31 + name.charCodeAt(i) >>> 0;
+  const color = MODEL_PALETTE[hash % MODEL_PALETTE.length];
+  modelColorCache.set(name, color);
+  return color;
+}
+var TOKEN_BUCKET = {
+  input: NAMED_HEX.blue,
+  output: NAMED_HEX.green,
+  cacheCreate: NAMED_HEX.yellow,
+  cacheRead: NAMED_HEX.cyan
+};
+
+// src/usage-semantics.ts
+var clampPct = (value) => Math.max(0, Math.min(100, value));
+function inferRole(metric) {
+  if (metric.role) return metric.role;
+  if (metric.format.kind !== "percent" && !(metric.limit != null && metric.limit > 0)) return "unbounded";
+  const label = metric.label.trim().toLowerCase();
+  if (label === "session" || label.includes("five hour")) return "session";
+  if (label === "weekly" || label.includes("seven day") || label.includes("weekly all")) return "weekly";
+  if (metric.modelId || !metric.primary && metric.format.kind === "percent" && !["usage", "api", "auto"].includes(label)) return "model";
+  return "other";
+}
+function valueText(metric, usedPct) {
+  if (usedPct !== null) return `${Math.round(usedPct)}% used`;
+  if (!Number.isFinite(metric.used)) return "\u2014";
+  if (metric.format.kind === "dollars") {
+    try {
+      return new Intl.NumberFormat("en-US", { style: "currency", currency: metric.format.currency ?? "USD", maximumFractionDigits: 2 }).format(metric.used);
+    } catch {
+      return `$${metric.used.toFixed(2)}`;
+    }
+  }
+  if (metric.format.kind === "count") {
+    const suffix = metric.format.suffix?.trim();
+    return `${Math.round(metric.used).toLocaleString("en-US")}${suffix ? ` ${suffix}` : ""}`;
+  }
+  return `${Math.round(metric.used)}% used`;
+}
+var roleOrder = (role) => role === "session" ? 0 : role === "weekly" ? 1 : role === "model" ? 2 : role === "other" ? 3 : 4;
+function deriveQuotaView(metric, sourceIndex = 0) {
+  const bounded = metric.format.kind === "percent" || metric.limit != null && Number.isFinite(metric.limit) && metric.limit > 0;
+  const usedPct = metric.format.kind === "percent" ? metric.used : metric.limit != null && metric.limit > 0 ? metric.used / metric.limit * 100 : null;
+  const finiteUsedPct = usedPct == null || !Number.isFinite(usedPct) ? null : clampPct(usedPct);
+  const resets = metric.resetsAt ? Date.parse(metric.resetsAt) : Number.NaN;
+  return {
+    key: metric.key ?? `${metric.label}:${sourceIndex}`,
+    label: metric.label.replace(/\s*(limit|usage)$/i, "").trim() || metric.label,
+    role: inferRole(metric),
+    modelId: metric.modelId ?? null,
+    usedPct: finiteUsedPct,
+    remainingPct: bounded && finiteUsedPct != null ? clampPct(100 - finiteUsedPct) : null,
+    resetsAt: Number.isFinite(resets) ? resets : null,
+    bounded,
+    primary: metric.primary === true,
+    active: metric.active === true,
+    displayOrder: sourceIndex,
+    valueText: valueText(metric, finiteUsedPct)
+  };
+}
+function deriveQuotaViews(metrics) {
+  return metrics.map(deriveQuotaView).sort((a, b) => roleOrder(a.role) - roleOrder(b.role) || (a.role === "model" ? a.label.localeCompare(b.label) : a.displayOrder - b.displayOrder) || a.key.localeCompare(b.key)).map((quota, displayOrder) => ({ ...quota, displayOrder }));
+}
+function resolveQuotaViews(input) {
+  return input.quotas == null ? deriveQuotaViews(input.metrics ?? []) : [...input.quotas];
+}
+function usageFromHeadroom(value) {
+  return value === null || !Number.isFinite(value) ? null : clampPct(100 - value);
+}
+function severity(remaining) {
+  if (remaining === null || !Number.isFinite(remaining)) return "unknown";
+  if (remaining <= 10) return "crit";
+  if (remaining <= 25) return "warn";
+  return "ok";
+}
+function deriveAccountIdentity(input) {
+  const registered = input.name.trim() || input.providerName;
+  const email = input.email?.trim() || null;
+  const displayName = input.displayName?.trim() || null;
+  if (input.privacyMode && (containsEmail(registered) || containsEmail(email))) {
+    const title2 = `${input.providerName} account ${input.ordinal}`;
+    return { title: title2, subtitle: null, accessibleLabel: title2, redacted: true };
+  }
+  const title = input.privacyMode ? redactEmail(registered) : registered;
+  const subtitleCandidate = !input.privacyMode ? email && !registered.toLowerCase().includes(email.toLowerCase()) ? email : displayName : displayName && !containsEmail(displayName) ? displayName : null;
+  const subtitle = subtitleCandidate && subtitleCandidate !== title ? subtitleCandidate : null;
+  return { title, subtitle, accessibleLabel: subtitle ? `${title}, ${subtitle}` : title, redacted: input.privacyMode && title !== registered };
+}
+function accountIdentityText(account, providerName) {
+  const identity = account.identity;
+  if (!identity) return account.name || providerName;
+  const parts = [identity.title, identity.subtitle].filter((value) => !!value?.trim()).filter((value, index, values) => values.indexOf(value) === index).filter((value) => value.toLocaleLowerCase() !== providerName.toLocaleLowerCase());
+  return parts.join(" \xB7 ") || identity.title || providerName;
+}
+function blendHeadroom(a, b) {
+  const low = Math.min(clampPct(a), clampPct(b));
+  const high = Math.max(clampPct(a), clampPct(b));
+  return low * (0.9 + 0.1 * high / 100);
+}
+function tightestQuotaView(quotas) {
+  return quotas.filter((q) => q.remainingPct !== null).sort((a, b) => a.remainingPct - b.remainingPct || (a.resetsAt ?? Infinity) - (b.resetsAt ?? Infinity) || a.key.localeCompare(b.key))[0] ?? null;
+}
+function accountHeadroom(account) {
+  const session = account.quotas.find((q) => q.role === "session" && q.remainingPct !== null);
+  const models = account.quotas.filter((q) => q.role === "model" && q.remainingPct !== null);
+  const activeModel = models.find((q) => q.active) ?? null;
+  const weekly = account.quotas.find((q) => q.role === "weekly" && q.remainingPct !== null);
+  const factors = [];
+  let value = null;
+  let mode = "unavailable";
+  if (session && activeModel) {
+    value = blendHeadroom(session.remainingPct, activeModel.remainingPct);
+    mode = "smart";
+    factors.push(
+      { key: session.key, label: session.label, role: session.role, remainingPct: session.remainingPct, included: true, reason: "session" },
+      { key: activeModel.key, label: activeModel.label, role: activeModel.role, remainingPct: activeModel.remainingPct, included: true, reason: "active-model" }
+    );
+  } else if (session || activeModel) {
+    const only = session ?? activeModel;
+    value = only.remainingPct;
+    mode = "single-window";
+    factors.push({ key: only.key, label: only.label, role: only.role, remainingPct: only.remainingPct, included: true, reason: session ? "session" : "active-model" });
+  } else {
+    const primary = account.quotas.find((q) => q.primary && q.remainingPct !== null) ?? null;
+    if (primary) {
+      value = primary.remainingPct;
+      mode = "single-window";
+      factors.push({ key: primary.key, label: primary.label, role: primary.role, remainingPct: primary.remainingPct, included: true, reason: "primary" });
+    } else {
+      const floor = tightestQuotaView(account.quotas);
+      if (floor) {
+        value = floor.remainingPct;
+        mode = "fallback-floor";
+        factors.push({ key: floor.key, label: floor.label, role: floor.role, remainingPct: floor.remainingPct, included: true, reason: "fallback-floor" });
+      }
+    }
+  }
+  if (value !== null && weekly) {
+    const close = weekly.remainingPct <= 30 || weekly.remainingPct <= value + 10;
+    value = Math.min(value, weekly.remainingPct);
+    factors.push({ key: weekly.key, label: weekly.label, role: weekly.role, remainingPct: weekly.remainingPct, included: close, reason: "weekly-cap" });
+  }
+  const included = factors.filter((f) => f.included);
+  return {
+    value,
+    unit: "index-100",
+    mode,
+    factors,
+    explanation: value === null ? "No bounded quota data" : `Based on ${included.map((f) => f.label).join(" + ") || "available quota data"}`
+  };
+}
+function cumulativeQuotaViews(accounts) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const account of accounts) {
+    for (const quota of account.quotas) {
+      if (quota.remainingPct === null) continue;
+      const identity = quota.role === "session" || quota.role === "weekly" ? quota.role : quota.role === "model" ? `${quota.role}:${quota.modelId ?? quota.label.toLowerCase()}` : `${quota.role}:${quota.key}`;
+      const rows = groups.get(identity) ?? [];
+      rows.push(quota);
+      groups.set(identity, rows);
+    }
+  }
+  return [...groups.values()].filter((rows) => rows[0].role !== "model" || rows.length > 1 || accounts.length === 1).map((rows) => {
+    const first = rows[0];
+    const remainingPct = rows.reduce((sum, quota) => sum + quota.remainingPct, 0) / rows.length;
+    const usedPct = 100 - remainingPct;
+    const resets = rows.map((quota) => quota.resetsAt).filter((value) => value !== null);
+    return {
+      ...first,
+      usedPct,
+      remainingPct,
+      resetsAt: resets.length > 0 ? Math.min(...resets) : null,
+      primary: rows.some((quota) => quota.primary),
+      active: rows.some((quota) => quota.active),
+      displayOrder: Math.min(...rows.map((quota) => quota.displayOrder)),
+      valueText: `${Math.round(usedPct)}% used`
+    };
+  }).sort((a, b) => roleOrder(a.role) - roleOrder(b.role) || a.displayOrder - b.displayOrder || a.key.localeCompare(b.key));
+}
+function deriveProviderHeadroom(accounts, activeTimeoutMin, now, displayMetric = "smartHeadroom") {
+  const activeCutoff = now - activeTimeoutMin * 6e4;
+  const activeIds = accounts.filter((a) => a.lastActivityAt !== null && a.lastActivityAt >= activeCutoff).map((a) => a.id);
+  if (displayMetric === "smartHeadroom" && accounts.length > 1) {
+    const pooled = accountHeadroom({ id: "cumulative", lastActivityAt: null, quotas: cumulativeQuotaViews(accounts) });
+    if (pooled.value === null) return { ...pooled, basis: "unavailable", representativeAccountId: null, activeAccountIds: activeIds };
+    const dataCount = accounts.filter((account) => account.quotas.some((quota) => quota.remainingPct !== null)).length;
+    return {
+      ...pooled,
+      basis: activeIds.length > 0 ? "active" : "idle-runway",
+      representativeAccountId: null,
+      activeAccountIds: activeIds,
+      explanation: `${pooled.explanation}; ${dataCount} accounts combined`
+    };
+  }
+  const rows = accounts.map((account) => {
+    const smart = accountHeadroom(account);
+    if (displayMetric === "smartHeadroom") return { account, value: smart.value, view: smart };
+    const floor = tightestQuotaView(account.quotas);
+    const value = floor?.remainingPct ?? null;
+    return { account, value, view: { value, unit: "index-100", mode: floor ? "fallback-floor" : "unavailable", factors: floor ? [{ key: floor.key, label: floor.label, role: floor.role, remainingPct: value, included: true, reason: "fallback-floor" }] : [], explanation: floor ? `Based on ${floor.label}` : "No bounded quota data" } };
+  }).filter((row) => row.value !== null);
+  if (rows.length === 0) return { value: null, unit: "index-100", mode: "unavailable", basis: "unavailable", representativeAccountId: null, activeAccountIds: activeIds, factors: [], explanation: "No bounded quota data" };
+  const active = rows.filter((row) => activeIds.includes(row.account.id));
+  const candidates = active.length > 0 ? active : rows;
+  candidates.sort((a, b) => a.value !== b.value ? active.length > 0 ? a.value - b.value : b.value - a.value : active.length > 0 && a.account.lastActivityAt !== b.account.lastActivityAt ? (b.account.lastActivityAt ?? 0) - (a.account.lastActivityAt ?? 0) : a.account.id.localeCompare(b.account.id));
+  const selected = candidates[0];
+  const basis = active.length > 0 ? "active" : "idle-runway";
+  return { ...selected.view, basis, representativeAccountId: selected.account.id, activeAccountIds: activeIds, explanation: `${selected.view.explanation}; ${basis === "active" ? "active account" : "best available account"}` };
+}
+
+// src/peak.ts
+async function fetchPeak() {
+  try {
+    const res = await fetch("https://promoclock.co/api/status", {
+      headers: { "Accept": "application/json", "User-Agent": "tokmon" },
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) return null;
+    const data = await readJson(res);
+    if (!data) return null;
+    let state;
+    if (data.isPeak === true || data.status === "peak") state = "peak";
+    else if (data.isWeekend === true || data.status === "weekend") state = "weekend";
+    else if (data.isOffPeak === true || data.status === "off_peak" || data.status === "off-peak") state = "off-peak";
+    else return null;
+    const minutesUntilChange = typeof data.minutesUntilChange === "number" && Number.isFinite(data.minutesUntilChange) ? data.minutesUntilChange : null;
+    return {
+      state,
+      label: state === "peak" ? "Peak" : state === "weekend" ? "Weekend" : "Off-Peak",
+      minutesUntilChange,
+      changesAt: minutesUntilChange !== null ? new Date(Date.now() + minutesUntilChange * 6e4).toISOString() : null
+    };
+  } catch {
+    return null;
+  }
+}
+
+export {
+  buildAccounts,
+  accountsByProvider,
+  namedHex,
+  colorHex,
+  modelColor,
+  deriveQuotaViews,
+  resolveQuotaViews,
+  usageFromHeadroom,
+  severity,
+  deriveAccountIdentity,
+  accountIdentityText,
+  deriveProviderHeadroom,
+  fetchPeak
+};

package/dist/chunk-UYPDMVW5.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+// src/web/daemon-channel.ts
+var RELEASE_DAEMON_CHANNEL = "release";
+var DEV_DAEMON_CHANNEL = "dev";
+function resolveDaemonChannel(explicit, env = process.env) {
+  if (explicit) return explicit;
+  const configured = env.TOKMON_CHANNEL ?? env.TOKMON_RUNTIME_CHANNEL ?? env.TOKMON_RUNTIME_TAG;
+  return configured === DEV_DAEMON_CHANNEL ? DEV_DAEMON_CHANNEL : RELEASE_DAEMON_CHANNEL;
+}
+function daemonChannelFromWire(value) {
+  if (value === void 0) return RELEASE_DAEMON_CHANNEL;
+  if (value === RELEASE_DAEMON_CHANNEL) return RELEASE_DAEMON_CHANNEL;
+  if (value === DEV_DAEMON_CHANNEL) return DEV_DAEMON_CHANNEL;
+  return null;
+}
+
+export {
+  resolveDaemonChannel,
+  daemonChannelFromWire
+};