mevebu 0.3.0 → 0.4.0

package/mevebu/libs/js/tools/abstract-checklist.js

@@ -0,0 +1,54 @@
+// Checks the usual parts of a research abstract.
+import { el, bench, stack, panel, textArea, toggleRow, notice, copyButton, actions, toolcard } from "../core.js";
+
+const PARTS = [
+  { value: "background", label: "Background" },
+  { value: "aim", label: "Aim" },
+  { value: "method", label: "Method" },
+  { value: "results", label: "Results" },
+  { value: "conclusion", label: "Conclusion" },
+];
+
+function tile(label) {
+  const value = el("span", { class: "mvb-stat__v" }, "0");
+  const node = el("div", { class: "mvb-stat" }, value, el("span", { class: "mvb-stat__k" }, label));
+  node.set = (text) => { value.textContent = text; };
+  return node;
+}
+
+const countWords = (text) => (text.trim() ? text.trim().split(/\s+/).length : 0);
+
+export function mount(slot) {
+  const source = textArea({ rows: 12, "aria-label": "Abstract", placeholder: "Paste the abstract" });
+  const parts = toggleRow(PARTS.map((part) => ({ ...part, checked: false })));
+  const wordsTile = tile("Words");
+  const tickedTile = tile("Ticked");
+  const stats = el("div", { class: "mvb-stats" }, wordsTile, tickedTile);
+  const note = notice("note");
+  note.write("This checks structure only, not quality.");
+  let summary = "";
+
+  function run() {
+    const ticked = parts.values();
+    wordsTile.set(String(countWords(source.value)));
+    tickedTile.set(String(ticked.length));
+    summary = PARTS.map((part) => `${part.label}: ${ticked.includes(part.value) ? "yes" : "no"}`).join("\n");
+  }
+
+  source.addEventListener("input", run);
+  parts.addEventListener("change", run);
+
+  const card = toolcard({
+    body: bench(
+      stack(panel("Abstract", source), note),
+      stack(stats, panel("Parts found", parts))
+    ),
+    foot: actions(copyButton(() => summary, "Copy checklist", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

package/mevebu/libs/js/tools/add-subtract-days.js

@@ -0,0 +1,105 @@
+// Moves a date forward or back by days, weeks, months or years.
+import { el, bench, stack, panel, textInput, numberInput, selectInput, chipRow, notice, copyButton, actions, toolcard } from "../core.js";
+
+const UNITS = [
+  { value: "days", label: "Days" },
+  { value: "weeks", label: "Weeks" },
+  { value: "months", label: "Months" },
+  { value: "years", label: "Years" },
+];
+
+const pad = (n) => String(n).padStart(2, "0");
+
+function parseDate(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]) - 1;
+  const day = Number(match[3]);
+  const date = new Date(year, month, day);
+  if (date.getFullYear() !== year || date.getMonth() !== month || date.getDate() !== day) return null;
+  return date;
+}
+
+const iso = (date) => `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+
+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 date = textInput({ type: "date", value: "2026-01-01", "aria-label": "Start date" });
+  const amount = numberInput({ value: "30", min: "0", "aria-label": "Amount" });
+  const unit = selectInput(UNITS, { value: "days", "aria-label": "Unit" });
+  let mode = "add";
+  const direction = chipRow(
+    [{ value: "add", label: "Add" }, { value: "subtract", label: "Subtract" }],
+    { value: "add", label: "Direction", onChange: (value) => { mode = value; run(); } }
+  );
+  const result = el("span", { class: "mvb-stat__v" }, "-");
+  const tile = el("div", { class: "mvb-stat" }, result, el("span", { class: "mvb-stat__k" }, "Result"));
+  const stats = el("div", { class: "mvb-stats" }, tile);
+  const isoOut = el("span", { class: "mvb-kv__v" }, "-");
+  const weekday = el("span", { class: "mvb-kv__v" }, "-");
+  const kv = el("div", { class: "mvb-kv" }, kvRow("ISO date", isoOut), kvRow("Weekday", weekday));
+  const error = notice("error");
+  let text = "";
+
+  function clear() {
+    result.textContent = "-";
+    isoOut.textContent = "-";
+    weekday.textContent = "-";
+    text = "";
+  }
+
+  function run() {
+    error.write("");
+    const base = parseDate(date.value);
+    const count = Number(amount.value);
+    if (!base) {
+      clear();
+      error.write("Pick a valid date.");
+      return;
+    }
+    if (amount.value.trim() === "" || !Number.isFinite(count) || count < 0) {
+      clear();
+      error.write("Enter a number of days, weeks, months or years.");
+      return;
+    }
+    const sign = mode === "subtract" ? -1 : 1;
+    const step = sign * Math.floor(count);
+    const out = new Date(base.getFullYear(), base.getMonth(), base.getDate());
+    if (unit.value === "days") out.setDate(out.getDate() + step);
+    else if (unit.value === "weeks") out.setDate(out.getDate() + step * 7);
+    else if (unit.value === "months") out.setMonth(out.getMonth() + step);
+    else out.setFullYear(out.getFullYear() + step);
+
+    result.textContent = out.toLocaleDateString(undefined, { day: "numeric", month: "short", year: "numeric" });
+    isoOut.textContent = iso(out);
+    weekday.textContent = out.toLocaleDateString(undefined, { weekday: "long" });
+    text = `${out.toLocaleDateString(undefined, { weekday: "long", day: "numeric", month: "long", year: "numeric" })} (${iso(out)})`;
+  }
+
+  date.addEventListener("input", run);
+  amount.addEventListener("input", run);
+  unit.addEventListener("change", run);
+
+  const card = toolcard({
+    body: bench(
+      stack(
+        panel("Date", date),
+        panel("Amount", amount),
+        panel("Unit", unit),
+        panel("Direction", direction),
+        error
+      ),
+      stack(stats, panel("Result", kv))
+    ),
+    foot: actions(copyButton(() => text, "Copy result", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

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

@@ -0,0 +1,108 @@
+// Age in years, months and days on any date, plus the next birthday.
+import { el, bench, stack, panel, textInput, notice, copyButton, actions, toolcard } from "../core.js";
+
+const DAY = 86400000;
+
+const pad = (n) => String(n).padStart(2, "0");
+
+function parseDate(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]) - 1;
+  const day = Number(match[3]);
+  const date = new Date(year, month, day);
+  if (date.getFullYear() !== year || date.getMonth() !== month || date.getDate() !== day) return null;
+  return date;
+}
+
+function calendarDiff(from, to) {
+  let years = to.getFullYear() - from.getFullYear();
+  let months = to.getMonth() - from.getMonth();
+  let days = to.getDate() - from.getDate();
+  if (days < 0) {
+    months -= 1;
+    days += new Date(to.getFullYear(), to.getMonth(), 0).getDate();
+  }
+  if (months < 0) {
+    years -= 1;
+    months += 12;
+  }
+  return { years, months, days };
+}
+
+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 today = new Date();
+  const birth = textInput({ type: "date", value: "1990-01-01", "aria-label": "Birth date" });
+  const at = textInput({ type: "date", value: `${today.getFullYear()}-${pad(today.getMonth() + 1)}-${pad(today.getDate())}`, "aria-label": "Age at date" });
+
+  const age = el("span", { class: "mvb-kv__v" }, "-");
+  const totalDays = el("span", { class: "mvb-kv__v" }, "-");
+  const nextDate = el("span", { class: "mvb-kv__v" }, "-");
+  const nextIn = el("span", { class: "mvb-kv__v" }, "-");
+  const kv = el(
+    "div",
+    { class: "mvb-kv" },
+    kvRow("Age", age),
+    kvRow("Total days", totalDays),
+    kvRow("Next birthday", nextDate),
+    kvRow("Until next birthday", nextIn)
+  );
+  const error = notice("error");
+  let text = "";
+
+  function clear() {
+    age.textContent = "-";
+    totalDays.textContent = "-";
+    nextDate.textContent = "-";
+    nextIn.textContent = "-";
+    text = "";
+  }
+
+  function run() {
+    error.write("");
+    const born = parseDate(birth.value);
+    const measure = parseDate(at.value);
+    if (!born || !measure) {
+      clear();
+      error.write("Enter a valid birth date and measure date.");
+      return;
+    }
+    if (measure < born) {
+      clear();
+      error.write("The measure date is before the birth date.");
+      return;
+    }
+    const diff = calendarDiff(born, measure);
+    const total = Math.round((measure - born) / DAY);
+
+    let next = new Date(measure.getFullYear(), born.getMonth(), born.getDate());
+    if (next < measure) next = new Date(measure.getFullYear() + 1, born.getMonth(), born.getDate());
+    const untilNext = Math.round((next - measure) / DAY);
+
+    age.textContent = `${diff.years} years ${diff.months} months ${diff.days} days`;
+    totalDays.textContent = String(total);
+    nextDate.textContent = next.toLocaleDateString(undefined, { weekday: "long", day: "numeric", month: "long", year: "numeric" });
+    nextIn.textContent = untilNext === 0 ? "Today" : `${untilNext} days`;
+    text = `${diff.years} years ${diff.months} months ${diff.days} days`;
+  }
+
+  for (const input of [birth, at]) input.addEventListener("input", run);
+
+  const card = toolcard({
+    body: bench(
+      stack(panel("Birth date", birth), panel("Age at", at), error),
+      stack(panel("Result", kv))
+    ),
+    foot: actions(copyButton(() => text, "Copy age", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

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

@@ -0,0 +1,98 @@
+// Builds an APA 7 reference and its in-text citation from source details.
+import { bench, stack, panel, textInput, selectInput, output, notice, copyButton, actions, toolcard } from "../core.js";
+
+const TYPES = [
+  { value: "book", label: "Book" },
+  { value: "article", label: "Journal article" },
+  { value: "chapter", label: "Chapter in a book" },
+  { value: "web", label: "Web page" },
+];
+
+const parts = (raw) => raw.split(";").map((item) => item.trim()).filter(Boolean);
+const surname = (author) => author.split(",")[0].trim();
+
+function authorList(raw) {
+  const list = parts(raw);
+  if (!list.length) return "";
+  if (list.length === 1) return list[0];
+  if (list.length === 2) return `${list[0]}, & ${list[1]}`;
+  return `${list.slice(0, -1).join(", ")}, & ${list[list.length - 1]}`;
+}
+
+function inText(raw, year) {
+  const list = parts(raw);
+  const y = year.trim();
+  if (!list.length) return y ? `(${y})` : "";
+  if (list.length === 1) return `(${surname(list[0])}, ${y})`;
+  if (list.length === 2) return `(${surname(list[0])} & ${surname(list[1])}, ${y})`;
+  return `(${surname(list[0])} et al., ${y})`;
+}
+
+const endDot = (value) => (/[.!?]$/.test(value) ? value : `${value}.`);
+
+export function mount(slot) {
+  const type = selectInput(TYPES, { value: "book", "aria-label": "Source type" });
+  const authors = textInput({ placeholder: "Smith, J. A.; Doe, B.", "aria-label": "Authors" });
+  const year = textInput({ placeholder: "2020", "aria-label": "Year" });
+  const title = textInput({ placeholder: "Title of the work", "aria-label": "Title" });
+  const source = textInput({ placeholder: "Journal, publisher or site", "aria-label": "Source" });
+  const details = textInput({ placeholder: "Volume, issue, pages or edition", "aria-label": "Details" });
+  const link = textInput({ placeholder: "https://doi.org/10.0000/abc", "aria-label": "DOI or URL" });
+
+  const reference = output({ rows: 6 });
+  const citation = output({ rows: 2 });
+  const note = notice("note");
+  note.write("Check the details against the source and the APA 7 guide.");
+  let refText = "";
+
+  function build() {
+    const pieces = [];
+    const au = authorList(authors.value);
+    const yr = year.value.trim();
+    if (au) pieces.push(au);
+    if (yr) pieces.push(`(${yr}).`);
+    const ti = title.value.trim();
+    if (ti) pieces.push(endDot(ti));
+    const src = source.value.trim();
+    const det = details.value.trim();
+    if (type.value === "article") {
+      if (src) pieces.push(det ? `${src}, ${det}.` : endDot(src));
+    } else {
+      if (src) pieces.push(endDot(src));
+      if (det) pieces.push(endDot(det));
+    }
+    if (link.value.trim()) pieces.push(link.value.trim());
+    refText = pieces.join(" ");
+    reference.write(refText);
+    citation.write(inText(authors.value, yr));
+  }
+
+  for (const input of [authors, year, title, source, details, link]) input.addEventListener("input", build);
+  type.addEventListener("change", build);
+
+  const card = toolcard({
+    body: bench(
+      stack(
+        panel("Source type", type),
+        panel("Authors", authors),
+        panel("Year", year),
+        panel("Title", title),
+        panel("Source", source),
+        panel("Details", details),
+        panel("DOI or URL", link),
+        note
+      ),
+      stack(panel("Reference", reference), panel("In-text citation", citation))
+    ),
+    foot: actions(
+      copyButton(() => citation.textContent, "Copy in-text"),
+      copyButton(() => refText, "Copy reference", "fill")
+    ),
+  });
+  slot.append(card.node);
+  build();
+
+  return {};
+}
+
+export default { mount };

package/mevebu/libs/js/tools/api-request-builder.js

@@ -0,0 +1,76 @@
+// Builds an HTTP request and writes it out as a fetch snippet.
+import { bench, stack, panel, textInput, textArea, selectInput, notice, output, copyButton, actions, toolcard } from "../core.js";
+
+const METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+const BODYLESS = new Set(["GET", "HEAD"]);
+
+function parseHeaders(text) {
+  const headers = {};
+  for (const raw of text.replace(/\r\n?/g, "\n").split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    const at = line.indexOf(":");
+    if (at === -1) continue;
+    headers[line.slice(0, at).trim()] = line.slice(at + 1).trim();
+  }
+  return headers;
+}
+
+function build(method, url, headers, body) {
+  const lines = [];
+  lines.push(`const response = await fetch(${JSON.stringify(url)}, {`);
+  lines.push(`  method: ${JSON.stringify(method)},`);
+  const keys = Object.keys(headers);
+  if (keys.length) {
+    lines.push("  headers: {");
+    for (const key of keys) lines.push(`    ${JSON.stringify(key)}: ${JSON.stringify(headers[key])},`);
+    lines.push("  },");
+  }
+  if (!BODYLESS.has(method) && body) lines.push(`  body: ${JSON.stringify(body)},`);
+  lines.push("});");
+  lines.push("");
+  lines.push("const data = await response.json();");
+  return lines.join("\n");
+}
+
+export function mount(slot) {
+  const methodSelect = selectInput(METHODS, { value: "GET", "aria-label": "Method" });
+  const urlInput = textInput({ value: "https://api.example.com/users", "aria-label": "URL", spellcheck: "false" });
+  const headerInput = textArea({ rows: 5, class: "mvb-in mvb-in--area mvb-in--mono", "aria-label": "Headers", placeholder: "Content-Type: application/json", value: "Accept: application/json" });
+  const bodyInput = textArea({ rows: 6, class: "mvb-in mvb-in--area mvb-in--mono", "aria-label": "Body", placeholder: '{"name":"Ada"}', value: '{\n  "name": "Ada"\n}' });
+  const result = output({ rows: 14 });
+  const hint = notice("note");
+
+  function run() {
+    const method = methodSelect.value;
+    const bodyless = BODYLESS.has(method);
+    bodyInput.disabled = bodyless;
+    hint.write(bodyless ? `${method} requests carry no body.` : "");
+    result.write(build(method, urlInput.value.trim() || "https://api.example.com/resource", parseHeaders(headerInput.value), bodyInput.value.trim()));
+  }
+
+  methodSelect.addEventListener("change", run);
+  urlInput.addEventListener("input", run);
+  headerInput.addEventListener("input", run);
+  bodyInput.addEventListener("input", run);
+
+  const card = toolcard({
+    body: bench(
+      stack(
+        panel("Method", methodSelect),
+        panel("URL", urlInput),
+        panel("Headers", headerInput),
+        panel("Body", bodyInput),
+        hint
+      ),
+      stack(panel("fetch", result))
+    ),
+    foot: actions(copyButton(() => result.textContent, "Copy snippet", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

package/mevebu/libs/js/tools/area-converter.js

@@ -0,0 +1,87 @@
+// Converts an area between metric and imperial units, with the factor used.
+import { el, bench, stack, panel, numberInput, selectInput, notice, copyButton, button, actions, toolcard } from "../core.js";
+
+const UNITS = [
+  { value: "mm2", label: "Square millimeter", factor: 0.000001 },
+  { value: "cm2", label: "Square centimeter", factor: 0.0001 },
+  { value: "m2", label: "Square meter", factor: 1 },
+  { value: "ha", label: "Hectare", factor: 10000 },
+  { value: "km2", label: "Square kilometer", factor: 1000000 },
+  { value: "in2", label: "Square inch", factor: 0.00064516 },
+  { value: "ft2", label: "Square foot", factor: 0.09290304 },
+  { value: "yd2", label: "Square yard", factor: 0.83612736 },
+  { value: "acre", label: "Acre", factor: 4046.8564224 },
+];
+
+const byId = Object.fromEntries(UNITS.map((unit) => [unit.value, unit]));
+const options = UNITS.map(({ value, label }) => ({ value, label }));
+
+function fmt(value) {
+  if (!Number.isFinite(value)) return "-";
+  if (value === 0) return "0";
+  const abs = Math.abs(value);
+  if (abs >= 1e-6 && abs < 1e15) return String(Number(value.toPrecision(8)));
+  return value.toExponential(4);
+}
+
+export function mount(slot) {
+  const value = numberInput({ value: "1", step: "any", "aria-label": "Value" });
+  const from = selectInput(options, { value: "m2", "aria-label": "From unit" });
+  const to = selectInput(options, { value: "ft2", "aria-label": "To unit" });
+  const result = el("span", { class: "mvb-stat__v" }, "-");
+  const stats = el("div", { class: "mvb-stats" }, el("div", { class: "mvb-stat" }, el("span", { class: "mvb-stat__k" }, "Result"), result));
+  const factor = el("p", { class: "mvb-note" });
+  const error = notice("error");
+  const scroll = el("div", { class: "mvb-scroll" });
+  let text = "";
+
+  function run() {
+    error.write("");
+    const raw = value.value.trim();
+    const n = Number(raw);
+    if (!raw || !Number.isFinite(n)) {
+      result.textContent = "-";
+      factor.textContent = "";
+      scroll.replaceChildren();
+      text = "";
+      error.write("Enter a number.");
+      return;
+    }
+    const a = byId[from.value];
+    const b = byId[to.value];
+    const out = (n * a.factor) / b.factor;
+    result.textContent = `${fmt(out)} ${b.value}`;
+    factor.textContent = `1 ${a.value} = ${fmt(a.factor / b.factor)} ${b.value}`;
+    scroll.replaceChildren(el("table", { class: "mvb-ttable" },
+      el("thead", {}, el("tr", {}, el("th", {}, "Unit"), el("th", {}, "Value"))),
+      el("tbody", {}, ...UNITS.map((unit) => el("tr", {},
+        el("td", {}, unit.label),
+        el("td", {}, fmt((n * a.factor) / unit.factor)))))));
+    text = `${fmt(out)} ${b.value}`;
+  }
+
+  value.addEventListener("input", run);
+  from.addEventListener("change", run);
+  to.addEventListener("change", run);
+
+  const swap = button("Swap", { icon: "arrow-left-right", onclick: () => {
+    const held = from.value;
+    from.value = to.value;
+    to.value = held;
+    run();
+  }});
+
+  const card = toolcard({
+    body: bench(
+      stack(panel("Value", value), panel("From", from), panel("To", to), error),
+      stack(panel("Result", stats), factor, panel("All units", scroll))
+    ),
+    foot: actions(swap, copyButton(() => text, "Copy result", "fill")),
+  });
+  slot.append(card.node);
+  run();
+
+  return {};
+}
+
+export default { mount };

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

@@ -0,0 +1,81 @@
+// Simplify an aspect ratio and find a missing width or height.
+import { el, bench, stack, panel, numberInput, output, copyButton, actions, toolcard } from "../core.js";
+
+const gcd = (a, b) => (b ? gcd(b, a % b) : a);
+const round2 = (n) => Math.round(n * 100) / 100;
+
+export function mount(slot) {
+  const width = numberInput({ value: 1920, min: "1", "aria-label": "Width" });
+  const height = numberInput({ value: 1080, min: "1", "aria-label": "Height" });
+
+  const ratioValue = el("span", { class: "mvb-kv__v" }, "-");
+  const decimalValue = el("span", { class: "mvb-kv__v" }, "-");
+  const list = el(
+    "div",
+    { class: "mvb-kv" },
+    el("div", { class: "mvb-kv__row" }, el("span", { class: "mvb-kv__k" }, "Ratio"), ratioValue),
+    el("div", { class: "mvb-kv__row" }, el("span", { class: "mvb-kv__k" }, "Decimal"), decimalValue)
+  );
+
+  const newWidth = numberInput({ value: 800, min: "1", "aria-label": "New width" });
+  const newHeight = numberInput({ value: 450, min: "1", "aria-label": "New height" });
+  const box = el("div", { class: "mvb-preview__box" });
+  const code = output();
+  let ratioText = "16 / 9";
+
+  function readSides() {
+    const w = parseFloat(width.value) || 0;
+    const h = parseFloat(height.value) || 0;
+    return { w, h };
+  }
+
+  function update() {
+    const { w, h } = readSides();
+    if (w > 0 && h > 0) {
+      const g = gcd(Math.round(w), Math.round(h)) || 1;
+      const sw = Math.round(w) / g;
+      const sh = Math.round(h) / g;
+      ratioText = `${sw} / ${sh}`;
+      ratioValue.textContent = `${sw}:${sh}`;
+      decimalValue.textContent = (w / h).toFixed(2);
+      box.style.height = "auto";
+      box.style.aspectRatio = `${w} / ${h}`;
+      box.textContent = `${sw}:${sh}`;
+      code.write(`aspect-ratio: ${ratioText};`);
+      const nw = parseFloat(newWidth.value) || 0;
+      if (nw > 0) newHeight.value = round2((nw * h) / w);
+    } else {
+      ratioValue.textContent = "-";
+      decimalValue.textContent = "-";
+      code.write("");
+    }
+  }
+
+  width.addEventListener("input", update);
+  height.addEventListener("input", update);
+
+  newWidth.addEventListener("input", () => {
+    const { w, h } = readSides();
+    const nw = parseFloat(newWidth.value) || 0;
+    if (w > 0 && nw > 0) newHeight.value = round2((nw * h) / w);
+  });
+  newHeight.addEventListener("input", () => {
+    const { w, h } = readSides();
+    const nh = parseFloat(newHeight.value) || 0;
+    if (h > 0 && nh > 0) newWidth.value = round2((nh * w) / h);
+  });
+
+  const card = toolcard({
+    body: bench(
+      stack(panel("Width", width), panel("Height", height), list),
+      stack(el("div", { class: "mvb-preview" }, box), panel("New width", newWidth), panel("New height", newHeight), code)
+    ),
+    foot: actions(copyButton(() => `aspect-ratio: ${ratioText};`, "Copy CSS", "fill")),
+  });
+  slot.append(card.node);
+  update();
+
+  return {};
+}
+
+export default { mount };