vitral 0.7.2 → 0.8.0

package/README.md

@@ -186,6 +186,8 @@ Exemplo completo, com Dockerfiles e configuração do nginx: [`examples/docker`]
 
 No Next e no Nuxt o componente renderiza o `fallback` no servidor e monta o remote no cliente.
 
+Uma zona do Multi-Zones vira remote sem reescrever o código Next (`vitral({ next: true })`), e o app Next principal vira host com `withVitral` e `<NextRemote>`, trocando de área sem recarregar. Veja [Next.js](https://joaogabriel15.github.io/vitral/frameworks/next).
+
 ### Host em Vue
 
 ```vue

package/dist/angular.d.ts

@@ -1,6 +1,6 @@
 import { InjectionToken, Type, ApplicationConfig, Signal, Provider, EnvironmentProviders } from '@angular/core';
-import { R as RemoteContext, P as Props, a as RemoteModule, S as Shared, V as VitralConfig } from './types-EOz1rOHs.js';
-export { e as events } from './events-DLdbFqBM.js';
+import { R as RemoteContext, P as Props, a as RemoteModule, S as Shared, V as VitralConfig } from './types-wsKR1gfx.js';
+export { e as events } from './events-Cieg_far.js';
 export { n as navigate } from './navigate-BRG1WJUM.js';
 import './errors-kjBv6IH_.js';
 

package/dist/angular.js

@@ -1,18 +1,20 @@
 import {
   defineVitralElement
-} from "./chunk-V24ZNHUF.js";
-import "./chunk-TXSHK3SK.js";
+} from "./chunk-ZRAGLT3I.js";
+import "./chunk-ZJ4IM2PZ.js";
 import {
   defineRemote,
-  events,
   memoSelect,
-  navigate,
   same,
   shared
-} from "./chunk-O7DV3EVB.js";
+} from "./chunk-NTXMEZIZ.js";
+import {
+  events,
+  navigate
+} from "./chunk-EQZOJU3B.js";
 import {
   configure
-} from "./chunk-72H4FXMD.js";
+} from "./chunk-6T25WKNK.js";
 import "./chunk-KU6HF2EW.js";
 import "./chunk-TW7KYJQ6.js";
 import "./chunk-463H6B56.js";

package/dist/auto.js

@@ -1,9 +1,10 @@
 import {
   defineVitralElement
-} from "./chunk-V24ZNHUF.js";
-import "./chunk-TXSHK3SK.js";
-import "./chunk-O7DV3EVB.js";
-import "./chunk-72H4FXMD.js";
+} from "./chunk-ZRAGLT3I.js";
+import "./chunk-ZJ4IM2PZ.js";
+import "./chunk-NTXMEZIZ.js";
+import "./chunk-EQZOJU3B.js";
+import "./chunk-6T25WKNK.js";
 import "./chunk-KU6HF2EW.js";
 import "./chunk-TW7KYJQ6.js";
 import "./chunk-463H6B56.js";

package/dist/chunk-4IWZIFAL.js

@@ -0,0 +1,165 @@
+import {
+  RemoteTree,
+  VitralContext
+} from "./chunk-B2MPYF4M.js";
+import {
+  hostSlot
+} from "./chunk-ZJ4IM2PZ.js";
+import {
+  defineRemote,
+  memoSelect,
+  same,
+  shared
+} from "./chunk-NTXMEZIZ.js";
+import {
+  events
+} from "./chunk-EQZOJU3B.js";
+import {
+  preload
+} from "./chunk-6T25WKNK.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/react.tsx
+import {
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  useSyncExternalStore
+} from "react";
+import { createRoot, hydrateRoot } from "react-dom/client";
+import * as ReactAll from "react";
+import * as ReactDOM from "react-dom";
+import * as ReactDOMClient from "react-dom/client";
+import * as JSXRuntime from "react/jsx-runtime";
+import * as JSXDevRuntime from "react/jsx-dev-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
+function reactRemote(Component) {
+  const start = (el, props, ctx, hydrate) => {
+    const tree = (p) => /* @__PURE__ */ jsx(RemoteTree, { Component, props: p, ctx });
+    const options = { onUncaughtError: (e) => ctx.reportError(e) };
+    const root = hydrate ? hydrateRoot(el, tree(props), options) : createRoot(el, options);
+    const render = (p) => root.render(tree(p));
+    if (!hydrate) render(props);
+    return { update: render, unmount: () => root.unmount() };
+  };
+  return defineRemote({
+    mount: (el, props, ctx) => start(el, props, ctx, false),
+    hydrate: (el, props, ctx) => start(el, props, ctx, true)
+  });
+}
+function useVitral() {
+  return useContext(VitralContext);
+}
+function usePortalContainer() {
+  return useVitral()?.portalContainer;
+}
+function useEvent(type, handler) {
+  const ref = useRef(handler);
+  ref.current = handler;
+  useEffect(() => events.on(type, (p) => ref.current(p)), [type]);
+}
+function useEventValue(type) {
+  const [value, setValue] = useState(() => events.last(type));
+  useEvent(type, setValue);
+  return value;
+}
+function useShared(key, select = same) {
+  const handle = useMemo(() => shared(key), [key]);
+  const [pick] = useState(memoSelect);
+  return useSyncExternalStore(
+    handle.subscribe,
+    () => pick(handle.get(), select),
+    () => pick(void 0, select)
+  );
+}
+var offeredTo;
+function offerReact() {
+  const p = protocol();
+  if (offeredTo === p) return;
+  offeredTo = p;
+  const compiler = ReactAll.__COMPILER_RUNTIME;
+  const modules = {
+    react: ReactAll,
+    "react-dom": ReactDOM,
+    "react-dom/client": ReactDOMClient,
+    "react/jsx-runtime": JSXRuntime,
+    "react/jsx-dev-runtime": JSXDevRuntime,
+    // O React 19 expõe o react/compiler-runtime pelo próprio react.
+    ...compiler && { "react/compiler-runtime": compiler }
+  };
+  p.pending(import("./dedupe-PZCSKL3L.js").then((m) => m.offer(p, { react: { version: ReactAll.version, modules } })).catch(() => {
+  }));
+}
+function preload2(name, options) {
+  offerReact();
+  preload(name, options);
+}
+function Remote({
+  name,
+  src,
+  props,
+  isolate,
+  fallback = null,
+  error,
+  onError,
+  className,
+  loading,
+  prefetch,
+  priority,
+  keepAlive
+}) {
+  const target = useRef(null);
+  const slot = useRef(null);
+  const [state, setState] = useState({ status: "loading", error: null });
+  const onErrorRef = useRef(onError);
+  onErrorRef.current = onError;
+  useEffect(() => {
+    offerReact();
+    const s = hostSlot(target.current, {
+      name,
+      src,
+      props: props ?? {},
+      isolate,
+      loading,
+      prefetch,
+      priority,
+      keepAlive,
+      onStatus(status2, e) {
+        setState({ status: status2, error: e });
+        if (e) {
+          if (onErrorRef.current) onErrorRef.current(e);
+          else console.error(e);
+        }
+      }
+    });
+    slot.current = s;
+    return () => {
+      slot.current = null;
+      queueMicrotask(() => s.destroy());
+    };
+  }, []);
+  useEffect(() => slot.current?.set({ name, src, isolate }), [name, src, isolate]);
+  useEffect(() => slot.current?.update(props ?? {}), [props]);
+  const retry = () => slot.current?.retry();
+  const { status, error: err } = state;
+  return /* @__PURE__ */ jsxs("div", { className, "data-vitral": name ?? src, "data-vitral-status": status, children: [
+    status === "loading" && fallback,
+    status === "error" && err && (typeof error === "function" ? error(err, retry) : error ?? null),
+    /* @__PURE__ */ jsx("div", { ref: target })
+  ] });
+}
+
+export {
+  reactRemote,
+  useVitral,
+  usePortalContainer,
+  useEvent,
+  useEventValue,
+  useShared,
+  preload2 as preload,
+  Remote
+};

package/dist/chunk-6AFVJCQG.js

@@ -0,0 +1,311 @@
+// src/vite/dedupe.ts
+import { existsSync, readFileSync, realpathSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { pathToFileURL } from "url";
+
+// src/vite/exports.ts
+var nameOf = (n) => n.type === "Identifier" ? n.name : String(n.value);
+function bindings(node, out = []) {
+  if (!node) return out;
+  if (node.type === "Identifier") out.push(node.name);
+  else if (node.type === "ObjectPattern") for (const p of node.properties) bindings(p.type === "RestElement" ? p.argument : p.value, out);
+  else if (node.type === "ArrayPattern") for (const e of node.elements) bindings(e?.type === "RestElement" ? e.argument : e, out);
+  else if (node.type === "AssignmentPattern") bindings(node.left, out);
+  else if (node.type === "RestElement") bindings(node.argument, out);
+  return out;
+}
+async function exportOrigins(ctx, file, cache) {
+  const parsed = /* @__PURE__ */ new Map();
+  const queue = [file];
+  while (queue.length) {
+    const f = queue.shift();
+    if (parsed.has(f)) continue;
+    let p = cache.get(f);
+    if (!p) cache.set(f, p = read(ctx, f));
+    const done = await p;
+    parsed.set(f, done);
+    queue.push(...done.star, ...done.named.flatMap((n) => n.source ? [n.source] : []));
+  }
+  return origins(file, parsed, /* @__PURE__ */ new Map(), []);
+}
+function origins(file, parsed, memo, stack) {
+  if (stack.includes(file)) return /* @__PURE__ */ new Map();
+  const known = memo.get(file);
+  if (known) return known;
+  const p = parsed.get(file);
+  const next = [...stack, file];
+  const out = new Map(p.local);
+  for (const n of p.named) out.set(n.exported, n.source && origins(n.source, parsed, memo, next).get(n.name) || n.fallback);
+  for (const s of p.star) for (const [name, origin] of origins(s, parsed, memo, next)) if (name !== "default" && !out.has(name)) out.set(name, origin);
+  memo.set(file, out);
+  return out;
+}
+async function read(ctx, file) {
+  const out = { local: /* @__PURE__ */ new Map(), named: [], star: [] };
+  const info = await ctx.load({ id: file });
+  if (!info.code) return out;
+  const body = ctx.parse(info.code).body ?? [];
+  const target = async (source) => {
+    const r = await ctx.resolve(source, file, { skipSelf: false });
+    return r && !r.external ? r.id : void 0;
+  };
+  const imports = /* @__PURE__ */ new Map();
+  for (const n of body)
+    if (n.type === "ImportDeclaration") {
+      for (const s of n.specifiers)
+        if (s.type !== "ImportNamespaceSpecifier")
+          imports.set(s.local.name, { source: n.source.value, name: s.type === "ImportDefaultSpecifier" ? "default" : nameOf(s.imported) });
+    }
+  const fixed = /* @__PURE__ */ new Set();
+  for (const n of body) {
+    const d = n.type === "ExportNamedDeclaration" ? n.declaration : n;
+    if (d?.type === "FunctionDeclaration" || d?.type === "ClassDeclaration") d.id && fixed.add(d.id.name);
+    else if (d?.type === "VariableDeclaration" && d.kind === "const") for (const x of d.declarations) for (const name of bindings(x.id)) fixed.add(name);
+  }
+  for (const n of body) {
+    if (n.type === "ExportDefaultDeclaration") {
+      const id = n.declaration.type === "Identifier" ? n.declaration.name : void 0;
+      const via = id ? imports.get(id) : void 0;
+      if (via) out.named.push({ exported: "default", name: via.name, source: await target(via.source), fallback: `${file}#default` });
+      else out.local.set("default", id && fixed.has(id) ? `${file}#${id}` : `${file}#default`);
+    } else if (n.type === "ExportAllDeclaration") {
+      if (n.exported) out.local.set(nameOf(n.exported), `${file}#${nameOf(n.exported)}`);
+      else {
+        const t = await target(n.source.value);
+        if (t) out.star.push(t);
+      }
+    } else if (n.type === "ExportNamedDeclaration") {
+      if (n.exportKind === "type") continue;
+      if (n.declaration) {
+        const d = n.declaration;
+        const names = d.type === "VariableDeclaration" ? d.declarations.flatMap((x) => bindings(x.id)) : d.id ? [d.id.name] : [];
+        for (const name of names) out.local.set(name, `${file}#${name}`);
+      }
+      for (const s of n.specifiers ?? []) {
+        if (s.exportKind === "type") continue;
+        const exported = nameOf(s.exported);
+        const local = nameOf(s.local);
+        const via = n.source ? { source: n.source.value, name: local } : imports.get(local);
+        const fallback = `${file}#${n.source ? exported : local}`;
+        out.named.push({ exported, name: via?.name ?? local, source: via ? await target(via.source) : void 0, fallback });
+      }
+    }
+  }
+  return out;
+}
+
+// src/vite/dedupe.ts
+var REACT = ["react", "react-dom", "react-dom/client", "react/jsx-runtime", "react/jsx-dev-runtime", "react/compiler-runtime"];
+var BOOT = "virtual:vitral-boot";
+var DEPS = "\0vitral-deps";
+var OWN = "\0vitral-own:";
+var SHIM = "\0vitral-shim:";
+var DEEP = "\0vitral-deep:";
+var pkgOf = (spec) => spec.split("/").slice(0, spec.startsWith("@") ? 2 : 1).join("/");
+var norm = (p) => p.replace(/\\/g, "/");
+var groupOf = (spec) => REACT.includes(spec) || pkgOf(spec) === "scheduler" ? "react" : pkgOf(spec);
+var ident = /^[A-Za-z_$][\w$]*$/;
+function packageOf(file, pkg) {
+  for (let dir = dirname(file); dir !== dirname(dir); dir = dirname(dir)) {
+    const json = join(dir, "package.json");
+    if (!existsSync(json)) continue;
+    const data = JSON.parse(readFileSync(json, "utf8"));
+    if (data.name === pkg) return { dir, data };
+  }
+  throw new Error(`vitral: vers\xE3o de ${pkg} n\xE3o encontrada`);
+}
+function subpaths(pkg, data) {
+  const exp = data.exports;
+  if (!exp || typeof exp !== "object" || Array.isArray(exp) || !Object.keys(exp).some((k) => k.startsWith("."))) return [pkg];
+  const target = (v) => typeof v === "string" ? v : v && typeof v === "object" ? target(v.import ?? v.default ?? v.require ?? Object.values(v)[0]) : "";
+  return Object.keys(exp).filter((k) => !k.includes("*") && !/\.(json|css|scss)$/.test(target(exp[k]))).map((k) => k === "." ? pkg : pkg + k.slice(1));
+}
+async function groups(list, root, entry, resolveId) {
+  const importer = resolve(root, entry);
+  const byName = /* @__PURE__ */ new Map();
+  const all = /* @__PURE__ */ new Set();
+  for (const spec of list) {
+    const g = groupOf(spec);
+    if (spec.endsWith("/*")) all.add(g);
+    byName.set(g, [.../* @__PURE__ */ new Set([...byName.get(g) ?? [], ...g === "react" ? REACT : [spec.endsWith("/*") ? g : spec]])]);
+  }
+  const out = [];
+  for (const [name, list2] of byName) {
+    const group = { name, range: "", version: "", keys: [], names: {}, pkgs: name === "react" ? ["react", "react-dom", "scheduler"] : [name] };
+    let specs = list2;
+    for (let i = 0; i < specs.length; i++) {
+      const spec = specs[i];
+      const found = await resolveId(spec, importer);
+      if (!found) {
+        if (spec === name) throw new Error(`vitral: dedupe: ${spec} n\xE3o est\xE1 instalado`);
+        continue;
+      }
+      if (spec === name) {
+        const pkg = packageOf(found.id, name);
+        group.version = pkg.data.version;
+        group.dir = norm(realpathSync(pkg.dir));
+        if (all.has(name)) {
+          group.files = true;
+          specs = [.../* @__PURE__ */ new Set([...specs, ...subpaths(name, pkg.data)])];
+        }
+      }
+      try {
+        const mod = await import(pathToFileURL(found.id.split("?")[0]).href);
+        const extra = mod.default && typeof mod.default === "object" ? Object.keys(mod.default) : [];
+        group.names[spec] = [.../* @__PURE__ */ new Set([...Object.keys(mod), ...extra])].filter((n) => n !== "default" && ident.test(n));
+      } catch {
+      }
+      group.keys.push(spec);
+    }
+    group.range = name === "svelte" || name.startsWith("@angular/") ? group.version : `^${group.version}`;
+    out.push(group);
+  }
+  return out;
+}
+var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\0/g, "\\x00");
+function dedupeIds(list) {
+  const specs = new Set(list.flatMap((s) => groupOf(s) === "react" ? REACT : [s.replace(/\/\*$/, "")]));
+  return new RegExp(`${escape(BOOT)}$|^(${[DEPS, ...specs].map(escape).join("|")})$|^(${escape(OWN)}|${escape(SHIM)}|${escape(DEEP)})`);
+}
+function dedupeHooks(entry, getGroups) {
+  const keyOf = (id) => getGroups().find((g) => g.keys.includes(id));
+  const inside = (g, file) => {
+    const f = norm(file);
+    return g.pkgs.some((p) => f.includes(`/node_modules/${p}/`)) || !!g.dir && f.startsWith(g.dir + "/");
+  };
+  let entries;
+  let origins2 = /* @__PURE__ */ new Map();
+  const exports = /* @__PURE__ */ new Map();
+  const entryFiles = (ctx) => entries ??= (async () => {
+    const map = /* @__PURE__ */ new Map();
+    for (const g of getGroups())
+      if (g.files)
+        for (const k of g.keys) {
+          const r = await ctx.resolve(k, void 0, { skipSelf: true });
+          if (r && !r.external) map.set(r.id, k);
+        }
+    return map;
+  })();
+  const originsOf = (ctx, g) => {
+    if (!origins2.has(g.name))
+      origins2.set(g.name, (async () => {
+        const files = await entryFiles(ctx);
+        const index = /* @__PURE__ */ new Map();
+        for (const [file, spec] of files) {
+          if (!g.keys.includes(spec)) continue;
+          for (const [name, origin] of await exportOrigins(ctx, file, exports)) if (!index.has(origin)) index.set(origin, { spec, name });
+        }
+        return index;
+      })());
+    return origins2.get(g.name);
+  };
+  return {
+    /** Nova build: esquece o que foi lido da anterior. */
+    reset() {
+      entries = void 0;
+      origins2 = /* @__PURE__ */ new Map();
+      exports.clear();
+    },
+    /** Algum grupo troca também os imports que chegam a arquivos do pacote? */
+    files: () => getGroups().some((g) => g.files),
+    resolveId: {
+      order: "pre",
+      handler(id, importer) {
+        if (id.endsWith(BOOT)) return `\0${BOOT}`;
+        if (id === DEPS || id.startsWith(OWN) || id.startsWith(SHIM) || id.startsWith(DEEP)) return id;
+        const g = keyOf(id);
+        if (!g || !importer || importer.startsWith(OWN)) return null;
+        if (inside(g, importer)) return null;
+        return SHIM + id;
+      }
+    },
+    /**
+     * Um import já resolvido que chega a um arquivo de um grupo com `files`
+     * (por alias, `paths` do tsconfig ou caminho direto): vira o shim do
+     * especificador daquele arquivo, ou de um arquivo interno que o pacote reexporta.
+     */
+    async resolved(ctx, file, importer) {
+      if (!importer || importer.startsWith("\0")) return null;
+      const g = getGroups().find((x) => x.files && inside(x, file));
+      if (!g || inside(g, importer)) return null;
+      const spec = (await entryFiles(ctx)).get(file);
+      return spec ? SHIM + spec : DEEP + file;
+    },
+    async load(ctx, id) {
+      if (id === `\0${BOOT}`) return boot(entry(), getGroups());
+      if (id === DEPS) return "export const deps = {}";
+      if (id.startsWith(OWN)) {
+        const g = getGroups().find((x) => x.name === id.slice(OWN.length));
+        return g.keys.map((k, i) => `import * as m${i} from ${JSON.stringify(k)}`).join("\n") + `
+export default {${g.keys.map((k, i) => `${JSON.stringify(k)}: m${i}`).join(", ")}}
+`;
+      }
+      if (id.startsWith(SHIM)) {
+        const spec = id.slice(SHIM.length);
+        const g = keyOf(spec);
+        let names = g.names[spec];
+        if (!names) {
+          const file = [...await entryFiles(ctx)].find(([, k]) => k === spec)?.[0];
+          names = file ? [...(await exportOrigins(ctx, file, exports)).keys()].filter((n) => n !== "default" && ident.test(n)) : [];
+        }
+        return `import { deps } from ${JSON.stringify(DEPS)}
+const m = deps[${JSON.stringify(spec)}]
+export default m.default ?? m
+` + (names.length ? `export const { ${names.join(", ")} } = m
+` : "");
+      }
+      if (id.startsWith(DEEP)) {
+        const file = id.slice(DEEP.length);
+        const g = getGroups().find((x) => x.files && inside(x, file));
+        const index = await originsOf(ctx, g);
+        const own = await exportOrigins(ctx, file, exports);
+        const via = [...own].map(([name, origin]) => [name, index.get(origin)]);
+        const f = JSON.stringify(file);
+        const shared = via.filter(([, v]) => v);
+        const rest = via.filter(([, v]) => !v).map(([name]) => name);
+        if (!shared.length) {
+          ctx.warn?.(`dedupe: ${file.slice(g.dir.length + 1)} n\xE3o sai por nenhum export de ${g.name}: o remote leva uma c\xF3pia pr\xF3pria deste arquivo`);
+          return `export * from ${f}
+` + (own.has("default") ? `export { default } from ${f}
+` : "");
+        }
+        if (rest.length)
+          ctx.warn?.(`dedupe: ${file.slice(g.dir.length + 1)}: ${rest.join(", ")} n\xE3o sai(em) por nenhum export de ${g.name}: esses nomes v\xEAm de uma c\xF3pia pr\xF3pria deste arquivo`);
+        return `import { deps } from ${JSON.stringify(DEPS)}
+` + shared.map(([name, v], i) => `const v${i} = deps[${JSON.stringify(v.spec)}][${JSON.stringify(v.name)}]
+` + (name === "default" ? `export default v${i}
+` : `export { v${i} as ${JSON.stringify(name)} }
+`)).join("") + (rest.length ? `export { ${rest.map((n) => n === "default" ? "default" : JSON.stringify(n)).join(", ")} } from ${f}
+` : "");
+      }
+      return null;
+    }
+  };
+}
+function boot(entry, groups2) {
+  const calls = groups2.map(
+    (g) => `need(${JSON.stringify(g.name)}, ${JSON.stringify(g.range)}, ${JSON.stringify(g.version)}, ${JSON.stringify(g.keys)}, () => import(${JSON.stringify(OWN + g.name)}).then((m) => m.default))`
+  );
+  return `const { deps } = await import(${JSON.stringify(DEPS)})
+const p = globalThis[Symbol.for("vitral")]
+const shared = !!(p && p.dedupe) && /\\/split\\/[^/]*$/.test(import.meta.url)
+async function need(name, range, version, keys, load) {
+  let m = shared && (await p.dedupe(name, range, { version, load }))
+  const missing = m ? keys.filter((k) => !(k in m)) : []
+  if (missing.length) console.warn("[vitral] dedupe: a oferta de " + name + " n\xE3o tem " + missing.join(", ") + "; o remote usa a c\xF3pia pr\xF3pria inteira")
+  if (!m || missing.length) m = await load()
+  Object.assign(deps, m)
+}
+await Promise.all([${calls.join(", ")}])
+const remote = await import(${JSON.stringify(entry)})
+export default remote.default
+`;
+}
+
+export {
+  BOOT,
+  subpaths,
+  groups,
+  dedupeIds,
+  dedupeHooks
+};

