claude-token-saver 2.0.0

package/examples/statusline-with-rz1989s.sh

@@ -0,0 +1,52 @@
+#!/bin/sh
+# Combine rz1989s/claude-code-statusline (rich layout: repo, cost, MCP, prayer times)
+# with claude-token-saver (cache hit rate, TTL countdown, 1M-context detection,
+# spike diagnosis). The two projects don't overlap — rz1989s runs first, our
+# cache chip is appended as the final segment.
+#
+# Install:
+#   1) Follow rz1989s install instructions so bash ~/.claude/statusline.sh works:
+#      https://github.com/rz1989s/claude-code-statusline
+#   2) npm install -g claude-token-saver   (or rely on npx — fallback below)
+#   3) Save this file as: ~/.claude/statusline-with-rz1989s.sh
+#      chmod +x ~/.claude/statusline-with-rz1989s.sh
+#   4) In ~/.claude/settings.json:
+#      {
+#        "statusLine": {
+#          "type": "command",
+#          "command": "bash ~/.claude/statusline-with-rz1989s.sh",
+#          "refreshInterval": 1
+#        }
+#      }
+#
+# refreshInterval: 1 keeps our TTL countdown ticking while you're idle.
+# Drop to 2 or 5 for lower local CPU if your rz1989s config does heavy work.
+
+# Claude Code sends the session JSON on stdin. Both tools want to read it,
+# so we buffer it and tee to each.
+input=$(cat)
+
+# --- 1) rz1989s layout (if installed) ---
+RZ_STATUSLINE="${CLAUDE_RZ_STATUSLINE:-$HOME/.claude/statusline.sh}"
+if [ -f "$RZ_STATUSLINE" ]; then
+  printf '%s' "$input" | bash "$RZ_STATUSLINE"
+  # Separator between the two tools. Dim pipe.
+  printf ' \033[90m|\033[00m '
+fi
+
+# --- 2) claude-token-saver ---
+# Pass --exclude-session so the current session's tool calls don't reset the
+# TTL countdown. The path comes from the session JSON if present.
+session_path=$(printf '%s' "$input" | sed -n 's/.*"path"[[:space:]]*:[[:space:]]*"\([^"]*\.jsonl\)".*/\1/p' | head -n1)
+exclude_flag=""
+if [ -n "$session_path" ]; then
+  exclude_flag="--exclude-session $session_path"
+fi
+
+if command -v claude-token-saver >/dev/null 2>&1; then
+  # shellcheck disable=SC2086
+  claude-token-saver --statusline --icon $exclude_flag 2>/dev/null || true
+else
+  # shellcheck disable=SC2086
+  npx --yes claude-token-saver@latest --statusline --icon $exclude_flag 2>/dev/null || true
+fi

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "claude-token-saver",
+  "version": "2.0.0",
+  "description": "Save tokens on Claude Code — spike diagnosis, 1M-context detection, TTL countdown, statusline. (formerly claude-cache-monitor)",
+  "type": "module",
+  "bin": {
+    "claude-token-saver": "./bin/cli.js",
+    "claude-cache-monitor": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "examples/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude",
+    "anthropic",
+    "cache",
+    "monitoring",
+    "prompt-caching",
+    "cli",
+    "statusline",
+    "claude-code",
+    "token-usage",
+    "cost-savings",
+    "1m-context"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rootstudioyaml/claude-token-saver"
+  }
+}

package/src/advice.js

