swayrouter 1.0.0

package/src/executors/grok-web.js

@@ -0,0 +1,342 @@
+import { BaseExecutor } from "./base.js";
+import { PROVIDERS } from "../config/providers.js";
+import { SSE_DONE, SSE_HEADERS_NO_BUFFER } from "../utils/sseConstants.js";
+import { sseChunk } from "../utils/sse.js";
+
+const GROK_CHAT_API = PROVIDERS["grok-web"].baseUrl;
+const GROK_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36";
+
+const MODEL_MAP = {
+  "grok-3": { grokModel: "grok-3", modelMode: "MODEL_MODE_GROK_3", isThinking: false },
+  "grok-3-mini": { grokModel: "grok-3", modelMode: "MODEL_MODE_GROK_3_MINI_THINKING", isThinking: true },
+  "grok-3-thinking": { grokModel: "grok-3", modelMode: "MODEL_MODE_GROK_3_THINKING", isThinking: true },
+  "grok-4": { grokModel: "grok-4", modelMode: "MODEL_MODE_GROK_4", isThinking: false },
+  "grok-4-mini": { grokModel: "grok-4-mini", modelMode: "MODEL_MODE_GROK_4_MINI_THINKING", isThinking: true },
+  "grok-4-thinking": { grokModel: "grok-4", modelMode: "MODEL_MODE_GROK_4_THINKING", isThinking: true },
+  "grok-4-heavy": { grokModel: "grok-4", modelMode: "MODEL_MODE_HEAVY", isThinking: true },
+  "grok-4.1-mini": { grokModel: "grok-4-1-thinking-1129", modelMode: "MODEL_MODE_GROK_4_1_MINI_THINKING", isThinking: true },
+  "grok-4.1-fast": { grokModel: "grok-4-1-thinking-1129", modelMode: "MODEL_MODE_FAST", isThinking: false },
+  "grok-4.1-expert": { grokModel: "grok-4-1-thinking-1129", modelMode: "MODEL_MODE_EXPERT", isThinking: true },
+  "grok-4.1-thinking": { grokModel: "grok-4-1-thinking-1129", modelMode: "MODEL_MODE_GROK_4_1_THINKING", isThinking: true },
+  "grok-4.2": { grokModel: "grok-420", modelMode: "MODEL_MODE_GROK_420", isThinking: false },
+  "grok-4.20": { grokModel: "grok-420", modelMode: "MODEL_MODE_GROK_420", isThinking: false },
+  "grok-4.20-beta": { grokModel: "grok-420", modelMode: "MODEL_MODE_GROK_420", isThinking: false },
+};
+
+function randomString(length, alphanumeric = false) {
+  const chars = alphanumeric ? "abcdefghijklmnopqrstuvwxyz0123456789" : "abcdefghijklmnopqrstuvwxyz";
+  let result = "";
+  for (let i = 0; i < length; i++) result += chars[Math.floor(Math.random() * chars.length)];
+  return result;
+}
+
+function generateStatsigId() {
+  const msg = Math.random() < 0.5
+    ? `e:TypeError: Cannot read properties of null (reading 'children["${randomString(5, true)}"]')`
+    : `e:TypeError: Cannot read properties of undefined (reading '${randomString(10)}')`;
+  return btoa(msg);
+}
+
+function randomHex(bytes) {
+  const arr = new Uint8Array(bytes);
+  crypto.getRandomValues(arr);
+  return Array.from(arr, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+function parseOpenAIMessages(messages) {
+  const extracted = [];
+  for (const msg of messages) {
+    let role = String(msg.role || "user");
+    if (role === "developer") role = "system";
+    let content = "";
+    if (typeof msg.content === "string") {
+      content = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      content = msg.content.filter((c) => c.type === "text").map((c) => String(c.text || "")).join(" ");
+    }
+    if (!content.trim()) continue;
+    extracted.push({ role, text: content });
+  }
+
+  let lastUserIdx = -1;
+  for (let i = extracted.length - 1; i >= 0; i--) {
+    if (extracted[i].role === "user") { lastUserIdx = i; break; }
+  }
+
+  const parts = [];
+  for (let i = 0; i < extracted.length; i++) {
+    const { role, text } = extracted[i];
+    parts.push(i === lastUserIdx ? text : `${role}: ${text}`);
+  }
+  return parts.join("\n\n");
+}
+
+async function* readGrokNdjsonEvents(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) return;
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      while (true) {
+        const idx = buffer.indexOf("\n");
+        if (idx < 0) break;
+        const line = buffer.slice(0, idx).trim();
+        buffer = buffer.slice(idx + 1);
+        if (!line) continue;
+        try { yield JSON.parse(line); } catch {            }
+      }
+    }
+    buffer += decoder.decode();
+    const remaining = buffer.trim();
+    if (remaining) {
+      try { yield JSON.parse(remaining); } catch {            }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+async function* extractContent(eventStream, isThinkingModel, signal) {
+  let fingerprint = "";
+  let responseId = "";
+  let thinkOpened = false;
+
+  for await (const event of readGrokNdjsonEvents(eventStream, signal)) {
+    if (event.error) {
+      yield { error: event.error.message || `Grok error: ${event.error.code}`, done: true };
+      return;
+    }
+    const resp = event.result?.response;
+    if (!resp) continue;
+
+    if (resp.llmInfo?.modelHash && !fingerprint) fingerprint = resp.llmInfo.modelHash;
+    if (resp.responseId) responseId = resp.responseId;
+
+    if (resp.modelResponse) {
+      const mr = resp.modelResponse;
+      if (thinkOpened && isThinkingModel) {
+        if (mr.message) yield { thinking: mr.message };
+        thinkOpened = false;
+      }
+      if (mr.message) yield { fullMessage: mr.message, fingerprint, responseId };
+      if (mr.metadata?.llm_info?.modelHash) fingerprint = mr.metadata.llm_info.modelHash;
+      continue;
+    }
+
+    if (resp.token != null) yield { delta: resp.token, fingerprint, responseId };
+  }
+  yield { done: true, fingerprint, responseId };
+}
+
+function buildStreamingResponse(eventStream, model, cid, created, isThinkingModel, signal) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        controller.enqueue(encoder.encode(sseChunk({
+          id: cid, object: "chat.completion.chunk", created, model, system_fingerprint: null,
+          choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null, logprobs: null }],
+        })));
+
+        let fp = "";
+        for await (const chunk of extractContent(eventStream, isThinkingModel, signal)) {
+          if (chunk.fingerprint) fp = chunk.fingerprint;
+
+          if (chunk.error) {
+            controller.enqueue(encoder.encode(sseChunk({
+              id: cid, object: "chat.completion.chunk", created, model, system_fingerprint: fp || null,
+              choices: [{ index: 0, delta: { content: `[Error: ${chunk.error}]` }, finish_reason: null, logprobs: null }],
+            })));
+            break;
+          }
+          if (chunk.thinking) {
+            controller.enqueue(encoder.encode(sseChunk({
+              id: cid, object: "chat.completion.chunk", created, model, system_fingerprint: fp || null,
+              choices: [{ index: 0, delta: { reasoning_content: chunk.thinking }, finish_reason: null, logprobs: null }],
+            })));
+            continue;
+          }
+          if (chunk.done) break;
+          if (chunk.delta) {
+            controller.enqueue(encoder.encode(sseChunk({
+              id: cid, object: "chat.completion.chunk", created, model, system_fingerprint: fp || null,
+              choices: [{ index: 0, delta: { content: chunk.delta }, finish_reason: null, logprobs: null }],
+            })));
+          }
+        }
+
+        controller.enqueue(encoder.encode(sseChunk({
+          id: cid, object: "chat.completion.chunk", created, model, system_fingerprint: fp || null,
+          choices: [{ index: 0, delta: {}, finish_reason: "stop", logprobs: null }],
+        })));
+        controller.enqueue(encoder.encode(SSE_DONE));
+      } catch (err) {
+        controller.enqueue(encoder.encode(sseChunk({
+          id: cid, object: "chat.completion.chunk", created, model, system_fingerprint: null,
+          choices: [{ index: 0, delta: { content: `[Stream error: ${err.message || String(err)}]` }, finish_reason: "stop", logprobs: null }],
+        })));
+        controller.enqueue(encoder.encode(SSE_DONE));
+      } finally {
+        controller.close();
+      }
+    },
+  });
+}
+
+async function buildNonStreamingResponse(eventStream, model, cid, created, isThinkingModel, signal) {
+  let fullContent = "";
+  let fingerprint = "";
+  const thinkingParts = [];
+
+  for await (const chunk of extractContent(eventStream, isThinkingModel, signal)) {
+    if (chunk.fingerprint) fingerprint = chunk.fingerprint;
+    if (chunk.error) {
+      return new Response(JSON.stringify({
+        error: { message: chunk.error, type: "upstream_error", code: "GROK_ERROR" },
+      }), { status: 502, headers: { "Content-Type": "application/json" } });
+    }
+    if (chunk.thinking) { thinkingParts.push(chunk.thinking); continue; }
+    if (chunk.done) break;
+    if (chunk.fullMessage) fullContent = chunk.fullMessage;
+    else if (chunk.delta) fullContent += chunk.delta;
+  }
+
+  const msg = { role: "assistant", content: fullContent };
+  if (thinkingParts.length > 0) msg.reasoning_content = thinkingParts.join("\n");
+
+  const promptTokens = Math.ceil(fullContent.length / 4);
+  const completionTokens = Math.ceil(fullContent.length / 4);
+
+  return new Response(JSON.stringify({
+    id: cid, object: "chat.completion", created, model, system_fingerprint: fingerprint || null,
+    choices: [{ index: 0, message: msg, finish_reason: "stop", logprobs: null }],
+    usage: { prompt_tokens: promptTokens, completion_tokens: completionTokens, total_tokens: promptTokens + completionTokens },
+  }), { status: 200, headers: { "Content-Type": "application/json" } });
+}
+
+export class GrokWebExecutor extends BaseExecutor {
+  constructor() {
+    super("grok-web", PROVIDERS["grok-web"]);
+  }
+
+  async execute({ model, body, stream, credentials, signal, log }) {
+    const messages = body?.messages;
+    if (!messages || !Array.isArray(messages) || messages.length === 0) {
+      const errResp = new Response(JSON.stringify({
+        error: { message: "Missing or empty messages array", type: "invalid_request" },
+      }), { status: 400, headers: { "Content-Type": "application/json" } });
+      return { response: errResp, url: GROK_CHAT_API, headers: {}, transformedBody: body };
+    }
+
+    const modelInfo = MODEL_MAP[model];
+    if (!modelInfo) log?.info?.("GROK-WEB", `Unmapped model ${model}, defaulting to grok-4.1-fast`);
+    const { grokModel, modelMode, isThinking } = modelInfo || MODEL_MAP["grok-4.1-fast"];
+
+    const message = parseOpenAIMessages(messages);
+    if (!message.trim()) {
+      const errResp = new Response(JSON.stringify({
+        error: { message: "Empty query after processing", type: "invalid_request" },
+      }), { status: 400, headers: { "Content-Type": "application/json" } });
+      return { response: errResp, url: GROK_CHAT_API, headers: {}, transformedBody: body };
+    }
+
+    const grokPayload = {
+      temporary: true, modelName: grokModel, modelMode, message,
+      fileAttachments: [], imageAttachments: [],
+      disableSearch: false, enableImageGeneration: false, returnImageBytes: false,
+      returnRawGrokInXaiRequest: false, enableImageStreaming: false, imageGenerationCount: 0,
+      forceConcise: false, toolOverrides: {}, enableSideBySide: true, sendFinalMetadata: true,
+      isReasoning: false, disableTextFollowUps: false, disableMemory: true,
+      forceSideBySide: false, isAsyncChat: false, disableSelfHarmShortCircuit: false,
+      deviceEnvInfo: {
+        darkModeEnabled: false, devicePixelRatio: 2,
+        screenWidth: 2056, screenHeight: 1329, viewportWidth: 2056, viewportHeight: 1083,
+      },
+    };
+
+    const traceId = randomHex(16);
+    const spanId = randomHex(8);
+    const headers = {
+      Accept: "*/*",
+      "Accept-Encoding": "gzip, deflate, br, zstd",
+      "Accept-Language": "en-US,en;q=0.9",
+      Baggage: "sentry-environment=production,sentry-release=d6add6fb0460641fd482d767a335ef72b9b6abb8,sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c",
+      "Cache-Control": "no-cache",
+      "Content-Type": "application/json",
+      Origin: "https://grok.com",
+      Pragma: "no-cache",
+      Referer: "https://grok.com/",
+      "Sec-Ch-Ua": '"Google Chrome";v="136", "Chromium";v="136", "Not(A:Brand";v="24"',
+      "Sec-Ch-Ua-Mobile": "?0",
+      "Sec-Ch-Ua-Platform": '"macOS"',
+      "Sec-Fetch-Dest": "empty",
+      "Sec-Fetch-Mode": "cors",
+      "Sec-Fetch-Site": "same-origin",
+      "User-Agent": GROK_USER_AGENT,
+      "x-statsig-id": generateStatsigId(),
+      "x-xai-request-id": crypto.randomUUID(),
+      traceparent: `00-${traceId}-${spanId}-00`,
+    };
+
+    if (credentials.apiKey) {
+      let token = credentials.apiKey;
+      if (token.startsWith("sso=")) token = token.slice(4);
+      headers["Cookie"] = `sso=${token}`;
+    }
+
+    log?.info?.("GROK-WEB", `Query to ${model} (grok=${grokModel}, mode=${modelMode}), len=${message.length}`);
+
+    let response;
+    try {
+      response = await fetch(GROK_CHAT_API, {
+        method: "POST", headers, body: JSON.stringify(grokPayload), signal,
+      });
+    } catch (err) {
+      log?.error?.("GROK-WEB", `Fetch failed: ${err.message || String(err)}`);
+      const errResp = new Response(JSON.stringify({
+        error: { message: `Grok connection failed: ${err.message || String(err)}`, type: "upstream_error" },
+      }), { status: 502, headers: { "Content-Type": "application/json" } });
+      return { response: errResp, url: GROK_CHAT_API, headers, transformedBody: grokPayload };
+    }
+
+    if (!response.ok) {
+      const status = response.status;
+      let errMsg = `Grok returned HTTP ${status}`;
+      if (status === 401 || status === 403) errMsg = "Grok auth failed — SSO cookie may be expired. Re-paste your sso cookie value from grok.com.";
+      else if (status === 429) errMsg = "Grok rate limited. Wait a moment and retry, or rotate cookies.";
+      log?.warn?.("GROK-WEB", errMsg);
+      const errResp = new Response(JSON.stringify({
+        error: { message: errMsg, type: "upstream_error", code: `HTTP_${status}` },
+      }), { status, headers: { "Content-Type": "application/json" } });
+      return { response: errResp, url: GROK_CHAT_API, headers, transformedBody: grokPayload };
+    }
+
+    if (!response.body) {
+      const errResp = new Response(JSON.stringify({
+        error: { message: "Grok returned empty response body", type: "upstream_error" },
+      }), { status: 502, headers: { "Content-Type": "application/json" } });
+      return { response: errResp, url: GROK_CHAT_API, headers, transformedBody: grokPayload };
+    }
+
+    const cid = `chatcmpl-grok-${crypto.randomUUID().slice(0, 12)}`;
+    const created = Math.floor(Date.now() / 1000);
+
+    let finalResponse;
+    if (stream) {
+      const sseStream = buildStreamingResponse(response.body, model, cid, created, isThinking, signal);
+      finalResponse = new Response(sseStream, {
+        status: 200,
+        headers: { ...SSE_HEADERS_NO_BUFFER },
+      });
+    } else {
+      finalResponse = await buildNonStreamingResponse(response.body, model, cid, created, isThinking, signal);
+    }
+    return { response: finalResponse, url: GROK_CHAT_API, headers, transformedBody: grokPayload };
+  }
+}
+
+export default GrokWebExecutor;

