mevebu 0.3.1 → 0.4.0

package/mevebu/libs/js/tools/ratio-calculator.js

@@ -0,0 +1,103 @@
+// Simplifies a ratio and solves the missing term in a proportion.
+import { el, bench, stack, panel, numberInput, textInput, notice, copyButton, actions, toolcard } from "../core.js";
+
+function gcd(a, b) {
+  a = Math.abs(a);
+  b = Math.abs(b);
+  while (b) {
+    const next = a % b;
+    a = b;
+    b = next;
+  }
+  return a;
+}
+
+function fmt(n) {
+  return n.toLocaleString(undefined, { maximumFractionDigits: 6 });
+}
+
+const kvRow = (key, value) =>
+  el("div", { class: "mvb-kv__row" }, el("span", { class: "mvb-kv__k" }, key), el("span", { class: "mvb-kv__v" }, value));
+
+export function mount(slot) {
+  const ratioInput = textInput({ value: "12:18:24", "aria-label": "Ratio" });
+  const a = numberInput({ placeholder: "A", "aria-label": "First term" });
+  const b = numberInput({ placeholder: "B", "aria-label": "Second term" });
+  const c = numberInput({ placeholder: "C", "aria-label": "Third term" });
+  const d = numberInput({ placeholder: "D", "aria-label": "Fourth term" });
+  const simplified = el("span", { class: "mvb-kv__v" }, "-");
+  const decimal = el("span", { class: "mvb-kv__v" }, "-");
+  const missing = el("span", { class: "mvb-kv__v" }, "-");
+  const kv = el(
+    "div",
+    { class: "mvb-kv" },
+    kvRow("Simplified ratio", simplified),
+    kvRow("Decimal", decimal),
+    kvRow("Missing term", missing)
+  );
+  const error = notice("error");
+  let text = "";
+
+  function simplify() {
+    const tokens = ratioInput.value.split(/[^0-9.]+/).filter(Boolean);
+    const nums = tokens.map(Number);
+    simplified.textContent = "-";
+    decimal.textContent = "-";
+    if (!ratioInput.value.trim()) return "";
+    if (tokens.length < 2 || !nums.every(Number.isFinite)) {
+      error.write("Use numbers separated by colons, for example 12:18:24.");
+      return "";
+    }
+    const divisor = nums.reduce((acc, n) => gcd(acc, n), 0);
+    if (!divisor) return "";
+    const out = nums.map((n) => n / divisor);
+    simplified.textContent = out.join(" : ");
+    if (nums.length === 2 && nums[1] !== 0) decimal.textContent = fmt(nums[0] / nums[1]);
+    return out.join(":");
+  }
+
+  function solve() {
+    const terms = [a, b, c, d].map((input) => input.value.trim());
+    missing.textContent = "-";
+    if (terms.filter((term) => term !== "").length !== 3) return "";
+    const nums = terms.map((term) => (term === "" ? null : Number(term)));
+    if (nums.some((n) => n !== null && !Number.isFinite(n))) return "";
+    const [A, B, C, D] = nums;
+    let value = null;
+    if (D === null) value = A === 0 ? null : (B * C) / A;
+    else if (A === null) value = D === 0 ? null : (B * C) / D;
+    else if (B === null) value = C === 0 ? null : (A * D) / C;
+    else if (C === null) value = A === 0 ? null : (B * D) / A;
+    if (value === null || !Number.isFinite(value)) return "";
+    missing.textContent = fmt(value);
+    return fmt(value);
+  }
+
+  function run() {
+    error.write("");
+    const ratio = simplify();
+    const term = solve();
+    text = ratio || term;
+  }
+
+  ratioInput.addEventListener("input", run);
+  for (const input of [a, b, c, d]) input.addEventListener("input", run);
+
+  const card = toolcard({
+    body: bench(
+      stack(
+        panel("Ratio", ratioInput),
+        panel("Proportion", el("div", { class: "mvb-row" }, a, b, c, d)),
+        error
+      ),
+      stack(panel("Result", kv))
+    ),
+    foot: actions(copyButton(() => text, "Copy result", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

package/mevebu/libs/js/tools/readability.js

@@ -0,0 +1,112 @@
+// Common readability formulas over a pasted text, with the counts behind them.
+import { el, bench, stack, panel, textArea, notice, copyButton, actions, toolcard } from "../core.js";
+
+function wordsOf(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return [];
+  if (typeof Intl !== "undefined" && Intl.Segmenter) {
+    try {
+      const segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+      return [...segmenter.segment(trimmed)].filter((part) => part.isWordLike).map((part) => part.segment);
+    } catch {
+      /* fall back to the whitespace split below */
+    }
+  }
+  return trimmed.split(/\s+/);
+}
+
+const sentencesOf = (text) => text.trim()
+  ? text.trim().split(/[.!?\u2026]+/).map((part) => part.trim()).filter(Boolean)
+  : [];
+
+function syllablesOf(word) {
+  const clean = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (!clean) return 0;
+  const groups = clean.replace(/e$/, "").match(/[aeiouy]+/g);
+  return Math.max(1, groups ? groups.length : 1);
+}
+
+function tile(label, initial = "-") {
+  const value = el("span", { class: "mvb-stat__v" }, initial);
+  const node = el("div", { class: "mvb-stat" }, value, el("span", { class: "mvb-stat__k" }, label));
+  node.set = (text) => { value.textContent = text; };
+  return node;
+}
+
+const kvRow = (key, value) => el("div", { class: "mvb-kv__row" },
+  el("span", { class: "mvb-kv__k" }, key),
+  el("span", { class: "mvb-kv__v" }, value));
+
+export function mount(slot) {
+  const source = textArea({ rows: 12, "aria-label": "Text", placeholder: "Type or paste text" });
+
+  const easeTile = tile("Reading ease");
+  const gradeTile = tile("Grade level");
+  const fogTile = tile("Gunning Fog");
+  const stats = el("div", { class: "mvb-stats" }, easeTile, gradeTile, fogTile);
+
+  const counts = {
+    words: el("span", { class: "mvb-kv__v" }, "0"),
+    sentences: el("span", { class: "mvb-kv__v" }, "0"),
+    syllables: el("span", { class: "mvb-kv__v" }, "0"),
+  };
+  const countList = el("div", { class: "mvb-kv" },
+    kvRow("Words", counts.words),
+    kvRow("Sentences", counts.sentences),
+    kvRow("Syllables", counts.syllables));
+
+  const note = notice("note");
+  note.write("These formulas suit English best, so read the result with care.");
+
+  let summary = "";
+
+  function run() {
+    const words = wordsOf(source.value);
+    const sentences = sentencesOf(source.value);
+    const syllableCount = words.reduce((sum, word) => sum + syllablesOf(word), 0);
+    counts.words.textContent = String(words.length);
+    counts.sentences.textContent = String(sentences.length);
+    counts.syllables.textContent = String(syllableCount);
+
+    if (!words.length || !sentences.length) {
+      easeTile.set("-");
+      gradeTile.set("-");
+      fogTile.set("-");
+      summary = "";
+      return;
+    }
+
+    const perSentence = words.length / sentences.length;
+    const perWord = syllableCount / words.length;
+    const ease = 206.835 - 1.015 * perSentence - 84.6 * perWord;
+    const grade = 0.39 * perSentence + 11.8 * perWord - 15.59;
+    const complex = words.filter((word) => syllablesOf(word) >= 3).length;
+    const fog = 0.4 * (perSentence + 100 * (complex / words.length));
+
+    easeTile.set(ease.toFixed(1));
+    gradeTile.set(grade.toFixed(1));
+    fogTile.set(fog.toFixed(1));
+    summary = [
+      `Reading ease ${ease.toFixed(1)}`,
+      `Grade level ${grade.toFixed(1)}`,
+      `Gunning Fog ${fog.toFixed(1)}`,
+      `${words.length} words, ${sentences.length} sentences, ${syllableCount} syllables`,
+    ].join("\n");
+  }
+
+  source.addEventListener("input", run);
+
+  const card = toolcard({
+    body: bench(
+      stack(panel("Text", source)),
+      stack(stats, countList, note)
+    ),
+    foot: actions(copyButton(() => summary, "Copy scores", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

package/mevebu/libs/js/tools/reading-time.js

@@ -0,0 +1,76 @@
+// Reading and speaking time for a text, at a speed the user sets.
+import { el, bench, stack, panel, textArea, numberInput, notice, copyButton, actions, toolcard } from "../core.js";
+
+const countWords = (text) => {
+  const trimmed = text.trim();
+  if (!trimmed) return 0;
+  if (typeof Intl !== "undefined" && Intl.Segmenter) {
+    try {
+      const segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+      let count = 0;
+      for (const part of segmenter.segment(trimmed)) if (part.isWordLike) count++;
+      return count;
+    } catch {
+      /* fall back to the whitespace split below */
+    }
+  }
+  return trimmed.split(/\s+/).length;
+};
+
+const clock = (minutes) => {
+  const total = Math.round(minutes * 60);
+  return `${Math.floor(total / 60)}:${String(total % 60).padStart(2, "0")}`;
+};
+
+function tile(label) {
+  const value = el("span", { class: "mvb-stat__v" }, "0:00");
+  const node = el("div", { class: "mvb-stat" }, value, el("span", { class: "mvb-stat__k" }, label));
+  node.set = (text) => { value.textContent = text; };
+  return node;
+}
+
+export function mount(slot) {
+  const source = textArea({ rows: 10, "aria-label": "Text", placeholder: "Type or paste text" });
+  const speed = numberInput({ min: "50", max: "1000", step: "10", value: "200", "aria-label": "Reading speed in words per minute" });
+
+  const wordsTile = tile("Words");
+  const readTile = tile("Reading time");
+  const speakTile = tile("Speaking time");
+  const stats = el("div", { class: "mvb-stats" }, wordsTile, readTile, speakTile);
+  const note = notice("note");
+  note.write("Reading and speaking speeds vary by person and text.");
+
+  let summary = "";
+
+  function run() {
+    const words = countWords(source.value);
+    const wpm = Math.max(1, parseInt(speed.value, 10) || 200);
+    const readMinutes = words / wpm;
+    const speakMinutes = words / 130;
+    wordsTile.set(String(words));
+    readTile.set(words ? clock(readMinutes) : "0:00");
+    speakTile.set(words ? clock(speakMinutes) : "0:00");
+    summary = [
+      `${words} words`,
+      `Reading ${words ? clock(readMinutes) : "0:00"} at ${wpm} words per minute`,
+      `Speaking ${words ? clock(speakMinutes) : "0:00"} at 130 words per minute`,
+    ].join("\n");
+  }
+
+  source.addEventListener("input", run);
+  speed.addEventListener("input", run);
+
+  const card = toolcard({
+    body: bench(
+      stack(panel("Text", source), panel("Reading speed", speed, "Words per minute")),
+      stack(stats, note)
+    ),
+    foot: actions(copyButton(() => summary, "Copy estimate", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

package/mevebu/libs/js/tools/readme-generator.js

@@ -0,0 +1,50 @@
+// Drafts a README from a project name, description and the sections you pick.
+import { bench, stack, panel, textInput, toggleRow, output, copyButton, actions, toolcard } from "../core.js";
+
+export function mount(slot) {
+  const name = textInput({ value: "my-project", "aria-label": "Project name" });
+  const description = textInput({ value: "A short description of the project.", "aria-label": "Description" });
+  const license = textInput({ value: "MIT", "aria-label": "License" });
+  const sections = toggleRow([
+    { value: "features", label: "Features" },
+    { value: "install", label: "Installation" },
+    { value: "usage", label: "Usage" },
+    { value: "license", label: "License" },
+    { value: "contributing", label: "Contributing", checked: false },
+  ]);
+  const out = output({ rows: 18 });
+  let text = "";
+
+  function run() {
+    const picked = new Set(sections.values());
+    const project = name.value.trim() || "Project";
+    const lines = [`# ${project}`, ""];
+    if (description.value.trim()) lines.push(description.value.trim(), "");
+    if (picked.has("features")) lines.push("## Features", "", "- First feature", "- Second feature", "");
+    if (picked.has("install")) lines.push("## Installation", "", "```bash", `npm install ${project}`, "```", "");
+    if (picked.has("usage")) lines.push("## Usage", "", "```js", "// Example", "```", "");
+    if (picked.has("license")) lines.push("## License", "", license.value.trim() || "MIT", "");
+    if (picked.has("contributing")) lines.push("## Contributing", "", "Issues and pull requests are welcome.", "");
+    text = `${lines.join("\n").replace(/\n+$/, "")}\n`;
+    out.write(text);
+  }
+
+  name.addEventListener("input", run);
+  description.addEventListener("input", run);
+  license.addEventListener("input", run);
+  sections.addEventListener("change", run);
+
+  const card = toolcard({
+    body: bench(
+      stack(panel("Project name", name), panel("Description", description), panel("License", license), panel("Sections", sections)),
+      stack(panel("README", out))
+    ),
+    foot: actions(copyButton(() => text, "Copy Markdown", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

package/mevebu/libs/js/tools/reference-completeness.js

@@ -0,0 +1,62 @@
+// Checks a reference for the usual parts.
+import { el, bench, stack, panel, textArea, notice, copyButton, actions, toolcard } from "../core.js";
+
+const PARTS = ["Author", "Year", "Title", "Source"];
+
+function kvRow(key) {
+  const value = el("span", { class: "mvb-kv__v" }, "-");
+  const row = el("div", { class: "mvb-kv__row" }, el("span", { class: "mvb-kv__k" }, key), value);
+  return { row, value };
+}
+
+function check(text) {
+  const t = text.trim();
+  return {
+    Author: /^[A-Z][A-Za-z'’.-]+,/.test(t) || /\b(and|&)\s+[A-Z]/.test(t),
+    Year: /\b(1[5-9]\d{2}|20\d{2})\b/.test(t),
+    Title: /["“][^"”]{2,}["”]/.test(t) || t.replace(/^[^.]*\./, "").trim().length > 8,
+    Source: /https?:\/\/|www\.|\bIn\b|\b(Journal|Press|Publishing|Publishers|University|vol\.|pp\.|ed\.)\b/i.test(t),
+  };
+}
+
+export function mount(slot) {
+  const source = textArea({ rows: 6, "aria-label": "Reference", placeholder: "Paste one reference" });
+  const rows = {};
+  const kv = el("div", { class: "mvb-kv" });
+  for (const key of PARTS) {
+    rows[key] = kvRow(key);
+    kv.append(rows[key].row);
+  }
+  const status = notice("note");
+  const note = notice("note");
+  note.write("A complete reference is not proof the source is real.");
+  let summary = "";
+
+  function run() {
+    const hasText = source.value.trim() !== "";
+    const found = check(source.value);
+    const missing = [];
+    for (const key of PARTS) {
+      rows[key].value.textContent = hasText ? (found[key] ? "Found" : "Missing") : "-";
+      if (hasText && !found[key]) missing.push(key);
+    }
+    status.write(hasText ? (missing.length ? `Missing: ${missing.join(", ")}.` : "All four parts found.") : "");
+    summary = hasText ? PARTS.map((key) => `${key}: ${found[key] ? "found" : "missing"}`).join("\n") : "";
+  }
+
+  source.addEventListener("input", run);
+
+  const card = toolcard({
+    body: bench(
+      stack(panel("Reference", source), note),
+      stack(panel("Parts", kv), status)
+    ),
+    foot: actions(copyButton(() => summary, "Copy check", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

package/mevebu/libs/js/tools/regex-tester.js

@@ -0,0 +1,86 @@
+// Tests a pattern against sample text, highlighting matches and listing groups.
+import { el, bench, stack, panel, textInput, textArea, notice, copyButton, actions, toolcard } from "../core.js";
+
+const MAX_MATCHES = 1000;
+
+export function mount(slot) {
+  const patternInput = textInput({ value: "\\b(\\w+)@(\\w+)\\.com\\b", "aria-label": "Pattern", spellcheck: "false" });
+  const flagsInput = textInput({ value: "g", "aria-label": "Flags", spellcheck: "false", placeholder: "g i m s u y" });
+  const source = textArea({
+    rows: 8,
+    class: "mvb-in mvb-in--area mvb-in--mono",
+    "aria-label": "Text to test",
+    value: "Contact ada@example.com or grace@navy.com for details.",
+  });
+  const pane = el("div", { class: "mvb-pane" });
+  const listWrap = el("div", { class: "mvb-scroll" });
+  const error = notice("error");
+  let lines = [];
+
+  function run() {
+    error.write("");
+    pane.replaceChildren();
+    listWrap.replaceChildren();
+    lines = [];
+    const pattern = patternInput.value;
+    if (!pattern) return;
+    let flags = flagsInput.value.replace(/[^gimsuy]/g, "");
+    if (!flags.includes("g")) flags += "g";
+    let re;
+    try {
+      re = new RegExp(pattern, flags);
+    } catch (caught) {
+      error.write(caught.message);
+      return;
+    }
+    const text = source.value;
+    const nodes = [];
+    const rows = [];
+    let last = 0;
+    let count = 0;
+    let match;
+    while ((match = re.exec(text)) && count < MAX_MATCHES) {
+      if (match.index === re.lastIndex) re.lastIndex++;
+      nodes.push(document.createTextNode(text.slice(last, match.index)));
+      nodes.push(el("span", { class: "mvb-hl" }, match[0] || "\u200b"));
+      last = match.index + match[0].length;
+      const groups = match.slice(1).map((group) => group ?? "").join(", ");
+      rows.push(el("tr", {},
+        el("th", {}, String(count + 1)),
+        el("td", {}, match[0] || "(empty)"),
+        el("td", {}, groups)
+      ));
+      lines.push(match[0]);
+      count++;
+    }
+    nodes.push(document.createTextNode(text.slice(last)));
+    pane.append(...nodes);
+    if (!count) {
+      listWrap.append(el("p", { class: "mvb-note" }, "No matches."));
+      return;
+    }
+    const table = el("table", { class: "mvb-ttable" },
+      el("thead", {}, el("tr", {}, el("th", {}, "#"), el("th", {}, "Match"), el("th", {}, "Groups"))),
+      el("tbody", {}, ...rows)
+    );
+    listWrap.append(table);
+  }
+
+  patternInput.addEventListener("input", run);
+  flagsInput.addEventListener("input", run);
+  source.addEventListener("input", run);
+
+  const card = toolcard({
+    body: bench(
+      stack(panel("Pattern", patternInput), panel("Flags", flagsInput), panel("Text", source), error),
+      stack(panel("Matches", pane), panel("Groups", listWrap))
+    ),
+    foot: actions(copyButton(() => lines.join("\n"), "Copy matches", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

package/mevebu/libs/js/tools/remove-duplicate-lines.js

@@ -0,0 +1,46 @@
+// Drops repeated lines and keeps the first time each one appears.
+import { bench, stack, panel, textArea, checkbox, notice, copyButton, actions, toolcard } from "../core.js";
+
+export function mount(slot) {
+  const source = textArea({ rows: 12, "aria-label": "Text", placeholder: "Paste your list, one entry per line" });
+  const ignoreCase = checkbox("Ignore case", { checked: false });
+  const result = textArea({ rows: 12, readonly: true, class: "mvb-in mvb-in--area mvb-in--mono", "aria-label": "Result" });
+  const note = notice("note");
+
+  function run() {
+    const text = source.value;
+    if (!text) {
+      result.value = "";
+      note.write("");
+      return;
+    }
+    const lines = text.split("\n");
+    const seen = new Set();
+    const kept = [];
+    let removed = 0;
+    for (const line of lines) {
+      const key = ignoreCase.input.checked ? line.toLowerCase() : line;
+      if (seen.has(key)) removed++;
+      else { seen.add(key); kept.push(line); }
+    }
+    result.value = kept.join("\n");
+    note.write(removed ? `${removed} lines removed.` : "No duplicate lines found.");
+  }
+
+  source.addEventListener("input", run);
+  ignoreCase.input.addEventListener("change", run);
+
+  const card = toolcard({
+    body: bench(
+      stack(panel("Text", source), ignoreCase, note),
+      stack(panel("Result", result))
+    ),
+    foot: actions(copyButton(() => result.value, "Copy result", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

package/mevebu/libs/js/tools/remove-extra-spaces.js

@@ -0,0 +1,41 @@
+// Tidies spacing in pasted text: collapses runs of spaces, trims each line and
+// optionally drops blank lines.
+import { bench, stack, panel, textArea, toggleRow, copyButton, actions, toolcard } from "../core.js";
+
+export function mount(slot) {
+  const source = textArea({ rows: 12, "aria-label": "Text", placeholder: "Paste your text" });
+  const result = textArea({ rows: 12, readonly: true, class: "mvb-in mvb-in--area mvb-in--mono", "aria-label": "Result" });
+  const options = toggleRow([
+    { value: "collapse", label: "Collapse spaces", checked: true },
+    { value: "trim", label: "Trim lines", checked: true },
+    { value: "blank", label: "Remove blank lines", checked: false },
+  ]);
+
+  function run() {
+    const text = source.value;
+    if (!text) { result.value = ""; return; }
+    const opts = options.values();
+    let lines = text.split("\n");
+    if (opts.includes("trim")) lines = lines.map((line) => line.trim());
+    if (opts.includes("collapse")) lines = lines.map((line) => line.replace(/[ \t]+/g, " "));
+    if (opts.includes("blank")) lines = lines.filter((line) => line.trim());
+    result.value = lines.join("\n");
+  }
+
+  source.addEventListener("input", run);
+  options.addEventListener("change", run);
+
+  const card = toolcard({
+    body: bench(
+      stack(panel("Text", source), options),
+      stack(panel("Result", result))
+    ),
+    foot: actions(copyButton(() => result.value, "Copy result", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

package/mevebu/libs/js/tools/robots-txt.js

@@ -0,0 +1,60 @@
+// Builds a robots.txt from a user agent and the allow and disallow paths, one
+// per line.
+import { bench, stack, panel, textInput, textArea, output, notice, copyButton, actions, toolcard } from "../core.js";
+
+const isUrl = (value) => {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export function mount(slot) {
+  const agent = textInput({ value: "*", "aria-label": "User agent" });
+  const disallow = textArea({ rows: 5, class: "mvb-in mvb-in--area mvb-in--mono", placeholder: "/admin\n/private", "aria-label": "Disallow paths" });
+  const allow = textArea({ rows: 3, class: "mvb-in mvb-in--area mvb-in--mono", placeholder: "/public", "aria-label": "Allow paths" });
+  const sitemap = textInput({ value: "https://example.com/sitemap.xml", "aria-label": "Sitemap URL" });
+  const result = output({ rows: 8 });
+  const error = notice("error");
+
+  const list = (area) => area.value.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+
+  function build() {
+    error.write("");
+    const lines = [`User-agent: ${agent.value.trim() || "*"}`];
+    const blocked = list(disallow);
+    if (blocked.length) for (const path of blocked) lines.push(`Disallow: ${path}`);
+    else lines.push("Disallow:");
+    for (const path of list(allow)) lines.push(`Allow: ${path}`);
+    const site = sitemap.value.trim();
+    if (site) {
+      if (isUrl(site)) lines.push(`Sitemap: ${site}`);
+      else error.write("The sitemap address is not a valid URL.");
+    }
+    result.write(lines.join("\n"));
+  }
+
+  for (const input of [agent, disallow, allow, sitemap]) input.addEventListener("input", build);
+
+  const card = toolcard({
+    body: bench(
+      stack(
+        panel("User-agent", agent),
+        panel("Disallow", disallow),
+        panel("Allow", allow),
+        panel("Sitemap", sitemap),
+        error
+      ),
+      stack(panel("robots.txt", result))
+    ),
+    foot: actions(copyButton(() => result.textContent, "Copy robots.txt", "fill")),
+  });
+  slot.append(card.node);
+  build();
+
+  return {};
+}
+
+export default { mount };