@@ -0,0 +1,138 @@
+/**
+ * Human-readable advice for each diagnostic issue code.
+ * Platform-specific commands are selected from process.platform.
+ */
+
+function platformKind() {
+  if (process.platform === 'win32') return 'win';
+  // WSL shows up as 'linux' but $WSL_DISTRO_NAME is set — treat as linux either way.
+  return 'posix';
+}
+
+function disable1mEnvSnippet() {
+  if (platformKind() === 'win') {
+    return [
+      'setx CLAUDE_CODE_DISABLE_1M_CONTEXT 1',
+      '(PowerShell) $env:CLAUDE_CODE_DISABLE_1M_CONTEXT = "1"',
+    ];
+  }
+  return [
+    "echo 'export CLAUDE_CODE_DISABLE_1M_CONTEXT=1' >> ~/.zshrc && source ~/.zshrc",
+    '(bash) echo \'export CLAUDE_CODE_DISABLE_1M_CONTEXT=1\' >> ~/.bashrc && source ~/.bashrc',
+  ];
+}
+
+function toggleShortcut() {
+  return platformKind() === 'win' ? 'Alt + P' : '⌥ P (mac) / Alt + P (linux)';
+}
+
+export const ISSUE_MESSAGES = {
+  LARGE_INPUT_PER_REQUEST: {
+    title: '요청당 입력 토큰이 평소보다 매우 큽니다 (1M 컨텍스트 의심)',
+    explain:
+      'Opus 4.7부터 1M 컨텍스트가 표준 가격으로 풀리면서 Max 플랜은 자동으로 1M로 승격됩니다. ' +
+      '한 번 컨텍스트가 200k를 넘으면 long-context 단가가 적용되고 캐시 재사용도 어려워집니다.',
+    actions: () => [
+      {
+        label: '1M 컨텍스트 OFF (환경변수)',
+        commands: disable1mEnvSnippet(),
+      },
+      {
+        label: '세션 내 토글',
+        commands: [`단축키 ${toggleShortcut()} 로 즉시 On/Off`],
+      },
+      {
+        label: '⚠ 알려진 버그 #31640',
+        commands: [
+          '/model 로 200k 선택해도 컨텍스트가 1M에 머무는 케이스가 있습니다.',
+          '확실히 끄려면 위 환경변수를 설정한 뒤 Claude Code를 재시작하세요.',
+        ],
+      },
+    ],
+  },
+  LOW_HIT_RATE: {
+    title: '캐시 히트율이 낮습니다',
+    explain:
+      '캐시 히트율이 떨어지면 같은 프롬프트 prefix를 매번 다시 작성하게 되어 입력 비용이 커집니다.',
+    actions: () => [
+      {
+        label: '세션을 너무 자주 새로 열지 않았는지 확인',
+        commands: ['한 작업은 같은 세션에서 이어가세요 (컨텍스트 전환 = 캐시 미스)'],
+      },
+      {
+        label: '프롬프트 prefix 안정화',
+        commands: ['시스템 프롬프트·도구 정의가 요청마다 바뀌면 캐시가 매번 무효화됩니다'],
+      },
+    ],
+  },
+  BUCKET_5M_DOMINANT: {
+    title: '5분 TTL 쓰기가 대부분입니다',
+    explain:
+      'Pro 플랜은 5분 TTL로 고정됩니다. 5분 이상 간격이 벌어지면 캐시가 만료되어 재작성 비용이 발생합니다.',
+    actions: () => [
+      {
+        label: '5분 규칙',
+        commands: [
+          '5분 안에 아무 프롬프트라도 보내면 prefix 캐시가 유지됩니다',
+          '긴 작업이 필요하면 Max 플랜으로 1h TTL 자동 적용',
+        ],
+      },
+    ],
+  },
+  HIGH_OUTPUT_RATIO: {
+    title: 'Output 비중이 비정상적으로 높습니다',
+    explain:
+      'Output 토큰은 입력보다 5배 이상 비쌉니다. 에이전트가 장문을 반복 생성하지 않는지 확인하세요.',
+    actions: () => [
+      {
+        label: '출력 길이 제한',
+        commands: [
+          '불필요한 전체 파일 쓰기·재생성 지양 (Edit 툴 활용)',
+          '긴 문서·README 생성 요청을 스크립트화해서 줄이세요',
+        ],
+      },
+    ],
+  },
+  HIGH_REQUEST_COUNT: {
+    title: '세션의 API 호출 수가 평소의 3배 이상입니다',
+    explain:
+      '툴 호출이 과도하거나 루프/재시도가 많으면 호출당 prefix 재전송으로 입력 비용이 폭증합니다.',
+    actions: () => [
+      {
+        label: '병렬/일괄 처리',
+        commands: ['독립적인 조사는 한 메시지에 여러 도구 호출로 묶으세요'],
+      },
+      {
+        label: '루프 감지',
+        commands: ['같은 테스트·검색을 반복하는 에이전트 루프가 없는지 확인'],
+      },
+    ],
+  },
+  FREQUENT_CACHE_REBUILD: {
+    title: '캐시 쓰기가 읽기보다 많습니다',
+    explain:
+      '캐시를 만들고 재사용하지 못하고 있습니다. 세션이 자주 끊기거나 TTL이 만료된 후 새로 시작한 경우 흔합니다.',
+    actions: () => [
+      {
+        label: '세션 지속 시간 확인',
+        commands: ['한 작업은 같은 Claude Code 세션에서 이어가세요'],
+      },
+    ],
+  },
+};
+
+/**
+ * For the statusline: the single most relevant short chip (1~2 words).
+ * Priority reflects what a user can act on *right now*.
+ */
+export function chipForIssues(issues, contextWindow) {
+  if (contextWindow?.size === '1M') return '⚠ 1M컨텍스트';
+  const codes = issues.map((i) => i.code);
+  if (codes.includes('LARGE_INPUT_PER_REQUEST')) return '⚠ 입력폭주';
+  if (codes.includes('BUCKET_5M_DOMINANT')) return '⚠ 5m TTL';
+  if (codes.includes('LOW_HIT_RATE')) return '⚠ 캐시미스';
+  if (codes.includes('FREQUENT_CACHE_REBUILD')) return '⚠ 재작성';
+  if (codes.includes('HIGH_OUTPUT_RATIO')) return '⚠ 출력과다';
+  if (codes.includes('HIGH_REQUEST_COUNT')) return '⚠ 호출폭주';
+  return null;
+}

