ogthing 0.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 extoci
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,141 @@
+# ogthing – inspect link metadata from your own machine
+
+ogthing is golbat energy for your localhost: a metadata inspector that runs on
+your device so the urls you actually care about — `localhost:3000`, your dev
+preview, your coworker's half-finished branch deployed on port 8080 — can be
+inspected directly. no tunnel, no deploy, no public exposure.
+
+## usage
+
+on your machine:
+
+```sh
+bunx ogthing
+```
+
+your browser opens the inspector. paste any url, including local ones:
+
+```text
+http://localhost:3000        # works. it is running next to you.
+```
+
+the exact url is printed in the terminal. if a compatible Portless proxy is
+already running, ogthing reuses it and normally opens:
+
+```text
+https://ogthing.localhost
+```
+
+otherwise it starts its own unprivileged HTTP proxy, usually at:
+
+```text
+http://ogthing.localhost:1355
+```
+
+no sudo prompt is needed just to get a nice name for localhost.
+
+if you want the clean HTTPS url, start Portless yourself before running ogthing:
+
+```sh
+portless proxy start --https --tld localhost
+bunx ogthing
+```
+
+## what it does
+
+* fetches the page **from your machine**, then parses title, description,
+  Open Graph, Twitter/X card, favicon, canonical, robots and viewport tags
+* previews how the link renders on Telegram, Discord, Slack, X, Facebook,
+  LinkedIn, and WhatsApp
+* scores metadata quality out of 100 with per-check pass/fail dots
+* picks the user agent the way real crawlers do: facebookbot, twitterbot,
+  slackbot, discordbot, telegrambot, WhatsApp, LinkedInBot, or a plain browser
+  (some sites only serve their social tags to known bots)
+* validates image dimensions against recommended sizes (1200×630 for OG)
+* checks for robots.txt and sitemap.xml
+* copies the metadata as JSON or as ready-to-paste HTML meta tags
+* keeps your last few inspected urls around
+
+keyboard shortcuts: keys **1-7** switch tabs while results are showing.
+
+because the fetch happens on your device rather than on some hosted inspector,
+sites behind your firewall, your docker network, and plain old localhost are all
+fair game. that is the whole point.
+
+## requirements
+
+* Bun `1.3.14` or newer
+
+Portless ships with ogthing. you do not need to install it separately.
+
+## environment variables
+
+the useful ones:
+
+* `OGTHING_PORT` – local app/API port (default: `4646`)
+* `OGTHING_NO_OPEN=1` – start without opening a browser
+* `OGTHING_FETCH_TIMEOUT_MS` – fetch timeout in ms (default: `15000`)
+
+Portless knobs, if you need them:
+
+* `OGTHING_PROXY_PORT` – preferred proxy port (default: `443`)
+* `OGTHING_PROXY_TLS=0` – use HTTP for the preferred proxy
+* `OGTHING_FALLBACK_PROXY_PORT` – unprivileged fallback port (default: `1355`)
+* `OGTHING_FALLBACK_PROXY_TLS=1` – use HTTPS on the fallback port
+* `OGTHING_PORTLESS_STATE_DIR` – state for the proxy ogthing starts (default: `~/.ogthing/portless`)
+* `OGTHING_NO_PORTLESS=1` – serve directly on `127.0.0.1:<port>` instead
+* `OGTHING_NO_PORTLESS_AUTOSTART=1` – fail instead of starting a proxy automatically
+
+example:
+
+```sh
+OGTHING_NO_OPEN=1 OGTHING_PORT=5000 bunx ogthing
+```
+
+## trust and privacy
+
+ogthing does not send your urls anywhere except to the sites themselves. every
+request goes straight from your machine to the target host.
+
+note that the inspector will happily fetch internal addresses — that feature is
+not a bug. do not expose your ogthing port or its Portless route to networks you
+do not trust; it has no authentication and it makes requests on behalf of whoever
+asks.
+
+## troubleshooting
+
+* **the browser opened the wrong url** – use the exact url printed by ogthing.
+  a fresh setup normally uses `http://ogthing.localhost:1355`, not HTTPS on port 443.
+* **a site shows no og tags** – try a crawler user agent in the selector; some
+  sites gate social metadata on bot user agents.
+* **Safari cannot resolve ogthing.localhost** – Chrome, Firefox, and Edge resolve
+  `.localhost` natively. for Safari, run `portless hosts sync` once.
+
+## development
+
+install dependencies and run the named local app:
+
+```sh
+bun install
+bun run dev:named
+```
+
+run the checks:
+
+```sh
+bun run typecheck
+bun run lint
+bun run format:check
+bun test
+bun run build
+bun run pack:check
+```
+
+for a direct smoke test without Portless or a browser:
+
+```sh
+OGTHING_NO_PORTLESS=1 OGTHING_NO_OPEN=1 bun bin/ogthing.mjs
+```
+
+the parser reads the html itself because asking permission from cheerio for
+seven tags felt excessive.