package/src/executors/index.js

@@ -0,0 +1,86 @@
+import { AntigravityExecutor } from "./antigravity.js";
+import { AzureExecutor } from "./azure.js";
+import { GeminiCLIExecutor } from "./gemini-cli.js";
+import { GithubExecutor } from "./github.js";
+import { QoderExecutor } from "./qoder.js";
+import { KiroExecutor } from "./kiro.js";
+import { KimchiExecutor } from "./kimchi.js";
+import { CodexExecutor } from "./codex.js";
+import { CursorExecutor } from "./cursor.js";
+import { VertexExecutor } from "./vertex.js";
+import { OpenCodeExecutor } from "./opencode.js";
+import { OpenCodeGoExecutor } from "./opencode-go.js";
+import { GrokWebExecutor } from "./grok-web.js";
+import { GrokCliExecutor } from "./grok-cli.js";
+import { OllamaLocalExecutor } from "./ollama-local.js";
+import { CommandCodeExecutor } from "./commandcode.js";
+import { XiaomiTokenplanExecutor } from "./xiaomi-tokenplan.js";
+import { CodeBuddyExecutor } from "./codebuddy-cn.js";
+import { CodeBuddyIntlExecutor } from "./codebuddy-intl.js";
+import TraeExecutor from "./trae.js";
+import WindsurfExecutor from "./windsurf.js";
+import { DefaultExecutor } from "./default.js";
+
+const executors = {
+  antigravity: new AntigravityExecutor(),
+  azure: new AzureExecutor(),
+  "gemini-cli": new GeminiCLIExecutor(),
+  github: new GithubExecutor(),
+  qoder: new QoderExecutor(),
+  kiro: new KiroExecutor(),
+  kimchi: new KimchiExecutor(),
+  codex: new CodexExecutor(),
+  cursor: new CursorExecutor(),
+  cu: new CursorExecutor(),
+  vertex: new VertexExecutor("vertex"),
+  "vertex-partner": new VertexExecutor("vertex-partner"),
+  opencode: new OpenCodeExecutor(),
+  "opencode-go": new OpenCodeGoExecutor(),
+  "grok-web": new GrokWebExecutor(),
+  "grok-cli": new GrokCliExecutor(),
+  gcli: new GrokCliExecutor(),
+  gb: new GrokCliExecutor(),
+  "ollama-local": new OllamaLocalExecutor(),
+  commandcode: new CommandCodeExecutor(),
+  "xiaomi-tokenplan": new XiaomiTokenplanExecutor(),
+  "codebuddy-cn": new CodeBuddyExecutor(),
+  "codebuddy-intl": new CodeBuddyIntlExecutor(),
+  trae: new TraeExecutor(),
+  windsurf: new WindsurfExecutor(),
+};
+
+const defaultCache = new Map();
+
+export function getExecutor(provider) {
+  if (executors[provider]) return executors[provider];
+  if (!defaultCache.has(provider)) defaultCache.set(provider, new DefaultExecutor(provider));
+  return defaultCache.get(provider);
+}
+
+export function hasSpecializedExecutor(provider) {
+  return !!executors[provider];
+}
+
+export { BaseExecutor } from "./base.js";
+export { AntigravityExecutor } from "./antigravity.js";
+export { AzureExecutor } from "./azure.js";
+export { GeminiCLIExecutor } from "./gemini-cli.js";
+export { GithubExecutor } from "./github.js";
+export { QoderExecutor } from "./qoder.js";
+export { KiroExecutor } from "./kiro.js";
+export { KimchiExecutor } from "./kimchi.js";
+export { CodexExecutor } from "./codex.js";
+export { CursorExecutor } from "./cursor.js";
+export { VertexExecutor } from "./vertex.js";
+export { DefaultExecutor } from "./default.js";
+export { OpenCodeExecutor } from "./opencode.js";
+export { OpenCodeGoExecutor } from "./opencode-go.js";
+export { GrokWebExecutor } from "./grok-web.js";
+export { GrokCliExecutor } from "./grok-cli.js";
+export { OllamaLocalExecutor } from "./ollama-local.js";
+export { CommandCodeExecutor } from "./commandcode.js";
+export { XiaomiTokenplanExecutor } from "./xiaomi-tokenplan.js";
+export { CodeBuddyExecutor } from "./codebuddy-cn.js";
+export { CodeBuddyIntlExecutor } from "./codebuddy-intl.js";
+export { default as TraeExecutor } from "./trae.js";
+export { default as WindsurfExecutor } from "./windsurf.js";

