@research-copilot/plugin 1.1.17 → 1.1.19

package/dist/skills/llm-wiki/deps/baoyu-url-to-markdown/scripts/media-localizer.ts

@@ -0,0 +1,317 @@
+import path from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+
+type MediaKind = "image" | "video";
+type MediaHint = "image" | "unknown";
+
+type MarkdownLinkCandidate = {
+  url: string;
+  hint: MediaHint;
+};
+
+export type LocalizeMarkdownMediaOptions = {
+  markdownPath: string;
+  log?: (message: string) => void;
+};
+
+export type LocalizeMarkdownMediaResult = {
+  markdown: string;
+  downloadedImages: number;
+  downloadedVideos: number;
+  imageDir: string | null;
+  videoDir: string | null;
+};
+
+const MARKDOWN_LINK_RE = /(!?\[[^\]\n]*\])\((<)?(https?:\/\/[^)\s>]+)(>)?\)/g;
+const FRONTMATTER_COVER_RE = /^(coverImage:\s*")(https?:\/\/[^"]+)(")/m;
+
+const IMAGE_EXTENSIONS = new Set([
+  "jpg",
+  "jpeg",
+  "png",
+  "webp",
+  "gif",
+  "bmp",
+  "avif",
+  "heic",
+  "heif",
+  "svg",
+]);
+
+const VIDEO_EXTENSIONS = new Set(["mp4", "m4v", "mov", "webm", "mkv"]);
+
+const MIME_EXTENSION_MAP: Record<string, string> = {
+  "image/jpeg": "jpg",
+  "image/jpg": "jpg",
+  "image/png": "png",
+  "image/webp": "webp",
+  "image/gif": "gif",
+  "image/bmp": "bmp",
+  "image/avif": "avif",
+  "image/heic": "heic",
+  "image/heif": "heif",
+  "image/svg+xml": "svg",
+  "video/mp4": "mp4",
+  "video/webm": "webm",
+  "video/quicktime": "mov",
+  "video/x-m4v": "m4v",
+};
+
+const DOWNLOAD_USER_AGENT =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36";
+
+function normalizeContentType(raw: string | null): string {
+  return raw?.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+
+function normalizeExtension(raw: string | undefined | null): string | undefined {
+  if (!raw) return undefined;
+  const trimmed = raw.replace(/^\./, "").trim().toLowerCase();
+  if (!trimmed) return undefined;
+  if (trimmed === "jpeg") return "jpg";
+  if (trimmed === "jpg") return "jpg";
+  return trimmed;
+}
+
+function resolveExtensionFromUrl(rawUrl: string): string | undefined {
+  try {
+    const parsed = new URL(rawUrl);
+    const extFromPath = normalizeExtension(path.posix.extname(parsed.pathname));
+    if (extFromPath) return extFromPath;
+    const extFromFormat = normalizeExtension(parsed.searchParams.get("format"));
+    if (extFromFormat) return extFromFormat;
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+function resolveKindFromContentType(contentType: string): MediaKind | undefined {
+  if (!contentType) return undefined;
+  if (contentType.startsWith("image/")) return "image";
+  if (contentType.startsWith("video/")) return "video";
+  return undefined;
+}
+
+function resolveKindFromExtension(ext: string | undefined): MediaKind | undefined {
+  if (!ext) return undefined;
+  if (IMAGE_EXTENSIONS.has(ext)) return "image";
+  if (VIDEO_EXTENSIONS.has(ext)) return "video";
+  return undefined;
+}
+
+function resolveMediaKind(
+  rawUrl: string,
+  contentType: string,
+  extension: string | undefined,
+  hint: MediaHint
+): MediaKind | undefined {
+  const kindFromType = resolveKindFromContentType(contentType);
+  if (kindFromType) return kindFromType;
+
+  const kindFromExtension = resolveKindFromExtension(extension);
+  if (kindFromExtension) return kindFromExtension;
+
+  if (contentType && contentType !== "application/octet-stream") {
+    return undefined;
+  }
+
+  return hint === "image" ? "image" : undefined;
+}
+
+function resolveOutputExtension(
+  contentType: string,
+  extension: string | undefined,
+  kind: MediaKind
+): string {
+  const extFromMime = normalizeExtension(MIME_EXTENSION_MAP[contentType]);
+  if (extFromMime) return extFromMime;
+
+  const normalizedExt = normalizeExtension(extension);
+  if (normalizedExt) return normalizedExt;
+
+  return kind === "video" ? "mp4" : "jpg";
+}
+
+function safeDecodeURIComponent(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function sanitizeFileSegment(input: string): string {
+  return input
+    .replace(/[^a-zA-Z0-9_-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^[-_]+|[-_]+$/g, "")
+    .slice(0, 48);
+}
+
+function resolveFileStem(rawUrl: string, extension: string): string {
+  try {
+    const parsed = new URL(rawUrl);
+    const base = path.posix.basename(parsed.pathname);
+    if (!base) return "";
+    const decodedBase = safeDecodeURIComponent(base);
+    const normalizedExt = normalizeExtension(extension);
+    const stripExt = normalizedExt ? new RegExp(`\\.${normalizedExt}$`, "i") : null;
+    const rawStem = stripExt ? decodedBase.replace(stripExt, "") : decodedBase;
+    return sanitizeFileSegment(rawStem);
+  } catch {
+    return "";
+  }
+}
+
+function buildFileName(kind: MediaKind, index: number, sourceUrl: string, extension: string): string {
+  const stem = resolveFileStem(sourceUrl, extension);
+  const prefix = kind === "image" ? "img" : "video";
+  const serial = String(index).padStart(3, "0");
+  const suffix = stem ? `-${stem}` : "";
+  return `${prefix}-${serial}${suffix}.${extension}`;
+}
+
+function collectMarkdownLinkCandidates(markdown: string): MarkdownLinkCandidate[] {
+  const candidates: MarkdownLinkCandidate[] = [];
+  const seen = new Set<string>();
+
+  const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---/);
+  if (fmMatch) {
+    const coverMatch = fmMatch[1]?.match(FRONTMATTER_COVER_RE);
+    if (coverMatch?.[2] && !seen.has(coverMatch[2])) {
+      seen.add(coverMatch[2]);
+      candidates.push({ url: coverMatch[2], hint: "image" });
+    }
+  }
+
+  MARKDOWN_LINK_RE.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = MARKDOWN_LINK_RE.exec(markdown))) {
+    const label = match[1] ?? "";
+    const rawUrl = match[3] ?? "";
+    if (!rawUrl || seen.has(rawUrl)) continue;
+    seen.add(rawUrl);
+    candidates.push({
+      url: rawUrl,
+      hint: label.startsWith("![") ? "image" : "unknown",
+    });
+  }
+
+  return candidates;
+}
+
+function rewriteMarkdownMediaLinks(markdown: string, replacements: Map<string, string>): string {
+  if (replacements.size === 0) return markdown;
+  MARKDOWN_LINK_RE.lastIndex = 0;
+
+  let result = markdown.replace(MARKDOWN_LINK_RE, (full, label, _openAngle, rawUrl) => {
+    const localPath = replacements.get(rawUrl);
+    if (!localPath) return full;
+    return `${label}(${localPath})`;
+  });
+
+  result = result.replace(FRONTMATTER_COVER_RE, (full, prefix, rawUrl, suffix) => {
+    const localPath = replacements.get(rawUrl);
+    if (!localPath) return full;
+    return `${prefix}${localPath}${suffix}`;
+  });
+
+  return result;
+}
+
+export async function localizeMarkdownMedia(
+  markdown: string,
+  options: LocalizeMarkdownMediaOptions
+): Promise<LocalizeMarkdownMediaResult> {
+  const log = options.log ?? (() => {});
+  const markdownDir = path.dirname(options.markdownPath);
+  const candidates = collectMarkdownLinkCandidates(markdown);
+
+  if (candidates.length === 0) {
+    return {
+      markdown,
+      downloadedImages: 0,
+      downloadedVideos: 0,
+      imageDir: null,
+      videoDir: null,
+    };
+  }
+
+  const replacements = new Map<string, string>();
+  let downloadedImages = 0;
+  let downloadedVideos = 0;
+
+  for (const candidate of candidates) {
+    try {
+      const response = await fetch(candidate.url, {
+        method: "GET",
+        redirect: "follow",
+        headers: {
+          "user-agent": DOWNLOAD_USER_AGENT,
+        },
+      });
+
+      if (!response.ok) {
+        log(`[url-to-markdown] Skip media (${response.status}): ${candidate.url}`);
+        continue;
+      }
+
+      const sourceUrl = response.url || candidate.url;
+      const contentType = normalizeContentType(response.headers.get("content-type"));
+      const extension = resolveExtensionFromUrl(sourceUrl) ?? resolveExtensionFromUrl(candidate.url);
+      const kind = resolveMediaKind(sourceUrl, contentType, extension, candidate.hint);
+      if (!kind) {
+        continue;
+      }
+
+      const outputExtension = resolveOutputExtension(contentType, extension, kind);
+      const nextIndex = kind === "image" ? downloadedImages + 1 : downloadedVideos + 1;
+      const dirName = kind === "image" ? "imgs" : "videos";
+      const targetDir = path.join(markdownDir, dirName);
+      await mkdir(targetDir, { recursive: true });
+
+      const fileName = buildFileName(kind, nextIndex, sourceUrl, outputExtension);
+      const absolutePath = path.join(targetDir, fileName);
+      const relativePath = path.posix.join(dirName, fileName);
+      const bytes = Buffer.from(await response.arrayBuffer());
+      await writeFile(absolutePath, bytes);
+      replacements.set(candidate.url, relativePath);
+
+      if (kind === "image") {
+        downloadedImages = nextIndex;
+      } else {
+        downloadedVideos = nextIndex;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error ?? "");
+      log(`[url-to-markdown] Failed to download media ${candidate.url}: ${message}`);
+    }
+  }
+
+  return {
+    markdown: rewriteMarkdownMediaLinks(markdown, replacements),
+    downloadedImages,
+    downloadedVideos,
+    imageDir: downloadedImages > 0 ? path.join(markdownDir, "imgs") : null,
+    videoDir: downloadedVideos > 0 ? path.join(markdownDir, "videos") : null,
+  };
+}
+
+export function countRemoteMedia(markdown: string): { images: number; videos: number; hasCoverImage: boolean } {
+  const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---/);
+  const hasCoverImage = !!(fmMatch?.[1]?.match(FRONTMATTER_COVER_RE)?.[2]);
+  const candidates = collectMarkdownLinkCandidates(markdown);
+  let images = 0;
+  let videos = 0;
+  for (const c of candidates) {
+    const ext = resolveExtensionFromUrl(c.url);
+    const kind = resolveKindFromExtension(ext);
+    if (kind === "video") {
+      videos++;
+    } else if (kind === "image" || c.hint === "image") {
+      images++;
+    }
+  }
+  return { images, videos, hasCoverImage };
+}

package/dist/skills/llm-wiki/deps/baoyu-url-to-markdown/scripts/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "baoyu-url-to-markdown-scripts",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "@mozilla/readability": "^0.6.0",
+    "baoyu-chrome-cdp": "file:./vendor/baoyu-chrome-cdp",
+    "defuddle": "^0.12.0",
+    "jsdom": "^24.1.3",
+    "linkedom": "^0.18.12",
+    "turndown": "^7.2.2",
+    "turndown-plugin-gfm": "^1.0.2"
+  }
+}