package/src/cost.js

@@ -0,0 +1,150 @@
+/**
+ * Cost impact estimation based on Anthropic pricing.
+ * Source: https://docs.claude.com/en/docs/about-claude/pricing
+ * Prices per million tokens (USD). Updated 2026-04 for Opus 4.7 release.
+ *
+ * Note: Opus 4.5/4.6/4.7 use reduced pricing ($5/$25) vs. older Opus 4/4.1 ($15/$75).
+ * Cache writes are now tracked separately for 5m and 1h TTLs, each with their own rate.
+ */
+
+const PRICING = {
+  // Opus 4.5+ (new pricing tier — includes 4.5, 4.6, 4.7, and future)
+  'claude-opus-new': {
+    input: 5.0,
+    cacheWrite5m: 6.25,
+    cacheWrite1h: 10.0,
+    cacheRead: 0.5,
+    output: 25.0,
+  },
+  // Opus 4 / 4.1 / Opus 3 (legacy premium pricing)
+  'claude-opus-legacy': {
+    input: 15.0,
+    cacheWrite5m: 18.75,
+    cacheWrite1h: 30.0,
+    cacheRead: 1.5,
+    output: 75.0,
+  },
+  // Sonnet 4 / 4.5 / 4.6 / 3.7
+  'claude-sonnet': {
+    input: 3.0,
+    cacheWrite5m: 3.75,
+    cacheWrite1h: 6.0,
+    cacheRead: 0.3,
+    output: 15.0,
+  },
+  // Haiku 4.5
+  'claude-haiku-4-5': {
+    input: 1.0,
+    cacheWrite5m: 1.25,
+    cacheWrite1h: 2.0,
+    cacheRead: 0.1,
+    output: 5.0,
+  },
+  // Haiku 3.5
+  'claude-haiku-3-5': {
+    input: 0.8,
+    cacheWrite5m: 1.0,
+    cacheWrite1h: 1.6,
+    cacheRead: 0.08,
+    output: 4.0,
+  },
+  // Haiku 3 (deprecated)
+  'claude-haiku-3': {
+    input: 0.25,
+    cacheWrite5m: 0.3,
+    cacheWrite1h: 0.5,
+    cacheRead: 0.03,
+    output: 1.25,
+  },
+};
+
+/**
+ * Detect pricing tier from Claude model identifier.
+ * Examples: 'claude-opus-4-7', 'claude-sonnet-4-5', 'claude-haiku-4-5'.
+ */
+function detectPricingTier(model) {
+  if (!model) return 'claude-sonnet';
+  const m = model.toLowerCase();
+
+  if (m.includes('opus')) {
+    // Opus 4.5, 4.6, 4.7, and future 5+ use the new reduced pricing.
+    if (/opus[-_.]?4[-_.]?[5-9]\b/.test(m)) return 'claude-opus-new';
+    if (/opus[-_.]?[5-9]/.test(m)) return 'claude-opus-new';
+    // Opus 4, 4.1, 3 → legacy premium pricing.
+    return 'claude-opus-legacy';
+  }
+
+  if (m.includes('haiku')) {
+    if (/haiku[-_.]?4[-_.]?5/.test(m)) return 'claude-haiku-4-5';
+    if (/haiku[-_.]?3[-_.]?5/.test(m)) return 'claude-haiku-3-5';
+    if (/haiku[-_.]?3\b/.test(m)) return 'claude-haiku-3';
+    return 'claude-haiku-4-5';
+  }
+
+  // Sonnet (default fallback): 3.7, 4, 4.5, 4.6 all share the same pricing.
+  return 'claude-sonnet';
+}
+
+function tokensToMillions(n) {
+  return n / 1_000_000;
+}
+
+/**
+ * Estimate costs for given token totals.
+ *
+ * totals shape (from parser.js):
+ *   input            — non-cached input tokens
+ *   cacheCreation    — total cache-write tokens (5m + 1h combined, as reported by API)
+ *   cacheRead        — cache-hit tokens
+ *   ephemeral5m      — portion of cacheCreation billed at 5m rate (1.25x input)
+ *   ephemeral1h      — portion of cacheCreation billed at 1h rate (2x input)
+ *   output           — output tokens
+ */
+export function estimateCost(totals, model) {
+  const tier = detectPricingTier(model);
+  const p = PRICING[tier];
+
+  // Prefer explicit 5m/1h split when available; fall back to cacheCreation at 5m rate
+  // (conservative — 5m is cheaper than 1h).
+  const write5m = totals.ephemeral5m ?? 0;
+  const write1h = totals.ephemeral1h ?? 0;
+  const trackedWrites = write5m + write1h;
+  const untracked = Math.max(0, (totals.cacheCreation ?? 0) - trackedWrites);
+
+  const actual =
+    tokensToMillions(totals.input) * p.input +
+    tokensToMillions(write5m + untracked) * p.cacheWrite5m +
+    tokensToMillions(write1h) * p.cacheWrite1h +
+    tokensToMillions(totals.cacheRead) * p.cacheRead +
+    tokensToMillions(totals.output) * p.output;
+
+  // What it would cost without any caching (all input billed at base rate).
+  const totalInput = totals.input + totals.cacheCreation + totals.cacheRead;
+  const noCacheCost =
+    tokensToMillions(totalInput) * p.input +
+    tokensToMillions(totals.output) * p.output;
+
+  // What it would cost if all 1h-tier writes had been 5m instead
+  // (higher miss rate — estimate 3x more cache re-creation for sessions > 5min).
+  const extra5mCreation = write1h * 2; // sessions that would re-create under 5m TTL
+  const scenario5mWrites = write5m + write1h + untracked + extra5mCreation;
+  const scenario5mCost =
+    tokensToMillions(totals.input) * p.input +
+    tokensToMillions(scenario5mWrites) * p.cacheWrite5m +
+    tokensToMillions(Math.max(0, totals.cacheRead - extra5mCreation)) * p.cacheRead +
+    tokensToMillions(totals.output) * p.output;
+
+  return {
+    tier,
+    actual: round(actual),
+    noCacheCost: round(noCacheCost),
+    savings: round(noCacheCost - actual),
+    savingsRate: noCacheCost > 0 ? (noCacheCost - actual) / noCacheCost : 0,
+    scenario5mCost: round(scenario5mCost),
+    extraCostIf5m: round(scenario5mCost - actual),
+  };
+}
+
+function round(n) {
+  return Math.round(n * 100) / 100;
+}