package/src/executors/kimchi.js

@@ -0,0 +1,116 @@
+import { DefaultExecutor } from "./default.js";
+import { getCachedKimchiModelMetadata } from "../services/kimchiModels.js";
+
+const TOP_LEVEL_OPENAI_GATEWAY_DROPS = [
+  "anthropic_version",
+  "anthropic_beta",
+  "client_metadata",
+  "mcp_servers",
+  "stop_sequences",
+  "thinking",
+  "top_k",
+];
+
+function systemToText(system) {
+  if (typeof system === "string") return system;
+  if (Array.isArray(system)) {
+    return system
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (typeof part?.text === "string") return part.text;
+        return "";
+      })
+      .filter(Boolean)
+      .join("\n");
+  }
+  return "";
+}
+
+function mergeTopLevelSystem(body) {
+  if (!body?.system || !Array.isArray(body.messages)) return;
+  const text = systemToText(body.system).trim();
+  if (!text) return;
+
+  const existing = body.messages.find((msg) => msg?.role === "system");
+  if (!existing) {
+    body.messages.unshift({ role: "system", content: text });
+    return;
+  }
+
+  if (typeof existing.content === "string") {
+    existing.content = `${text}\n\n${existing.content}`;
+  } else if (Array.isArray(existing.content)) {
+    existing.content.unshift({ type: "text", text });
+  }
+}
+
+function stripMessageArtifacts(body) {
+  if (!Array.isArray(body?.messages)) return;
+  for (const msg of body.messages) {
+    if (!msg || typeof msg !== "object") continue;
+    delete msg.cache_control;
+    if (!Array.isArray(msg.content)) continue;
+    msg.content = msg.content.map((part) => {
+      if (!part || typeof part !== "object") return part;
+      const { cache_control, signature, ...clean } = part;
+      return clean;
+    });
+  }
+}
+
+function stripToolArtifacts(body) {
+  if (!Array.isArray(body?.tools)) return;
+  body.tools = body.tools.map((tool) => {
+    if (!tool || typeof tool !== "object") return tool;
+    const { cache_control, ...clean } = tool;
+    return clean;
+  });
+}
+
+const REASONING_PLACEHOLDER_MAX_LEN = 8;
+
+export function stripReasoningContent(body) {
+  if (!Array.isArray(body?.messages)) return;
+  for (const msg of body.messages) {
+    if (msg && msg.role === "assistant" && typeof msg.reasoning_content === "string"
+        && msg.reasoning_content.length > REASONING_PLACEHOLDER_MAX_LEN) {
+      delete msg.reasoning_content;
+    }
+  }
+}
+
+function isAnthropicBackedKimchiModel(model) {
+  const meta = getCachedKimchiModelMetadata(model);
+  if (meta?.provider === "anthropic" || meta?.upstreamProvider === "anthropic") return true;
+  return /(^|[-_/])(?:claude|anthropic)(?:[-_/]|$)/i.test(String(model || ""));
+}
+
+export class KimchiExecutor extends DefaultExecutor {
+  constructor() {
+    super("kimchi");
+  }
+
+  transformRequest(model, body, stream, credentials) {
+    const transformed = super.transformRequest(model, body, stream, credentials);
+    if (!transformed || typeof transformed !== "object") return transformed;
+
+    mergeTopLevelSystem(transformed);
+    for (const key of TOP_LEVEL_OPENAI_GATEWAY_DROPS) {
+      if (transformed[key] !== undefined) delete transformed[key];
+    }
+    delete transformed.system;
+
+    if (isAnthropicBackedKimchiModel(model)) {
+      delete transformed.reasoning_effort;
+      delete transformed.reasoning;
+      delete transformed.thinking;
+    }
+
+    stripMessageArtifacts(transformed);
+    stripToolArtifacts(transformed);
+    stripReasoningContent(transformed);
+    return transformed;
+  }
+}
+
+export default KimchiExecutor;