package/dist/skills/llm-wiki/deps/baoyu-url-to-markdown/scripts/paths.ts

@@ -0,0 +1,29 @@
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+
+const APP_DATA_DIR = "baoyu-skills";
+const URL_TO_MARKDOWN_DATA_DIR = "url-to-markdown";
+const PROFILE_DIR_NAME = "chrome-profile";
+
+export function resolveUserDataRoot(): string {
+  if (process.platform === "win32") {
+    return process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+  }
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support");
+  }
+  return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+}
+
+export function resolveUrlToMarkdownDataDir(): string {
+  const override = process.env.URL_DATA_DIR?.trim();
+  if (override) return path.resolve(override);
+  return path.join(process.cwd(), URL_TO_MARKDOWN_DATA_DIR);
+}
+
+export function resolveUrlToMarkdownChromeProfileDir(): string {
+  const override = process.env.BAOYU_CHROME_PROFILE_DIR?.trim() || process.env.URL_CHROME_PROFILE_DIR?.trim();
+  if (override) return path.resolve(override);
+  return path.join(resolveUserDataRoot(), APP_DATA_DIR, PROFILE_DIR_NAME);
+}

package/dist/skills/llm-wiki/deps/baoyu-url-to-markdown/scripts/vendor/baoyu-chrome-cdp/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "baoyu-chrome-cdp",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  }
+}

