codex-snapshots 0.1.0 → 0.1.1

package/scripts/test-site-config.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const tempDir = await mkdtemp(path.join(os.tmpdir(), "codex-snapshots-site-config-test-"));
+
+try {
+  await assertWritesEmptyConfigWhenUnset();
+  await assertWritesNormalizedPublicApi();
+  await assertRejectsUnsafePublicApis();
+  await assertAllowLocalForLocalDevelopment();
+
+  console.log("✓ site config generation checks passed");
+} finally {
+  await rm(tempDir, { recursive: true, force: true });
+}
+
+async function assertWritesEmptyConfigWhenUnset() {
+  const output = path.join(tempDir, "empty-config.js");
+  await runConfig(["--output", output], {});
+  const text = await readFile(output, "utf8");
+  assert(text.includes('"apiUrl": ""'), "empty config should write an empty apiUrl");
+}
+
+async function assertWritesNormalizedPublicApi() {
+  const output = path.join(tempDir, "public-config.js");
+  await runConfig(["--output", output, "--api-url", "https://snapshots.mycompany.dev///"], {});
+  const text = await readFile(output, "utf8");
+  assert(text.includes('"apiUrl": "https://snapshots.mycompany.dev"'), "public config should normalize trailing slashes");
+}
+
+async function assertRejectsUnsafePublicApis() {
+  const unsafeUrls = [
+    "http://127.0.0.1:8787",
+    "http://localhost:8787",
+    "https://snapshots.example.com",
+    "https://192.168.1.5",
+    "ftp://snapshots.mycompany.dev",
+  ];
+
+  for (const unsafeUrl of unsafeUrls) {
+    const output = path.join(tempDir, `unsafe-${unsafeUrls.indexOf(unsafeUrl)}.js`);
+    const result = await runConfig(["--output", output, "--api-url", unsafeUrl], {}, { expectFailure: true });
+    assert(result.stderr.includes("CODEX_SNAPSHOTS_PUBLIC_API_URL"), `unsafe URL should fail with config error: ${unsafeUrl}`);
+  }
+}
+
+async function assertAllowLocalForLocalDevelopment() {
+  const output = path.join(tempDir, "local-config.js");
+  await runConfig(["--output", output, "--api-url", "http://127.0.0.1:8787", "--allow-local"], {});
+  const text = await readFile(output, "utf8");
+  assert(text.includes('"apiUrl": "http://127.0.0.1:8787"'), "allow-local should permit local API config");
+}
+
+async function runConfig(args, env, { expectFailure = false } = {}) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, ["scripts/write-site-config.mjs", ...args], {
+      cwd: ROOT_DIR,
+      env: {
+        ...process.env,
+        CODEX_SNAPSHOTS_PUBLIC_API_URL: "",
+        SNAPSHOT_SHARE_PUBLIC_API_URL: "",
+        SNAPSHOT_SHARE_API_URL: "",
+        ...env,
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      const result = { code, stdout, stderr };
+      if (expectFailure ? code !== 0 : code === 0) {
+        resolve(result);
+        return;
+      }
+      reject(new Error(`write-site-config ${args.join(" ")} exited ${code}\n${stdout}\n${stderr}`));
+    });
+  });
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}

