@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-grta8ap3.js

@@ -0,0 +1,238 @@
+// @bun
+import {
+  cacheComponents,
+  hangingPromise,
+  isPrerendering,
+  isRuntimePrefetchPrerender,
+  markRuntimeApiOnAwait
+} from "./index-kresp2n8.js";
+import {
+  PostponeError
+} from "./index-e3a6yx84.js";
+
+// src/request/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var WORK_UNIT_STORAGE = Symbol.for("pnext.workUnitStorage");
+var workUnitStorage = globalThis[WORK_UNIT_STORAGE] ??= new AsyncLocalStorage;
+function runWithWorkUnit(phase, callback) {
+  const unit = { phase, afterTasks: [], flushed: false };
+  return workUnitStorage.run(unit, callback);
+}
+function getWorkUnit() {
+  return workUnitStorage.getStore();
+}
+function setWorkUnitRelease(release) {
+  const unit = workUnitStorage.getStore();
+  if (unit)
+    unit.release = release;
+}
+function setPhase(phase) {
+  const unit = workUnitStorage.getStore();
+  if (unit)
+    unit.phase = phase;
+}
+function setWorkUnitRoute(routeKind, routeMode, responseHints) {
+  const unit = workUnitStorage.getStore();
+  if (!unit)
+    return;
+  unit.routeKind = routeKind;
+  if (routeMode)
+    unit.routeMode = routeMode;
+  if (responseHints)
+    unit.responseHints = responseHints;
+}
+function queueAfterTask(task) {
+  const unit = workUnitStorage.getStore();
+  if (!unit)
+    return false;
+  unit.afterTasks.push(task);
+  return true;
+}
+function flushWorkUnit(unit = workUnitStorage.getStore()) {
+  if (!unit || unit.flushed)
+    return;
+  unit.flushed = true;
+  if (unit.afterTasks.length === 0)
+    return;
+  const afterUnit = { ...unit, phase: "after" };
+  const flushing = workUnitStorage.run(afterUnit, async () => {
+    while (afterUnit.afterTasks.length) {
+      const tasks = afterUnit.afterTasks;
+      afterUnit.afterTasks = [];
+      for (const task of tasks) {
+        try {
+          await task();
+        } catch (error) {
+          console.error("after() task failed:", error);
+        }
+      }
+    }
+  });
+  pendingFlushes.add(flushing);
+  flushing.finally(() => pendingFlushes.delete(flushing));
+}
+var pendingFlushes = new Set;
+async function drainWorkUnits(timeoutMs = 1e4) {
+  if (pendingFlushes.size === 0)
+    return;
+  await Promise.race([
+    Promise.allSettled([...pendingFlushes]),
+    new Promise((resolve) => setTimeout(resolve, timeoutMs))
+  ]);
+}
+function flushWorkUnitOnClose(response, unit, signal) {
+  if (!unit)
+    return response;
+  if (!response.body) {
+    flushWorkUnit(unit);
+    return response;
+  }
+  if (response.headers.has("content-length")) {
+    flushWorkUnit(unit);
+    return response;
+  }
+  const reader = response.body.getReader();
+  const settle = () => {
+    signal?.removeEventListener("abort", settle);
+    flushWorkUnit(unit);
+  };
+  if (signal?.aborted)
+    settle();
+  else
+    signal?.addEventListener("abort", settle, { once: true });
+  const observed = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          settle();
+          controller.close();
+        } else {
+          controller.enqueue(chunk.value);
+        }
+      } catch (error) {
+        settle();
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      settle();
+      return reader.cancel(reason);
+    }
+  });
+  return new Response(observed, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+var REQUEST_STORAGE = Symbol.for("pnext.requestStorage");
+var requestStorage = globalThis[REQUEST_STORAGE] ??= new AsyncLocalStorage;
+function currentRequest() {
+  return requestStorage.getStore()?.request;
+}
+var WORK_UNIT_EXTERNAL = Symbol.for("pnext.workUnitExternal");
+function workUnitExternalStore() {
+  const request = currentRequest();
+  const type = isRuntimePrefetchPrerender() ? "prerender-runtime" : isPrerendering() || !request ? "prerender" : "request";
+  return {
+    type,
+    cookies: request?.cookies,
+    headers: request?.headers ?? new Headers
+  };
+}
+globalThis[WORK_UNIT_EXTERNAL] = workUnitExternalStore;
+function captureRequestScope() {
+  const scope = requestStorage.getStore();
+  if (!scope)
+    return (fn) => fn();
+  return (fn) => requestStorage.run(scope, fn);
+}
+function currentParams() {
+  return requestStorage.getStore()?.params ?? {};
+}
+function runWithRequest(request, callback, params = {}, extras = {}) {
+  if (!request)
+    return callback();
+  const scope = {
+    request,
+    params,
+    afterCallbacks: [],
+    responseHeaders: extras.responseHeaders
+  };
+  const result = requestStorage.run(scope, callback);
+  if (isThenable(result)) {
+    return result.then((value) => {
+      flushAfterCallbacks(scope);
+      return value;
+    }, (error) => {
+      flushAfterCallbacks(scope);
+      throw error;
+    });
+  }
+  flushAfterCallbacks(scope);
+  return result;
+}
+function currentResponseHeaders() {
+  return requestStorage.getStore()?.responseHeaders;
+}
+async function flushAfterCallbacks(scope) {
+  while (scope.afterCallbacks?.length) {
+    const callbacks = scope.afterCallbacks;
+    scope.afterCallbacks = [];
+    for (const callback of callbacks) {
+      try {
+        await requestStorage.run(scope, callback);
+      } catch (error) {
+        console.error("after() callback failed:", error);
+      }
+    }
+  }
+}
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+var BAILOUT_PROBE = Symbol.for("pnext.dynamicBailoutProbe");
+function beginDynamicBailoutProbe(route) {
+  globalThis[BAILOUT_PROBE] = route;
+}
+function endDynamicBailoutProbe() {
+  delete globalThis[BAILOUT_PROBE];
+}
+function dynamicBailoutRoute() {
+  const route = globalThis[BAILOUT_PROBE];
+  return typeof route === "string" ? route : undefined;
+}
+var LEGACY_REQUEST_APIS = Symbol.for("pnext.legacyRequestAPIs");
+function setLegacyRequestAPIs(enabled) {
+  globalThis[LEGACY_REQUEST_APIS] = enabled;
+}
+function legacyRequestAPIs() {
+  return globalThis[LEGACY_REQUEST_APIS] === true;
+}
+function requireRequest(api) {
+  const probeRoute = dynamicBailoutRoute();
+  if (probeRoute !== undefined) {
+    const error = new Error(`Route ${probeRoute} couldn't be rendered statically because it used \`${api.replace(/\(\)$/, "")}\`. ` + `See more info here: https://nextjs.org/docs/messages/dynamic-server-error`);
+    error.name = "DynamicServerError";
+    throw error;
+  }
+  const request = currentRequest();
+  if (!request) {
+    if (isPrerendering())
+      throw new PostponeError(api);
+    throw new Error(`${api} can only be used while rendering a dynamic PNext request.`);
+  }
+  return request;
+}
+function requestApiPromise(api, produce) {
+  if (isPrerendering() && cacheComponents()) {
+    if (isRuntimePrefetchPrerender() && api !== "connection()") {
+      return markRuntimeApiOnAwait(Promise.resolve(produce()));
+    }
+    return hangingPromise(api);
+  }
+  return Promise.resolve(produce());
+}
+
+export { runWithWorkUnit, getWorkUnit, setWorkUnitRelease, setPhase, setWorkUnitRoute, queueAfterTask, flushWorkUnit, drainWorkUnits, flushWorkUnitOnClose, currentRequest, captureRequestScope, currentParams, runWithRequest, currentResponseHeaders, beginDynamicBailoutProbe, endDynamicBailoutProbe, setLegacyRequestAPIs, legacyRequestAPIs, requireRequest, requestApiPromise };

package/dist/server/_chunks/index-h2a70tg4.js

@@ -0,0 +1,7 @@
+// @bun
+// src/compat/react/router-shim.ts
+function nextRouterShimScript() {
+  return '<script>window.next=window.next||{};window.next.version=window.next.version||"16.3.0";(function(){' + "var r=window.next.router=window.next.router||{};" + 'function d(){try{var n=document.getElementById("__PNEXT_PAGES_DATA__");' + "return n&&n.textContent?JSON.parse(n.textContent):null}catch(e){return null}}" + "function q(){var s=d(),o={};if(s&&s.query){for(var k in s.query)o[k]=s.query[k]}" + 'new URLSearchParams(location.search).forEach(function(v,k){if(k!=="_rsc")o[k]=v});return o}' + "r.isReady=true;r.isFallback=r.isFallback||false;" + 'if(!Object.getOwnPropertyDescriptor(r,"query"))Object.defineProperty(r,"query",{get:q,configurable:true});' + 'if(!Object.getOwnPropertyDescriptor(r,"pathname"))Object.defineProperty(r,"pathname",{get:function(){var s=d();return(s&&s.pathname)||location.pathname},configurable:true});' + 'if(!Object.getOwnPropertyDescriptor(r,"asPath"))Object.defineProperty(r,"asPath",{get:function(){return location.pathname+location.search},configurable:true});' + "r.push=r.push||function(href){var s=String(href);" + "if(window.__PNEXT_ROUTER__&&window.__PNEXT_ROUTER__.navigate){return window.__PNEXT_ROUTER__.navigate(s).then(function(){return true})}" + "location.assign(s);return Promise.resolve(true)};" + "r.replace=r.replace||function(href){location.replace(String(href));return Promise.resolve(true)};" + "r.prefetch=r.prefetch||function(){return Promise.resolve(null)};" + "})();</script>";
+}
+
+export { nextRouterShimScript };

package/dist/server/_chunks/index-h4xy648y.js

@@ -0,0 +1,51 @@
+// @bun
+// src/compat/react/use.ts
+import { useContext } from "preact/hooks";
+var REPLAY_STATE_KEY = Symbol.for("pnext.useReplayState");
+var replayState = globalThis[REPLAY_STATE_KEY] ??= {
+  active: null,
+  index: 0
+};
+function withUseThenableState(state, run) {
+  const previousState = replayState.active;
+  const previousIndex = replayState.index;
+  replayState.active = state;
+  replayState.index = 0;
+  try {
+    return run();
+  } finally {
+    replayState.active = previousState;
+    replayState.index = previousIndex;
+  }
+}
+function use(usable) {
+  if (usable && typeof usable.then === "function") {
+    let thenable = usable;
+    if (replayState.active) {
+      const index = replayState.index++;
+      const existing = replayState.active.thenables[index];
+      if (existing)
+        thenable = existing;
+      else
+        replayState.active.thenables[index] = thenable;
+    }
+    if (thenable.status === "fulfilled")
+      return thenable.value;
+    if (thenable.status === "rejected")
+      throw thenable.reason;
+    if (thenable.status !== "pending") {
+      thenable.status = "pending";
+      thenable.then((value) => {
+        thenable.status = "fulfilled";
+        thenable.value = value;
+      }, (reason) => {
+        thenable.status = "rejected";
+        thenable.reason = reason;
+      });
+    }
+    throw thenable;
+  }
+  return useContext(usable);
+}
+
+export { withUseThenableState, use };

package/dist/server/_chunks/index-hkdfj58q.js

@@ -0,0 +1,92 @@
+// @bun
+import {
+  compileSource,
+  evaluateConditions,
+  loadNextConfig,
+  parseConditions,
+  splitDestination,
+  substitute
+} from "./index-z84ab1w0.js";
+
+// src/compat/next/redirects.ts
+async function loadCompatRedirects(root) {
+  const config = await loadNextConfig(root);
+  const producer = config?.redirects;
+  if (typeof producer !== "function")
+    return [];
+  let value;
+  try {
+    value = await producer();
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(value))
+    return [];
+  const redirects = [];
+  for (const entry of value) {
+    if (!entry?.source || !entry.destination)
+      continue;
+    const has = parseConditions(entry.has);
+    const missing = parseConditions(entry.missing);
+    if (has === null || missing === null)
+      continue;
+    const compiled = compileSource(entry.source);
+    if (!compiled)
+      continue;
+    const status = typeof entry.statusCode === "number" ? entry.statusCode : entry.permanent ? 308 : 307;
+    redirects.push({
+      ...compiled,
+      destination: entry.destination,
+      has,
+      missing,
+      status,
+      outsideBasePath: entry.basePath === false
+    });
+  }
+  return redirects;
+}
+function resolveCompatRedirect(redirects, pathname, ctx) {
+  const context = ctx ?? {
+    host: "",
+    headers: new Headers,
+    cookies: {},
+    query: new URLSearchParams
+  };
+  for (const redirect of redirects) {
+    const match = redirect.regex.exec(pathname);
+    if (!match)
+      continue;
+    const params = {};
+    redirect.paramNames.forEach((name, index) => {
+      params[name] = match[index + 1] ?? "";
+    });
+    const conditionParams = evaluateConditions(redirect, context);
+    if (conditionParams === null)
+      continue;
+    Object.assign(params, conditionParams);
+    const [destPath, destQuery] = splitDestination(redirect.destination);
+    const { pathname: resolvedPath, used: usedInPath } = substitute(destPath, params);
+    const query = new URLSearchParams;
+    let usedInQuery = false;
+    if (destQuery) {
+      for (const [key, rawValue] of new URLSearchParams(destQuery).entries()) {
+        const { pathname: value, used } = substitute(rawValue, params);
+        if (used)
+          usedInQuery = true;
+        query.set(key, value);
+      }
+    }
+    if (usedInPath.size === 0 && !usedInQuery) {
+      for (const [name, value] of Object.entries(params)) {
+        if (!query.has(name))
+          query.append(name, value);
+      }
+    }
+    const search = query.toString();
+    const location = search ? `${resolvedPath}${resolvedPath.includes("?") ? "&" : "?"}${search}` : resolvedPath;
+    return { location, status: redirect.status };
+  }
+  return;
+}
+
+export { loadCompatRedirects, resolveCompatRedirect };

package/dist/server/_chunks/index-j2zrcp1k.js

@@ -0,0 +1,66 @@
+// @bun
+// src/compat/react/hooks-extra.ts
+import { options } from "preact";
+import { useCallback, useRef, useState } from "preact/hooks";
+var renderInFlight = false;
+function hooksUsable() {
+  return renderInFlight;
+}
+{
+  const anyOptions = options;
+  const previousRender = anyOptions.__r;
+  anyOptions.__r = (vnode) => {
+    renderInFlight = true;
+    previousRender?.(vnode);
+  };
+  const previousDiffed = options.diffed?.bind(options);
+  options.diffed = (vnode) => {
+    renderInFlight = false;
+    previousDiffed?.(vnode);
+  };
+}
+function useTransition() {
+  if (!hooksUsable())
+    return [false, (callback) => void callback()];
+  const [pending, setPending] = useState(0);
+  const startTransition = useCallback((callback) => {
+    const mpaBefore = globalThis.__pnextMpaNavigation ?? 0;
+    let result;
+    try {
+      result = callback();
+    } catch {
+      return;
+    }
+    const mpaAfter = globalThis.__pnextMpaNavigation ?? 0;
+    if (mpaAfter !== mpaBefore) {
+      setPending((count) => count + 1);
+      return;
+    }
+    if (result && typeof result.then === "function") {
+      setPending((count) => count + 1);
+      Promise.resolve(result).finally(() => setPending((count) => count - 1));
+    }
+  }, []);
+  return [pending > 0, startTransition];
+}
+function useOptimistic(passthrough, reducer) {
+  if (!hooksUsable())
+    return [passthrough, () => {
+      return;
+    }];
+  const [optimistic, setOptimistic] = useState(null);
+  const lastBase = useRef(passthrough);
+  if (lastBase.current !== passthrough) {
+    lastBase.current = passthrough;
+    if (optimistic)
+      setOptimistic(null);
+  }
+  const dispatch = useCallback((payload) => {
+    setOptimistic((current) => ({
+      value: reducer ? reducer(current ? current.value : lastBase.current, payload) : payload
+    }));
+  }, [reducer]);
+  return [optimistic ? optimistic.value : passthrough, dispatch];
+}
+
+export { hooksUsable, useTransition, useOptimistic };

package/dist/server/_chunks/index-jcsjq3d1.js

@@ -0,0 +1,20 @@
+// @bun
+// src/utils/error-log.ts
+var ERROR_LOGGED = Symbol.for("pnext.errorLogged");
+function markErrorLogged(error) {
+  if (error === null || typeof error !== "object" && typeof error !== "function") {
+    return true;
+  }
+  const holder = error;
+  if (holder[ERROR_LOGGED])
+    return false;
+  Object.defineProperty(error, ERROR_LOGGED, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+  return true;
+}
+
+export { markErrorLogged };

package/dist/server/_chunks/index-jepjvcrf.js

@@ -0,0 +1,198 @@
+// @bun
+import {
+  readDirListing,
+  toPosixPath
+} from "./index-20ppawv7.js";
+import {
+  extraPageExtensions
+} from "./index-zqpqyg8p.js";
+
+// src/routing/match.ts
+import path from "path";
+import { safeDecode } from "../../../src/utils/decode.ts";
+var BASE_PAGE_EXTENSIONS = ["tsx", "ts", "jsx", "js", "mjs"];
+function pageExtensions() {
+  return [...new Set([...BASE_PAGE_EXTENSIONS, ...extraPageExtensions()])];
+}
+var globalErrorBase = "global-error";
+function conventionFileName(dir, base) {
+  const { files } = readDirListing(dir);
+  for (const extension of pageExtensions()) {
+    if (files.has(`${base}.${extension}`))
+      return path.join(dir, `${base}.${extension}`);
+  }
+  return;
+}
+function findLayouts(appPath, routeFilePath) {
+  return findConventionFiles(appPath, routeFilePath, "layout");
+}
+function findConventionFiles(appPath, routeFilePath, name) {
+  const base = conventionBase(name);
+  const files = [];
+  let dir = path.dirname(routeFilePath);
+  while (dir.startsWith(appPath)) {
+    files.push(conventionFileName(dir, base) ?? path.join(dir, `${base}.tsx`));
+    if (dir === appPath)
+      break;
+    dir = path.dirname(dir);
+  }
+  return files.reverse();
+}
+function conventionBase(name) {
+  const match = new RegExp(`\\.(${pageExtensions().join("|")})$`).exec(name);
+  return match ? name.slice(0, -match[0].length) : name;
+}
+function findGlobalError(appPath) {
+  return conventionFileName(appPath, globalErrorBase);
+}
+function matchRoute(routes, pathname) {
+  const normalized = normalizePathname(pathname);
+  for (const route of routes) {
+    if (route.interception)
+      continue;
+    const match = routeRegex(route).exec(normalized);
+    if (!match)
+      continue;
+    return { route, params: routeMatchParams(route, match) };
+  }
+  return null;
+}
+function normalizePathname(pathname) {
+  return pathname.length > 1 ? pathname.replace(/\/+$/, "") || "/" : pathname;
+}
+function routeMatchParams(route, match) {
+  const params = {};
+  route.params.forEach((name, index) => {
+    const decoded = safeDecode(match[index + 1] ?? "");
+    params[name] = decoded === `[${name}]` ? encodeURIComponent(decoded) : decoded;
+  });
+  if (route.catchAll) {
+    params[route.catchAll] = (match[route.params.length + 1] ?? "").split("/").filter(Boolean).map(safeDecode);
+  }
+  return params;
+}
+function matchInterception(routes, pathname, fromPath) {
+  if (!fromPath)
+    return null;
+  const target = normalizePathname(pathname);
+  const from = normalizePathname(fromPath);
+  if (target === from)
+    return null;
+  let best = null;
+  let bestDepth = -1;
+  for (const route of routes) {
+    const interception = route.interception;
+    if (!interception)
+      continue;
+    const match = routeRegex(route).exec(target);
+    if (!match)
+      continue;
+    const basePattern = interception.basePattern ? `/${interception.basePattern}` : "";
+    if (!new RegExp(`^${basePattern}(?:/.*)?$`).test(from))
+      continue;
+    const depth = interception.base.split("/").filter(Boolean).length;
+    if (depth <= bestDepth)
+      continue;
+    bestDepth = depth;
+    best = { route, params: routeMatchParams(route, match) };
+  }
+  return best;
+}
+function selectRouteForRequest(routes, pathname, nav) {
+  const target = normalizePathname(pathname);
+  if (nav) {
+    const intercepted = matchInterception(routes, target, nav.children);
+    if (intercepted) {
+      if (!intercepted.route.interception?.slotDir) {
+        return {
+          route: intercepted.route,
+          params: intercepted.params,
+          childrenPath: target,
+          targetPath: target
+        };
+      }
+      const host = hostMatch(routes, nav.children);
+      if (host)
+        return { ...host, targetPath: target };
+    }
+  }
+  const matched = matchRoute(routes, target);
+  if (!matched)
+    return null;
+  if (nav && matched.route.synthetic && nav.children) {
+    const primary = matchRoute(routes.filter((route) => !route.synthetic), target);
+    const syntheticOwner = matched.route.syntheticSlotDir ? path.dirname(matched.route.syntheticSlotDir) : undefined;
+    const primaryFromOwner = primary && syntheticOwner ? path.relative(syntheticOwner, primary.route.file) : undefined;
+    if (primary && primaryFromOwner !== undefined && primaryFromOwner !== ".." && !primaryFromOwner.startsWith(`..${path.sep}`)) {
+      return {
+        route: primary.route,
+        params: primary.params,
+        childrenPath: target,
+        targetPath: target
+      };
+    }
+    const host = hostMatch(routes, nav.children);
+    if (host && host.route !== matched.route && matched.route.syntheticSlotDir && host.route.slotDirs?.includes(matched.route.syntheticSlotDir)) {
+      return { ...host, targetPath: target };
+    }
+  }
+  return {
+    route: matched.route,
+    params: matched.params,
+    childrenPath: target,
+    targetPath: target
+  };
+}
+function parseNavState(request) {
+  if (!request.headers.get("x-pnext-soft-nav"))
+    return;
+  const raw = request.headers.get("x-pnext-nav-state");
+  if (!raw)
+    return {};
+  try {
+    const parsed = JSON.parse(decodeURIComponent(raw));
+    if (parsed && typeof parsed === "object")
+      return parsed;
+  } catch {}
+  return {};
+}
+function hostMatch(routes, fromPath) {
+  if (!fromPath)
+    return null;
+  const from = normalizePathname(fromPath);
+  const host = matchRoute(routes, from);
+  if (host?.route.kind !== "page")
+    return null;
+  return { route: host.route, params: host.params, childrenPath: from, targetPath: from };
+}
+var routeRegexCache = new WeakMap;
+function routeRegex(route) {
+  let regex = routeRegexCache.get(route);
+  if (!regex) {
+    regex = new RegExp(`^${route.pattern}$`);
+    routeRegexCache.set(route, regex);
+  }
+  return regex;
+}
+function serverActionsUnsupportedMessage(offender) {
+  const file = offender.root ? toPosixPath(path.relative(offender.root, offender.file)) : offender.file;
+  const reach = offender.route ? `, reachable from the route ${offender.route}` : "";
+  return [
+    `Server actions need next compat, and this app is pure core.`,
+    ``,
+    `  ${file} has a 'use server' directive${reach}.`,
+    ``,
+    `pnext will not build this app: core has no server-action registry and no`,
+    `dispatch endpoint, so the action could only render as a form that submits`,
+    `nowhere.`,
+    ``,
+    `Fix it one of two ways:`,
+    `  1. Enable compat in pnext.config.ts:`,
+    `       export default { compat: { next: true } }`,
+    `  2. Or delete the 'use server' directive from ${file}, if those exports are`,
+    `     only ever called on the server (in core the directive does nothing).`
+  ].join(`
+`);
+}
+
+export { pageExtensions, conventionFileName, findLayouts, findConventionFiles, findGlobalError, matchRoute, normalizePathname, matchInterception, selectRouteForRequest, parseNavState, serverActionsUnsupportedMessage };

package/dist/server/_chunks/index-jks0x0a1.js

@@ -0,0 +1,14 @@
+// @bun
+// src/compat/next/config.ts
+var runtimeConfig = {
+  serverRuntimeConfig: {},
+  publicRuntimeConfig: typeof __PNEXT_PUBLIC_RUNTIME_CONFIG_INLINED__ === "boolean" ? __PNEXT_PUBLIC_RUNTIME_CONFIG_INLINE__ : {}
+};
+function getConfig() {
+  return runtimeConfig;
+}
+function setConfig(config) {
+  Object.assign(runtimeConfig, config);
+}
+
+export { getConfig, setConfig };