package/dist/skills/llm-wiki/deps/baoyu-url-to-markdown/scripts/vendor/baoyu-chrome-cdp/src/index.test.ts

@@ -0,0 +1,307 @@
+import assert from "node:assert/strict";
+import { spawn, type ChildProcess } from "node:child_process";
+import fs from "node:fs/promises";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test, { type TestContext } from "node:test";
+
+import {
+  discoverRunningChromeDebugPort,
+  findChromeExecutable,
+  findExistingChromeDebugPort,
+  getFreePort,
+  openPageSession,
+  resolveSharedChromeProfileDir,
+  waitForChromeDebugPort,
+} from "./index.ts";
+
+function useEnv(
+  t: TestContext,
+  values: Record<string, string | null>,
+): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key]);
+    if (value == null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  t.after(() => {
+    for (const [key, value] of previous.entries()) {
+      if (value == null) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+}
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+async function startDebugServer(port: number): Promise<http.Server> {
+  const server = http.createServer((req, res) => {
+    if (req.url === "/json/version") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+      }));
+      return;
+    }
+
+    res.writeHead(404);
+    res.end();
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve());
+  });
+
+  return server;
+}
+
+async function closeServer(server: http.Server): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+function shellPathForPlatform(): string | null {
+  if (process.platform === "win32") return null;
+  return "/bin/bash";
+}
+
+async function startFakeChromiumProcess(port: number): Promise<ChildProcess | null> {
+  const shell = shellPathForPlatform();
+  if (!shell) return null;
+
+  const child = spawn(
+    shell,
+    [
+      "-lc",
+      `exec -a chromium-mock ${JSON.stringify(process.execPath)} -e 'setInterval(() => {}, 1000)' -- --remote-debugging-port=${port}`,
+    ],
+    { stdio: "ignore" },
+  );
+
+  await new Promise((resolve) => setTimeout(resolve, 250));
+  return child;
+}
+
+async function stopProcess(child: ChildProcess | null): Promise<void> {
+  if (!child) return;
+  if (child.exitCode !== null || child.signalCode !== null) return;
+
+  child.kill("SIGTERM");
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  await new Promise((resolve) => child.once("exit", resolve));
+}
+
+test("getFreePort honors a fixed environment override and otherwise allocates a TCP port", async (t) => {
+  useEnv(t, { TEST_FIXED_PORT: "45678" });
+  assert.equal(await getFreePort("TEST_FIXED_PORT"), 45678);
+
+  const dynamicPort = await getFreePort();
+  assert.ok(Number.isInteger(dynamicPort));
+  assert.ok(dynamicPort > 0);
+});
+
+test("findChromeExecutable prefers env overrides and falls back to candidate paths", async (t) => {
+  const root = await makeTempDir("baoyu-chrome-bin-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const envChrome = path.join(root, "env-chrome");
+  const fallbackChrome = path.join(root, "fallback-chrome");
+  await fs.writeFile(envChrome, "");
+  await fs.writeFile(fallbackChrome, "");
+
+  useEnv(t, { BAOYU_CHROME_PATH: envChrome });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    envChrome,
+  );
+
+  useEnv(t, { BAOYU_CHROME_PATH: null });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    fallbackChrome,
+  );
+});
+
+test("resolveSharedChromeProfileDir supports env overrides, WSL paths, and default suffixes", (t) => {
+  useEnv(t, { BAOYU_SHARED_PROFILE: "/tmp/custom-profile" });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      envNames: ["BAOYU_SHARED_PROFILE"],
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.resolve("/tmp/custom-profile"),
+  );
+
+  useEnv(t, { BAOYU_SHARED_PROFILE: null });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      wslWindowsHome: "/mnt/c/Users/demo",
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.join("/mnt/c/Users/demo", ".local", "share", "demo-app", "demo-profile"),
+  );
+
+  const fallback = resolveSharedChromeProfileDir({
+    appDataDirName: "demo-app",
+    profileDirName: "demo-profile",
+  });
+  assert.match(fallback, /demo-app[\\/]demo-profile$/);
+});
+
+test("findExistingChromeDebugPort reads DevToolsActivePort and validates it against a live endpoint", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-profile-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await findExistingChromeDebugPort({ profileDir: root, timeoutMs: 1000 });
+  assert.equal(found, port);
+});
+
+test("discoverRunningChromeDebugPort reads DevToolsActivePort from the provided user-data dir", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.deepEqual(found, {
+    port,
+    wsUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+  });
+});
+
+test("discoverRunningChromeDebugPort ignores unrelated debugging processes", async (t) => {
+  if (process.platform === "win32") {
+    t.skip("Process discovery fallback is not used on Windows.");
+    return;
+  }
+
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  const fakeChromium = await startFakeChromiumProcess(port);
+  t.after(async () => { await stopProcess(fakeChromium); });
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.equal(found, null);
+});
+
+test("openPageSession reports whether it created a new target", async () => {
+  const calls: string[] = [];
+  const cdpExisting = {
+    send: async <T>(method: string): Promise<T> => {
+      calls.push(method);
+      if (method === "Target.getTargets") {
+        return {
+          targetInfos: [{ targetId: "existing-target", type: "page", url: "https://gemini.google.com/app" }],
+        } as T;
+      }
+      if (method === "Target.attachToTarget") return { sessionId: "session-existing" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const existing = await openPageSession({
+    cdp: cdpExisting as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(existing, {
+    sessionId: "session-existing",
+    targetId: "existing-target",
+    createdTarget: false,
+  });
+  assert.deepEqual(calls, ["Target.getTargets", "Target.attachToTarget"]);
+
+  const createCalls: string[] = [];
+  const cdpCreated = {
+    send: async <T>(method: string): Promise<T> => {
+      createCalls.push(method);
+      if (method === "Target.getTargets") return { targetInfos: [] } as T;
+      if (method === "Target.createTarget") return { targetId: "created-target" } as T;
+      if (method === "Target.attachToTarget") return { sessionId: "session-created" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const created = await openPageSession({
+    cdp: cdpCreated as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(created, {
+    sessionId: "session-created",
+    targetId: "created-target",
+    createdTarget: true,
+  });
+  assert.deepEqual(createCalls, ["Target.getTargets", "Target.createTarget", "Target.attachToTarget"]);
+});
+
+test("waitForChromeDebugPort retries until the debug endpoint becomes available", async (t) => {
+  const port = await getFreePort();
+
+  const serverPromise = (async () => {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    const server = await startDebugServer(port);
+    t.after(() => closeServer(server));
+  })();
+
+  const websocketUrl = await waitForChromeDebugPort(port, 4000, {
+    includeLastError: true,
+  });
+  await serverPromise;
+
+  assert.equal(websocketUrl, `ws://127.0.0.1:${port}/devtools/browser/demo`);
+});