@amir83nasr/10router 0.1.0

package/open-sse/utils/usageTracking.js

@@ -0,0 +1,473 @@
+/**
+ * Token Usage Tracking - Extract, normalize, estimate and log token usage
+ */
+
+import { FORMATS } from "../translator/formats.js";
+
+// Legacy per-chunk usage console line; off by default (superseded by "DONE")
+const DEBUG_USAGE = process.env.LOG_USAGE_VERBOSE === "1";
+
+// ANSI color codes
+export const COLORS = {
+  reset: "\x1b[0m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m",
+};
+
+// Buffer tokens to prevent context errors
+const BUFFER_TOKENS = 2000;
+
+// Get HH:MM:SS timestamp
+function getTimeString() {
+  return new Date().toLocaleTimeString("en-US", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  });
+}
+
+/**
+ * Add buffer tokens to usage to prevent context errors
+ * @param {object} usage - Usage object (any format)
+ * @returns {object} Usage with buffer added
+ */
+export function addBufferToUsage(usage) {
+  if (!usage || typeof usage !== "object") return usage;
+
+  const result = { ...usage };
+
+  // Claude format
+  if (result.input_tokens !== undefined) {
+    result.input_tokens += BUFFER_TOKENS;
+  }
+
+  // OpenAI format
+  if (result.prompt_tokens !== undefined) {
+    result.prompt_tokens += BUFFER_TOKENS;
+  }
+
+  // Calculate or update total_tokens
+  if (result.total_tokens !== undefined) {
+    result.total_tokens += BUFFER_TOKENS;
+  } else if (result.prompt_tokens !== undefined && result.completion_tokens !== undefined) {
+    // Calculate total_tokens if not exists
+    result.total_tokens = result.prompt_tokens + result.completion_tokens;
+  }
+
+  return result;
+}
+
+export function filterUsageForFormat(usage, targetFormat) {
+  if (!usage || typeof usage !== "object") return usage;
+
+  // Helper to pick only defined fields from usage
+  const pickFields = (fields) => {
+    const filtered = {};
+    for (const field of fields) {
+      if (usage[field] !== undefined) {
+        filtered[field] = usage[field];
+      }
+    }
+    return filtered;
+  };
+
+  // Define allowed fields for each format
+  const formatFields = {
+    [FORMATS.CLAUDE]: [
+      "input_tokens",
+      "output_tokens",
+      "cache_read_input_tokens",
+      "cache_creation_input_tokens",
+      "estimated",
+    ],
+    [FORMATS.GEMINI]: [
+      "promptTokenCount",
+      "candidatesTokenCount",
+      "totalTokenCount",
+      "cachedContentTokenCount",
+      "thoughtsTokenCount",
+      "estimated",
+    ],
+    [FORMATS.OPENAI_RESPONSES]: [
+      "input_tokens",
+      "output_tokens",
+      "input_tokens_details",
+      "output_tokens_details",
+      "estimated",
+    ],
+    // OpenAI format (default for OPENAI, CODEX, etc.)
+    default: [
+      "prompt_tokens",
+      "completion_tokens",
+      "total_tokens",
+      "cached_tokens",
+      "reasoning_tokens",
+      "prompt_tokens_details",
+      "completion_tokens_details",
+      "estimated",
+    ],
+  };
+
+  // Get fields for target format
+  let fields = formatFields[targetFormat];
+
+  // Use same fields for similar formats
+  if (targetFormat === FORMATS.ANTIGRAVITY) {
+    fields = formatFields[FORMATS.GEMINI];
+  } else if (targetFormat === FORMATS.OPENAI_RESPONSE) {
+    fields = formatFields[FORMATS.OPENAI_RESPONSES];
+  } else if (!fields) {
+    fields = formatFields.default;
+  }
+
+  return pickFields(fields);
+}
+
+/**
+ * Normalize usage object - ensure all values are valid numbers
+ */
+export function normalizeUsage(usage) {
+  if (!usage || typeof usage !== "object" || Array.isArray(usage)) return null;
+
+  const normalized = {};
+  const assignNumber = (key, value) => {
+    if (value === undefined || value === null) return;
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) normalized[key] = numeric;
+  };
+
+  assignNumber("prompt_tokens", usage?.prompt_tokens);
+  assignNumber("completion_tokens", usage?.completion_tokens);
+  assignNumber("total_tokens", usage?.total_tokens);
+  assignNumber("cache_read_input_tokens", usage?.cache_read_input_tokens);
+  assignNumber("cache_creation_input_tokens", usage?.cache_creation_input_tokens);
+  assignNumber("cached_tokens", usage?.cached_tokens);
+  assignNumber("reasoning_tokens", usage?.reasoning_tokens);
+
+  // Preserve nested details objects for OpenAI format forwarding
+  if (usage?.prompt_tokens_details && typeof usage.prompt_tokens_details === "object") {
+    normalized.prompt_tokens_details = usage.prompt_tokens_details;
+  }
+  if (usage?.completion_tokens_details && typeof usage.completion_tokens_details === "object") {
+    normalized.completion_tokens_details = usage.completion_tokens_details;
+  }
+
+  if (Object.keys(normalized).length === 0) return null;
+  return normalized;
+}
+
+/**
+ * Canonicalize usage into ONE storage/cost convention so token counts and cost
+ * are consistent across providers:
+ *   prompt_tokens               = total input INCLUDING cache read + cache creation
+ *   cached_tokens               = cache-read portion (subset of prompt_tokens)
+ *   cache_creation_input_tokens = cache-write portion (subset of prompt_tokens)
+ *   completion_tokens, reasoning_tokens, total_tokens
+ *
+ * Discriminator: Claude reports cache_read_input_tokens with a prompt that
+ * EXCLUDES cache, so we fold cache into prompt. OpenAI/Gemini report
+ * cached_tokens already counted inside prompt, so we pass through. Idempotent:
+ * once folded the output carries cached_tokens (not cache_read_input_tokens),
+ * so re-running takes the passthrough branch and does not double-add.
+ *
+ * @param {object} usage - a normalizeUsage()-shaped object
+ * @returns {object|null} canonical token object, or null for invalid input
+ */
+export function canonicalizeUsage(usage) {
+  if (!usage || typeof usage !== "object" || Array.isArray(usage)) return null;
+
+  const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
+  const completion = num(usage.completion_tokens ?? usage.output_tokens);
+  const reasoning = num(usage.reasoning_tokens);
+  // Fall back to the nested prompt_tokens_details.cache_creation_tokens shape
+  // (buildUsage()'s OpenAI-forwarding format) when the top-level field is
+  // absent, so callers that pass a buildUsage() object through don't silently
+  // drop cache_creation.
+  const cacheCreation = num(
+    usage.cache_creation_input_tokens ?? usage.prompt_tokens_details?.cache_creation_tokens,
+  );
+
+  let prompt = num(usage.prompt_tokens ?? usage.input_tokens);
+  let cached;
+
+  // Claude path: prompt excludes cache; cache_read_input_tokens and/or
+  // cache_creation_input_tokens are separate. A cache-miss "first write" only
+  // carries cache_creation_input_tokens (no cache_read_input_tokens yet), so
+  // check both fields — otherwise a first-write request falls through to the
+  // OpenAI passthrough branch below and cache_creation never gets folded in.
+  // Guard on the absence of `cached_tokens`: our own canonical output always
+  // sets that key (even to 0), so re-running canonicalizeUsage on an already-
+  // folded result takes the passthrough branch instead of folding again.
+  if (
+    usage.cached_tokens === undefined &&
+    (usage.cache_read_input_tokens !== undefined || usage.cache_creation_input_tokens !== undefined)
+  ) {
+    cached = num(usage.cache_read_input_tokens);
+    prompt = prompt + cached + cacheCreation;
+  } else {
+    // OpenAI/Gemini path (or already-canonical input): prompt already includes cached_tokens.
+    // Mirror the cacheCreation fallback above: buildUsage() only ever emits the
+    // nested prompt_tokens_details.cached_tokens shape, so without this the
+    // cache-read count is silently dropped on every buildUsage()-derived usage.
+    cached = num(usage.cached_tokens ?? usage.prompt_tokens_details?.cached_tokens);
+  }
+
+  const result = {
+    prompt_tokens: prompt,
+    completion_tokens: completion,
+    // Recompute rather than pass through: when the fold branch ran above,
+    // an upstream total_tokens (cache-exclusive) would otherwise be stale.
+    total_tokens: prompt + completion,
+    cached_tokens: cached,
+    cache_creation_input_tokens: cacheCreation,
+  };
+  if (reasoning > 0) result.reasoning_tokens = reasoning;
+  return result;
+}
+
+/**
+ * Check if usage has valid token data
+ * Valid = has at least one token field with value > 0
+ * Invalid = empty object {}, null, undefined, no token fields, or all zeros
+ */
+export function hasValidUsage(usage) {
+  if (!usage || typeof usage !== "object") return false;
+
+  // Check for any known token field with value > 0
+  const tokenFields = [
+    "prompt_tokens",
+    "completion_tokens",
+    "total_tokens", // OpenAI
+    "input_tokens",
+    "output_tokens", // Claude
+    "promptTokenCount",
+    "candidatesTokenCount", // Gemini
+  ];
+
+  for (const field of tokenFields) {
+    if (typeof usage[field] === "number" && usage[field] > 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Extract usage from any format (Claude, OpenAI, Gemini, Responses API)
+ */
+export function extractUsage(chunk) {
+  if (!chunk || typeof chunk !== "object") return null;
+
+  // Claude format (message_start event): carries input_tokens + cache_read +
+  // cache_creation. message_delta later carries only the final output_tokens,
+  // so callers must MERGE (mergeUsage), not overwrite, to keep cache counts.
+  if (
+    chunk.type === "message_start" &&
+    chunk.message?.usage &&
+    typeof chunk.message.usage === "object"
+  ) {
+    const u = chunk.message.usage;
+    return normalizeUsage({
+      prompt_tokens: u.input_tokens || 0,
+      completion_tokens: u.output_tokens || 0,
+      cache_read_input_tokens: u.cache_read_input_tokens,
+      cache_creation_input_tokens: u.cache_creation_input_tokens,
+    });
+  }
+
+  // Claude format (message_delta event)
+  if (chunk.type === "message_delta" && chunk.usage && typeof chunk.usage === "object") {
+    return normalizeUsage({
+      prompt_tokens: chunk.usage.input_tokens || 0,
+      completion_tokens: chunk.usage.output_tokens || 0,
+      cache_read_input_tokens: chunk.usage.cache_read_input_tokens,
+      cache_creation_input_tokens: chunk.usage.cache_creation_input_tokens,
+    });
+  }
+
+  // OpenAI Responses API format (response.completed or response.done)
+  if (
+    (chunk.type === "response.completed" || chunk.type === "response.done") &&
+    chunk.response?.usage &&
+    typeof chunk.response.usage === "object"
+  ) {
+    const usage = chunk.response.usage;
+    const cachedTokens = usage.input_tokens_details?.cached_tokens;
+    return normalizeUsage({
+      prompt_tokens: usage.input_tokens || usage.prompt_tokens || 0,
+      completion_tokens: usage.output_tokens || usage.completion_tokens || 0,
+      cached_tokens: cachedTokens,
+      reasoning_tokens: usage.output_tokens_details?.reasoning_tokens,
+      prompt_tokens_details: cachedTokens ? { cached_tokens: cachedTokens } : undefined,
+    });
+  }
+
+  // OpenAI format (also covers DeepSeek which uses prompt_cache_hit_tokens)
+  if (chunk.usage && typeof chunk.usage === "object" && chunk.usage.prompt_tokens !== undefined) {
+    return normalizeUsage({
+      prompt_tokens: chunk.usage.prompt_tokens,
+      completion_tokens: chunk.usage.completion_tokens || 0,
+      cached_tokens:
+        chunk.usage.prompt_tokens_details?.cached_tokens || chunk.usage.prompt_cache_hit_tokens,
+      reasoning_tokens: chunk.usage.completion_tokens_details?.reasoning_tokens,
+      prompt_tokens_details: chunk.usage.prompt_tokens_details,
+      completion_tokens_details: chunk.usage.completion_tokens_details,
+    });
+  }
+
+  // Gemini format (Antigravity)
+  // Antigravity wraps usageMetadata inside response: { response: { usageMetadata: {...} } }
+  const usageMeta = chunk.usageMetadata || chunk.response?.usageMetadata;
+  if (usageMeta && typeof usageMeta === "object") {
+    return normalizeUsage({
+      prompt_tokens: usageMeta.promptTokenCount || 0,
+      completion_tokens: usageMeta.candidatesTokenCount || 0,
+      total_tokens: usageMeta.totalTokenCount,
+      cached_tokens: usageMeta.cachedContentTokenCount,
+      reasoning_tokens: usageMeta.thoughtsTokenCount,
+    });
+  }
+
+  // Ollama NDJSON format (raw from provider, before translation)
+  // Ollama sends: {"model":"...","done":true,"prompt_eval_count":N,"eval_count":M}
+  if (chunk.done === true && typeof chunk.prompt_eval_count === "number") {
+    return normalizeUsage({
+      prompt_tokens: chunk.prompt_eval_count || 0,
+      completion_tokens: chunk.eval_count || 0,
+      total_tokens: (chunk.prompt_eval_count || 0) + (chunk.eval_count || 0),
+    });
+  }
+
+  return null;
+}
+
+// Field-wise max-merge of two usage objects. Anthropic splits usage across
+// events: message_start has real input+cache (output is a placeholder 1),
+// message_delta has the real cumulative output (input/cache absent). Max keeps
+// the meaningful value from each without clobbering. Idempotent for other
+// providers that emit a single complete usage object.
+export function mergeUsage(prev, next) {
+  if (!prev) return next || null;
+  if (!next) return prev;
+  const merged = { ...prev };
+  for (const [k, v] of Object.entries(next)) {
+    // typeof NaN === "number" — guard with Number.isFinite so one malformed
+    // chunk can't poison the whole accumulation (Math.max(x, NaN) is NaN).
+    if (typeof v === "number" && Number.isFinite(v)) {
+      merged[k] = Math.max(typeof merged[k] === "number" ? merged[k] : 0, v);
+    } else if (v && typeof v === "object") {
+      merged[k] = v; // nested details objects: take latest
+    }
+  }
+  return merged;
+}
+
+/**
+ * Estimate input tokens from request body
+ * Calculate total body size for more accurate estimation
+ */
+export function estimateInputTokens(body) {
+  if (!body || typeof body !== "object") return 0;
+
+  try {
+    // Calculate total body size (includes messages, tools, system, thinking config, etc.)
+    const bodyStr = JSON.stringify(body);
+    const totalChars = bodyStr.length;
+
+    // Estimate: ~4 chars per token (rough average across all tokenizers)
+    return Math.ceil(totalChars / 4);
+  } catch (err) {
+    // Fallback if stringify fails
+    return 0;
+  }
+}
+
+/**
+ * Estimate output tokens from content length
+ */
+export function estimateOutputTokens(contentLength) {
+  if (!contentLength || contentLength <= 0) return 0;
+  return Math.max(1, Math.floor(contentLength / 4));
+}
+
+/**
+ * Format usage object based on target format
+ * @param {number} inputTokens - Input/prompt tokens
+ * @param {number} outputTokens - Output/completion tokens
+ * @param {string} targetFormat - Target format from FORMATS
+ */
+export function formatUsage(inputTokens, outputTokens, targetFormat) {
+  // Claude format uses input_tokens/output_tokens
+  if (targetFormat === FORMATS.CLAUDE) {
+    return addBufferToUsage({
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      estimated: true,
+    });
+  }
+
+  // Default: OpenAI format (works for openai, gemini, responses, etc.)
+  return addBufferToUsage({
+    prompt_tokens: inputTokens,
+    completion_tokens: outputTokens,
+    total_tokens: inputTokens + outputTokens,
+    estimated: true,
+  });
+}
+
+/**
+ * Estimate full usage when provider doesn't return it
+ * @param {object} body - Request body for input token estimation
+ * @param {number} contentLength - Content length for output token estimation
+ * @param {string} targetFormat - Target format from FORMATS constant
+ */
+export function estimateUsage(body, contentLength, targetFormat = FORMATS.OPENAI) {
+  return formatUsage(estimateInputTokens(body), estimateOutputTokens(contentLength), targetFormat);
+}
+
+/**
+ * Log usage with cache info (green color)
+ */
+export function logUsage(provider, usage, model = null, connectionId = null, apiKey = null) {
+  if (!usage || typeof usage !== "object") return;
+
+  // Console output moved to the unified "DONE" line (streamingHandler). Kept as
+  // a no-op hook so callers stay unchanged; usage persistence happens via saveUsageStats.
+  if (!DEBUG_USAGE) return;
+
+  const p = provider?.toUpperCase() || "UNKNOWN";
+
+  // Support both formats:
+  // - OpenAI: prompt_tokens, completion_tokens
+  // - Claude: input_tokens, output_tokens
+  const inTokens = usage?.prompt_tokens || usage?.input_tokens || 0;
+  const outTokens = usage?.completion_tokens || usage?.output_tokens || 0;
+  const accountPrefix = connectionId ? connectionId.slice(0, 8) + "..." : "unknown";
+
+  let msg = `[${getTimeString()}] [USAGE] ${p} | in=${inTokens} | out=${outTokens} | account=${accountPrefix}`;
+
+  // Add estimated flag if present
+  if (usage.estimated) {
+    msg += ` (estimated)`;
+  }
+
+  // Add cache info if present (unified from different formats)
+  const cacheRead =
+    usage.cache_read_input_tokens ||
+    usage.cached_tokens ||
+    usage.prompt_tokens_details?.cached_tokens;
+  if (cacheRead) msg += ` | cache_read=${cacheRead}`;
+
+  const cacheCreation = usage.cache_creation_input_tokens;
+  if (cacheCreation) msg += ` | cache_create=${cacheCreation}`;
+
+  const reasoning = usage.reasoning_tokens;
+  if (reasoning) msg += ` | reasoning=${reasoning}`;
+
+  console.log(msg);
+}

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "@amir83nasr/10router",
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Amir83Nasr/10Router.git"
+  },
+  "packageManager": "pnpm@12.5.1",
+  "description": "10Router dashboard",
+  "bin": {
+    "10router": "bin/10router.mjs"
+  },
+  "files": [
+    "bin/",
+    "custom-server.js",
+    "scripts/dev-local.mjs",
+    "src/",
+    "open-sse/",
+    "public/",
+    "next.config.mjs",
+    "LICENSE.md",
+    ".next/BUILD_ID",
+    ".next/*.json",
+    ".next/server/",
+    ".next/static/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "node scripts/dev-local.mjs",
+    "dev:webpack": "next dev --webpack --port 20127",
+    "build": "next build --webpack",
+    "start": "node custom-server.js --port 20127",
+    "dev:bun": "bun --bun next dev --webpack --port 20127",
+    "dev:ui": "node scripts/dev-local.mjs --ui",
+    "build:bun": "bun --bun next build --webpack",
+    "start:bun": "bun ./.next/standalone/custom-server.js",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint .",
+    "test": "node scripts/run-tests.mjs",
+    "prepublishOnly": "pnpm build",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.{js,mjs,cjs,jsx,ts,tsx}": [
+      "prettier --write",
+      "eslint --fix"
+    ],
+    "*.{css,scss,json,md,yaml,yml}": [
+      "prettier --write"
+    ]
+  },
+  "dependencies": {
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/modifiers": "^9.0.0",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
+    "@next/third-parties": "^16.2.9",
+    "@node-saml/node-saml": "^5.1.0",
+    "@radix-ui/react-avatar": "^1.2.6",
+    "@radix-ui/react-dialog": "^1.1.23",
+    "@radix-ui/react-dropdown-menu": "^2.1.24",
+    "@radix-ui/react-label": "^2.1.15",
+    "@radix-ui/react-select": "^2.3.7",
+    "@radix-ui/react-separator": "^1.1.15",
+    "@radix-ui/react-slot": "^1.3.3",
+    "@radix-ui/react-switch": "^1.3.7",
+    "@radix-ui/react-tabs": "^1.1.21",
+    "@radix-ui/react-tooltip": "^1.2.16",
+    "@xyflow/react": "^12.10.1",
+    "bcryptjs": "^3.0.3",
+    "chalk": "^5.6.2",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cn": "^0.3.0",
+    "confbox": "^0.2.4",
+    "jose": "^6.1.3",
+    "lucide-react": "^1.47.0",
+    "marked": "^18.0.1",
+    "next": "^16.1.6",
+    "node-machine-id": "^1.1.12",
+    "open": "^11.0.0",
+    "ora": "^9.1.0",
+    "prop-types": "^15.8.1",
+    "radix-ui": "^1.6.7",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "recharts": "^3.8.0",
+    "sql.js": "^1.14.1",
+    "tailwind-merge": "^3.7.0",
+    "tw-animate-css": "^1.4.0",
+    "undici": "^7.19.2",
+    "uuid": "^13.0.0",
+    "zustand": "^5.0.10"
+  },
+  "optionalDependencies": {
+    "better-sqlite3": "^12.6.2"
+  },
+  "comment_better_sqlite3": "kept in optionalDependencies so npm install doesn't fail on systems without build tools — sql.js is used as fallback at runtime",
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.1.18",
+    "@types/node": "^26.6.1",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "eslint": "^9",
+    "eslint-config-next": "16.1.6",
+    "eslint-config-prettier": "^10.1.8",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.5.1",
+    "postcss": "^8.5.6",
+    "prettier": "^3.9.8",
+    "shadcn": "^4.21.0",
+    "tailwindcss": "^4",
+    "typescript": "^5.9.3"
+  }
+}

