vitral 0.1.0 → 0.3.0

package/dist/chunk-IHTUM6LT.js

@@ -0,0 +1,152 @@
+import {
+  createSlot
+} from "./chunk-I3VSKSAZ.js";
+import {
+  preload,
+  registerSrc
+} from "./chunk-TD4S3IHA.js";
+
+// src/core/host-slot.ts
+var noop = () => {
+};
+function timings(name) {
+  const out = {};
+  if (typeof performance === "undefined" || !performance.getEntriesByName) return out;
+  for (const stage of ["manifest", "js", "css", "mount"]) {
+    const m = performance.getEntriesByName(`vitral:${name}:${stage}`, "measure").pop();
+    if (m) out[stage] = Math.round(m.duration * 10) / 10;
+  }
+  return out;
+}
+function when(el, mode, fn) {
+  if (mode === "lazy" || mode === "visible") {
+    if (typeof IntersectionObserver === "undefined") return fn(), noop;
+    const io = new IntersectionObserver(
+      (entries) => {
+        if (entries.some((e) => e.isIntersecting)) io.disconnect(), fn();
+      },
+      { rootMargin: "200px" }
+    );
+    io.observe(el);
+    return () => io.disconnect();
+  }
+  if (mode === "idle") {
+    if (typeof requestIdleCallback === "undefined") {
+      const t = setTimeout(fn, 1);
+      return () => clearTimeout(t);
+    }
+    const id = requestIdleCallback(fn, { timeout: 2e3 });
+    return () => cancelIdleCallback(id);
+  }
+  if (mode === "hover") {
+    const go = () => (off(), fn());
+    const off = () => {
+      el.removeEventListener("pointerenter", go);
+      el.removeEventListener("focusin", go);
+    };
+    el.addEventListener("pointerenter", go);
+    el.addEventListener("focusin", go);
+    return off;
+  }
+  fn();
+  return noop;
+}
+var kept = /* @__PURE__ */ new Map();
+var shelf = null;
+function move(parent, node) {
+  try {
+    ;
+    parent.moveBefore(node, null);
+  } catch {
+    parent.appendChild(node);
+  }
+}
+function signal(node, type) {
+  for (const el of node.querySelectorAll("*")) {
+    if (el.hasAttribute("data-vitral-root")) el.dispatchEvent(new Event(type));
+    if (el.shadowRoot) signal(el.shadowRoot, type);
+  }
+}
+function park(key, item, max) {
+  kept.get(key)?.slot.destroy();
+  kept.delete(key);
+  if (!shelf?.isConnected) {
+    shelf = document.createElement("div");
+    shelf.hidden = true;
+    shelf.setAttribute("data-vitral-keep-alive", "");
+    document.body.appendChild(shelf);
+  }
+  move(shelf, item.box);
+  signal(item.box, "vitral:deactivate");
+  kept.set(key, item);
+  for (const [k, old] of kept) {
+    if (kept.size <= max) break;
+    kept.delete(k);
+    old.slot.destroy();
+    old.box.remove();
+  }
+}
+function hostSlot(target, options) {
+  let { props = {}, keepAlive } = options;
+  const key = (o) => o.src ? registerSrc(o.src, o.name) : o.name ?? "";
+  let name = key(options);
+  let status = "loading";
+  let item = null;
+  const onStatus = (s, e) => {
+    status = s;
+    options.onStatus?.(s, e);
+  };
+  const cancelPrefetch = options.prefetch ? when(target, options.prefetch, () => preload(name)) : noop;
+  const cancel = when(target, options.loading, () => {
+    cancelPrefetch();
+    const found = keepAlive ? kept.get(name) : void 0;
+    if (found) {
+      kept.delete(name);
+      item = found;
+      item.on = onStatus;
+      move(target, item.box);
+      item.slot.update(props);
+      signal(item.box, "vitral:activate");
+      onStatus(item.slot.status, null);
+      return;
+    }
+    let box = target;
+    if (keepAlive) {
+      box = target.appendChild(document.createElement("div"));
+      box.style.display = "contents";
+    }
+    const it = { box, on: onStatus, slot: null };
+    it.slot = createSlot(box, { ...options, name, src: void 0, props, onStatus: (s, e) => it.on(s, e) });
+    item = it;
+  });
+  return {
+    update(next) {
+      props = next;
+      item?.slot.update(next);
+    },
+    set(next) {
+      if (next.src || next.name !== void 0) name = key(next);
+      item?.slot.set({ ...next, src: void 0, name });
+    },
+    retry: () => item?.slot.retry(),
+    destroy() {
+      cancel();
+      cancelPrefetch();
+      if (!item) return;
+      if (keepAlive && status === "ready") park(name, item, keepAlive === true ? 5 : keepAlive);
+      else {
+        item.slot.destroy();
+        if (item.box !== target) item.box.remove();
+      }
+      item = null;
+    },
+    get status() {
+      return status;
+    }
+  };
+}
+
+export {
+  timings,
+  hostSlot
+};