package/bin/dev-named.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = fileURLToPath(new URL("..", import.meta.url));
+const viteModule = fileURLToPath(await import.meta.resolve("vite"));
+const viteBin = viteModule.replace(/dist[\\/]node[\\/]index\.js$/, "bin/vite.js");
+const port = process.env.PORT || "4646";
+
+const child = spawn(process.execPath, [viteBin, "--host", "127.0.0.1", "--port", port], {
+  cwd: packageRoot,
+  stdio: "inherit",
+  env: { ...process.env },
+});
+
+const forwardSignal = (signal) => child.kill(signal);
+process.on("SIGINT", () => forwardSignal("SIGINT"));
+process.on("SIGTERM", () => forwardSignal("SIGTERM"));
+
+child.on("exit", (code, signal) => {
+  if (signal) process.kill(process.pid, signal);
+  process.exit(code ?? 0);
+});

package/bin/ogthing.mjs

@@ -0,0 +1,387 @@
+#!/usr/bin/env bun
+
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import http from "node:http";
+import https from "node:https";
+import { createServer } from "node:net";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = fileURLToPath(new URL("..", import.meta.url));
+const packageMetadata = JSON.parse(
+  await readFile(new URL("../package.json", import.meta.url), "utf8"),
+);
+const packageVersion = packageMetadata.version || "unknown";
+const args = process.argv.slice(2);
+const portlessModule = fileURLToPath(await import.meta.resolve("portless"));
+const portlessBin = portlessModule.replace(/dist[\\/]index\.js$/, "dist/cli.js");
+const appEntry = process.env.OGTHING_TEST_APP_ENTRY || "bin/dev-named.mjs";
+const appPort = Number(process.env.OGTHING_PORT || "4646");
+const fallbackProxyPort = Number(process.env.OGTHING_FALLBACK_PROXY_PORT || "1355");
+const ownedPortlessStateDir =
+  process.env.OGTHING_PORTLESS_STATE_DIR || join(homedir(), ".ogthing", "portless");
+
+const usage = () => {
+  console.log(
+    `ogthing - inspect link metadata from your own machine\n\nUsage:\n  bunx ogthing            Inspect any url, localhost included, at ogthing.localhost\n  bunx ogthing --version  Print the installed ogthing version\n\nEnvironment:\n  OGTHING_PORT                 Local app port (default: 4646)\n  OGTHING_PROXY_PORT           Portless proxy port (default: 443)\n  OGTHING_PROXY_TLS            Set to 0 for an HTTP Portless proxy\n  OGTHING_FALLBACK_PROXY_PORT  Unprivileged fallback port (default: 1355)\n  OGTHING_NO_OPEN=1            Start without opening a browser\n  OGTHING_NO_PORTLESS=1        Serve directly on 127.0.0.1 without Portless\n  OGTHING_NO_PORTLESS_AUTOSTART  Fail instead of starting a proxy automatically`,
+  );
+};
+
+if (args.includes("--help") || args.includes("-h")) {
+  usage();
+  process.exit(0);
+}
+
+if (args.includes("--version") || args.includes("-v")) {
+  console.log(`ogthing ${packageVersion}`);
+  process.exit(0);
+}
+
+console.log(`ogthing ${packageVersion}`);
+
+const parsePort = (value, name) => {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`${name} must be a port between 1 and 65535`);
+  }
+  return port;
+};
+
+try {
+  parsePort(appPort, "OGTHING_PORT");
+} catch (error) {
+  console.error(`ogthing: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+}
+
+const wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+
+const requestStatus = (url, { requirePortless = false, requireSuccess = true } = {}) =>
+  new Promise((resolve) => {
+    const parsed = new URL(url);
+    const isHttps = parsed.protocol === "https:";
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    };
+    const request = (isHttps ? https : http).request(
+      {
+        hostname: "127.0.0.1",
+        port: parsed.port || (isHttps ? 443 : 80),
+        path: `${parsed.pathname}${parsed.search}`,
+        method: "GET",
+        headers: { host: parsed.host },
+        rejectUnauthorized: false,
+        servername: parsed.hostname,
+        timeout: 750,
+      },
+      (response) => {
+        const portless = response.headers["x-portless"] === "1";
+        response.resume();
+        finish({
+          ok:
+            (!requireSuccess || (response.statusCode >= 200 && response.statusCode < 300)) &&
+            (!requirePortless || portless),
+          portless,
+        });
+      },
+    );
+    request.once("error", () => finish({ ok: false, portless: false }));
+    request.once("timeout", () => {
+      finish({ ok: false, portless: false });
+      request.destroy();
+    });
+    request.end();
+  });
+
+const waitForUrl = async (url, options, attempts = 100, shouldStop = () => false) => {
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    if (shouldStop()) return false;
+    if ((await requestStatus(url, options)).ok) return true;
+    await wait(100);
+  }
+  return false;
+};
+
+const proxyUrlFor = (port, tls) => {
+  const protocol = tls ? "https" : "http";
+  const defaultProxyPort = tls ? 443 : 80;
+  return `${protocol}://ogthing.localhost${port === defaultProxyPort ? "" : `:${port}`}/`;
+};
+
+const stopProcess = (child) => {
+  if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  child.kill("SIGTERM");
+  setTimeout(() => {
+    if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+  }, 2_000).unref();
+};
+
+const portlessProxyArgs = (port, tls) => [
+  "proxy",
+  "start",
+  "--foreground",
+  "--port",
+  String(port),
+  tls ? "--https" : "--no-tls",
+];
+
+const portlessProxyEnv = (port, tls, stateDir) => ({
+  ...process.env,
+  PORTLESS_HTTPS: tls ? "1" : "0",
+  PORTLESS_LAN: "0",
+  PORTLESS_PORT: String(port),
+  ...(stateDir ? { PORTLESS_STATE_DIR: stateDir } : {}),
+  PORTLESS_SYNC_HOSTS: "0",
+  PORTLESS_TLD: "localhost",
+});
+
+const hasCompatiblePortlessConfig = (port, tls) =>
+  new Promise((resolve) => {
+    const child = spawn(process.execPath, [portlessBin, ...portlessProxyArgs(port, tls)], {
+      cwd: packageRoot,
+      env: portlessProxyEnv(port, tls, process.env.PORTLESS_STATE_DIR),
+      stdio: "ignore",
+    });
+    let settled = false;
+    const finish = (compatible) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      resolve(compatible);
+    };
+    const timeout = setTimeout(() => {
+      stopProcess(child);
+      finish(false);
+    }, 3_000);
+    child.once("error", () => finish(false));
+    child.once("exit", (code) => finish(code === 0));
+  });
+
+const findAvailablePort = () =>
+  new Promise((resolve, reject) => {
+    const server = createServer();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("could not determine an available Portless port"));
+        return;
+      }
+      server.close((error) => (error ? reject(error) : resolve(address.port)));
+    });
+  });
+
+const startPortlessProxy = (port, tls, stateDir) => {
+  const child = spawn(process.execPath, [portlessBin, ...portlessProxyArgs(port, tls)], {
+    cwd: packageRoot,
+    env: portlessProxyEnv(port, tls, stateDir),
+    stdio: ["ignore", "ignore", "pipe"],
+  });
+  let exited = false;
+  let stderr = "";
+  child.stderr?.setEncoding("utf8");
+  child.stderr?.on("data", (chunk) => {
+    stderr = `${stderr}${chunk}`.slice(-3000);
+  });
+  child.once("exit", () => {
+    exited = true;
+  });
+  return {
+    child,
+    get exited() {
+      return exited;
+    },
+    get stderr() {
+      return stderr;
+    },
+  };
+};
+
+const tryStartOwnedProxy = async (port, tls) => {
+  const url = proxyUrlFor(port, tls);
+  const started = startPortlessProxy(port, tls, ownedPortlessStateDir);
+  const ready = await waitForUrl(
+    url,
+    { requirePortless: true, requireSuccess: false },
+    150,
+    () => started.exited,
+  );
+  if (!ready) {
+    stopProcess(started.child);
+    return null;
+  }
+  return { port, tls, url, owned: started.child, stateDir: ownedPortlessStateDir };
+};
+
+const ensurePortlessProxy = async (requestedPort, requestedTls) => {
+  const requestedUrl = proxyUrlFor(requestedPort, requestedTls);
+  const requestedProxyRunning = await waitForUrl(
+    requestedUrl,
+    { requirePortless: true, requireSuccess: false },
+    3,
+  );
+  if (requestedProxyRunning && (await hasCompatiblePortlessConfig(requestedPort, requestedTls))) {
+    return {
+      port: requestedPort,
+      tls: requestedTls,
+      url: requestedUrl,
+      owned: null,
+      stateDir: process.env.PORTLESS_STATE_DIR,
+    };
+  }
+
+  if (process.env.OGTHING_NO_PORTLESS_AUTOSTART === "1") {
+    throw new Error(
+      requestedProxyRunning
+        ? `Portless at ${requestedUrl.replace(/\/$/, "")} is not configured for ogthing routing`
+        : `Portless is not running at ${requestedUrl.replace(/\/$/, "")}`,
+    );
+  }
+
+  let port = requestedPort;
+  let tls = requestedTls;
+  const needsPrivilege = port < 1024 && (process.getuid?.() ?? 1000) !== 0;
+  if (needsPrivilege || requestedProxyRunning) {
+    port = parsePort(fallbackProxyPort, "OGTHING_FALLBACK_PROXY_PORT");
+    tls = process.env.OGTHING_FALLBACK_PROXY_TLS === "1";
+  }
+
+  let url = proxyUrlFor(port, tls);
+  const fallbackRunning = await waitForUrl(
+    url,
+    { requirePortless: true, requireSuccess: false },
+    3,
+  );
+  if (fallbackRunning && (await hasCompatiblePortlessConfig(port, tls))) {
+    return {
+      port,
+      tls,
+      url,
+      owned: null,
+      stateDir: process.env.PORTLESS_STATE_DIR,
+    };
+  }
+  if (!fallbackRunning) {
+    const started = await tryStartOwnedProxy(port, tls);
+    if (started) return started;
+  }
+
+  // The fallback port is taken by something incompatible, or it refused us.
+  // Grab a random free port so ogthing still gets a named URL.
+  port = await findAvailablePort();
+  const started = await tryStartOwnedProxy(port, tls);
+  if (started) {
+    console.log(`ogthing: using fallback proxy port ${port}`);
+    return started;
+  }
+  throw new Error(`Portless could not start at ${url.replace(/\/$/, "")}`);
+};
+
+const openBrowser = (url) => {
+  if (process.env.OGTHING_NO_OPEN === "1") return;
+  const command =
+    process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const commandArgs = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const browser = spawn(command, commandArgs, { detached: true, stdio: "ignore" });
+  browser.once("error", () => {});
+  browser.unref();
+};
+
+let localUrl = "";
+try {
+  const requestedProxyPort = parsePort(
+    process.env.OGTHING_PROXY_PORT || "443",
+    "OGTHING_PROXY_PORT",
+  );
+  const requestedProxyTls = process.env.OGTHING_PROXY_TLS !== "0";
+  const bypassPortless = process.env.OGTHING_NO_PORTLESS === "1";
+  const proxy = bypassPortless
+    ? {
+        port: requestedProxyPort,
+        tls: requestedProxyTls,
+        url: `http://127.0.0.1:${appPort}/`,
+        owned: null,
+      }
+    : await ensurePortlessProxy(requestedProxyPort, requestedProxyTls);
+  const { port: proxyPort, tls: proxyTls, url: proxyUrl, owned: ownedProxy } = proxy;
+  localUrl = bypassPortless ? proxy.url : proxyUrl;
+  const appUrl = `http://127.0.0.1:${appPort}/`;
+
+  const env = {
+    ...process.env,
+    OGTHING_MODE: "server",
+    PORTLESS_HTTPS: proxyTls ? "1" : "0",
+    PORTLESS_PORT: String(proxyPort),
+    PORTLESS_TLD: "localhost",
+    PORTLESS_LAN: "0",
+    PORTLESS_SYNC_HOSTS: "0",
+    PORT: String(appPort),
+    ...(proxy.stateDir ? { PORTLESS_STATE_DIR: proxy.stateDir } : {}),
+  };
+
+  const child = spawn(
+    process.execPath,
+    bypassPortless
+      ? [appEntry]
+      : [
+          portlessBin,
+          "ogthing",
+          "--force",
+          "--app-port",
+          String(appPort),
+          process.execPath,
+          appEntry,
+        ],
+    { cwd: packageRoot, env, stdio: ["ignore", "ignore", "pipe"] },
+  );
+
+  let childExited = false;
+  let stderr = "";
+  child.stderr?.setEncoding("utf8");
+  child.stderr?.on("data", (chunk) => {
+    stderr = `${stderr}${chunk}`.slice(-3000);
+  });
+
+  const forwardSignal = (signal) => {
+    if (childExited) return;
+    child.kill(signal);
+    stopProcess(ownedProxy);
+    setTimeout(() => {
+      if (!childExited) child.kill("SIGKILL");
+    }, 2000).unref();
+  };
+
+  process.once("SIGINT", () => forwardSignal("SIGINT"));
+  process.once("SIGTERM", () => forwardSignal("SIGTERM"));
+
+  child.once("error", (error) => {
+    stderr = `${stderr}\n${error.message}`.slice(-3000);
+  });
+
+  child.once("exit", (code, signal) => {
+    childExited = true;
+    stopProcess(ownedProxy);
+    if (code !== 0 && code !== 130 && code !== 143 && signal === null) {
+      const detail = stderr.trim().split("\n").filter(Boolean).slice(-1)[0];
+      console.error(`ogthing: ${detail || `the app exited with code ${code}`}`);
+    }
+    process.exit(signal ? 128 : (code ?? 0));
+  });
+
+  if (await waitForUrl(appUrl, {}, 150, () => childExited)) {
+    if (ownedProxy) console.log(`ogthing: started Portless at ${proxyUrl}`);
+    console.log(`ogthing running at ${localUrl}`);
+    openBrowser(localUrl);
+  } else if (!childExited) {
+    console.error("ogthing: Portless could not route to the local app");
+    forwardSignal("SIGTERM");
+  }
+} catch (error) {
+  console.error(`ogthing: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+}

package/index.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="dark light" />
+    <link
+      rel="icon"
+      href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Ctext y='.9em' font-size='90'%3E%F0%9F%A6%87%3C/text%3E%3C/svg%3E"
+    />
+    <title>ogthing</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "ogthing",
+  "version": "0.0.0-alpha.1",
+  "description": "Inspect Open Graph and social metadata from your own machine, localhost included.",
+  "keywords": [
+    "cli",
+    "opengraph",
+    "open-graph",
+    "metadata",
+    "seo",
+    "link-preview",
+    "twitter-card",
+    "bun"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/extoci/ogthing.git"
+  },
+  "bin": {
+    "ogthing": "bin/ogthing.mjs"
+  },
+  "files": [
+    "bin",
+    "server",
+    "src",
+    "index.html",
+    "tsconfig.json",
+    "vite.config.ts",
+    "portless.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "dev:named": "bun bin/dev-named.mjs",
+    "build": "vite build",
+    "start": "vite preview",
+    "test": "bun run build && bun test",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint bin server src tests vite.config.ts",
+    "format": "oxfmt --write bin server src tests vite.config.ts",
+    "format:check": "oxfmt --check bin server src tests vite.config.ts",
+    "pack:check": "bun pm pack --dry-run",
+    "prepublishOnly": "bun run typecheck && bun run lint && bun run format:check && bun test && bun run build"
+  },
+  "dependencies": {
+    "@vitejs/plugin-react": "6.0.2",
+    "portless": "0.12.0",
+    "react": "19.2.6",
+    "react-dom": "19.2.6",
+    "vite": "8.0.13"
+  },
+  "devDependencies": {
+    "@types/node": "22.19.19",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
+    "bun-types": "1.3.14",
+    "oxfmt": "0.61.0",
+    "oxlint": "1.76.0",
+    "typescript": "7.0.2"
+  },
+  "engines": {
+    "bun": ">=1.3.14"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "packageManager": "bun@1.3.14"
+}

package/portless.json

@@ -0,0 +1,4 @@
+{
+  "name": "ogthing",
+  "script": "dev:named"
+}