@thomas.f/prnext 0.1.0-alpha.1

package/compat/navigation-server.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const controls = require('./navigation-controls.cjs');
+const { currentRequest } = require('./headers.cjs');
+function clientHook(name) {
+  return function () { throw new Error(`${name} is a Client Component hook. Add "use client" to the component that calls it.`); };
+}
+module.exports.useRouter = clientHook('useRouter');
+module.exports.usePathname = clientHook('usePathname');
+module.exports.useSearchParams = clientHook('useSearchParams');
+module.exports.useParams = clientHook('useParams');
+module.exports.useSelectedLayoutSegment = clientHook('useSelectedLayoutSegment');
+module.exports.useSelectedLayoutSegments = clientHook('useSelectedLayoutSegments');
+module.exports.redirect = function redirect(url, type) {
+  if (type == null) {
+    let action = false;
+    try { action = Boolean(currentRequest().action); } catch { /* Calls outside a request keep the render default. */ }
+    type = action ? controls.RedirectType.push : controls.RedirectType.replace;
+  }
+  return controls.redirect(url, type);
+};
+module.exports.permanentRedirect = controls.permanentRedirect;
+module.exports.notFound = controls.notFound;
+module.exports.RedirectType = controls.RedirectType;
+module.exports.unstable_rethrow = controls.unstable_rethrow;

package/compat/navigation.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+const controls = require('./navigation-controls.cjs');
+
+// Server Components may import redirect/notFound. Load the client context only
+// when a client hook actually runs, since React's server build has no contexts.
+function context() {
+  const React = require('react');
+  const { AppRouterContext } = require('./app-context.cjs');
+  const value = React.useContext(AppRouterContext);
+  if (!value) throw new Error('App Router hooks must be used inside the PRNext App Router');
+  return value;
+}
+
+function useRouter() { return context().router; }
+function usePathname() { return context().pathname; }
+function useSearchParams() { return context().searchParams; }
+function useParams() { return context().params; }
+function useSelectedLayoutSegments(parallelRoutesKey = 'children') {
+  const React = require('react');
+  const { AppRouterContext } = require('./app-context.cjs');
+  // Generic PPR cannot publish segment names whose params are still unknown.
+  // The provider's getter postpones this hook only during that build phase.
+  void React.useContext(AppRouterContext)?.params;
+  const { LayoutContext } = require('./app-layout-context.cjs');
+  const segments = React.useContext(LayoutContext);
+  return segments[parallelRoutesKey] || [];
+}
+function useSelectedLayoutSegment(parallelRoutesKey = 'children') {
+  const segments = useSelectedLayoutSegments(parallelRoutesKey);
+  return (parallelRoutesKey === 'children' ? segments[0] : segments.at(-1)) ?? null;
+}
+
+class ReadonlyURLSearchParams extends URLSearchParams {
+  append() { throw new TypeError('ReadonlyURLSearchParams cannot be modified'); }
+  delete() { throw new TypeError('ReadonlyURLSearchParams cannot be modified'); }
+  set() { throw new TypeError('ReadonlyURLSearchParams cannot be modified'); }
+  sort() { throw new TypeError('ReadonlyURLSearchParams cannot be modified'); }
+}
+
+module.exports.useRouter = useRouter;
+module.exports.usePathname = usePathname;
+module.exports.useSearchParams = useSearchParams;
+module.exports.useParams = useParams;
+module.exports.useSelectedLayoutSegment = useSelectedLayoutSegment;
+module.exports.useSelectedLayoutSegments = useSelectedLayoutSegments;
+module.exports.ReadonlyURLSearchParams = ReadonlyURLSearchParams;
+module.exports.redirect = controls.redirect;
+module.exports.permanentRedirect = controls.permanentRedirect;
+module.exports.notFound = controls.notFound;
+module.exports.RedirectType = controls.RedirectType;
+module.exports.unstable_rethrow = controls.unstable_rethrow;

package/compat/navigation.d.cts