package/dist/{chunk-72H4FXMD.js → chunk-6T25WKNK.js}

@@ -26,7 +26,7 @@ function configure(config) {
   const { remotes, dedupe, ...rest } = config;
   p.configure(rest);
   if (rest.captureGlobalErrors) import("./capture-TT5WBLJ6.js").then((m) => m.capture());
-  if (dedupe) p.pending(import("./dedupe-S7BHQMOZ.js").then((m) => m.offer(p, dedupe)).catch(() => {
+  if (dedupe) p.pending(import("./dedupe-PZCSKL3L.js").then((m) => m.offer(p, dedupe)).catch(() => {
   }));
   if (typeof remotes === "string") {
     const url = absolute(remotes);
@@ -79,27 +79,48 @@ function loadRemote(name) {
   return load(name).then((r) => r.module);
 }
 function loadModule(name) {
-  return import("./expose-ZLYQZUP2.js").then((m) => m.resolveModule(name, (n) => loadFile(n))).catch(fail);
+  return import("./expose-V5ASGX4E.js").then((m) => m.resolveModule(name, (n) => loadFile(n))).catch(fail);
 }
-function preload(name) {
-  load(name).catch(() => {
+function preload(name, options = {}) {
+  const done = load(name);
+  done.catch(() => {
   });
+  if (options.routes) done.then(warmRoutes, () => {
+  });
+}
+function routeChunks(r) {
+  const s = r.split;
+  if (!s) return [];
+  if (s.lazy) return s.lazy;
+  const dir = s.entry.slice(0, s.entry.lastIndexOf("/") + 1);
+  const loaded = /* @__PURE__ */ new Set([s.entry, ...s.chunks, ...s.probe ?? [], ...(s.dedupe ?? []).flatMap((d) => [d.file, ...d.chunks ?? []])]);
+  return Object.keys(r.sri ?? {}).filter((u) => u.startsWith(dir) && u.endsWith(".js") && !loaded.has(u));
+}
+function warmRoutes(r) {
+  const c = navigator.connection;
+  if (c?.saveData || /2g/.test(c?.effectiveType)) return;
+  const queue = routeChunks(r).slice();
+  const next = () => queue.length && fetch(queue.shift(), { priority: "low" }).then((res) => res.arrayBuffer()).catch(() => {
+  }).then(next);
+  const run = () => [0, 0, 0].map(next);
+  if (typeof requestIdleCallback === "function") requestIdleCallback(run, { timeout: 1e4 });
+  else setTimeout(run, 1);
 }
 var paths;
 function warm() {
   if (paths) return;
-  paths = import("./sri-576GTDIA.js").catch(() => null);
-  import("./dedupe-S7BHQMOZ.js").catch(() => {
+  paths = import("./sri-TBZ6PYYY.js").catch(() => null);
+  import("./dedupe-PZCSKL3L.js").catch(() => {
   });
 }
 function warmSsr(holder) {
-  paths ??= import("./sri-576GTDIA.js").catch(() => null);
-  if (holder.querySelector("script[data-vitral-manifest]")?.textContent?.includes('"dedupe"')) import("./dedupe-S7BHQMOZ.js").catch(() => {
+  paths ??= import("./sri-TBZ6PYYY.js").catch(() => null);
+  if (holder.querySelector("script[data-vitral-manifest]")?.textContent?.includes('"dedupe"')) import("./dedupe-PZCSKL3L.js").catch(() => {
   });
 }
 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-ZLYQZUP2.js").then((m) => m.resolveTarget(name, file))).catch(fail);
+  return (protocol().entry(name) || !name.includes("/") ? file(name).then((r) => mountable(name, r)) : import("./expose-V5ASGX4E.js").then((m) => m.resolveTarget(name, file))).catch(fail);
 }
 function loadFile(name, isolate, priority) {
   const p = protocol();
@@ -143,7 +164,7 @@ async function resolveEntry(name, entry, priority) {
   if (m?.stable) return resolveEntry(name, await (await import("./channel-2YPYGX3J.js")).pick(name, entry, m), priority);
   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);
+    const why = await (await import("./contract-OMHCH6LI.js")).checkContract(m.contract, entry.contract);
     if (why) throw new RemoteError("CONTRACT_MISMATCH", name, why);
   }
   const abs = (u) => absolute(u, entry.url);
@@ -155,17 +176,19 @@ async function resolveEntry(name, entry, priority) {
     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,
+    integrity: entry.integrity === false ? void 0 : entry.integrity ?? m.integrity,
     isolate: entry.isolate,
     scope: m.scope,
     version: m.version,
     sri,
     priority,
-    split: m.split && !entry.integrity ? {
+    split: m.split && typeof entry.integrity !== "string" ? {
       entry: abs(m.split.entry),
       chunks: (m.split.chunks ?? []).map(abs),
+      ...m.split.lazy && { lazy: m.split.lazy.map(abs) },
       sri,
       priority,
+      ...m.probe && { probe: m.probe.map(abs) },
       dedupe: m.dedupe?.map((d) => ({ ...d, file: abs(d.file), chunks: d.chunks?.map(abs) }))
     } : void 0
   };
@@ -193,7 +216,15 @@ async function importModule(name, r) {
   )).catch((e) => {
     throw isRemoteError(e) ? e : new RemoteError("LOAD_FAILED", name, `falha ao importar ${r.entry}`, e);
   });
-  if (!r.integrity) return run(r.entry);
+  if (!r.integrity) {
+    if (!r.split) return run(r.entry);
+    if (r.split.dedupe?.length) {
+      const { shared } = await import("./dedupe-PZCSKL3L.js");
+      for (const d of r.split.dedupe)
+        shared(protocol())(d.name, d.range, { version: d.version, url: d.file, load: async () => (await run(d.file)).default });
+    }
+    return run(r.split.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);