package/dist/chunk-SDB5AZEI.js

@@ -0,0 +1,51 @@
+import {
+  mountable
+} from "./chunk-TD4S3IHA.js";
+import {
+  RemoteError
+} from "./chunk-AKNNHQ2H.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/expose.ts
+function splitName(name) {
+  const p = protocol();
+  let i = name.length;
+  if (!p.entry(name)) while ((i = name.lastIndexOf("/", i - 1)) > 0 && !p.entry(name.slice(0, i))) ;
+  return i > 0 && i < name.length ? [name.slice(0, i), "." + name.slice(i)] : [name, null];
+}
+function resolveTarget(name, loadFile) {
+  return resolveAny(name, loadFile).then((r) => mountable(name, r));
+}
+function resolveAny(name, loadFile) {
+  const p = protocol();
+  if (p.entry(name) || !name.includes("/")) return loadFile(name);
+  return p.pending().then(async () => {
+    const [remote, key] = splitName(name);
+    if (!key) return loadFile(name);
+    const r = await loadFile(remote);
+    const table = r.exports?.exposes;
+    if (!table?.[key]) throw new RemoteError("NOT_EXPOSED", name, `${remote} n\xE3o exp\xF5e ${key}. Expostos: ${Object.keys(table ?? {}).join(", ")}`);
+    try {
+      const value = table[key];
+      const ns = await (typeof value == "function" ? value() : value);
+      return { ...r, module: ns?.default ?? ns, exports: ns };
+    } catch (e) {
+      throw new RemoteError("LOAD_FAILED", name, String(e), e);
+    }
+  });
+}
+async function resolveModule(name, loadFile) {
+  const r = await resolveAny(name, loadFile);
+  if (!r.exports) {
+    throw new RemoteError("INVALID_MODULE", name, "o remote foi carregado por uma c\xF3pia antiga da lib, que n\xE3o guarda os exports");
+  }
+  return r.exports;
+}
+
+export {
+  splitName,
+  resolveTarget,
+  resolveModule
+};

package/dist/chunk-TD4S3IHA.js