@@ -0,0 +1,28 @@
+export interface NavigateOptions { scroll?: boolean }
+export interface PrefetchOptions { onInvalidate?: () => void }
+export interface AppRouterInstance {
+  push(href: string, options?: NavigateOptions): void;
+  replace(href: string, options?: NavigateOptions): void;
+  refresh(): void;
+  back(): void;
+  forward(): void;
+  prefetch(href: string, options?: PrefetchOptions): void;
+}
+export class ReadonlyURLSearchParams extends URLSearchParams {
+  append(): never;
+  delete(): never;
+  set(): never;
+  sort(): never;
+}
+export function useRouter(): AppRouterInstance;
+export function usePathname(): string;
+export function useSearchParams(): ReadonlyURLSearchParams;
+export function useParams<T extends Record<string, string | string[]> = Record<string, string | string[]>>(): T;
+export function useSelectedLayoutSegment(parallelRoutesKey?: string): string | null;
+export function useSelectedLayoutSegments(parallelRoutesKey?: string): string[];
+export const RedirectType: Readonly<{ push: 'push'; replace: 'replace' }>;
+export type RedirectType = 'push' | 'replace';
+export function redirect(url: string, type?: RedirectType): never;
+export function permanentRedirect(url: string, type?: RedirectType): never;
+export function notFound(): never;
+export function unstable_rethrow(error: unknown): void;

package/compat/next-app-router-context.cjs

@@ -0,0 +1,6 @@
+'use client';
+'use strict';
+const React = require('react');
+const AppRouterContext = React.createContext(null);
+AppRouterContext.displayName = 'AppRouterContext';
+exports.AppRouterContext = AppRouterContext;

package/compat/next-router-context.cjs

@@ -0,0 +1,3 @@
+'use client';
+'use strict';
+exports.RouterContext = require('./router.cjs').RouterContext;

package/compat/og.cjs

@@ -0,0 +1,32 @@
+'use strict';
+let implementation;
+function renderer() {
+  return implementation ||= import('../runtime/og/index.node.mjs').catch(error => {
+    if (error.code !== 'ERR_MODULE_NOT_FOUND') throw error;
+    return import('../runtime/og-loader.mjs').then(module => module.loadImageRenderer());
+  });
+}
+class ImageResponse extends Response {
+  constructor(element, options = {}) {
+    const headers = new Headers(options.headers);
+    if (!headers.has('content-type')) headers.set('content-type', 'image/png');
+    if (!headers.has('cache-control')) headers.set('cache-control', process.env.NODE_ENV === 'development' ? 'no-cache, no-store' : 'public, immutable, no-transform, max-age=31536000');
+    let reader;
+    let cancelled = false;
+    super(new ReadableStream({
+      async start(controller) {
+        try {
+          const { ImageResponse: Render } = await renderer();
+          if (cancelled) return;
+          reader = new Render(element, options).body.getReader();
+        } catch (error) { controller.error(error); }
+      },
+      async pull(controller) {
+        try { const chunk = await reader.read(); if (chunk.done) controller.close(); else controller.enqueue(chunk.value); }
+        catch (error) { controller.error(error); }
+      },
+      cancel(reason) { cancelled = true; return reader?.cancel(reason); },
+    }), { status: options.status, statusText: options.statusText, headers });
+  }
+}
+module.exports = { ImageResponse };

package/compat/og.d.cts

@@ -0,0 +1 @@
+export { ImageResponse, type ImageResponseOptions } from '@vercel/og';