package/src/formatters/csv.js

@@ -0,0 +1,8 @@
+export function formatReport({ trend }) {
+  const header = 'date,hit_rate,api_calls,cache_read,cache_creation,ephemeral_5m,ephemeral_1h,input,output';
+  const rows = trend.map(
+    (d) =>
+      `${d.date},${d.hitRate.toFixed(4)},${d.apiCalls},${d.cacheRead},${d.cacheCreation},${d.ephemeral5m},${d.ephemeral1h},${d.input},${d.output}`,
+  );
+  return [header, ...rows].join('\n');
+}

package/src/formatters/json.js

@@ -0,0 +1,3 @@
+export function formatReport(data) {
+  return JSON.stringify(data, null, 2);
+}

package/src/formatters/statusline.js

@@ -0,0 +1,164 @@
+/**
+ * Statusline formatter — compact single-line output for Claude Code statusline API.
+ * Called every ~300ms, so kept minimal and fast. ANSI color codes included by default.
+ *
+ * Example output (color):
+ *   🧠 97.5% · 1h · ⏱ 42:15 · 💰 $4.8K · 7d
+ *
+ * Disable color with NO_COLOR=1 env var or --no-color flag.
+ * Disable the TTL countdown with --no-timer.
+ *
+ * Usage in ~/.claude/settings.json:
+ *   {
+ *     "statusLine": {
+ *       "type": "command",
+ *       "command": "npx claude-token-saver --statusline"
+ *     }
+ *   }
+ */
+
+const RESET = '\x1b[0m';
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const GRAY = '\x1b[90m';
+const BOLD = '\x1b[1m';
+
+function formatMoney(usd) {
+  if (usd >= 1000) return `$${(usd / 1000).toFixed(1)}K`;
+  if (usd >= 100) return `$${usd.toFixed(0)}`;
+  if (usd >= 10) return `$${usd.toFixed(1)}`;
+  return `$${usd.toFixed(2)}`;
+}
+
+function formatPct(v) {
+  return `${(v * 100).toFixed(1)}%`;
+}
+
+/**
+ * Format a remaining-seconds countdown as MM:SS (or H:MM when ≥ 1h).
+ */
+function formatTimer(remainingSec) {
+  if (remainingSec <= 0) return 'EXPIRED';
+  const totalSec = Math.floor(remainingSec);
+  const h = Math.floor(totalSec / 3600);
+  const m = Math.floor((totalSec % 3600) / 60);
+  const s = totalSec % 60;
+  if (h > 0) return `${h}:${String(m).padStart(2, '0')}`;
+  return `${m}:${String(s).padStart(2, '0')}`;
+}
+
+/**
+ * @param {object} data - output of main report pipeline (summary, ttl, cost, options, lastActivity)
+ * @param {object} [opts]
+ * @param {boolean} [opts.color=true] - emit ANSI escape codes
+ * @param {boolean} [opts.verbose=false] - longer layout with labels
+ * @param {boolean} [opts.timer=true] - show TTL countdown segment
+ * @param {'text'|'icon'} [opts.mode='text'] - label style. 'icon' uses 🧠 ⏳ 💰 instead of word labels.
+ */
+export function formatReport(data, { color = true, verbose = false, timer = true, mode = 'text' } = {}) {
+  const { summary, ttl, cost, options, lastActivity, contextWindow, spikeChip } = data;
+  const { hitRate } = summary;
+
+  // Hit rate → color signal
+  const hitColor =
+    hitRate >= 0.85 ? GREEN :
+    hitRate >= 0.70 ? YELLOW :
+    RED;
+
+  // TTL dominance → color signal (1h = good, 5m = warning).
+  // The subscription plan fixes this, so the bucket rarely changes — it's the countdown that matters.
+  const is1h = ttl.pct1h >= 0.5;
+  const bucketLabel = is1h ? '1h' : '5m';
+  const bucketColor = is1h ? GREEN : YELLOW;
+  const ttlSeconds = is1h ? 3600 : 300;
+
+  const savings = cost?.savings ?? 0;
+
+  const c = (v) => (color ? v : '');
+  const isIcon = mode === 'icon';
+
+  // Labels per mode.
+  //   text:       "Cache hit 98.3%"                 |  verbose: "Cache hit 98.3%"
+  //   icon:       "🧠 98.3%"                          |  verbose: "🧠 Cache hit 98.3%"
+  const hitLabel = isIcon
+    ? (verbose ? '🧠 Cache hit' : '🧠')
+    : 'Cache hit';
+  const hitSeg = `${c(BOLD)}${hitLabel}${c(RESET)} ${c(hitColor)}${formatPct(hitRate)}${c(RESET)}`;
+
+  //   text:       "Cost saved $1.5K"                |  same in verbose
+  //   icon:       "💰 $1.5K"                          |  verbose: "💰 Cost saved $1.5K"
+  const saveLabel = isIcon
+    ? (verbose ? '💰 Cost saved' : '💰')
+    : 'Cost saved';
+  const saveSeg = `${c(CYAN)}${saveLabel}${c(RESET)} ${formatMoney(savings)}`;
+
+  const periodSeg = verbose
+    ? `${c(GRAY)}last ${options.days}d${c(RESET)}`
+    : `${c(GRAY)}${options.days}d${c(RESET)}`;
+
+  // TTL countdown — how much time is left on the last API call's cache entry.
+  // Matches Anthropic's actual prompt-cache behaviour: each call starts a fresh
+  // TTL window, and the next call (hit) within that window resets it. So the
+  // countdown visibly ticks down between prompts, and "resets" happens as a
+  // jump back toward the bucket max the moment you send another message.
+  //   text compact:   "Expires 1h 59:58"
+  //   text verbose:   "1h bucket · expires in 59:58"
+  //   icon compact:   "⏳ 1h 59:58"
+  //   icon verbose:   "⏳ Expires 1h 59:58"
+  let ttlSeg;
+  if (timer && lastActivity) {
+    const elapsed = (Date.now() - lastActivity) / 1000;
+    const remaining = ttlSeconds - elapsed;
+    const text = formatTimer(remaining);
+    const pct = remaining / ttlSeconds;
+    const timerColor =
+      remaining <= 0 ? RED :
+      pct > 0.30 ? GREEN :
+      pct > 0.10 ? YELLOW :
+      RED;
+
+    if (isIcon) {
+      const prefix = verbose ? '⏳ Expires ' : '⏳ ';
+      ttlSeg = `${c(bucketColor)}${prefix}${bucketLabel}${c(RESET)} ${c(timerColor)}${text}${c(RESET)}`;
+    } else if (verbose) {
+      ttlSeg = `${c(bucketColor)}${bucketLabel} bucket${c(RESET)} · ${c(timerColor)}expires in ${text}${c(RESET)}`;
+    } else {
+      ttlSeg = `${c(bucketColor)}Expires ${bucketLabel}${c(RESET)} ${c(timerColor)}${text}${c(RESET)}`;
+    }
+  } else {
+    if (isIcon) {
+      const prefix = verbose ? '⏳ Bucket ' : '⏳ ';
+      ttlSeg = `${c(bucketColor)}${prefix}${bucketLabel}${c(RESET)}`;
+    } else if (verbose) {
+      ttlSeg = `${c(bucketColor)}${bucketLabel} bucket${c(RESET)}`;
+    } else {
+      ttlSeg = `${c(bucketColor)}Bucket ${bucketLabel}${c(RESET)}`;
+    }
+  }
+
+  // Context window chip (e.g. "📦 1M" or "📦 200k"). 1M gets a warning color
+  // because it's the expensive default on Max plans after Opus 4.7.
+  let ctxSeg = null;
+  if (contextWindow && contextWindow.size && contextWindow.size !== 'unknown') {
+    const label = contextWindow.size === '1M' ? '1M' : '200k';
+    const ctxColor = contextWindow.size === '1M' ? RED : GREEN;
+    if (isIcon) {
+      ctxSeg = `${c(ctxColor)}📦 ${label}${c(RESET)}`;
+    } else if (verbose) {
+      ctxSeg = `${c(ctxColor)}Context ${label}${c(RESET)}`;
+    } else {
+      ctxSeg = `${c(ctxColor)}Ctx ${label}${c(RESET)}`;
+    }
+  }
+
+  // Spike chip — one word only, keeps the statusline single-line.
+  const spikeSeg = spikeChip ? `${c(RED)}${spikeChip}${c(RESET)}` : null;
+
+  const segs = [hitSeg, ttlSeg, saveSeg];
+  if (ctxSeg) segs.push(ctxSeg);
+  if (spikeSeg) segs.push(spikeSeg);
+  segs.push(periodSeg);
+  return segs.join(' · ');
+}