package/public/favicon.svg

@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Layer_2" data-name="Layer 2" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 515 515">
+  <defs>
+    <style>
+      .cls-1, .cls-2 {
+        fill: none;
+      }
+
+      .cls-2 {
+        stroke: url(#Glass_Gradient_copy);
+        stroke-width: 3px;
+      }
+
+      .cls-3 {
+        fill: #32ec83;
+      }
+
+      .cls-4, .cls-5 {
+        fill: #fff;
+      }
+
+      .cls-5 {
+        opacity: 0;
+      }
+
+      .cls-6 {
+        clip-path: url(#clippath);
+      }
+    </style>
+    <clipPath id="clippath">
+      <path class="cls-1" d="M257.5,513.5h0c-84.77-1.13-154.97-15.98-196.91-59.09C17.48,412.47,2.63,342.27,1.5,257.5c0,0,0,0,0,0,1.13-84.77,15.98-154.97,59.09-196.91C102.53,17.48,172.73,2.63,257.5,1.5c0,0,0,0,0,0,84.77,1.13,154.97,15.98,196.91,59.09,43.11,41.94,57.96,112.14,59.09,196.91,0,0,0,0,0,0-1.13,84.77-15.98,154.97-59.09,196.91-41.94,43.11-112.14,57.96-196.91,59.09Z"/>
+    </clipPath>
+    <linearGradient id="Glass_Gradient_copy" data-name="Glass Gradient copy" x1="59.52" y1="455.48" x2="455.48" y2="59.52" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#fff" stop-opacity=".05"/>
+      <stop offset=".03" stop-color="#fff" stop-opacity=".07"/>
+      <stop offset=".05" stop-color="#fff" stop-opacity=".11"/>
+      <stop offset=".08" stop-color="#fff" stop-opacity=".19"/>
+      <stop offset=".1" stop-color="#fff" stop-opacity=".3"/>
+      <stop offset=".13" stop-color="#fff" stop-opacity=".44"/>
+      <stop offset=".15" stop-color="#fff" stop-opacity=".61"/>
+      <stop offset=".18" stop-color="#fff" stop-opacity=".81"/>
+      <stop offset=".2" stop-color="#fff"/>
+      <stop offset=".8" stop-color="#fff"/>
+      <stop offset=".82" stop-color="#fff" stop-opacity=".82"/>
+      <stop offset=".85" stop-color="#fff" stop-opacity=".62"/>
+      <stop offset=".87" stop-color="#fff" stop-opacity=".44"/>
+      <stop offset=".9" stop-color="#fff" stop-opacity=".3"/>
+      <stop offset=".92" stop-color="#fff" stop-opacity=".19"/>
+      <stop offset=".95" stop-color="#fff" stop-opacity=".11"/>
+      <stop offset=".97" stop-color="#fff" stop-opacity=".07"/>
+      <stop offset="1" stop-color="#fff" stop-opacity=".05"/>
+    </linearGradient>
+  </defs>
+  <g id="Layer_1-2" data-name="Layer 1">
+    <g>
+      <g class="cls-6">
+        <g>
+          <rect class="cls-3" x="1.5" y="1.5" width="512" height="512"/>
+          <g>
+            <path d="M1.5,215.26l.06,194.82h-.06v103.42h419.65l.93-425L1.5,215.26ZM168.94,392.21l1.14-25.65.3-80.94c.06-14.02-.51-27.05-1.64-41.04,3.62,1.2,7.23,3.26,10.85,4.21,12.31,3.29,24.3,5.89,36.79,8.43,4.57.93,9.21,1.23,13.75,1.29l-.87,17.04.3,109.66,1.49,7.23c-20.86-1.82-41.28-1.67-62.11-.24ZM324.1,391.85c-20.41-1.2-40.44-.69-61.87.3l1.02-5.53.81-79.48-.63-49.56c11.78.24,23.25-1.88,34.76-4.6,9.21-2.15,17.96-4.78,26.84-8.52-1.08,7.62-1.91,14.41-1.94,21.91l-.18,113.07,1.2,12.4Z"/>
+            <path class="cls-4" d="M322.9,379.45l1.2,12.4c-20.41-1.2-40.44-.69-61.87.3l1.02-5.53.81-79.48-.63-49.56c11.78.24,23.25-1.88,34.76-4.6,9.21-2.15,17.96-4.78,26.84-8.52-1.08,7.62-1.91,14.41-1.94,21.91l-.18,113.07Z"/>
+            <path class="cls-4" d="M231.05,392.45c-20.86-1.82-41.28-1.67-62.11-.24l1.14-25.65.3-80.94c.06-14.02-.51-27.05-1.64-41.04,3.62,1.2,7.23,3.26,10.85,4.21,12.31,3.29,24.3,5.89,36.79,8.43,4.57.93,9.21,1.23,13.75,1.29l-.87,17.04.3,109.66,1.49,7.23Z"/>
+          </g>
+        </g>
+      </g>
+      <g>
+        <path class="cls-2" d="M257.5,513.5h0c-84.77-1.13-154.97-15.98-196.91-59.09C17.48,412.47,2.63,342.27,1.5,257.5c0,0,0,0,0,0,1.13-84.77,15.98-154.97,59.09-196.91C102.53,17.48,172.73,2.63,257.5,1.5c0,0,0,0,0,0,84.77,1.13,154.97,15.98,196.91,59.09,43.11,41.94,57.96,112.14,59.09,196.91,0,0,0,0,0,0-1.13,84.77-15.98,154.97-59.09,196.91-41.94,43.11-112.14,57.96-196.91,59.09Z"/>
+        <path class="cls-5" d="M257.5,513.5h0c-84.77-1.13-154.97-15.98-196.91-59.09C17.48,412.47,2.63,342.27,1.5,257.5c0,0,0,0,0,0,1.13-84.77,15.98-154.97,59.09-196.91C102.53,17.48,172.73,2.63,257.5,1.5c0,0,0,0,0,0,84.77,1.13,154.97,15.98,196.91,59.09,43.11,41.94,57.96,112.14,59.09,196.91,0,0,0,0,0,0-1.13,84.77-15.98,154.97-59.09,196.91-41.94,43.11-112.14,57.96-196.91,59.09Z"/>
+      </g>
+    </g>
+  </g>
+</svg>