package/compat/paths.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+function normalizeBasePath(value = '') {
+  if (typeof value !== 'string' || (value && (!value.startsWith('/') || value.endsWith('/') || /[?#\\\s\x00-\x1f\x7f-\uffff]/.test(value) || /%(?![\da-f]{2})/i.test(value) || value.split('/').some((part, index) => index && (!part || part === '.' || part === '..'))))) {
+    throw new TypeError('basePath must be empty or an absolute path without a trailing slash, query or fragment');
+  }
+  return value;
+}
+function hasBasePath(path, basePath = '') {
+  const pathname = String(path).split(/[?#]/, 1)[0];
+  return !basePath || pathname === basePath || pathname.startsWith(`${basePath}/`);
+}
+function addBasePath(path, basePath = '') {
+  return basePath && String(path).startsWith('/') ? `${basePath}${path}` : path;
+}
+function removeBasePath(path, basePath = '') {
+  if (!basePath || !hasBasePath(path, basePath)) return path;
+  const rest = path.slice(basePath.length);
+  return !rest || rest[0] === '?' || rest[0] === '#' ? `/${rest}` : rest;
+}
+function assetBase(basePath = '', assetPrefix = '') {
+  return `${(assetPrefix || basePath).replace(/\/$/, '')}/_prnext/assets`;
+}
+// Same client policy as Next: extension URLs stay slashless. The native
+// redirect layer additionally excludes .well-known paths.
+function normalizeTrailingSlash(path, { trailingSlash = false, skipTrailingSlashRedirect = false } = {}) {
+  if (!String(path).startsWith('/') || String(path).startsWith('//') || skipTrailingSlashRedirect) return path;
+  const match = /^([^?#]*)(.*)$/.exec(path);
+  const pathname = match[1], rest = match[2];
+  const trimmed = pathname.endsWith('/') ? pathname.slice(0, -1) || '/' : pathname;
+  return (trailingSlash && !/\.[^/]+\/?$/.test(pathname) ? (pathname.endsWith('/') ? pathname : pathname + '/') : trimmed) + rest;
+}
+module.exports = { normalizeTrailingSlash, normalizeBasePath, hasBasePath, addBasePath, removeBasePath, assetBase };

package/compat/preview.cjs

@@ -0,0 +1,41 @@
+'use strict';
+const { parseCookieHeader } = require('./cookies.cjs');
+const { isDraftRequest, previewId, draftCookie, cookieHeader } = require('./draft.cjs');
+const NAME = '__next_preview_data';
+function key(input) {
+  const value = input.previewModeEncryptionKey || input.manifest?.previewModeEncryptionKey;
+  if (typeof value !== 'string' || !/^[a-f0-9]{64}$/.test(value)) throw new Error('Preview Mode requires a build with an encryption key');
+  return Buffer.from(value, 'hex');
+}
+function readPreviewData(input) {
+  if (!isDraftRequest(input)) return false;
+  const token = parseCookieHeader(cookieHeader(input.headers)).get(NAME)?.value;
+  if (!token) return {};
+  if (token.length > 2048 || !/^[A-Za-z0-9_-]+$/.test(token)) return false;
+  try {
+    const { createDecipheriv } = require('node:crypto');
+    const data = Buffer.from(token, 'base64url');
+    if (data.toString('base64url') !== token) return false;
+    if (data.length < 29) return false;
+    const cipher = createDecipheriv('aes-256-gcm', key(input), data.subarray(0, 12));
+    cipher.setAAD(Buffer.from(previewId(input))); cipher.setAuthTag(data.subarray(12, 28));
+    const payload = JSON.parse(Buffer.concat([cipher.update(data.subarray(28)), cipher.final()]).toString());
+    if (payload.v !== 1 || !Object.hasOwn(payload, 'data') || (payload.expires !== null && (!Number.isFinite(payload.expires) || payload.expires <= Date.now()))) return false;
+    return payload.data;
+  } catch { return false; }
+}
+function previewCookies(input, data, { maxAge, path = '/' } = {}) {
+  if (typeof path !== 'string' || !path.startsWith('/') || /[;\r\n\0]/.test(path)) throw new TypeError('Preview cookie path must be an absolute cookie path');
+  if (maxAge !== undefined && (!Number.isSafeInteger(maxAge) || maxAge < 0 || maxAge > 2147483647)) throw new TypeError('Preview maxAge must be a nonnegative integer number of seconds');
+  const json = JSON.stringify({ v: 1, data, expires: maxAge === undefined ? null : Date.now() + maxAge * 1000 });
+  if (data === undefined || Buffer.byteLength(json) > 2048) throw new TypeError('Preview data must be JSON serializable and fit in its 2 KiB cookie');
+  const { randomBytes, createCipheriv } = require('node:crypto');
+  const iv = randomBytes(12), cipher = createCipheriv('aes-256-gcm', key(input), iv);
+  cipher.setAAD(Buffer.from(previewId(input)));
+  const body = Buffer.concat([cipher.update(json), cipher.final()]);
+  const value = Buffer.concat([iv, cipher.getAuthTag(), body]).toString('base64url');
+  if (value.length > 2048) throw new TypeError('Encrypted preview data exceeds its 2 KiB cookie');
+  const bypass = { ...draftCookie(input, true, { path }), ...(maxAge === undefined ? {} : { maxAge }) };
+  return [bypass, { ...bypass, name: NAME, value }];
+}
+module.exports = { NAME, readPreviewData, previewCookies };

package/compat/rewrite.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+function parseRewrite(source) {
+  if (!source) return undefined;
+  if (source.length > 256 * 1024) throw new Error('Rewrite metadata exceeds the response limit');
+  const value = JSON.parse(source);
+  if (!value || typeof value.url !== 'string' || !value.url.startsWith('/') || value.url.startsWith('//') ||
+      !value.params || typeof value.params !== 'object' || Array.isArray(value.params)) {
+    throw new Error('Invalid rewrite metadata');
+  }
+  for (const parameter of Object.values(value.params)) {
+    if (typeof parameter !== 'string' && !(Array.isArray(parameter) && parameter.every(item => typeof item === 'string'))) {
+      throw new Error('Invalid rewrite parameter');
+    }
+  }
+  return value;
+}
+
+function readRewriteMarker(document) {
+  const marker = document.getElementById('__PRNEXT_REWRITE__');
+  if (!marker) return undefined;
+  const value = parseRewrite(marker.textContent);
+  marker.remove();
+  return value;
+}
+
+function readRewriteHeader(response) {
+  const value = response.headers.get('x-prnext-rewrite');
+  return value ? parseRewrite(decodeURIComponent(value)) : undefined;
+}
+
+function rewriteQuery(rewrite) {
+  const query = Object.create(null);
+  for (const [key, value] of new URL(rewrite.url, 'http://prnext.local').searchParams) {
+    if (Object.hasOwn(query, key)) query[key] = [...(Array.isArray(query[key]) ? query[key] : [query[key]]), value];
+    else query[key] = value;
+  }
+  return Object.assign(query, rewrite.params);
+}
+
+module.exports = { parseRewrite, readRewriteMarker, readRewriteHeader, rewriteQuery };

package/compat/route-request.cjs

@@ -0,0 +1,64 @@
+'use strict';
+const { NextRequest, NextURL } = require('./server.cjs');
+const { CookieStore } = require('./cookies.cjs');
+const { inCacheScope } = require('./data-cache.cjs');
+const { dynamicUsage, forceStaticRender } = require('./static-generation.cjs');
+
+const requestData = new Set(['headers', 'cookies', 'url', 'body', 'blob', 'json', 'text', 'arrayBuffer', 'formData', 'bytes']);
+const urlData = new Set(['search', 'searchParams', 'url', 'href', 'origin', 'toJSON', 'toString']);
+
+function reflect(target, property) {
+  const value = Reflect.get(target, property, target);
+  return typeof value === 'function' ? value.bind(target) : value;
+}
+
+function proxyRouteRequest(request, context) {
+  const force = forceStaticRender(context);
+  const dynamic = expression => {
+    if (inCacheScope()) throw new Error(`${expression} cannot be accessed inside unstable_cache; read it outside and pass the required values as arguments`);
+    dynamicUsage(expression, context);
+  };
+  const emptyHeaders = new Proxy(new Headers(), { get(target, property) {
+    if (['set', 'append', 'delete'].includes(property)) return () => { throw new Error('Request headers are read-only in force-static routes'); };
+    return reflect(target, property);
+  } });
+  const emptyCookies = new CookieStore('');
+  function proxyUrl(url) {
+    const searchParams = new URLSearchParams();
+    let proxy;
+    proxy = new Proxy(url, { get(target, property) {
+      if (property === 'clone') return () => proxyUrl(target.clone());
+      if (force) {
+        if (property === 'search') return '';
+        if (property === 'searchParams') return searchParams;
+        if (property === 'url') return undefined;
+        if (property === 'href') {
+          const canonical = new URL(target.href);
+          canonical.host = 'localhost:3000'; canonical.protocol = 'http:'; canonical.search = '';
+          return canonical.href;
+        }
+        if (property === 'toString' || property === 'toJSON') return () => proxy.href;
+      } else if (urlData.has(property)) dynamic(`nextUrl.${property}`);
+      return reflect(target, property);
+    }, set(target, property, value) {
+      // Native URL accessors use private slots, so mutations on a cloned
+      // nextUrl must use the real URL as their receiver as well as reads.
+      return Reflect.set(target, property, value, target);
+    } });
+    return proxy;
+  }
+  const nextUrl = proxyUrl(request.nextUrl);
+  return new Proxy(request, { get(target, property) {
+    if (property === 'nextUrl') return nextUrl;
+    if (property === 'clone') return () => proxyRouteRequest(new NextRequest(target.clone(), { nextConfig: target.nextUrl._nextConfig }), context);
+    if (force) {
+      if (property === 'headers') return emptyHeaders;
+      if (property === 'cookies') return emptyCookies;
+      if (property === 'url') return nextUrl.href;
+      if (property === 'geo' || property === 'ip') return undefined;
+    } else if (requestData.has(property)) dynamic(`request.${property}`);
+    return reflect(target, property);
+  } });
+}
+
+module.exports = { proxyRouteRequest };

package/compat/router.cjs

@@ -0,0 +1,137 @@
+'use strict';
+
+const React = require('react');
+const { rewriteQuery } = require('./rewrite.cjs');
+const { removeBasePath } = require('./paths.cjs');
+const { localePath } = require('./locale.cjs');
+const RouterContext = React.createContext(null);
+
+function formatUrl(value) {
+  if (typeof value === 'string') return value;
+  if (!value || typeof value !== 'object') throw new TypeError('Expected a URL string or object');
+  let pathname = value.pathname || '';
+  const query = new URLSearchParams(typeof value.query === 'string' ? value.query : undefined);
+  for (const [name, values] of Object.entries(typeof value.query === 'object' && value.query || {})) {
+    for (const item of Array.isArray(values) ? values : [values]) {
+      if (item !== undefined && item !== null) query.append(name, String(item));
+    }
+  }
+  // Interpolate dynamic route names when a URL object is supplied.
+  pathname = pathname.replace(/\[\[\.\.\.([^\]]+)\]\]|\[\.\.\.([^\]]+)\]|\[([^\]]+)\]/g, (match, optional, catchall, single) => {
+    const name = optional || catchall || single;
+    const raw = typeof value.query === 'string' ? (query.has(name) ? query.getAll(name) : undefined) : value.query?.[name];
+    if (raw === undefined) return optional ? '' : match;
+    query.delete(name);
+    return (Array.isArray(raw) ? raw : [raw]).map(item => encodeURIComponent(String(item))).join('/');
+  });
+  const search = (value.search != null ? String(value.search).replace(/^\?/, '') : query.toString()).replace(/#/g, '%23');
+  const hash = value.hash ? `#${String(value.hash).replace(/^#/, '')}` : '';
+  let protocol = value.protocol || '';
+  if (protocol && !protocol.endsWith(':')) protocol += ':';
+  let host = value.host || '';
+  if (!host && value.hostname) {
+    host = value.hostname.includes(':') && !value.hostname.startsWith('[') ? `[${value.hostname}]` : value.hostname;
+    if (value.port) host += `:${value.port}`;
+  }
+  if (value.auth && host) host = `${encodeURIComponent(value.auth).replace(/%3A/i, ':')}@${host}`;
+  const slashes = value.slashes || (host && (!protocol || /^(?:https?|ftp|gopher|file):$/.test(protocol)));
+  if (slashes && pathname && !pathname.startsWith('/')) pathname = `/${pathname}`;
+  pathname = pathname.replace(/[?#]/g, encodeURIComponent);
+  return `${protocol}${slashes ? '//' : ''}${host}${pathname}${search ? `?${search}` : ''}${hash}`;
+}
+
+const handlers = new Map();
+const events = {
+  on(type, callback) { const list = handlers.get(type) || []; list.push(callback); handlers.set(type, list); },
+  off(type, callback) { const list = handlers.get(type); if (!list) return; const index = list.indexOf(callback); if (index !== -1) list.splice(index, 1); if (!list.length) handlers.delete(type); },
+  emit(type, ...args) { for (const callback of [...(handlers.get(type) || [])]) callback(...args); },
+};
+let controller;
+function installPagesRouter(value) { controller = value; }
+function navigate(url, as, options, replace) {
+  if (typeof window === 'undefined') throw new Error('Router navigation is only available in the browser');
+  if (controller) return controller.navigate(url, as, { ...options, replace });
+  const target = new URL(formatUrl(as || url), window.location.href);
+  if (!['http:', 'https:'].includes(target.protocol)) throw new Error('Unsupported navigation protocol');
+  window.location[replace ? 'replace' : 'assign'](target.href);
+  return Promise.resolve(true);
+}
+const methods = {
+  push: (url, as, options) => navigate(url, as, options, false),
+  replace: (url, as, options) => navigate(url, as, options, true),
+  reload: () => { if (typeof window !== 'undefined') window.location.reload(); },
+  back: () => { if (typeof window !== 'undefined') { controller?.saveScroll(); window.history.back(); } },
+  forward: () => { if (typeof window !== 'undefined') { controller?.saveScroll(); window.history.forward(); } },
+  prefetch: (url, as, options) => controller ? controller.prefetch(url, as, options) : Promise.resolve(),
+  beforePopState: callback => { if (controller) controller.beforePopState(callback); },
+};
+function makeRouter(snapshot) {
+  return { pathname: '/', query: {}, asPath: '/', basePath: '', isReady: true, isFallback: false, isPreview: false,
+    ...snapshot, route: snapshot.pathname || '/', ...methods, events };
+}
+
+function withRouteParams(query, router) {
+  for (const segment of String(router?.pathname || '').split('/')) {
+    const match = /^\[(?:\[)?(?:\.\.\.)?([^\]]+)\]\]?$/.exec(segment);
+    if (match && router?.query && Object.hasOwn(router.query, match[1])) {
+      Object.defineProperty(query, match[1], { value: router.query[match[1]], enumerable: true, configurable: true, writable: true });
+    }
+  }
+  return query;
+}
+
+function RouterProvider({ router, children, managed = false }) {
+  const [location, setLocation] = React.useState(null);
+  React.useEffect(() => {
+    if (managed) return;
+    const refresh = () => {
+      const url = new URL(window.location.href);
+      const query = router?.rewrite ? rewriteQuery(router.rewrite) : Object.create(null);
+      if (!router?.rewrite) for (const [key, value] of url.searchParams) {
+        if (Object.hasOwn(query, key)) query[key] = [...(Array.isArray(query[key]) ? query[key] : [query[key]]), value];
+        else query[key] = value;
+      }
+      withRouteParams(query, router);
+      setLocation({ query, asPath: `${localePath(removeBasePath(url.pathname, router?.basePath || ''), router?.i18n).pathname}${url.search}${url.hash}` });
+    };
+    refresh();
+    window.addEventListener('hashchange', refresh);
+    window.addEventListener('popstate', refresh);
+    return () => { window.removeEventListener('hashchange', refresh); window.removeEventListener('popstate', refresh); };
+  }, [router, managed]);
+  // A fallback data update introduces route params before the location effect reruns.
+  // Keep those params in the same render as the new props and isFallback:false.
+  const value = React.useMemo(() => makeRouter({ ...router, ...(managed ? {} : location),
+    ...(!managed && location ? { query: withRouteParams({ ...location.query }, router) } : {}),
+  }), [router, location, managed]);
+  return React.createElement(RouterContext.Provider, { value }, children);
+}
+
+function useRouter() {
+  const value = React.useContext(RouterContext);
+  if (!value) throw new Error('useRouter must be used inside the PRNext router provider');
+  return value;
+}
+
+function withRouter(Component) {
+  function WithRouter(props) { return React.createElement(Component, { ...props, router: useRouter() }); }
+  WithRouter.displayName = `withRouter(${Component.displayName || Component.name || 'Component'})`;
+  return WithRouter;
+}
+
+const singleton = { ...methods, events };
+for (const field of ['route', 'pathname', 'query', 'asPath', 'basePath', 'isReady', 'isFallback', 'isPreview', 'locale', 'locales', 'defaultLocale', 'domainLocales', 'isLocaleDomain']) {
+  Object.defineProperty(singleton, field, { enumerable: true, get() {
+    if (!controller) throw new Error('No router instance found. Use next/router in the browser or useRouter inside a page.');
+    return makeRouter(controller.snapshot())[field];
+  } });
+}
+module.exports = singleton;
+module.exports.default = singleton;
+module.exports.RouterProvider = RouterProvider;
+module.exports.RouterContext = RouterContext;
+module.exports.useRouter = useRouter;
+module.exports.withRouter = withRouter;
+module.exports.formatUrl = formatUrl;
+module.exports.makeRouter = makeRouter;
+module.exports.installPagesRouter = installPagesRouter;

package/compat/router.d.cts

@@ -0,0 +1,58 @@
+import type { ComponentType, ReactNode, ReactElement } from 'react';
+export interface UrlObject {
+  auth?: string | null;
+  host?: string | null;
+  hostname?: string | null;
+  href?: string | null;
+  path?: string | null;
+  pathname?: string | null;
+  port?: string | number | null;
+  protocol?: string | null;
+  slashes?: boolean | null;
+  query?: string | Record<string, string | number | boolean | Array<string | number | boolean> | null | undefined> | null;
+  search?: string | null;
+  hash?: string | null;
+}
+export interface RouterSnapshot {
+  locale?: string;
+  locales?: string[];
+  defaultLocale?: string;
+  domainLocales?: NonNullable<import('./index.js').NextConfig['i18n']>['domains'];
+  isLocaleDomain?: boolean;
+  pathname: string;
+  query: Record<string, string | string[] | undefined>;
+  asPath: string;
+  isReady?: boolean;
+  isFallback?: boolean;
+  isPreview?: boolean;
+  basePath?: string;
+}
+export interface PRNextRouter extends RouterSnapshot {
+  route: string;
+  isReady: boolean;
+  isFallback: boolean;
+  isPreview: boolean;
+  basePath: string;
+  push(url: string | UrlObject, as?: string | UrlObject, options?: { scroll?: boolean; shallow?: boolean; locale?: string | false }): Promise<boolean>;
+  replace(url: string | UrlObject, as?: string | UrlObject, options?: { scroll?: boolean; shallow?: boolean; locale?: string | false }): Promise<boolean>;
+  prefetch(url: string | UrlObject, as?: string | UrlObject, options?: { priority?: boolean; locale?: string | false }): Promise<void>;
+  beforePopState(callback: (state: { url: string; as: string; options: { shallow?: boolean; scroll?: boolean } }) => boolean): void;
+  events: RouterEvents;
+  reload(): void;
+  back(): void;
+  forward(): void;
+}
+export type RouterEvent = 'routeChangeStart' | 'beforeHistoryChange' | 'routeChangeComplete' | 'routeChangeError' | 'hashChangeStart' | 'hashChangeComplete';
+export interface RouterEvents {
+  on(type: RouterEvent, callback: (...args: any[]) => void): void;
+  off(type: RouterEvent, callback: (...args: any[]) => void): void;
+  emit(type: RouterEvent, ...args: any[]): void;
+}
+export type NextRouter = PRNextRouter;
+export function useRouter(): PRNextRouter;
+export function RouterProvider(props: { router: RouterSnapshot; children?: ReactNode; managed?: boolean }): ReactElement;
+export function withRouter<Props extends { router: PRNextRouter }>(Component: ComponentType<Props>): ComponentType<Omit<Props, 'router'>>;
+export function formatUrl(url: string | UrlObject): string;
+export function makeRouter(snapshot: RouterSnapshot): PRNextRouter;
+declare const router: PRNextRouter;
+export default router;

package/compat/script-context.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+const React = require('react');
+
+module.exports.ScriptContext = React.createContext({});