@@ -0,0 +1,201 @@
+import {
+  prefetchCss
+} from "./chunk-ZAC6QQI6.js";
+import {
+  absolute,
+  addLink,
+  fetchJson,
+  metric,
+  pageOrigin,
+  withRetry,
+  withTimeout
+} from "./chunk-GNHCZRQP.js";
+import {
+  RemoteError,
+  fail,
+  isRemoteError,
+  report
+} from "./chunk-AKNNHQ2H.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/registry.ts
+function configure(config) {
+  const p = protocol();
+  const { remotes, dedupe, ...rest } = config;
+  p.configure(rest);
+  if (rest.captureGlobalErrors) import("./capture-JYFERAPL.js").then((m) => m.capture());
+  if (dedupe) p.pending(import("./dedupe-S7BHQMOZ.js").then((m) => m.offer(p, dedupe)).catch(() => {
+  }));
+  if (typeof remotes === "string") {
+    const url = absolute(remotes);
+    p.pending(
+      fetchJson(url, p.settings().timeout, "remotes", { cache: "no-cache" }).then((map) => registerAll(map, url))
+    ).catch(() => {
+    });
+  } else if (remotes) {
+    registerAll(remotes);
+  }
+}
+function register(name, entry) {
+  const e = typeof entry === "string" ? { url: entry } : entry;
+  if (!e.url && !e.module) throw new RemoteError("NOT_REGISTERED", name, "informe url ou module");
+  if (!e.url) return protocol().register(name, e);
+  const url = absolute(e.url);
+  protocol().register(name, { ...e, url });
+  const { origin } = new URL(url);
+  if (typeof document !== "undefined" && origin !== pageOrigin() && origin !== "null" && !document.querySelector(`link[href="${origin}"]`)) {
+    addLink("preconnect", origin);
+  }
+}
+function registerSrc(src, name, trusted = true) {
+  const p = protocol();
+  const url = absolute(src);
+  const key = name || url;
+  if (p.entry(key)?.url !== url) p.register(key, { url });
+  const origin = new URL(url).origin;
+  const list = p.settings().trusted ?? [];
+  if (trusted && !list.includes(origin)) p.configure({ trusted: [...list, origin] });
+  return key;
+}
+function registerAll(map, base) {
+  for (const [name, entry] of Object.entries(map)) {
+    const e = typeof entry === "string" ? { url: entry } : entry;
+    register(name, e.url ? { ...e, url: absolute(e.url, base) } : e);
+  }
+}
+function checkOrigin(name, url) {
+  const p = protocol();
+  const origin = new URL(url).origin;
+  const { allowedOrigins, trusted = [] } = p.settings();
+  const allowed = [...allowedOrigins ?? [pageOrigin(), ...p.origins()].filter(Boolean), ...trusted];
+  if (allowed.includes("*") || allowed.includes(origin) || url.startsWith("blob:")) return;
+  throw new RemoteError("ORIGIN_BLOCKED", name, `origem ${origin} n\xE3o est\xE1 em allowedOrigins`);
+}
+
+// src/core/loader.ts
+function loadRemote(name) {
+  return load(name).then((r) => r.module);
+}
+function loadModule(name) {
+  return import("./expose-JUOUN5N5.js").then((m) => m.resolveModule(name, (n) => loadFile(n))).catch(fail);
+}
+function preload(name) {
+  load(name).catch(() => {
+  });
+}
+var paths;
+function load(name, isolate, priority) {
+  const file = (n) => loadFile(n, isolate, priority);
+  return (protocol().entry(name) || !name.includes("/") ? file(name).then((r) => mountable(name, r)) : import("./expose-JUOUN5N5.js").then((m) => m.resolveTarget(name, file))).catch(fail);
+}
+function loadFile(name, isolate, priority) {
+  const p = protocol();
+  return p.load(name, async () => {
+    paths ??= import("./sri-JMX6JLQP.js").catch(() => null);
+    let resolved;
+    try {
+      await p.pending();
+      const override = await devOverride(name);
+      const entry = override ? { isolate: p.entry(name)?.isolate, ...override } : p.entry(name);
+      if (!entry) throw new RemoteError("NOT_REGISTERED", name, "remote n\xE3o registrado. Use configure({ remotes }).");
+      if (entry.module) return await loadLocal(name, entry);
+      let t = performance.now();
+      resolved = await resolveEntry(name, entry, priority);
+      metric(name, "manifest", t);
+      prefetchCss(resolved, (isolate ?? resolved.isolate ?? p.settings().isolate) === "shadow", priority);
+      t = performance.now();
+      const ns = await withRetry(p.settings().retries, () => importModule(name, resolved));
+      metric(name, "js", t);
+      return { ...resolved, module: ns?.default ?? ns, exports: ns };
+    } catch (e) {
+      throw report(isRemoteError(e) ? e : new RemoteError("LOAD_FAILED", name, String(e?.message ?? e), e), resolved);
+    }
+  });
+}
+function devOverride(name) {
+  try {
+    if (/vitral/.test(location.search + localStorage.getItem("vitral:overrides"))) return import("./overrides-NZAIUGK5.js").then((m) => m.overrideFor(name));
+  } catch {
+  }
+}
+async function loadLocal(name, entry) {
+  let ns = entry.module;
+  if (typeof ns === "function") ns = await ns();
+  return { module: ns?.default ?? ns, exports: ns, entry: typeof location !== "undefined" ? location.href : "http://localhost/", css: entry.css ?? [], isolate: entry.isolate };
+}
+async function resolveEntry(name, entry, priority) {
+  checkOrigin(name, entry.url);
+  const m = entry.manifest ?? (new URL(entry.url).pathname.endsWith(".json") ? await fetchJson(entry.url, protocol().settings().timeout, name, { cache: "no-cache", priority }) : { name, entry: entry.url });
+  if (typeof m?.entry !== "string") throw new RemoteError("INVALID_MODULE", name, `manifesto inv\xE1lido em ${entry.url}`);
+  if (m.contract && (entry.contract || protocol().settings().contract)) {
+    const why = await (await import("./contract-46EZFQPQ.js")).checkContract(m.contract, entry.contract);
+    if (why) throw new RemoteError("CONTRACT_MISMATCH", name, why);
+  }
+  const abs = (u) => absolute(u, entry.url);
+  const sri = {};
+  for (const file in m.files ?? {}) sri[abs(file)] = m.files[file];
+  const resolved = {
+    entry: abs(m.entry),
+    css: [...m.css ?? [], ...entry.css ?? []].map(abs),
+    shadow: m.shadow,
+    // A integridade declarada pelo host vence a do manifesto, e aí só o
+    // arquivo único (o que ela descreve) é usado.
+    integrity: entry.integrity ?? m.integrity,
+    isolate: entry.isolate,
+    scope: m.scope,
+    version: m.version,
+    sri,
+    priority,
+    split: m.split && !entry.integrity ? {
+      entry: abs(m.split.entry),
+      chunks: (m.split.chunks ?? []).map(abs),
+      sri,
+      priority,
+      dedupe: m.dedupe?.map((d) => ({ ...d, file: abs(d.file), chunks: d.chunks?.map(abs) }))
+    } : void 0
+  };
+  checkOrigin(name, resolved.entry);
+  for (const u of [resolved.split?.entry, ...(resolved.split?.dedupe ?? []).map((d) => d.file)]) if (u) checkOrigin(name, u);
+  if (name === entry.url && m.name) {
+    const override = await devOverride(m.name);
+    if (override) return { ...await resolveEntry(name, override), name: m.name };
+    resolved.name = m.name;
+    if (!protocol().entry(m.name)) protocol().register(m.name, entry);
+  }
+  return resolved;
+}
+async function importModule(name, r) {
+  const { timeout } = protocol().settings();
+  const run = (url) => withTimeout(timeout, name, import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    url
+  )).catch((e) => {
+    throw isRemoteError(e) ? e : new RemoteError("LOAD_FAILED", name, `falha ao importar ${r.entry}`, e);
+  });
+  if (!r.integrity) return run(r.entry);
+  const sri = await paths;
+  if (!sri) throw new RemoteError("LOAD_FAILED", name, "n\xE3o foi poss\xEDvel carregar o verificador de integrity");
+  return sri.importVerified(name, r, run, timeout);
+}
+function mountable(name, r) {
+  if (typeof r.module?.mount != "function") {
+    throw new RemoteError("INVALID_MODULE", name, "o m\xF3dulo n\xE3o exporta mount(). Use defineRemote(), ou loadModule() para m\xF3dulo sem UI.");
+  }
+  return r;
+}
+
+export {
+  configure,
+  register,
+  registerSrc,
+  loadRemote,
+  loadModule,
+  preload,
+  load,
+  loadFile,
+  resolveEntry,
+  mountable
+};