package/scripts/test-static-site.mjs

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { JSDOM } from "jsdom";
+
+const ROOT_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const PUBLIC_API_URL = "https://snapshots.example.test";
+
+async function testHomepagePublicSessions() {
+  const requests = [];
+  const { document } = await runStaticPage("site/index.html", {
+    locationHref: "https://ffffhx.github.io/codex-snapshots/",
+    config: { apiUrl: PUBLIC_API_URL },
+    fetch: async (url, options = {}) => {
+      requests.push(String(url));
+      if (String(url) === "http://127.0.0.1:4321/") {
+        return jsonResponse({ ok: true });
+      }
+      if (String(url).startsWith(`${PUBLIC_API_URL}/api/auth/me`)) {
+        assert(options.credentials === "include", "homepage auth check should include credentials");
+        return jsonResponse({ configured: true, user: null, loginUrl: `${PUBLIC_API_URL}/api/auth/github/start` });
+      }
+      if (String(url) === `${PUBLIC_API_URL}/api/snapshots/health`) {
+        return jsonResponse({ ok: true, shares: 1 });
+      }
+      if (String(url) === `${PUBLIC_API_URL}/api/snapshots?limit=12`) {
+        return jsonResponse({
+          schemaVersion: 1,
+          shares: [
+            {
+              id: "snap_publicsession123456",
+              title: "Public Session from Aliyun",
+              engine: "codex",
+              engineLabel: "Codex",
+              createdAt: "2026-05-28T00:00:00.000Z",
+              redacted: true,
+              turnCount: 2,
+              url: "https://ffffhx.github.io/codex-snapshots/share/?id=snap_publicsession123456",
+            },
+          ],
+          count: 1,
+          total: 1,
+          limit: 12,
+          offset: 0,
+        });
+      }
+      throw new Error(`unexpected fetch: ${url}`);
+    },
+  });
+
+  await waitFor(() => document.querySelector(".public-session-card"));
+
+  const card = document.querySelector(".public-session-card");
+  const link = card?.querySelector(".public-session-link");
+  const title = card?.querySelector("h3");
+
+  assert(requests.includes(`${PUBLIC_API_URL}/api/snapshots?limit=12`), "homepage should fetch the configured public list API");
+  assert(!document.getElementById("share-form"), "homepage should not render the manual share opener form");
+  assert(
+    sectionOrder(document).indexOf("status-grid") > sectionOrder(document).indexOf("commands"),
+    "homepage should show the local viewer opener after install commands",
+  );
+  assert(card, "homepage should render a public session card");
+  assert(title?.textContent === "Public Session from Aliyun", "homepage should render public session title");
+  assert(link?.href.includes("/share/index.html?"), `homepage card should link to the static share page: ${link?.href}`);
+  assert(link?.href.includes(`api=${encodeURIComponent(PUBLIC_API_URL)}`), `homepage card should preserve the public API URL: ${link?.href}`);
+  assert(link?.target === "_blank", "homepage card should open in a new tab");
+  assert(link?.rel === "noopener noreferrer", "homepage card should protect the opener");
+  assert(!card?.querySelector(".public-session-delete"), "anonymous users should not see a delete action");
+}
+
+async function testHomepageDeletesOwnPublicSessionWithGithubLogin() {
+  const requests = [];
+  let deleted = false;
+  const { document, window } = await runStaticPage("site/index.html", {
+    locationHref: "https://ffffhx.github.io/codex-snapshots/",
+    config: { apiUrl: PUBLIC_API_URL },
+    confirm: () => true,
+    fetch: async (url, options = {}) => {
+      requests.push({
+        url: String(url),
+        method: String(options.method || "GET").toUpperCase(),
+        authorization: options.headers?.authorization || "",
+        credentials: options.credentials || "",
+      });
+      if (String(url) === "http://127.0.0.1:4321/") {
+        return jsonResponse({ ok: true });
+      }
+      if (String(url).startsWith(`${PUBLIC_API_URL}/api/auth/me`)) {
+        return jsonResponse({
+          configured: true,
+          user: {
+            id: "42",
+            login: "alice",
+            avatarUrl: "",
+            profileUrl: "https://github.com/alice",
+            isOwner: false,
+          },
+          loginUrl: `${PUBLIC_API_URL}/api/auth/github/start`,
+        });
+      }
+      if (String(url) === `${PUBLIC_API_URL}/api/snapshots/health`) {
+        return jsonResponse({ ok: true, shares: deleted ? 0 : 1 });
+      }
+      if (String(url) === `${PUBLIC_API_URL}/api/snapshots?limit=12`) {
+        return jsonResponse({
+          schemaVersion: 1,
+          shares: deleted
+            ? []
+            : [
+                {
+                  id: "snap_publicsession123456",
+                  title: "Public Session from Aliyun",
+                  engine: "codex",
+                  engineLabel: "Codex",
+                  createdAt: "2026-05-28T00:00:00.000Z",
+                  redacted: true,
+                  turnCount: 2,
+                  owner: {
+                    id: "42",
+                    login: "alice",
+                  },
+                },
+              ],
+          count: deleted ? 0 : 1,
+          total: deleted ? 0 : 1,
+          limit: 12,
+          offset: 0,
+        });
+      }
+      if (String(url) === `${PUBLIC_API_URL}/api/snapshots/snap_publicsession123456` && options.method === "DELETE") {
+        assert(!options.headers?.authorization, "delete should not send the old shared bearer token");
+        assert(options.credentials === "include", "delete should send the GitHub session cookie");
+        deleted = true;
+        return jsonResponse({ ok: true, deleted: true, id: "snap_publicsession123456" });
+      }
+      throw new Error(`unexpected fetch: ${url}`);
+    },
+  });
+
+  await waitFor(() => document.querySelector(".public-session-card"));
+  await flushPromises(window);
+
+  document.querySelector(".public-session-delete")?.dispatchEvent(
+    new window.MouseEvent("click", {
+      bubbles: true,
+      cancelable: true,
+    }),
+  );
+
+  await waitFor(() => !document.querySelector(".public-session-card"));
+
+  assert(deleted, "homepage should call the delete endpoint");
+  assert(
+    requests.some((request) => request.method === "DELETE" && request.url.endsWith("/api/snapshots/snap_publicsession123456")),
+    "homepage should issue a DELETE request for the selected share",
+  );
+  assert(document.querySelector(".public-session-status")?.textContent === "已删除分享快照。", "homepage should show delete success");
+  assert(document.getElementById("public-sessions")?.textContent === "暂无公开 Session。", "homepage should remove the deleted share from the list");
+}
+
+async function testPublicHomepageWithoutConfiguredApiDoesNotFetchLoopback() {
+  const requests = [];
+  const { document } = await runStaticPage("site/index.html", {
+    locationHref: "https://ffffhx.github.io/codex-snapshots/",
+    config: {},
+    storage: {
+      "codex-snapshots.api": "http://127.0.0.1:8787",
+    },
+    fetch: async (url) => {
+      requests.push(String(url));
+      if (String(url) === "http://127.0.0.1:4321/") {
+        return jsonResponse({ ok: true });
+      }
+      throw new Error(`unexpected fetch: ${url}`);
+    },
+  });
+
+  await waitFor(() => document.getElementById("public-sessions")?.textContent === "公开分享 API 尚未配置。");
+
+  assert(!document.getElementById("share-form"), "public homepage should not render the manual share opener form");
+  assert(
+    document.getElementById("public-sessions")?.textContent === "公开分享 API 尚未配置。",
+    "public homepage should explain that the public API is not configured",
+  );
+  assert(
+    !requests.some((request) => request.includes("127.0.0.1:8787")),
+    "public homepage should not fetch the loopback share API when config is missing",
+  );
+}
+
+async function testLocalHomepageDefaultsToLocalApi() {
+  const requests = [];
+  const { document } = await runStaticPage("site/index.html", {
+    locationHref: "http://127.0.0.1:4322/",
+    config: {},
+    fetch: async (url) => {
+      requests.push(String(url));
+      if (String(url) === "http://127.0.0.1:4321/") {
+        return jsonResponse({ ok: true });
+      }
+      if (String(url).startsWith("http://127.0.0.1:8787/api/auth/me")) {
+        return jsonResponse({ configured: false, user: null, loginUrl: null });
+      }
+      if (String(url) === "http://127.0.0.1:8787/api/snapshots/health") {
+        return jsonResponse({ ok: true, shares: 0 });
+      }
+      if (String(url) === "http://127.0.0.1:8787/api/snapshots?limit=12") {
+        return jsonResponse({ schemaVersion: 1, shares: [], count: 0, total: 0, limit: 12, offset: 0 });
+      }
+      throw new Error(`unexpected fetch: ${url}`);
+    },
+  });
+
+  await waitFor(() => document.getElementById("public-sessions")?.textContent === "暂无公开 Session。");
+
+  assert(!document.getElementById("share-form"), "local homepage should not render the manual share opener form");
+  assert(requests.includes("http://127.0.0.1:8787/api/snapshots?limit=12"), "local homepage should load local public sessions");
+}
+
+async function testSharePageLoadsFromConfiguredApi() {
+  const requests = [];
+  const { document } = await runStaticPage("site/share/index.html", {
+    locationHref: "https://ffffhx.github.io/codex-snapshots/share/?id=snap_publicsession123456",
+    config: { apiUrl: PUBLIC_API_URL },
+    fetch: async (url) => {
+      requests.push(String(url));
+      if (String(url) === `${PUBLIC_API_URL}/api/snapshots/snap_publicsession123456`) {
+        return jsonResponse({
+          schemaVersion: 1,
+          share: {
+            id: "snap_publicsession123456",
+            title: "Public Session from Aliyun",
+            engineLabel: "Codex",
+            redacted: true,
+            turnCount: 2,
+          },
+          snapshot: {
+            title: "Public Session from Aliyun",
+            engineLabel: "Codex",
+            goalObjective: "Explain how the public share page loads data.",
+            redacted: true,
+            turns: [
+              {
+                role: "user",
+                text: "Can everyone view this session?",
+              },
+              {
+                role: "assistant",
+                text: "Yes, the static share page loaded it from the public API.",
+                images: [
+                  {
+                    src: "data:image/png;base64,iVBORw0KGgo=",
+                    mimeType: "image/png",
+                    size: "148 KB",
+                    alt: "Screenshot",
+                  },
+                ],
+              },
+            ],
+          },
+        });
+      }
+      throw new Error(`unexpected fetch: ${url}`);
+    },
+  });
+
+  await waitFor(() => document.getElementById("share-title")?.textContent === "Public Session from Aliyun");
+
+  assert(
+    requests.includes(`${PUBLIC_API_URL}/api/snapshots/snap_publicsession123456`),
+    "share page should fetch snapshot detail from the configured public API",
+  );
+  assert(document.getElementById("share-title")?.textContent === "Public Session from Aliyun", "share page should render the public title");
+  assert(document.getElementById("share-meta")?.textContent.includes(PUBLIC_API_URL), "share page metadata should show the API URL");
+  assert(
+    document.querySelector(".share-goal")?.textContent.includes("Explain how the public share page loads data."),
+    "share page should render the snapshot goal metadata",
+  );
+  assert(
+    document.getElementById("share-content")?.innerHTML.includes("static share page loaded it from the public API"),
+    "share page should render transcript content",
+  );
+  assert(
+    !document.getElementById("share-content")?.innerHTML.includes("image/png /") &&
+      !document.getElementById("share-content")?.innerHTML.includes("148 KB") &&
+      !document.getElementById("share-content")?.innerHTML.includes("figcaption"),
+    "share page should not render image mime type or size captions",
+  );
+}
+
+async function testPublicSharePageWithoutConfiguredApiDoesNotFetchLoopback() {
+  const requests = [];
+  const { document } = await runStaticPage("site/share/index.html", {
+    locationHref: "https://ffffhx.github.io/codex-snapshots/share/?id=snap_publicsession123456",
+    config: {},
+    storage: {
+      "codex-snapshots.api": "http://127.0.0.1:8787",
+    },
+    fetch: async (url) => {
+      requests.push(String(url));
+      throw new Error(`unexpected fetch: ${url}`);
+    },
+  });
+
+  await waitFor(() => document.getElementById("share-title")?.textContent === "缺少分享 API");
+
+  assert(document.getElementById("share-title")?.textContent === "缺少分享 API", "share page should show missing API state");
+  assert(document.getElementById("share-meta")?.textContent === "公开站点需要配置分享 API。", "share page should explain missing public API");
+  assert(requests.length === 0, "share page should not fetch loopback API when public config is missing");
+}
+
+async function runStaticPage(relativeHtmlPath, { locationHref, config, fetch, storage = {}, open = () => null, confirm = () => false }) {
+  const html = await readFile(path.join(ROOT_DIR, relativeHtmlPath), "utf8");
+  const dom = new JSDOM(html, {
+    pretendToBeVisual: true,
+    runScripts: "outside-only",
+    url: locationHref,
+  });
+  const { window } = dom;
+
+  window.CODEX_SNAPSHOTS_CONFIG = config;
+  window.fetch = fetch;
+  window.open = open;
+  window.confirm = confirm;
+  Object.defineProperty(window.navigator, "clipboard", {
+    configurable: true,
+    value: {
+      writeText: async () => undefined,
+    },
+  });
+  if (typeof window.AbortSignal.timeout !== "function") {
+    Object.defineProperty(window.AbortSignal, "timeout", {
+      configurable: true,
+      value: AbortSignal.timeout?.bind(AbortSignal) || (() => undefined),
+    });
+  }
+
+  for (const [key, value] of Object.entries(storage)) {
+    window.localStorage.setItem(key, value);
+  }
+
+  const scriptPath = relativeHtmlPath.includes("/share/") ? "site/assets/share.js" : "site/assets/site.js";
+  const code = await readFile(path.join(ROOT_DIR, scriptPath), "utf8");
+  window.eval(code);
+  await flushPromises(window);
+
+  return {
+    document: window.document,
+    window,
+  };
+}
+
+function sectionOrder(document) {
+  return Array.from(document.querySelectorAll("main.shell > section")).map((section) => String(section.className || ""));
+}
+
+function jsonResponse(payload, ok = true, status = ok ? 200 : 500) {
+  return {
+    ok,
+    status,
+    async json() {
+      return payload;
+    },
+    async text() {
+      return JSON.stringify(payload);
+    },
+  };
+}
+
+async function waitFor(predicate, { timeoutMs = 1000 } = {}) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (predicate()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  assert(predicate(), "timed out waiting for expected DOM state");
+}
+
+async function flushPromises(window) {
+  for (let index = 0; index < 10; index += 1) {
+    await new Promise((resolve) => window.setTimeout(resolve, 0));
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+await testHomepagePublicSessions();
+await testHomepageDeletesOwnPublicSessionWithGithubLogin();
+await testPublicHomepageWithoutConfiguredApiDoesNotFetchLoopback();
+await testLocalHomepageDefaultsToLocalApi();
+await testSharePageLoadsFromConfiguredApi();
+await testPublicSharePageWithoutConfiguredApiDoesNotFetchLoopback();
+
+console.log("✓ static site public share checks passed");

package/scripts/write-site-config.mjs

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+import { mkdir, writeFile } from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+
+const parsed = parseArgs(process.argv.slice(2));
+
+if (parsed.help) {
+  printHelp();
+  process.exit(0);
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});
+
+async function main() {
+  const apiUrl = normalizePublicApiUrl(
+    parsed.options.apiUrl ||
+      process.env.CODEX_SNAPSHOTS_PUBLIC_API_URL ||
+      process.env.SNAPSHOT_SHARE_PUBLIC_API_URL ||
+      process.env.SNAPSHOT_SHARE_API_URL ||
+      "",
+    { allowLocal: parsed.options.allowLocal }
+  );
+  const outputPath = path.resolve(parsed.options.output || "site/assets/config.js");
+
+  await mkdir(path.dirname(outputPath), { recursive: true });
+  await writeFile(
+    outputPath,
+    `window.CODEX_SNAPSHOTS_CONFIG = ${inlineJson({ apiUrl })};\n`,
+    "utf8"
+  );
+
+  console.log(`Wrote ${outputPath}`);
+  console.log(`Public share API: ${apiUrl || "(not configured)"}`);
+}
+
+function normalizePublicApiUrl(value, { allowLocal }) {
+  const text = String(value || "").trim().replace(/\/+$/, "");
+  if (!text) {
+    return "";
+  }
+
+  let url;
+  try {
+    url = new URL(text);
+  } catch {
+    throw new Error(`CODEX_SNAPSHOTS_PUBLIC_API_URL must be a valid URL: ${text}`);
+  }
+
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`CODEX_SNAPSHOTS_PUBLIC_API_URL must start with http:// or https://: ${text}`);
+  }
+
+  if (!allowLocal && !isPublicHost(url.hostname)) {
+    throw new Error(`CODEX_SNAPSHOTS_PUBLIC_API_URL must be a public API host, got ${text}`);
+  }
+
+  return url.toString().replace(/\/+$/, "");
+}
+
+function isPublicHost(hostname) {
+  const host = String(hostname || "").toLowerCase();
+  if (!host || host === "localhost" || host.endsWith(".localhost") || host === "::1" || host === "[::1]") {
+    return false;
+  }
+  if (host === "example.com" || host.endsWith(".example.com") || host === "snapshots.example.com") {
+    return false;
+  }
+
+  const ipVersion = net.isIP(host);
+  if (ipVersion === 4) {
+    return !isPrivateIpv4(host);
+  }
+  if (ipVersion === 6) {
+    return !isPrivateIpv6(host);
+  }
+
+  return true;
+}
+
+function isPrivateIpv4(host) {
+  const parts = host.split(".").map((part) => Number(part));
+  const [a, b] = parts;
+
+  return (
+    a === 0 ||
+    a === 10 ||
+    a === 127 ||
+    (a === 169 && b === 254) ||
+    (a === 172 && b >= 16 && b <= 31) ||
+    (a === 192 && b === 168)
+  );
+}
+
+function isPrivateIpv6(host) {
+  const normalized = host.replace(/^\[|\]$/g, "").toLowerCase();
+  return normalized === "::1" || normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe80:");
+}
+
+function inlineJson(value) {
+  return JSON.stringify(value, null, 2).replace(/[<>&\u2028\u2029]/g, (char) => {
+    if (char === "<") return "\\u003c";
+    if (char === ">") return "\\u003e";
+    if (char === "&") return "\\u0026";
+    if (char === "\u2028") return "\\u2028";
+    return "\\u2029";
+  });
+}
+
+function parseArgs(args) {
+  const options = {
+    allowLocal: false,
+    apiUrl: "",
+    output: "",
+  };
+  let help = false;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "-h" || arg === "--help") {
+      help = true;
+      continue;
+    }
+    if (arg === "--allow-local") {
+      options.allowLocal = true;
+      continue;
+    }
+    if (arg === "--api-url") {
+      options.apiUrl = String(args[++index] || "");
+      continue;
+    }
+    if (arg === "--output") {
+      options.output = String(args[++index] || "");
+      continue;
+    }
+    throw new Error(`unknown option: ${arg}`);
+  }
+
+  return { help, options };
+}
+
+function printHelp() {
+  console.log(`write-site-config
+
+Usage:
+  node scripts/write-site-config.mjs --api-url https://snapshots.example.com --output site/assets/config.js
+
+Environment:
+  CODEX_SNAPSHOTS_PUBLIC_API_URL  Public share API URL used by GitHub Pages.
+
+Options:
+  --api-url URL    Public share API URL. Defaults to CODEX_SNAPSHOTS_PUBLIC_API_URL.
+  --output FILE    Config file to write. Defaults to site/assets/config.js.
+  --allow-local    Allow localhost/private API URLs for local development only.
+  -h, --help       Show help.
+`);
+}