vite-plugin-ai-mock 0.1.5 → 1.0.0

package/README.md

@@ -8,12 +8,13 @@
 [![CI](https://img.shields.io/github/actions/workflow/status/quanzhiyuan/vite-plugin-ai-mock/ci.yml?label=CI)](https://github.com/quanzhiyuan/vite-plugin-ai-mock/actions)
 [![license](https://img.shields.io/npm/l/vite-plugin-ai-mock)](./LICENSE)
 
-A standalone Vite plugin for AI scene mocking. Returns streaming data in JSON format, simulating various AI scenarios.
+A standalone Vite plugin for AI scene mocking. Supports both JSON and TypeScript mock files, returning SSE streaming or JSON responses to simulate various AI scenarios.
 
-- Reads mock files from `mock/*.json`
+- Reads mock files from `mock/*.json` or `mock/*.ts`
 - Returns SSE streaming response by default
 - Use `?transport=json` to get JSON format response
 - Supports 11 streaming scenarios with request parameters
+- TypeScript mock files support dynamic data and full middleware control — **hot-reloaded without server restart**
 
 ## Install
 
@@ -33,7 +34,8 @@ pnpm add vite-plugin-ai-mock -D
 project/
 ├── mock/
 │   └── ai/
-│       ├── chat.json
+│       ├── chat.json        ← JSON mock
+│       ├── sessions.ts      ← TypeScript mock
 │       └── default.json
 ├── src/
 └── vite.config.ts
@@ -86,6 +88,75 @@ export default defineConfig({
 
 > 💡 See full examples: [examples](https://github.com/quanzhiyuan/vite-plugin-ai-mock/tree/main/examples) (includes Ant Design X, Assistant UI, Lobe Chat integrations)
 
+## TypeScript Mock Files
+
+In addition to `.json` files, mock files can be written in TypeScript. `.ts` takes priority over `.json` when both exist.
+
+Three export patterns are supported:
+
+### Pattern 1 — Static default export (same as JSON)
+
+```ts
+// mock/ai/chat.ts
+export default {
+  chunks: [
+    { id: "1", data: { delta: "Hello" } },
+    { id: "2", data: { delta: " World" } },
+  ],
+};
+```
+
+### Pattern 2 — Factory function (called per request)
+
+The function receives the incoming request and can return dynamic data. Supports `async`.
+
+```ts
+// mock/ai/chat.ts
+import type { Connect } from "vite";
+
+export default (req: Connect.IncomingMessage) => {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const lang = url.searchParams.get("lang") ?? "en";
+  return {
+    chunks: [
+      { id: "1", data: { delta: lang === "zh" ? "你好" : "Hello" } },
+    ],
+  };
+};
+```
+
+### Pattern 3 — Handler (full middleware control)
+
+Replaces the need to write a separate `configureServer` plugin. Receives `(req, res, next)` and handles the response directly — ideal for dynamic routes like session create/delete.
+
+```ts
+// mock/ai/session.ts
+import type { MockRequestHandler } from "vite-plugin-ai-mock";
+
+const sessions = new Set<string>();
+
+export const handler: MockRequestHandler = (req, res) => {
+  if (req.method === "POST") {
+    const id = `sess-${Date.now()}`;
+    sessions.add(id);
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ status: "success", data: { session_id: id } }));
+    return;
+  }
+  if (req.method === "DELETE") {
+    const id = (req.url ?? "").split("/").pop() ?? "";
+    sessions.delete(id);
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ status: "success" }));
+    return;
+  }
+  res.statusCode = 405;
+  res.end();
+};
+```
+
+**Hot reload**: TypeScript mock files are loaded via Vite's `ssrLoadModule`. Any edit is picked up on the next request — **no server restart required**.
+
 ## Scenarios (11)
 
 1. Normal completion (default)
@@ -169,7 +240,7 @@ Precedence: `?transport=json` / `?transport=sse` > `jsonApis` config > default S
 
 ## Mock file format
 
-Each file is a JSON object with a `chunks` array. Every chunk maps to one SSE event:
+Each mock file is a JSON object (or TypeScript module) with a `chunks` array. Every chunk maps to one SSE event:
 
 | Field     | Type   | Description                                                     |
 | --------- | ------ | --------------------------------------------------------------- |
@@ -356,12 +427,12 @@ pnpm release:npm
 
 ### Plugin Options `AiMockPluginOptions`
 
-| Option            | Type                                       | Default          | Description                                                     |
-| ----------------- | ------------------------------------------ | ---------------- | --------------------------------------------------------------- |
-| `dataDir`         | `string`                                   | `"mock"`         | Directory for mock files, relative to project root              |
-| `endpoint`        | `string \| RegExp \| (string \| RegExp)[]` | `"/api"`         | API path to intercept, supports string, RegExp, or array        |
-| `defaultScenario` | `DefaultScenarioConfig`                    | `undefined`      | Global default scenario config, can be overridden by URL params |
-| `jsonApis`        | `(string \| RegExp)[]`                     | `undefined`      | List of API paths that should return JSON format                |
+| Option            | Type                                       | Default          | Description                                                                               |
+| ----------------- | ------------------------------------------ | ---------------- | ----------------------------------------------------------------------------------------- |
+| `dataDir`         | `string`                                   | `"mock"`         | Directory for mock files (`.json` or `.ts`), relative to project root                    |
+| `endpoint`        | `string \| RegExp \| (string \| RegExp)[]` | `"/api"`         | API path to intercept, supports string, RegExp, or array                                  |
+| `defaultScenario` | `DefaultScenarioConfig`                    | `undefined`      | Global default scenario config, can be overridden by URL params                           |
+| `jsonApis`        | `(string \| RegExp)[]`                     | `undefined`      | List of API paths that should return JSON format (applies to both `.json` and `.ts` files)|
 
 ### Scenario Config `DefaultScenarioConfig`
 

package/README.zh-CN.md

@@ -1,13 +1,14 @@
 # vite-plugin-ai-mock
 
-一个用于 AI 场景模拟的独立 Vite 插件。可以返回 JSON 格式的流式数据，模拟不同的 AI 场景。
+一个用于 AI 场景模拟的独立 Vite 插件。支持 JSON 和 TypeScript 两种 mock 文件格式，返回 SSE 流式或 JSON 响应，模拟不同的 AI 场景。
 
 > [English](./README.md) | 中文
 
-- 从 `mock/*.json` 读取 mock 文件
+- 从 `mock/*.json` 或 `mock/*.ts` 读取 mock 文件
 - 默认返回 SSE 流式响应
 - 使用 `?transport=json` 获取 JSON 格式响应
 - 支持 11 种流式场景，通过请求参数控制
+- TypeScript mock 文件支持动态数据和完整中间件控制——**修改后无需重启服务**
 
 ## 安装
 
@@ -27,7 +28,8 @@ pnpm add vite-plugin-ai-mock -D
 project/
 ├── mock/
 │   └── ai/
-│       ├── chat.json
+│       ├── chat.json        ← JSON mock
+│       ├── sessions.ts      ← TypeScript mock
 │       └── default.json
 ├── src/
 └── vite.config.ts
@@ -80,6 +82,75 @@ export default defineConfig({
 
 > 💡 查看完整示例：[examples](https://github.com/quanzhiyuan/vite-plugin-ai-mock/tree/main/examples)（包含 Ant Design X、Assistant UI、Lobe Chat 等集成示例）
 
+## TypeScript Mock 文件
+
+除 `.json` 外，mock 文件可以用 TypeScript 编写。当同名 `.ts` 和 `.json` 文件同时存在时，`.ts` 优先。
+
+支持三种 export 模式：
+
+### 模式一 — 静态 default export（等同于 JSON）
+
+```ts
+// mock/ai/chat.ts
+export default {
+  chunks: [
+    { id: "1", data: { delta: "你好" } },
+    { id: "2", data: { delta: "世界" } },
+  ],
+};
+```
+
+### 模式二 — 工厂函数（每次请求都会调用）
+
+函数接收请求对象，可返回动态数据。支持 `async`。
+
+```ts
+// mock/ai/chat.ts
+import type { Connect } from "vite";
+
+export default (req: Connect.IncomingMessage) => {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const lang = url.searchParams.get("lang") ?? "en";
+  return {
+    chunks: [
+      { id: "1", data: { delta: lang === "zh" ? "你好" : "Hello" } },
+    ],
+  };
+};
+```
+
+### 模式三 — Handler（完全控制 req/res）
+
+替代在 `vite.config.ts` 中单独编写 `configureServer` 插件。接收 `(req, res, next)`，直接控制响应——适用于会话创建/删除等动态路由。
+
+```ts
+// mock/ai/session.ts
+import type { MockRequestHandler } from "vite-plugin-ai-mock";
+
+const sessions = new Set<string>();
+
+export const handler: MockRequestHandler = (req, res) => {
+  if (req.method === "POST") {
+    const id = `sess-${Date.now()}`;
+    sessions.add(id);
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ status: "success", data: { session_id: id } }));
+    return;
+  }
+  if (req.method === "DELETE") {
+    const id = (req.url ?? "").split("/").pop() ?? "";
+    sessions.delete(id);
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ status: "success" }));
+    return;
+  }
+  res.statusCode = 405;
+  res.end();
+};
+```
+
+**热更新**：TypeScript mock 文件通过 Vite 的 `ssrLoadModule` 加载。每次修改后，下一个请求即可生效，**无需重启开发服务器**。
+
 ## 场景（11 种）
 
 1. 正常完成（默认）
@@ -163,7 +234,7 @@ aiMockPlugin({
 
 ## Mock 文件格式
 
-每个文件是一个包含 `chunks` 数组的 JSON 对象，每个 chunk 对应一条 SSE 事件：
+每个 mock 文件（JSON 或 TypeScript）包含一个 `chunks` 数组，每个 chunk 对应一条 SSE 事件：
 
 | 字段      | 类型   | 说明                                                |
 | --------- | ------ | --------------------------------------------------- |
@@ -352,10 +423,10 @@ pnpm release:npm
 
 | 选项 | 类型 | 默认值 | 说明 |
 | --- | --- | --- | --- |
-| `dataDir` | `string` | `"mock"` | mock 文件所在目录，相对于项目根目录 |
+| `dataDir` | `string` | `"mock"` | mock 文件目录（支持 `.json` 和 `.ts`），相对于项目根目录 |
 | `endpoint` | `string \| RegExp \| (string \| RegExp)[]` | `"/api"` | 拦截的 API 路径，支持字符串、正则或数组 |
 | `defaultScenario` | `DefaultScenarioConfig` | `undefined` | 全局默认场景配置，可被 URL 参数覆盖 |
-| `jsonApis` | `(string \| RegExp)[]` | `undefined` | 指定返回 JSON 格式的 API 路径列表 |
+| `jsonApis` | `(string \| RegExp)[]` | `undefined` | 指定返回 JSON 格式的 API 路径（对 `.json` 和 `.ts` 均生效）|
 
 ### 场景配置 `DefaultScenarioConfig`
 

package/dist/index.cjs

@@ -64,14 +64,38 @@ function safeFileName(name) {
 function resolveDataFile(dataDir, fileName) {
   const safeName = safeFileName(fileName) || "default";
   const absoluteDataDir = import_node_path.default.resolve(process.cwd(), dataDir);
-  const candidate = safeName.endsWith(".json") ? import_node_path.default.join(absoluteDataDir, safeName) : import_node_path.default.join(absoluteDataDir, `${safeName}.json`);
-  if (!candidate.startsWith(absoluteDataDir)) {
-    throw new Error("Invalid mock file path.");
+  const baseName = safeName.replace(/\.(json|ts)$/, "");
+  const candidates = [
+    // .ts takes priority so dynamic mock can shadow a JSON file
+    { filePath: import_node_path.default.join(absoluteDataDir, `${baseName}.ts`), type: "ts" },
+    { filePath: import_node_path.default.join(absoluteDataDir, `${baseName}.json`), type: "json" }
+  ];
+  if (safeName.endsWith(".ts")) {
+    candidates.unshift({ filePath: import_node_path.default.join(absoluteDataDir, safeName), type: "ts" });
+  } else if (safeName.endsWith(".json")) {
+    candidates.unshift({ filePath: import_node_path.default.join(absoluteDataDir, safeName), type: "json" });
   }
-  if (!import_node_fs.default.existsSync(candidate)) {
-    throw new Error(`Mock data file not found: ${import_node_path.default.basename(candidate)}`);
+  for (const candidate of candidates) {
+    if (!candidate.filePath.startsWith(absoluteDataDir)) continue;
+    if (import_node_fs.default.existsSync(candidate.filePath)) return candidate;
   }
-  return candidate;
+  throw new Error(
+    `Mock data file not found: tried ${baseName}.ts and ${baseName}.json in "${dataDir}"`
+  );
+}
+async function loadTsMockModule(server, absoluteFilePath) {
+  const existingMod = server.moduleGraph.getModuleById(absoluteFilePath);
+  if (existingMod) {
+    server.moduleGraph.invalidateModule(existingMod);
+  }
+  const viteRoot = server.config.root;
+  let moduleUrl;
+  if (absoluteFilePath.startsWith(viteRoot)) {
+    moduleUrl = "/" + import_node_path.default.relative(viteRoot, absoluteFilePath).replace(/\\/g, "/");
+  } else {
+    moduleUrl = "/@fs/" + absoluteFilePath;
+  }
+  return await server.ssrLoadModule(moduleUrl);
 }
 function normalizeChunks(raw) {
   const source = Array.isArray(raw) ? raw : typeof raw === "object" && raw !== null && "chunks" in raw ? raw.chunks : [raw];
@@ -112,8 +136,8 @@ function parseScenarioOptions(reqUrl, lastEventIdHeader, defaultScenario) {
     return fallback;
   };
   const firstChunkDelayMs = getParam("firstChunkDelayMs", 0);
-  let minIntervalMs = getParam("minIntervalMs", 200);
-  let maxIntervalMs = getParam("maxIntervalMs", 700);
+  const minIntervalMs = getParam("minIntervalMs", 200);
+  const maxIntervalMs = getParam("maxIntervalMs", 700);
   return {
     file: params.get("file") ?? "default",
     firstChunkDelayMs,
@@ -207,6 +231,108 @@ function matchEndpoint(pathname, endpoint) {
   }
   return endpoint.test(pathname) ? { fileFromPath: "" } : null;
 }
+function streamChunks(req, res, chunks, options) {
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+  res.setHeader("Cache-Control", "no-cache, no-transform");
+  res.setHeader("Connection", "keep-alive");
+  res.setHeader("X-Accel-Buffering", "no");
+  if ("flushHeaders" in res && typeof res.flushHeaders === "function") {
+    res.flushHeaders();
+  }
+  let closed = false;
+  let heartbeatTimer = null;
+  const pendingTimers = /* @__PURE__ */ new Set();
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    for (const timer of pendingTimers) clearTimeout(timer);
+    pendingTimers.clear();
+  };
+  req.on("close", cleanup);
+  if (options.heartbeatMs > 0) {
+    heartbeatTimer = setInterval(() => {
+      if (closed) return;
+      res.write(`: ping ${Date.now()}
+
+`);
+    }, options.heartbeatMs);
+  }
+  const schedule = (task, delay) => {
+    const timer = setTimeout(() => {
+      pendingTimers.delete(timer);
+      task();
+    }, delay);
+    pendingTimers.add(timer);
+  };
+  const writeChunk = (chunk, index) => {
+    if (closed) return;
+    const chunkNo = index + 1;
+    if (options.disconnectAt === chunkNo) {
+      cleanup();
+      if ("destroy" in res && typeof res.destroy === "function") {
+        res.destroy();
+        return;
+      }
+      res.end();
+      return;
+    }
+    if (options.errorAt === chunkNo) {
+      writeSseEvent(res, {
+        id: chunk.id,
+        event: "error",
+        data: { message: options.errorMessage, at: chunkNo }
+      });
+      cleanup();
+      res.end();
+      return;
+    }
+    if (options.malformedAt === chunkNo) {
+      res.write(`id: ${chunk.id}
+`);
+      res.write("event: message\n");
+      res.write('data: {"malformed": true\n\n');
+    } else {
+      writeSseEvent(res, {
+        id: chunk.id,
+        event: chunk.event,
+        data: chunk.data
+      });
+    }
+    if (options.stallAfter === chunkNo) {
+      schedule(() => {
+        if (!closed) {
+          cleanup();
+          res.end();
+        }
+      }, options.stallMs);
+      return;
+    }
+    const nextChunk = chunks[index + 1];
+    if (!nextChunk) {
+      if (options.includeDone) {
+        writeSseEvent(res, { event: "done", data: { done: true } });
+      }
+      cleanup();
+      res.end();
+      return;
+    }
+    const interval = typeof nextChunk.delayMs === "number" ? nextChunk.delayMs : options.minIntervalMs + Math.floor(
+      Math.random() * (options.maxIntervalMs - options.minIntervalMs + 1)
+    );
+    schedule(() => writeChunk(nextChunk, index + 1), interval);
+  };
+  if (chunks.length === 0) {
+    if (options.includeDone) {
+      writeSseEvent(res, { event: "done", data: { done: true } });
+    }
+    cleanup();
+    res.end();
+    return;
+  }
+  schedule(() => writeChunk(chunks[0], 0), options.firstChunkDelayMs);
+}
 function aiMockPlugin(config) {
   const dataDir = config?.dataDir ?? "mock/ai";
   const endpoint = config?.endpoint ?? AI_MOCK_BASE;
@@ -215,15 +341,10 @@ function aiMockPlugin(config) {
   return {
     name: "vite-plugin-ai-mock",
     configureServer(server) {
-      server.middlewares.use((req, res, next) => {
+      server.middlewares.use(async (req, res, next) => {
         if (!req.url) return next();
         const reqUrl = new URL(req.url, "http://localhost");
         const matched = matchEndpoint(reqUrl.pathname, endpoint);
-        if (req.url.startsWith("/api")) {
-          console.log("[aiMockPlugin] Request:", req.method, req.url);
-          console.log("[aiMockPlugin] Configured endpoint:", endpoint);
-          console.log("[aiMockPlugin] Matched:", matched);
-        }
         if (matched === null) return next();
         const fileFromPath = matched.fileFromPath;
         const lastEventIdHeader = typeof req.headers["last-event-id"] === "string" ? req.headers["last-event-id"] : void 0;
@@ -235,10 +356,6 @@ function aiMockPlugin(config) {
         if (fileFromPath) options.file = fileFromPath;
         try {
           if (options.httpErrorStatus >= 400) {
-            console.log(
-              "[aiMockPlugin] Returning HTTP error:",
-              options.httpErrorStatus
-            );
             res.statusCode = options.httpErrorStatus;
             res.setHeader("Content-Type", "application/json; charset=utf-8");
             res.end(
@@ -249,121 +366,44 @@ function aiMockPlugin(config) {
             );
             return;
           }
-          const filePath = resolveDataFile(dataDir, options.file);
-          console.log("[aiMockPlugin] Resolving mock file:", filePath);
-          if (!import_node_fs.default.existsSync(filePath)) {
-            console.error("[aiMockPlugin] Mock file not found:", filePath);
-          }
-          const raw = readJsonFile(filePath);
-          const chunks = applyChunkMutations(normalizeChunks(raw), options);
-          if (!isSseRequest(reqUrl, jsonApis)) {
-            console.log("[aiMockPlugin] Handling as JSON response");
-            res.statusCode = 200;
-            res.setHeader("Content-Type", "application/json; charset=utf-8");
-            res.end(JSON.stringify(raw));
-            return;
-          }
-          console.log("[aiMockPlugin] Handling as SSE stream");
-          res.statusCode = 200;
-          res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
-          res.setHeader("Cache-Control", "no-cache, no-transform");
-          res.setHeader("Connection", "keep-alive");
-          res.setHeader("X-Accel-Buffering", "no");
-          if ("flushHeaders" in res && typeof res.flushHeaders === "function") {
-            res.flushHeaders();
-          }
-          let closed = false;
-          let heartbeatTimer = null;
-          const pendingTimers = /* @__PURE__ */ new Set();
-          const cleanup = () => {
-            if (closed) return;
-            closed = true;
-            if (heartbeatTimer) clearInterval(heartbeatTimer);
-            for (const timer of pendingTimers) clearTimeout(timer);
-            pendingTimers.clear();
-          };
-          req.on("close", cleanup);
-          if (options.heartbeatMs > 0) {
-            heartbeatTimer = setInterval(() => {
-              if (closed) return;
-              res.write(`: ping ${Date.now()}
-
-`);
-            }, options.heartbeatMs);
-          }
-          const schedule = (task, delay) => {
-            const timer = setTimeout(() => {
-              pendingTimers.delete(timer);
-              task();
-            }, delay);
-            pendingTimers.add(timer);
-          };
-          const writeChunk = (chunk, index) => {
-            if (closed) return;
-            const chunkNo = index + 1;
-            if (options.disconnectAt === chunkNo) {
-              cleanup();
-              if ("destroy" in res && typeof res.destroy === "function") {
-                res.destroy();
-                return;
-              }
-              res.end();
-              return;
-            }
-            if (options.errorAt === chunkNo) {
-              writeSseEvent(res, {
-                id: chunk.id,
-                event: "error",
-                data: { message: options.errorMessage, at: chunkNo }
-              });
-              cleanup();
-              res.end();
-              return;
-            }
-            if (options.malformedAt === chunkNo) {
-              res.write(`id: ${chunk.id}
-`);
-              res.write("event: message\n");
-              res.write('data: {"malformed": true\n\n');
-            } else {
-              writeSseEvent(res, {
-                id: chunk.id,
-                event: chunk.event,
-                data: chunk.data
-              });
-            }
-            if (options.stallAfter === chunkNo) {
-              schedule(() => {
-                if (!closed) {
-                  cleanup();
-                  res.end();
-                }
-              }, options.stallMs);
+          const resolved = resolveDataFile(dataDir, options.file);
+          if (resolved.type === "ts") {
+            const mod = await loadTsMockModule(server, resolved.filePath);
+            if (typeof mod.handler === "function") {
+              await mod.handler(req, res, next);
               return;
             }
-            const nextChunk = chunks[index + 1];
-            if (!nextChunk) {
-              if (options.includeDone) {
-                writeSseEvent(res, { event: "done", data: { done: true } });
+            if ("default" in mod) {
+              const raw2 = typeof mod.default === "function" ? await mod.default(req) : mod.default;
+              if (!isSseRequest(reqUrl, jsonApis)) {
+                res.statusCode = 200;
+                res.setHeader("Content-Type", "application/json; charset=utf-8");
+                res.end(JSON.stringify(raw2));
+                return;
               }
-              cleanup();
-              res.end();
+              const chunks2 = applyChunkMutations(normalizeChunks(raw2), options);
+              streamChunks(req, res, chunks2, options);
               return;
             }
-            const interval = typeof nextChunk.delayMs === "number" ? nextChunk.delayMs : options.minIntervalMs + Math.floor(
-              Math.random() * (options.maxIntervalMs - options.minIntervalMs + 1)
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json; charset=utf-8");
+            res.end(
+              JSON.stringify({
+                error: "mock_empty_module",
+                message: `Mock file "${resolved.filePath}" must have a default export or a named "handler" export.`
+              })
             );
-            schedule(() => writeChunk(nextChunk, index + 1), interval);
-          };
-          if (chunks.length === 0) {
-            if (options.includeDone) {
-              writeSseEvent(res, { event: "done", data: { done: true } });
-            }
-            cleanup();
-            res.end();
             return;
           }
-          schedule(() => writeChunk(chunks[0], 0), options.firstChunkDelayMs);
+          const raw = readJsonFile(resolved.filePath);
+          if (!isSseRequest(reqUrl, jsonApis)) {
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json; charset=utf-8");
+            res.end(JSON.stringify(raw));
+            return;
+          }
+          const chunks = applyChunkMutations(normalizeChunks(raw), options);
+          streamChunks(req, res, chunks, options);
         } catch (error) {
           res.statusCode = 500;
           res.setHeader("Content-Type", "application/json; charset=utf-8");