package/dist/chunk-ZAC6QQI6.js

@@ -0,0 +1,64 @@
+import {
+  addLink,
+  fetchBytes
+} from "./chunk-GNHCZRQP.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/css.ts
+var loadedCss = /* @__PURE__ */ new WeakMap();
+var cssText = /* @__PURE__ */ new Map();
+var noop = () => {
+};
+var adopts = () => typeof CSSStyleSheet !== "undefined" && "replaceSync" in CSSStyleSheet.prototype;
+function fetchCssText(href, integrity, priority) {
+  const key = `${href} ${integrity ?? ""}`;
+  let p = cssText.get(key);
+  if (!p) {
+    p = fetchBytes(href, protocol().settings().timeout, href, { integrity, priority }).then((b) => new TextDecoder().decode(b));
+    p.catch(() => cssText.delete(key));
+    cssText.set(key, p);
+  }
+  return p;
+}
+function prefetchCss(r, shadow, priority = "auto") {
+  if (shadow && adopts()) import("./shadow-6HELCHCJ.js").then((m) => m.prefetch(r, priority), noop);
+  else for (const href of r.css) if (!document.querySelector(`link[href="${href}"]`)) addLink("preload", href, { as: "style", integrity: r.sri?.[href] ?? "", fetchPriority: priority });
+}
+function injectStyles(r, root, el, styles) {
+  return root ? import("./shadow-6HELCHCJ.js").then((m) => m.attachStyles(root, el, r, protocol().settings().styles, styles)) : injectCss(r.css, null, r.sri).then(() => [noop]);
+}
+function injectCss(urls, root, sri = {}) {
+  const owner = root ?? document;
+  let seen = loadedCss.get(owner);
+  if (!seen) loadedCss.set(owner, seen = /* @__PURE__ */ new Map());
+  const parent = root ?? document.head;
+  const timeout = protocol().settings().timeout;
+  return Promise.all(
+    urls.map((href) => {
+      let p = seen.get(href);
+      if (!p) {
+        p = new Promise((resolve) => {
+          const link = addLink("stylesheet", href, { integrity: sri[href] ?? "" }, parent);
+          setTimeout(resolve, timeout);
+          link.onload = () => resolve();
+          link.onerror = () => {
+            link.remove();
+            seen.delete(href);
+            resolve();
+          };
+        });
+        seen.set(href, p);
+      }
+      return p;
+    })
+  );
+}
+
+export {
+  fetchCssText,
+  prefetchCss,
+  injectStyles,
+  injectCss
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+
+// src/cli/types.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+var PROPS = /export type Props =\s*([\s\S]*?)\s*$/;
+function parseProps(dts) {
+  return PROPS.exec(dts.replace(/^\s*\/\/.*$/gm, "").trim())?.[1]?.replace(/;$/, "") || null;
+}
+var HASH = /^\/\/ vitral:hash ("(?:[^"\\]|\\.)*") (\S+)$/gm;
+function envFile(props, hashes = {}) {
+  const lines = Object.entries(props).map(([name, type]) => `    ${JSON.stringify(name)}: ${type}`);
+  const marks = Object.entries(hashes).map(([name, hash]) => `// vitral:hash ${JSON.stringify(name)} ${hash}
+`);
+  return `// Gerado por \`npx vitral types\`. N\xE3o edite.
+${marks.join("")}import 'vitral'
+
+declare module 'vitral' {
+  interface Remotes {
+${lines.join("\n")}
+  }
+}
+`;
+}
+function readHashes(env) {
+  return Object.fromEntries([...env.matchAll(HASH)].map((m) => [JSON.parse(m[1]), m[2]]));
+}
+async function manifestHash(get, url) {
+  try {
+    const res = await get(url);
+    if (!res.ok) return void 0;
+    const { integrity } = await res.json();
+    return typeof integrity === "string" ? integrity : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function check(remotes, out, get, log) {
+  if (!existsSync(out)) {
+    log(`[vitral] ${out} n\xE3o existe. Rode \`npx vitral types\`.`);
+    return 1;
+  }
+  const recorded = readHashes(readFileSync(out, "utf8"));
+  let stale = 0;
+  for (const [name, url] of Object.entries(remotes)) {
+    const hash = await manifestHash(get, url);
+    if (!hash) log(`[vitral] ${name}: manifesto sem hash, n\xE3o deu para conferir.`);
+    else if (recorded[name] !== hash) {
+      log(`[vitral] ${name}: tipos desatualizados (${recorded[name] ? "o manifesto mudou" : "sem hash registrado"}).`);
+      stale++;
+    }
+  }
+  for (const name of Object.keys(recorded)) {
+    if (!(name in remotes)) {
+      log(`[vitral] ${name}: n\xE3o est\xE1 mais no remotes.json.`);
+      stale++;
+    }
+  }
+  log(stale ? `[vitral] ${stale} remote(s) com tipos desatualizados. Rode \`npx vitral types\`.` : `[vitral] tipos em dia com os manifestos.`);
+  return stale;
+}
+function readRemotes(cwd, args2, base) {
+  const pairs = args2.filter((a) => a.includes("="));
+  if (pairs.length) return Object.fromEntries(pairs.map((p) => [p.slice(0, p.indexOf("=")), p.slice(p.indexOf("=") + 1)]));
+  const file = [args2[0], "public/remotes.json", "remotes.json"].find((f) => f && existsSync(resolve(cwd, f)));
+  if (!file) throw new Error("[vitral] remotes.json n\xE3o encontrado. Passe o caminho ou pares nome=url.");
+  const map = JSON.parse(readFileSync(resolve(cwd, file), "utf8"));
+  return Object.fromEntries(
+    Object.entries(map).map(([name, v]) => {
+      const url = typeof v === "string" ? v : v.url;
+      return [name, base ? new URL(url, base).href : url];
+    })
+  );
+}
+async function types(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const get = options.fetch ?? fetch;
+  const log = options.log ?? console.log;
+  const remotes = readRemotes(cwd, options.args ?? [], options.base);
+  const out = resolve(cwd, options.out ?? "vitral-env.d.ts");
+  if (options.check) return check(remotes, out, get, log);
+  const props = {};
+  const hashes = {};
+  let falhas = 0;
+  for (const [name, url] of Object.entries(remotes)) {
+    let dts;
+    try {
+      const res = await get(new URL("vitral.d.ts", url).href);
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      dts = await res.text();
+    } catch (err) {
+      log(`[vitral] ${name}: sem tipos (${err.message}).`);
+      falhas++;
+      continue;
+    }
+    const type = parseProps(dts);
+    if (!type) {
+      log(`[vitral] ${name}: vitral.d.ts sem "export type Props".`);
+      continue;
+    }
+    props[name] = type;
+    const hash = await manifestHash(get, url);
+    if (hash) hashes[name] = hash;
+  }
+  writeFileSync(out, envFile(props, hashes));
+  log(`[vitral] ${Object.keys(props).length} remote(s) em ${out}`);
+  return falhas;
+}
+
+// src/cli.ts
+var AJUDA = `Uso: vitral types [remotes.json | nome=url ...] [--base url] [--out arquivo] [--check]
+
+  Baixa o vitral.d.ts de cada remote e gera vitral-env.d.ts.
+  --check  s\xF3 confere se o hash de cada manifesto ainda \xE9 o registrado;
+           sai com erro se algum mudou (\xFAtil no CI).`;
+function flag(args2, name) {
+  const i = args2.indexOf(name);
+  if (i < 0) return void 0;
+  const value = args2[i + 1];
+  args2.splice(i, 2);
+  return value;
+}
+var [command, ...args] = process.argv.slice(2);
+if (command === "types") {
+  const base = flag(args, "--base");
+  const out = flag(args, "--out");
+  const check2 = args.includes("--check");
+  types({ args: args.filter((a) => a !== "--check"), base, out, check: check2 }).then(
+    (falhas) => process.exitCode = falhas ? 1 : 0,
+    (err) => {
+      console.error(err.message);
+      process.exitCode = 1;
+    }
+  );
+} else {
+  console.log(AJUDA);
+  process.exitCode = command && command !== "--help" ? 1 : 0;
+}

package/dist/contract-46EZFQPQ.js

@@ -0,0 +1,17 @@
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/contract.ts
+async function checkContract(c, range = protocol().settings().contract) {
+  const { satisfies } = await import("./dedupe-S7BHQMOZ.js");
+  if (c.version && !satisfies(c.version, range)) return `o host aceita contrato ${range}, o remote publica ${c.version}`;
+  const offered = protocol().settings().offered ?? {};
+  for (const dep in c.peers) {
+    const have = offered[dep];
+    if (have && !satisfies(have, c.peers[dep])) return `o remote espera ${dep} ${c.peers[dep]}, o host oferece ${have}`;
+  }
+}
+export {
+  checkContract
+};