framer-dalton 0.0.1

package/dist/start-relay-server.js

@@ -0,0 +1,718 @@
+import fs2 from 'fs';
+import os from 'os';
+import path from 'path';
+import 'child_process';
+import { fileURLToPath } from 'url';
+import http from 'http';
+import crypto from 'crypto';
+import { createRequire } from 'module';
+import * as vm from 'vm';
+import { connect } from 'framer-api';
+
+/* @framer/ai relay server v0.0.1 */
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function getLogPath() {
+  if (process.env.XDG_STATE_HOME) {
+    return path.join(process.env.XDG_STATE_HOME, "framer", "relay.log");
+  }
+  if (process.platform === "win32") {
+    return path.join(
+      process.env.APPDATA || os.homedir(),
+      "framer",
+      "relay.log"
+    );
+  }
+  return path.join(os.homedir(), ".local", "state", "framer", "relay.log");
+}
+__name(getLogPath, "getLogPath");
+var logPath = getLogPath();
+var initialized = false;
+function ensureLogDir() {
+  if (initialized) return;
+  const dir = path.dirname(logPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  initialized = true;
+}
+__name(ensureLogDir, "ensureLogDir");
+function log(message) {
+  ensureLogDir();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  fs2.appendFileSync(logPath, `${timestamp} ${message}
+`);
+}
+__name(log, "log");
+var __filename$1 = fileURLToPath(import.meta.url);
+path.dirname(__filename$1);
+var VERSION = "0.0.1" ;
+var RELAY_PORT = Number(process.env.FRAMER_CLI_PORT) || 19987;
+
+// src/connection-errors.ts
+var CONNECTION_ERROR_PATTERNS = [
+  "Connection closed",
+  // FramerAPIError PROJECT_CLOSED
+  "Connection to the server was closed",
+  // FramerAPIError PROJECT_CLOSED
+  "Connection timeout after",
+  // FramerAPIError TIMEOUT
+  "No connection to the server",
+  // FramerAPIError INTERNAL
+  "WebSocket upgrade failed",
+  // WebSocket handshake failure
+  "Session is not connected",
+  // Our own check in executor.ts
+  "Execution timed out after",
+  // Likely dead connection
+  "Session expired"
+  // Server-side session expiry
+];
+function isConnectionError(errorMessage) {
+  return CONNECTION_ERROR_PATTERNS.some(
+    (pattern) => errorMessage.includes(pattern)
+  );
+}
+__name(isConnectionError, "isConnectionError");
+var ScopedFS = class {
+  static {
+    __name(this, "ScopedFS");
+  }
+  allowedDirs;
+  constructor(allowedDirs) {
+    const defaultDirs = [process.cwd(), "/tmp", os.tmpdir()];
+    const dirs = allowedDirs ?? defaultDirs;
+    this.allowedDirs = [...new Set(dirs.map((d) => path.resolve(d)))];
+  }
+  isPathAllowed(resolved) {
+    return this.allowedDirs.some((dir) => {
+      return resolved === dir || resolved.startsWith(dir + path.sep);
+    });
+  }
+  resolvePath(filePath) {
+    const resolved = path.resolve(filePath);
+    if (!this.isPathAllowed(resolved)) {
+      const error2 = new Error(
+        `EPERM: operation not permitted, access outside allowed directories: ${filePath}`
+      );
+      error2.code = "EPERM";
+      error2.errno = -1;
+      error2.syscall = "access";
+      error2.path = filePath;
+      throw error2;
+    }
+    return resolved;
+  }
+  // Sync methods
+  readFileSync = /* @__PURE__ */ __name((filePath, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    return fs2.readFileSync(resolved, options);
+  }, "readFileSync");
+  writeFileSync = /* @__PURE__ */ __name((filePath, data, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    fs2.writeFileSync(
+      resolved,
+      data,
+      options
+    );
+  }, "writeFileSync");
+  appendFileSync = /* @__PURE__ */ __name((filePath, data, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    fs2.appendFileSync(
+      resolved,
+      data,
+      options
+    );
+  }, "appendFileSync");
+  readdirSync = /* @__PURE__ */ __name((dirPath, options) => {
+    const resolved = this.resolvePath(dirPath.toString());
+    return fs2.readdirSync(resolved, options);
+  }, "readdirSync");
+  mkdirSync = /* @__PURE__ */ __name((dirPath, options) => {
+    const resolved = this.resolvePath(dirPath.toString());
+    return fs2.mkdirSync(resolved, options);
+  }, "mkdirSync");
+  rmdirSync = /* @__PURE__ */ __name((dirPath, options) => {
+    const resolved = this.resolvePath(dirPath.toString());
+    fs2.rmdirSync(resolved, options);
+  }, "rmdirSync");
+  unlinkSync = /* @__PURE__ */ __name((filePath) => {
+    const resolved = this.resolvePath(filePath.toString());
+    fs2.unlinkSync(resolved);
+  }, "unlinkSync");
+  statSync = /* @__PURE__ */ __name((filePath, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    return fs2.statSync(resolved, options);
+  }, "statSync");
+  lstatSync = /* @__PURE__ */ __name((filePath, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    return fs2.lstatSync(resolved, options);
+  }, "lstatSync");
+  existsSync = /* @__PURE__ */ __name((filePath) => {
+    try {
+      const resolved = this.resolvePath(filePath.toString());
+      return fs2.existsSync(resolved);
+    } catch {
+      return false;
+    }
+  }, "existsSync");
+  accessSync = /* @__PURE__ */ __name((filePath, mode) => {
+    const resolved = this.resolvePath(filePath.toString());
+    fs2.accessSync(resolved, mode);
+  }, "accessSync");
+  copyFileSync = /* @__PURE__ */ __name((src, dest, mode) => {
+    const resolvedSrc = this.resolvePath(src.toString());
+    const resolvedDest = this.resolvePath(dest.toString());
+    fs2.copyFileSync(resolvedSrc, resolvedDest, mode);
+  }, "copyFileSync");
+  renameSync = /* @__PURE__ */ __name((oldPath, newPath) => {
+    const resolvedOld = this.resolvePath(oldPath.toString());
+    const resolvedNew = this.resolvePath(newPath.toString());
+    fs2.renameSync(resolvedOld, resolvedNew);
+  }, "renameSync");
+  rmSync = /* @__PURE__ */ __name((filePath, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    fs2.rmSync(resolved, options);
+  }, "rmSync");
+  // Stream methods
+  createReadStream = /* @__PURE__ */ __name((filePath, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    return fs2.createReadStream(resolved, options);
+  }, "createReadStream");
+  createWriteStream = /* @__PURE__ */ __name((filePath, options) => {
+    const resolved = this.resolvePath(filePath.toString());
+    return fs2.createWriteStream(resolved, options);
+  }, "createWriteStream");
+  // Promise-based API (fs.promises equivalent)
+  get promises() {
+    return {
+      readFile: /* @__PURE__ */ __name(async (filePath, options) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs2.promises.readFile(
+          resolved,
+          options
+        );
+      }, "readFile"),
+      writeFile: /* @__PURE__ */ __name(async (filePath, data, options) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs2.promises.writeFile(
+          resolved,
+          data,
+          options
+        );
+      }, "writeFile"),
+      appendFile: /* @__PURE__ */ __name(async (filePath, data, options) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs2.promises.appendFile(
+          resolved,
+          data,
+          options
+        );
+      }, "appendFile"),
+      readdir: /* @__PURE__ */ __name(async (dirPath, options) => {
+        const resolved = this.resolvePath(dirPath.toString());
+        return fs2.promises.readdir(
+          resolved,
+          options
+        );
+      }, "readdir"),
+      mkdir: /* @__PURE__ */ __name(async (dirPath, options) => {
+        const resolved = this.resolvePath(dirPath.toString());
+        return fs2.promises.mkdir(resolved, options);
+      }, "mkdir"),
+      rmdir: /* @__PURE__ */ __name(async (dirPath, options) => {
+        const resolved = this.resolvePath(dirPath.toString());
+        return fs2.promises.rmdir(resolved, options);
+      }, "rmdir"),
+      unlink: /* @__PURE__ */ __name(async (filePath) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs2.promises.unlink(resolved);
+      }, "unlink"),
+      stat: /* @__PURE__ */ __name(async (filePath, options) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs2.promises.stat(resolved, options);
+      }, "stat"),
+      access: /* @__PURE__ */ __name(async (filePath, mode) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs2.promises.access(resolved, mode);
+      }, "access"),
+      copyFile: /* @__PURE__ */ __name(async (src, dest, mode) => {
+        const resolvedSrc = this.resolvePath(src.toString());
+        const resolvedDest = this.resolvePath(dest.toString());
+        return fs2.promises.copyFile(resolvedSrc, resolvedDest, mode);
+      }, "copyFile"),
+      rename: /* @__PURE__ */ __name(async (oldPath, newPath) => {
+        const resolvedOld = this.resolvePath(oldPath.toString());
+        const resolvedNew = this.resolvePath(newPath.toString());
+        return fs2.promises.rename(resolvedOld, resolvedNew);
+      }, "rename"),
+      rm: /* @__PURE__ */ __name(async (filePath, options) => {
+        const resolved = this.resolvePath(filePath.toString());
+        return fs2.promises.rm(resolved, options);
+      }, "rm")
+    };
+  }
+  constants = fs2.constants;
+};
+
+// src/executor.ts
+var DEFAULT_TIMEOUT = 3e4;
+var baseRequire = createRequire(import.meta.url);
+var ALLOWED_MODULES = /* @__PURE__ */ new Set([
+  "path",
+  "node:path",
+  "url",
+  "node:url",
+  "fs",
+  "node:fs",
+  "fs/promises",
+  "node:fs/promises",
+  "crypto",
+  "node:crypto",
+  "buffer",
+  "node:buffer",
+  "util",
+  "node:util",
+  "os",
+  "node:os"
+]);
+function createSandboxedRequire(scopedFs) {
+  const sandboxedRequire = /* @__PURE__ */ __name(((id) => {
+    if (!ALLOWED_MODULES.has(id)) {
+      const error2 = new Error(
+        `Module "${id}" is not allowed. Allowed: ${[...ALLOWED_MODULES].filter((m) => !m.startsWith("node:")).join(", ")}`
+      );
+      error2.name = "ModuleNotAllowedError";
+      throw error2;
+    }
+    if (id === "fs" || id === "node:fs") {
+      return scopedFs;
+    }
+    if (id === "fs/promises" || id === "node:fs/promises") {
+      return scopedFs.promises;
+    }
+    return baseRequire(id);
+  }), "sandboxedRequire");
+  sandboxedRequire.resolve = baseRequire.resolve;
+  sandboxedRequire.cache = baseRequire.cache;
+  sandboxedRequire.extensions = baseRequire.extensions;
+  sandboxedRequire.main = baseRequire.main;
+  return sandboxedRequire;
+}
+__name(createSandboxedRequire, "createSandboxedRequire");
+async function sandboxedImport(scopedFs, specifier) {
+  if (!ALLOWED_MODULES.has(specifier)) {
+    const error2 = new Error(
+      `Module "${specifier}" is not allowed. Allowed: ${[...ALLOWED_MODULES].filter((m) => !m.startsWith("node:")).join(", ")}`
+    );
+    error2.name = "ModuleNotAllowedError";
+    throw error2;
+  }
+  if (specifier === "fs" || specifier === "node:fs") {
+    return scopedFs;
+  }
+  if (specifier === "fs/promises" || specifier === "node:fs/promises") {
+    return scopedFs.promises;
+  }
+  return import(specifier);
+}
+__name(sandboxedImport, "sandboxedImport");
+async function execute(session, connection, code, options = {}) {
+  const { timeout = DEFAULT_TIMEOUT, cwd } = options;
+  const output = [];
+  const customConsole = {
+    log: /* @__PURE__ */ __name((...args) => {
+      output.push(args.map((arg) => formatValue(arg)).join(" "));
+    }, "log"),
+    error: /* @__PURE__ */ __name((...args) => {
+      output.push(`[ERROR] ${args.map((arg) => formatValue(arg)).join(" ")}`);
+    }, "error"),
+    warn: /* @__PURE__ */ __name((...args) => {
+      output.push(`[WARN] ${args.map((arg) => formatValue(arg)).join(" ")}`);
+    }, "warn"),
+    info: /* @__PURE__ */ __name((...args) => {
+      output.push(args.map((arg) => formatValue(arg)).join(" "));
+    }, "info")
+  };
+  const scopedFs = cwd ? new ScopedFS([cwd, "/tmp"]) : new ScopedFS();
+  const sandboxedRequire = createSandboxedRequire(scopedFs);
+  const vmContextObj = {
+    // Framer API
+    framer: connection,
+    state: session.state,
+    // Console
+    console: customConsole,
+    // Module system (sandboxed)
+    require: sandboxedRequire,
+    import: /* @__PURE__ */ __name((specifier) => sandboxedImport(scopedFs, specifier), "import"),
+    // Timers
+    setTimeout,
+    clearTimeout,
+    setInterval,
+    clearInterval,
+    // Fetch & network
+    fetch,
+    // Common globals
+    Buffer,
+    URL,
+    URLSearchParams,
+    TextEncoder,
+    TextDecoder,
+    crypto,
+    AbortController,
+    AbortSignal,
+    structuredClone
+  };
+  const vmContext = vm.createContext(vmContextObj);
+  const wrappedCode = `(async () => { ${code} })()`;
+  try {
+    const script = new vm.Script(wrappedCode, {
+      filename: "framer-exec.js"
+    });
+    const resultPromise = script.runInContext(vmContext, {
+      timeout: 5e3
+      // Short timeout for sync part
+    });
+    const result = await Promise.race([
+      resultPromise,
+      new Promise(
+        (_, reject) => setTimeout(
+          () => reject(new Error(`Execution timed out after ${timeout}ms`)),
+          timeout
+        )
+      )
+    ]);
+    if (result !== void 0) {
+      output.push(formatValue(result));
+    }
+    return { output };
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    return {
+      output,
+      error: errorMessage
+    };
+  }
+}
+__name(execute, "execute");
+function formatValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (typeof value === "function")
+    return `[Function: ${value.name || "anonymous"}]`;
+  if (value instanceof Error) return value.message;
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof Map) return `Map(${value.size})`;
+  if (value instanceof Set) return `Set(${value.size})`;
+  if (Buffer.isBuffer(value)) return `Buffer(${value.length})`;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+__name(formatValue, "formatValue");
+var ConnectionPool = class {
+  static {
+    __name(this, "ConnectionPool");
+  }
+  pool = /* @__PURE__ */ new Map();
+  /**
+   * Acquire a connection for a session.
+   * If a connection already exists for the project, the session is added to it.
+   * Otherwise, a new connection is created.
+   */
+  async acquire(projectId, apiKey, session) {
+    const entry = this.pool.get(projectId);
+    if (entry) {
+      entry.sessions.add(session);
+      return entry.connection;
+    }
+    const connection = await connect(projectId, apiKey);
+    this.pool.set(projectId, {
+      connection,
+      sessions: /* @__PURE__ */ new Set([session])
+    });
+    return connection;
+  }
+  /**
+   * Get the connection for a project.
+   */
+  getConnection(projectId) {
+    const entry = this.pool.get(projectId);
+    return entry?.connection ?? null;
+  }
+  /**
+   * Reconnect a project's connection (call after catching a connection error).
+   * Uses the same connection object but swaps the underlying WebSocket.
+   */
+  async reconnect(projectId) {
+    const entry = this.pool.get(projectId);
+    if (!entry) {
+      return null;
+    }
+    await entry.connection.reconnect();
+    return entry.connection;
+  }
+  /**
+   * Release a session from a connection.
+   * If no sessions remain, the connection is disconnected and removed.
+   */
+  async release(projectId, session) {
+    const entry = this.pool.get(projectId);
+    if (!entry) {
+      return;
+    }
+    entry.sessions.delete(session);
+    if (entry.sessions.size === 0) {
+      await entry.connection.disconnect();
+      this.pool.delete(projectId);
+    }
+  }
+  /**
+   * Release all connections (for cleanup).
+   */
+  async releaseAll() {
+    for (const [projectId, entry] of this.pool) {
+      await entry.connection.disconnect();
+      this.pool.delete(projectId);
+    }
+  }
+};
+var connectionPool = new ConnectionPool();
+
+// src/session-manager.ts
+var SessionManager = class {
+  static {
+    __name(this, "SessionManager");
+  }
+  sessions = /* @__PURE__ */ new Map();
+  async create(projectId, apiKey) {
+    let id = 1;
+    while (this.sessions.has(String(id))) {
+      id++;
+    }
+    const session = {
+      id: String(id),
+      projectId,
+      apiKey,
+      state: {}
+    };
+    await connectionPool.acquire(projectId, apiKey, session);
+    this.sessions.set(String(id), session);
+    return String(id);
+  }
+  list() {
+    return Array.from(this.sessions.values()).map((session) => ({
+      id: session.id,
+      projectId: session.projectId,
+      stateKeys: Object.keys(session.state)
+    }));
+  }
+  get(id) {
+    return this.sessions.get(id);
+  }
+  getConnection(session) {
+    return connectionPool.getConnection(session.projectId);
+  }
+  async reconnect(session) {
+    return connectionPool.reconnect(session.projectId);
+  }
+  async destroy(id) {
+    const session = this.sessions.get(id);
+    if (!session) {
+      return;
+    }
+    await connectionPool.release(session.projectId, session);
+    this.sessions.delete(id);
+  }
+  async destroyAll() {
+    for (const id of this.sessions.keys()) {
+      await this.destroy(id);
+    }
+  }
+};
+var sessionManager = new SessionManager();
+
+// src/relay-server.ts
+function json(res, data, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+__name(json, "json");
+function error(res, message, status = 400) {
+  json(res, { error: message }, status);
+}
+__name(error, "error");
+async function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+__name(readBody, "readBody");
+async function startRelayServer(port = RELAY_PORT) {
+  const server = http.createServer(async (req, res) => {
+    const url = req.url || "/";
+    try {
+      if (req.method === "GET" && url === "/version") {
+        return json(res, { version: VERSION });
+      }
+      if (req.method === "GET" && url === "/cli/sessions") {
+        const sessions = sessionManager.list();
+        return json(res, { sessions });
+      }
+      if (req.method === "POST" && url === "/cli/session/new") {
+        const body = await readBody(req);
+        const projectId = body.projectId;
+        const apiKey = body.apiKey;
+        if (!projectId || !apiKey) {
+          return error(res, "projectId and apiKey are required");
+        }
+        const id = await sessionManager.create(projectId, apiKey);
+        log(`session.new id=${id} project=${projectId}`);
+        return json(res, { id });
+      }
+      if (req.method === "POST" && url === "/cli/session/destroy") {
+        const body = await readBody(req);
+        const sessionId = body.sessionId ? String(body.sessionId) : "";
+        if (!sessionId) {
+          return error(res, "sessionId is required");
+        }
+        await sessionManager.destroy(sessionId);
+        log(`session.destroy id=${sessionId}`);
+        return json(res, { success: true });
+      }
+      if (req.method === "POST" && url === "/cli/exec") {
+        const body = await readBody(req);
+        const sessionId = String(body.sessionId);
+        const code = body.code;
+        const timeout = body.timeout || 3e4;
+        const cwd = body.cwd;
+        if (!sessionId) {
+          return error(res, "sessionId is required");
+        }
+        if (!code) {
+          return error(res, "code is required");
+        }
+        const session = sessionManager.get(sessionId);
+        if (!session) {
+          return error(res, `Session ${sessionId} not found`, 404);
+        }
+        log(
+          `exec session=${sessionId} code=${JSON.stringify(code).slice(0, 100)}`
+        );
+        const connection = sessionManager.getConnection(session);
+        if (!connection) {
+          return json(res, {
+            output: [],
+            error: "Failed to get connection for session"
+          });
+        }
+        let result;
+        try {
+          result = await execute(session, connection, code, { timeout, cwd });
+        } catch (execErr) {
+          const errMsg = execErr instanceof Error ? execErr.message : String(execErr);
+          result = { output: [], error: errMsg };
+        }
+        if (result.error && isConnectionError(result.error)) {
+          log(
+            `reconnect session=${sessionId} project=${session.projectId} reason="${result.error}"`
+          );
+          const newConnection = await sessionManager.reconnect(session);
+          if (newConnection) {
+            try {
+              result = await execute(session, newConnection, code, {
+                timeout,
+                cwd
+              });
+              log(`reconnect.success session=${sessionId}`);
+            } catch (retryErr) {
+              const errMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+              log(`reconnect.failed session=${sessionId} error="${errMsg}"`);
+              result = { output: [], error: errMsg };
+            }
+          } else {
+            log(
+              `reconnect.failed session=${sessionId} error="no connection returned"`
+            );
+          }
+        }
+        if (result.error) {
+          log(`exec.error session=${sessionId} error="${result.error}"`);
+        }
+        return json(res, result);
+      }
+      if (req.method === "POST" && url === "/shutdown") {
+        log("shutdown requested");
+        json(res, { success: true });
+        setTimeout(() => {
+          process.exit(0);
+        }, 100);
+        return;
+      }
+      error(res, "Not found", 404);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log(`error: ${message}`);
+      error(res, message, 500);
+    }
+  });
+  return new Promise((resolve, reject) => {
+    server.on("error", reject);
+    server.listen(port, "127.0.0.1", () => {
+      resolve(server);
+    });
+  });
+}
+__name(startRelayServer, "startRelayServer");
+
+// src/start-relay-server.ts
+process.title = "framer-relay-server";
+process.on("uncaughtException", (err) => {
+  log(`uncaught exception: ${err.message}`);
+  console.error("Uncaught Exception:", err);
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+  log(`unhandled rejection: ${reason}`);
+  console.error("Unhandled Rejection:", reason);
+  process.exit(1);
+});
+async function main() {
+  const server = await startRelayServer(RELAY_PORT);
+  log(`started v${VERSION} on port ${RELAY_PORT}`);
+  console.log(`Framer relay server v${VERSION} running on port ${RELAY_PORT}`);
+  process.on("SIGINT", () => {
+    log("shutdown SIGINT");
+    console.log("\nShutting down...");
+    server.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    log("shutdown SIGTERM");
+    console.log("\nShutting down...");
+    server.close();
+    process.exit(0);
+  });
+}
+__name(main, "main");
+main().catch((err) => {
+  log(`startup failed: ${err.message}`);
+  console.error("Failed to start relay server:", err);
+  process.exit(1);
+});