vue-ssr-lite 0.2.2 → 0.2.4

package/dist/chunks/SsrServerRuntime-CkEnx8IY.mjs

@@ -0,0 +1,703 @@
+import { createServer as ae } from "node:http";
+import { stat as J, readFile as q } from "node:fs/promises";
+import { resolve as z, sep as K, extname as ee } from "node:path";
+import { o as ie, k as W, s as ce, q as le, g as de, p as ue, i as he, e as me } from "./SsrHtmlRuntime-BiQCklqA.mjs";
+import { c as fe, h as pe, r as ge } from "./SsrApplicationRuntime-D4arUtsy.mjs";
+import { renderToString as ye } from "@vue/server-renderer";
+import { c as we } from "./SsrDiagnosticsRuntime-B5VbSgsA.mjs";
+import { a as te } from "./SsrSerialization-k-3aCFYt.mjs";
+const U = () => globalThis.performance?.now?.() ?? Date.now(), V = (e) => new TextEncoder().encode(e).byteLength, X = (e, r, o, n) => {
+  for (const l of n) {
+    const d = { requestId: r, applicationId: o, code: l.code };
+    e?.warn ? e.warn(`ssr.diagnostic.${l.code}`, d) : console.warn(`[vue-ssr-lite] ${l.message}`, d);
+  }
+}, ve = async (e, r, o = {}) => {
+  const n = U(), l = Math.max(1, Math.floor(o.maxResolutionPasses ?? 4)), d = o.resolutionDeadlineMs ?? 0, v = o.diagnostics ?? process.env.NODE_ENV !== "production", b = pe(!0);
+  let D = n, p = n, m = n, w, t, s = "", f = "", a = 0, S;
+  const A = async () => {
+    if (!t) return;
+    const g = t;
+    t = void 0;
+    try {
+      await e.cleanup?.(g.context);
+    } catch (i) {
+      console.error("[vue-ssr-lite] application cleanup failed", i);
+    }
+    try {
+      g.hydration.dispose();
+    } catch (i) {
+      console.error("[vue-ssr-lite] hydration cleanup failed", i);
+    }
+  };
+  try {
+    let g = !1;
+    for (let y = 0; y < l && !g; y += 1) {
+      if (a = y + 1, b.beginPass(y), t = await fe(e, {
+        server: !0,
+        request: r,
+        resumeState: y === 0 ? void 0 : w,
+        resolution: b
+      }), y === 0 && (D = U()), t.router) {
+        const H = new URL(r.url);
+        await t.router.push(`${H.pathname}${H.search}${H.hash}`), await t.router.isReady(), t.router.currentRoute.value.matched.length === 0 && (t.context.response.statusCode = 404);
+      }
+      y === 0 && (p = U());
+      const I = {};
+      s = await ye(t.app, I), f = I.teleports?.body ?? "", m = U();
+      const P = b.pendingWork(), u = b.additionalPassRequested(), L = y === l - 1;
+      if (P.length === 0 && !u || L) {
+        g = !0, L && (P.length > 0 || u) && X(o.logger, r.requestId, e.id, [
+          {
+            code: "resolution-pass-limit",
+            message: `Resolution did not settle within ${l} render passes; serializing the last render.`
+          }
+        ]);
+        break;
+      }
+      await b.drain(d, r.signal), w = t.hydration.collect(), await A();
+    }
+    if (!t) throw new Error("SSR render produced no application instance.");
+    const i = await e.resolveHead?.(t.context) ?? t.context.head.value;
+    v && X(
+      o.logger,
+      r.requestId,
+      e.id,
+      we({
+        html: s,
+        route: t.router?.currentRoute.value ?? null,
+        requestUrl: r.url,
+        applicationId: e.id
+      })
+    );
+    const c = {
+      version: 1,
+      applicationId: e.id,
+      publicConfig: r.publicConfig,
+      domain: r.domain,
+      application: t.context.state,
+      plugins: t.hydration.collect()
+    }, C = V(te(c)), k = U();
+    return {
+      html: s,
+      teleports: f,
+      head: i,
+      response: t.context.response,
+      hydrationState: c,
+      metrics: {
+        requestId: r.requestId,
+        applicationId: e.id,
+        contextDurationMs: D - n,
+        routeDurationMs: p - D,
+        renderDurationMs: m - p,
+        totalDurationMs: k - n,
+        htmlBytes: V(s),
+        stateBytes: C,
+        renderPasses: a
+      }
+    };
+  } catch (g) {
+    throw S = g, g;
+  } finally {
+    let g;
+    if (t) {
+      try {
+        await e.cleanup?.(t.context);
+      } catch (i) {
+        g = i, console.error("[vue-ssr-lite] application cleanup failed", i);
+      }
+      try {
+        t.hydration.dispose();
+      } catch (i) {
+        console.error("[vue-ssr-lite] hydration cleanup failed", i), g || (g = i);
+      }
+    }
+    if (b.dispose(), !S && g) throw g;
+  }
+}, Se = {
+  ".css": "text/css; charset=utf-8",
+  ".gif": "image/gif",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".xml": "application/xml; charset=utf-8"
+}, be = async (e, r, o) => {
+  try {
+    const n = decodeURIComponent(r).replace(/^\/+/, "");
+    if (!n || o.includes(n)) return null;
+    const l = z(e, n), d = e.endsWith(K) ? e : `${e}${K}`;
+    return !l.startsWith(d) || !(await J(l)).isFile() ? null : {
+      statusCode: 200,
+      body: await q(l),
+      headers: {
+        "content-type": Se[ee(l)] || "application/octet-stream",
+        "cache-control": r.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "public, max-age=3600"
+      }
+    };
+  } catch {
+    return null;
+  }
+}, xe = (e) => typeof e == "string" ? new TextEncoder().encode(e).byteLength : e?.byteLength ?? 0, Q = (e) => ({
+  statusCode: e.statusCode,
+  body: e.body instanceof Uint8Array ? e.body.slice() : e.body,
+  headers: e.headers ? { ...e.headers } : void 0
+}), ze = (e = {}) => {
+  const r = Number(e.maxEntries ?? 500), o = Number(e.maxBytes ?? 32 * 1024 * 1024), n = Number.isFinite(r) ? Math.max(1, Math.floor(r)) : 500, l = Number.isFinite(o) ? Math.max(1, Math.floor(o)) : 32 * 1024 * 1024, d = /* @__PURE__ */ new Map();
+  let v = 0;
+  const b = (p) => {
+    const m = d.get(p);
+    return m ? (d.delete(p), v -= m.size, !0) : !1;
+  }, D = () => {
+    const p = Date.now();
+    for (const [m, w] of d)
+      w.expiresAt <= p && b(m);
+    for (; d.size > n || v > l; ) {
+      const m = d.keys().next().value;
+      if (!m) break;
+      b(m);
+    }
+  };
+  return {
+    get(p) {
+      const m = d.get(p);
+      return m ? m.expiresAt <= Date.now() ? (b(p), null) : (d.delete(p), d.set(p, m), Q(m.response)) : null;
+    },
+    set(p, m, w) {
+      const t = Number(w.ttlMs);
+      if (!Number.isFinite(t) || t <= 0) return;
+      b(p);
+      const s = Q(m), f = xe(s.body);
+      f > l || (d.set(p, {
+        response: s,
+        expiresAt: Date.now() + t,
+        size: f,
+        tags: new Set(w.tags ?? [])
+      }), v += f, D());
+    },
+    invalidate(p = {}) {
+      const m = new Set(p.keys ?? []), w = new Set(p.tags ?? []);
+      let t = 0;
+      for (const [s, f] of d)
+        (!m.size && !w.size || m.has(s) || [...w].some((S) => f.tags.has(S))) && b(s) && (t += 1);
+      return t;
+    }
+  };
+}, Re = async (e, r, o) => {
+  if (!o || r.method !== "GET" || r.cookie || !Number.isFinite(o.ttlMs) || o.ttlMs <= 0)
+    return null;
+  const n = o.vary ? await o.vary(r) : "";
+  return n == null ? null : JSON.stringify([
+    "vue-ssr-lite:v1",
+    e,
+    r.host,
+    r.pathname,
+    r.search,
+    n
+  ]);
+}, Ee = (e, r, o) => {
+  const n = Object.entries(e.headers ?? {}), l = String(
+    n.find(([v]) => v.toLowerCase() === "cache-control")?.[1] || ""
+  ).toLowerCase();
+  return e.statusCode === 200 && typeof e.body == "string" && !n.some(([v]) => v.toLowerCase() === "set-cookie") && !l.includes("private") && !l.includes("no-store") && (o.shouldCache?.(e, r) ?? !0);
+};
+class re extends Error {
+  constructor() {
+    super("SSR request timed out."), this.name = "SsrRequestTimeoutError";
+  }
+}
+const Ce = (e) => {
+  const r = e ?? 4173;
+  if (!Number.isInteger(r) || r < 0 || r > 65535)
+    throw new Error("SSR server port must be an integer between 0 and 65535.");
+  return r;
+}, Pe = (e) => e === "0.0.0.0" || e === "::" || e === "::1" ? "localhost" : e, Me = (e, r, o) => {
+  const n = `http://${Pe(e)}:${r}/`;
+  console.log(
+    [
+      "",
+      "✓  Server Ready",
+      "",
+      `  ➜ Local:  ${n}`,
+      `  ➜ Role:   ${o}`,
+      ""
+    ].join(`
+`)
+  );
+}, Y = async (e, r) => {
+  const o = await me(e, {
+    development: !r.production,
+    root: r.root,
+    importModule: r.vite ? async (n) => await r.vite.ssrLoadModule(n) : void 0
+  });
+  for (const n of o.applications) {
+    const l = !n.roles?.length || !o.server.role || n.roles.includes(o.server.role);
+    if (n.kind === "ssr" && l && !n.application)
+      throw new Error(
+        `SSR application "${n.id}" requires an ssr application definition.`
+      );
+  }
+  return o;
+}, Ie = (e, r, o, n) => {
+  const d = `<script type="application/json" id="vue-ssr-lite-domain">${te({
+    version: 1,
+    applicationId: r,
+    domain: o,
+    publicConfig: n
+  })}<\/script>`;
+  return e.includes("</body>") ? e.replace(/<\/body>/i, `	${d}
+</body>`) : `${e}
+${d}`;
+}, j = {
+  "referrer-policy": "strict-origin-when-cross-origin",
+  "x-content-type-options": "nosniff",
+  "x-frame-options": "SAMEORIGIN"
+}, F = (e, r) => {
+  if (e.method !== "GET" && e.method !== "HEAD") return !1;
+  if (e.headers["sec-fetch-mode"] === "navigate") return !0;
+  const o = String(e.headers.accept || "");
+  return o.includes("text/html") ? !0 : (!o || o === "*/*") && !ee(r);
+}, $e = (e, r, o = "") => r.end(e.method === "HEAD" ? "" : o), E = (e, r, o) => {
+  r.writeHead(o.statusCode, o.headers ?? {}), $e(e, r, o.body ?? "");
+}, T = (e, r, o, n) => E(e, r, {
+  statusCode: o,
+  body: JSON.stringify(n),
+  headers: {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store"
+  }
+}), Z = async (e, r, o) => {
+  if (!Number.isFinite(r) || r <= 0) return e;
+  let n;
+  const l = new Promise((d, v) => {
+    n = setTimeout(() => {
+      o.abort(), v(new re());
+    }, r);
+  });
+  try {
+    return await Promise.race([e, l]);
+  } finally {
+    n && clearTimeout(n);
+  }
+}, De = (e) => e.headers, ke = (e, r, o) => new Promise((n, l) => {
+  e.middlewares(r, o, (d) => {
+    d ? l(d) : n();
+  });
+}), Oe = async (e) => {
+  let r = !1;
+  const o = await Y(await e.loadRuntime(), e), n = o.server, l = n.host || "0.0.0.0", d = Ce(n.port), v = z(
+    n.root || e.root,
+    n.clientOutDir || "dist/client"
+  ), b = async () => e.production ? o : Y(await e.loadRuntime(), e), D = async (t, s, f) => {
+    const a = t.server.root || e.root, S = await q(
+      z(e.production ? v : a, s),
+      "utf8"
+    );
+    if (e.production || !e.vite) return S;
+    const A = `/${s.replaceAll("\\", "/").replace(/^\/+/, "")}`;
+    return e.vite.transformIndexHtml(A, S, f);
+  }, p = async (t) => {
+    const s = t.server.root || e.root, f = t.applications.filter(
+      (a) => !a.roles?.length || !t.server.role || a.roles.includes(t.server.role)
+    );
+    await Promise.all(
+      f.map(async (a) => {
+        if (!(await J(
+          z(
+            e.production ? v : s,
+            a.template
+          )
+        )).isFile())
+          throw new Error(`SSR client entry is missing: ${a.template}`);
+      })
+    ), await Promise.all((t.readiness ?? []).map((a) => a.run()));
+  }, m = o.applications.filter(
+    (t) => !t.roles?.length || !o.server.role || t.roles.includes(o.server.role)
+  );
+  await Promise.all(
+    m.map(async (t) => {
+      const s = o.server.root || e.root;
+      if (!(await J(
+        z(
+          e.production ? v : s,
+          t.template
+        )
+      )).isFile())
+        throw new Error(`Missing client entry: ${t.template}`);
+    })
+  );
+  const w = ae(async (t, s) => {
+    const f = Date.now();
+    let a = "/", S = "unknown", A;
+    const g = new AbortController();
+    t.once("aborted", () => g.abort()), s.once("close", () => {
+      s.writableEnded || g.abort();
+    });
+    try {
+      const i = await b(), c = i.server, C = new URL(t.url || "/", "http://internal");
+      a = C.pathname;
+      const k = c.healthPath || "/healthz", y = c.readinessPath || "/readyz";
+      if (a === k)
+        return T(t, s, 200, {
+          status: "ok",
+          service: i.name,
+          role: c.role || "default",
+          timestamp: new Date(f).toISOString()
+        });
+      if (a === y) {
+        if (r)
+          return T(t, s, 503, {
+            status: "error",
+            service: i.name,
+            message: "Server is shutting down."
+          });
+        try {
+          return await p(i), T(t, s, 200, {
+            status: "ok",
+            service: i.name,
+            role: c.role || "default"
+          });
+        } catch {
+          return T(t, s, 503, {
+            status: "error",
+            service: i.name,
+            message: "A required dependency is unavailable."
+          });
+        }
+      }
+      const I = ie(
+        t.headers["x-forwarded-host"],
+        t.headers.host,
+        c.trustProxy
+      );
+      if (!I)
+        return E(t, s, {
+          statusCode: 400,
+          body: F(t, a) ? W("Invalid request", "The Host header is invalid.") : JSON.stringify({ status: "error", message: "Invalid Host header." }),
+          headers: {
+            "content-type": F(t, a) ? "text/html; charset=utf-8" : "application/json; charset=utf-8",
+            "cache-control": "no-store",
+            ...j
+          }
+        });
+      const P = ce(
+        i.applications,
+        I,
+        i.defaultApplicationId
+      );
+      if (!P)
+        return T(t, s, 421, {
+          status: "error",
+          service: i.name,
+          message: "No application serves this host."
+        });
+      const u = P.entry;
+      if (S = u.id, c.logger?.debug?.("ssr.host_resolved", {
+        entryId: u.id,
+        category: P.category,
+        specificity: P.specificity,
+        matchedPattern: P.matchedPattern,
+        hostname: P.normalizedHostname,
+        role: c.role || "default"
+      }), u.roles?.length && c.role && !u.roles.includes(c.role)) {
+        const h = `Runtime role does not serve application "${u.id}".`;
+        return E(t, s, {
+          statusCode: 421,
+          body: F(t, a) ? W("Misdirected request", h) : JSON.stringify({ status: "error", message: h }),
+          headers: {
+            "content-type": F(t, a) ? "text/html; charset=utf-8" : "application/json; charset=utf-8",
+            "cache-control": "no-store",
+            ...j
+          }
+        });
+      }
+      const L = le(
+        t.headers["x-forwarded-proto"],
+        t.socket.encrypted ? "https" : "http",
+        c.trustProxy
+      ), H = ge(
+        I,
+        u,
+        i.development
+      ), oe = de(
+        t.headers.cookie,
+        u.cookieAllowlist,
+        u.cookieDenylist
+      ), R = {
+        requestId: String(t.headers["x-request-id"] || "").trim() || `${f.toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
+        url: new URL(
+          `${C.pathname}${C.search}`,
+          `${L}://${I}`
+        ).href,
+        host: I,
+        protocol: L,
+        method: t.method || "GET",
+        headers: De(t),
+        cookie: oe,
+        publicConfig: u.publicConfig,
+        domain: H,
+        signal: g.signal,
+        pathname: a,
+        search: C.search,
+        entryId: u.id
+      };
+      A = R;
+      const se = {
+        signal: g.signal,
+        logger: c.logger
+      };
+      for (const h of u.endpoints) {
+        if (!h.match(R)) continue;
+        const M = await Z(
+          Promise.resolve(h.handle(R, se)),
+          c.requestTimeoutMs ?? 15e3,
+          g
+        );
+        if (M) return E(t, s, M);
+      }
+      if (e.production) {
+        const h = await be(
+          v,
+          a,
+          i.applications.map(({ template: M }) => M)
+        );
+        if (h) return E(t, s, h);
+      } else if (e.vite && (a.startsWith("/src/") || a.startsWith("/@") || a.includes(".") || a === "/__vite_ping") && (await ke(e.vite, t, s), s.writableEnded))
+        return;
+      if (!F(t, a))
+        return T(t, s, 404, {
+          status: "error",
+          service: i.name,
+          message: "Resource not found."
+        });
+      const $ = u.kind === "ssr" ? u.responseCache : void 0;
+      let N = null;
+      try {
+        N = await Re(
+          u.id,
+          R,
+          $
+        );
+      } catch (h) {
+        c.logger?.warn?.("ssr.cache.key.failed", {
+          entryId: u.id,
+          requestId: R.requestId,
+          error: h instanceof Error ? h.message : "Unknown cache error"
+        });
+      }
+      if ($ && N)
+        try {
+          const h = await $.store.get(N);
+          if (h)
+            return E(t, s, {
+              ...h,
+              headers: {
+                ...h.headers,
+                "server-timing": 'cache;desc="hit"'
+              }
+            });
+        } catch (h) {
+          c.logger?.warn?.("ssr.cache.read.failed", {
+            entryId: u.id,
+            requestId: R.requestId,
+            error: h instanceof Error ? h.message : "Unknown cache error"
+          });
+        }
+      let O = await D(i, u.template, t.url || "/");
+      if (u.kind === "spa")
+        return E(t, s, {
+          statusCode: 200,
+          body: Ie(
+            O,
+            u.id,
+            H,
+            u.publicConfig
+          ),
+          headers: {
+            "content-type": "text/html; charset=utf-8",
+            "cache-control": u.cacheControl || "private, no-store",
+            vary: "Host, X-Forwarded-Host",
+            ...j
+          }
+        });
+      const _ = u.application;
+      O = ue(
+        O,
+        u.mountSelector || _.mountSelector || "#app"
+      );
+      const G = c.requestTimeoutMs ?? 15e3, x = await Z(
+        ve(_, R, {
+          maxResolutionPasses: c.maxResolutionPasses,
+          resolutionDeadlineMs: c.resolutionDeadlineMs ?? G,
+          diagnostics: c.diagnostics ?? !e.production,
+          logger: c.logger
+        }),
+        G,
+        g
+      );
+      if (x.response.redirect) {
+        const h = x.response.redirect, M = new URL(h.location, R.url);
+        if (M.protocol !== "http:" && M.protocol !== "https:")
+          throw new Error("SSR redirects must use HTTP or HTTPS.");
+        if (!h.allowExternal && M.origin !== new URL(R.url).origin)
+          throw new Error("Cross-origin redirect requires allowExternal: true.");
+        return E(t, s, {
+          statusCode: h.statusCode ?? 302,
+          headers: {
+            location: M.href,
+            "cache-control": "no-store"
+          }
+        });
+      }
+      const ne = he(O, {
+        applicationId: _.id,
+        html: x.html,
+        teleports: x.teleports,
+        head: x.head,
+        state: x.hydrationState
+      });
+      c.onMetrics?.(x.metrics), c.logger?.info?.("ssr.render.complete", x.metrics);
+      const B = {
+        statusCode: x.response.statusCode,
+        body: ne,
+        headers: {
+          "content-type": "text/html; charset=utf-8",
+          "cache-control": u.cacheControl || "private, no-store",
+          vary: "Host, X-Forwarded-Host",
+          "server-timing": [
+            `context;dur=${x.metrics.contextDurationMs.toFixed(1)}`,
+            `route;dur=${x.metrics.routeDurationMs.toFixed(1)}`,
+            `render;dur=${x.metrics.renderDurationMs.toFixed(1)}`
+          ].join(", "),
+          ...x.response.headers,
+          ...j
+        }
+      };
+      if ($ && N && Ee(B, R, $))
+        try {
+          await $.store.set(N, B, {
+            ttlMs: $.ttlMs,
+            tags: await $.tags?.(R)
+          });
+        } catch (h) {
+          c.logger?.warn?.("ssr.cache.write.failed", {
+            entryId: u.id,
+            requestId: R.requestId,
+            error: h instanceof Error ? h.message : "Unknown cache error"
+          });
+        }
+      return E(t, s, B);
+    } catch (i) {
+      e.vite?.ssrFixStacktrace(i);
+      const c = await b().catch(() => o);
+      if (c.server.logger?.error?.("ssr.request.failed", {
+        entryId: S,
+        pathname: a,
+        error: i instanceof Error ? i.message : "Unknown error"
+      }), s.writableEnded) return;
+      if (s.headersSent) return s.destroy();
+      const C = i instanceof re, k = C ? 504 : 500;
+      if (c.server.renderError)
+        try {
+          const y = await c.server.renderError({
+            error: i,
+            kind: C ? "timeout" : "internal",
+            production: e.production,
+            request: A,
+            entryId: S === "unknown" ? void 0 : S
+          });
+          if (y)
+            return E(t, s, {
+              ...y,
+              statusCode: y.statusCode >= 400 ? y.statusCode : k,
+              headers: {
+                ...y.headers,
+                "cache-control": "no-store",
+                ...j
+              }
+            });
+        } catch (y) {
+          c.server.logger?.error?.("ssr.error-renderer.failed", {
+            entryId: S,
+            error: y instanceof Error ? y.message : "Unknown error renderer failure"
+          });
+        }
+      return F(t, a) ? E(t, s, {
+        statusCode: k,
+        body: W(
+          C ? "Request timed out" : "Application unavailable",
+          e.production ? "The application could not render this page. Please try again." : i instanceof Error ? i.message : "Unknown rendering failure."
+        ),
+        headers: {
+          "content-type": "text/html; charset=utf-8",
+          "cache-control": "no-store",
+          ...j
+        }
+      }) : T(t, s, k, {
+        status: "error",
+        service: c.name
+      });
+    }
+  });
+  return {
+    nodeServer: w,
+    address: () => {
+      const t = w.address();
+      return {
+        host: typeof t == "object" && t ? t.address : l,
+        port: typeof t == "object" && t ? t.port : d
+      };
+    },
+    listen: () => new Promise((t, s) => {
+      const f = (a) => s(a);
+      w.once("error", f), w.listen(d, l, () => {
+        w.off("error", f), Me(
+          l,
+          d,
+          n.role || "default"
+        ), t();
+      });
+    }),
+    close: async () => {
+      if (r) return;
+      r = !0;
+      const t = n.shutdownTimeoutMs ?? 1e4;
+      let s;
+      try {
+        await Promise.race([
+          Promise.all([
+            new Promise((f, a) => {
+              w.close(
+                (S) => S ? a(S) : f()
+              );
+            }),
+            e.vite?.close()
+          ]),
+          new Promise((f, a) => {
+            s = setTimeout(() => {
+              w.closeAllConnections?.(), a(new Error("SSR server graceful shutdown timed out."));
+            }, t);
+          })
+        ]);
+      } finally {
+        s && clearTimeout(s);
+      }
+    }
+  };
+};
+export {
+  ze as a,
+  be as b,
+  Oe as c,
+  Re as d,
+  Ee as i,
+  ve as r
+};