@wular/pnext 0.1.5 → 0.1.7

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

@@ -0,0 +1,483 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  isReleaseCompile
+} from "./index-3xbr4eyv.js";
+import {
+  actionId,
+  moduleActionExports,
+  moduleLevelUseCache,
+  moduleLevelUseServer
+} from "./index-6q7zvrap.js";
+import {
+  readText,
+  toPosixPath
+} from "./index-20ppawv7.js";
+import {
+  frameworkRuntimeAliasEntries,
+  pnextAliases
+} from "./index-x93hv0sc.js";
+import {
+  escapeRegex,
+  isIdentifier,
+  uniqueIdentifier
+} from "./index-qjj6gddn.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/compat/aliases.ts
+import path2 from "path";
+import { createRequire } from "module";
+
+// src/compat/actions/client-plugin.ts
+import path from "path";
+import { realpathSync } from "fs";
+
+// src/compat/actions/client-stub.ts
+function clientStubSource(module) {
+  const lines = [];
+  lines.push(`// Generated pnext server-action client stub.`);
+  lines.push(`// Module: ${sanitizeComment(module.modulePath)}`);
+  lines.push(RUNTIME);
+  for (const name of module.exports) {
+    const id = module.actionIds[name];
+    if (!id)
+      continue;
+    const decl = name === "default" ? "export default" : `export const ${name} =`;
+    lines.push(`${decl} __pnextAction(${JSON.stringify(id)});`);
+  }
+  return lines.join(`
+`) + `
+`;
+}
+var RUNTIME = `
+function __pnextAction(id) {
+  const action = async function (...args) {
+    const runtime = (process.browser || typeof window !== 'undefined') ? window.__PNEXT_ACTIONS__ : undefined;
+    if (runtime) {
+      return runtime.call(id, args);
+    }
+    // Called on the SERVER: a client-imported 'use server' function invoked during a server
+    // render/action (a bound action a client page's useActionState registered, dispatched in the no-JS
+    // progressive path). Route it through the endpoint's server-side dispatcher, which resolves the id
+    // to the real compiled action and runs it in the active request scope, instead of throwing as if
+    // the browser runtime were missing.
+    const server =
+      typeof globalThis !== 'undefined' ? globalThis.__PNEXT_SERVER_ACTIONS__ : undefined;
+    if (server) {
+      return server.call(id, args);
+    }
+    throw new Error('pnext action runtime is not installed (is Next compat enabled?)');
+  };
+  action.$$pnextActionId = id;
+  return action;
+}
+`;
+function sanitizeComment(value) {
+  return value.replace(/\*\//g, "*\\/").replace(/[\r\n]/g, " ");
+}
+
+// src/compat/actions/client-plugin.ts
+var clientActionState;
+function setClientActionModules(root, files) {
+  const originals = new Set;
+  const canonicalFiles = new Set;
+  for (const file of files) {
+    originals.add(path.resolve(file));
+    canonicalFiles.add(canonical(file));
+  }
+  clientActionState = originals.size > 0 ? { root, files: originals, canonicalFiles } : undefined;
+}
+function canonical(file) {
+  const abs = path.resolve(file);
+  try {
+    return realpathSync.native(abs);
+  } catch {
+    return abs;
+  }
+}
+function clearClientActionModules() {
+  clientActionState = undefined;
+}
+function hasClientActionModules() {
+  return clientActionState !== undefined && clientActionState.files.size > 0;
+}
+function isActionModule(file) {
+  if (!clientActionState)
+    return false;
+  return clientActionState.files.has(path.resolve(file)) || clientActionState.canonicalFiles.has(canonical(file));
+}
+function isClientActionModule(file) {
+  return isActionModule(file);
+}
+function clientActionModulesRoot() {
+  return clientActionState?.root;
+}
+function clientActionModuleFiles() {
+  return clientActionState ? [...clientActionState.files] : [];
+}
+function actionStubSourceFor(file, root) {
+  return stubSourceFor(file, root ?? clientActionState?.root);
+}
+function actionClientStubPlugin() {
+  const paths = clientActionState ? [...clientActionState.files, ...clientActionState.canonicalFiles] : [];
+  const filter = new RegExp(`^(?:${[...new Set(paths)].map(escapeRegex).join("|")})$`);
+  return {
+    name: "pnext-action-client-stub",
+    setup(build) {
+      if (paths.length === 0)
+        return;
+      build.onLoad({ filter, namespace: "file" }, async (args) => {
+        if (!isActionModule(args.path))
+          return;
+        return {
+          contents: await stubSourceFor(args.path, clientActionState?.root),
+          loader: "js"
+        };
+      });
+    }
+  };
+}
+async function stubSourceFor(file, root) {
+  const source = await readText(file);
+  return stubSourceFromSource(file, source, root);
+}
+function stubSourceFromSource(file, source, root) {
+  if (!moduleLevelUseServer(source) && !moduleLevelUseCache(source))
+    return "export {};";
+  const exports = moduleActionExports(source);
+  const actionIds = {};
+  for (const name of exports)
+    actionIds[name] = canonicalActionId(file, name, root);
+  const modulePath = root ? toPosixPath(path.relative(root, file)) : file;
+  return clientStubSource({ modulePath, exports, actionIds });
+}
+async function loadClientActionSource(file, root) {
+  const source = await readText(file);
+  if (!moduleLevelUseServer(source) && !moduleLevelUseCache(source))
+    return { source };
+  return { source, stubSource: stubSourceFromSource(file, source, root) };
+}
+function canonicalActionId(file, exportName, root) {
+  return actionId(canonical(file), exportName, root ? canonical(root) : undefined);
+}
+
+// src/compat/ppr/root-params-transform.ts
+var ROOT_PARAMS_SPECIFIER = /['"]next\/root-params['"]/;
+var IMPORT_RE = /^[ \t]*import\s+\{([^}]*)\}\s+from\s+['"]next\/root-params['"]\s*;?[ \t]*(?:\r?\n)?/gm;
+function parseBindings(clause) {
+  return clause.split(",").map((part) => part.trim()).filter(Boolean).flatMap((part) => {
+    if (part.startsWith("type "))
+      return [];
+    const [importedRaw, localRaw] = part.split(/\s+as\s+/);
+    const imported = importedRaw?.trim();
+    const local = (localRaw ?? importedRaw)?.trim();
+    if (!imported || !local || !isIdentifier(imported) || !isIdentifier(local))
+      return [];
+    return [{ imported, local }];
+  });
+}
+function rewriteRootParamsSource(source) {
+  if (!ROOT_PARAMS_SPECIFIER.test(source))
+    return source;
+  const proxyName = uniqueIdentifier(source, "__pnextRootParams");
+  const declarations = [];
+  let importedProxy = false;
+  const rewritten = source.replace(IMPORT_RE, (_statement, clause) => {
+    const bindings = parseBindings(clause);
+    if (bindings.length === 0)
+      return "";
+    importedProxy = true;
+    for (const { imported, local } of bindings) {
+      declarations.push(`const ${local} = ${proxyName}[${JSON.stringify(imported)}];`);
+    }
+    return "";
+  });
+  if (!importedProxy)
+    return source;
+  return [
+    `import ${proxyName} from ${JSON.stringify("next/root-params")};`,
+    ...declarations,
+    rewritten
+  ].join(`
+`);
+}
+
+// src/compat/aliases.ts
+function reactCompatEnabled(config) {
+  return Boolean(config.compat?.next || config.compat?.react || reactCompilerOptions(config));
+}
+function reactCompilerOptions(config) {
+  if (!config.compat?.reactCompiler)
+    return;
+  return { target: "18" };
+}
+function nextCompatEnabled(config) {
+  return Boolean(config.compat?.next);
+}
+var SHIMMED_NEXT_DIST_PATHS = [
+  "next/dist/client/components/app-router-headers",
+  "next/dist/server/web/spec-extension/unstable-cache",
+  "next/dist/server/web/spec-extension/unstable-no-store",
+  "next/dist/server/web/spec-extension/revalidate",
+  "next/dist/server/app-render/work-unit-async-storage.external"
+];
+function missingCompatImportError(config, specifier) {
+  if (/^next(\/|$)/.test(specifier)) {
+    if (!nextCompatEnabled(config)) {
+      return `'${specifier}' requires Next compatibility. Enable compat.next in pnext.config.ts.`;
+    }
+    if (specifier.startsWith("next/dist/")) {
+      const bare = specifier.replace(/\.js$/, "");
+      if (!SHIMMED_NEXT_DIST_PATHS.includes(bare)) {
+        return `'${specifier}' is not a supported import: next/dist internals are not part of the ` + `public surface pnext shims. Only these next/dist/* paths are shimmed:
+` + SHIMMED_NEXT_DIST_PATHS.map((path3) => `  - ${path3}`).join(`
+`) + `
+See https://pnext.dev/docs/compat ("Smaller surfaces") and report the library that needs a new shim.`;
+      }
+    }
+    return;
+  }
+  if (/^react(-dom)?(\/|$)/.test(specifier) && !reactCompatEnabled(config)) {
+    return `'${specifier}' requires React compatibility. Enable compat.react (or compat.next) in pnext.config.ts.`;
+  }
+  return;
+}
+function compatAliases(config, target) {
+  return {
+    ...frameworkRuntimeAliasEntries(),
+    ...pnextAliases(target),
+    ...reactCompatAliases(config, target),
+    ...nextCompatAliases(config, target)
+  };
+}
+function reactServerLayerAliases(config) {
+  if (!reactCompatEnabled(config))
+    return {};
+  const reactRoot = path2.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/compat", "react");
+  return {
+    react: path2.join(reactRoot, "react-server.ts"),
+    "react-dom": path2.join(reactRoot, "dom-react-server.ts")
+  };
+}
+function reactCompatAliases(config, target) {
+  if (!reactCompatEnabled(config))
+    return {};
+  const reactRoot = path2.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/compat", "react");
+  const runtime = frameworkRuntimeAliasEntries();
+  return {
+    react: path2.join(reactRoot, target === "client" ? "client.ts" : "server.ts"),
+    "react-dom": path2.join(reactRoot, "dom.ts"),
+    "react-dom/client": runtime["preact/compat/client"],
+    "react-dom/server": path2.join(reactRoot, "dom-server.ts"),
+    "react-dom/server.edge": path2.join(reactRoot, "dom-server.ts"),
+    "react-dom/server.browser": path2.join(reactRoot, "dom-server.ts"),
+    "react/jsx-runtime": runtime["preact/jsx-runtime"],
+    "react/jsx-dev-runtime": runtime["preact/jsx-dev-runtime"],
+    "react/compiler-runtime": path2.join(reactRoot, "compiler-runtime.ts"),
+    "react-compiler-runtime": path2.join(reactRoot, "compiler-runtime.ts")
+  };
+}
+function nextCompatAliases(config, target) {
+  if (!nextCompatEnabled(config))
+    return {};
+  return nextCompatAliasEntries(target);
+}
+function nextCompatAliasEntries(target) {
+  const nextRoot = path2.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/compat", "next");
+  return withJsExtensionAliases({
+    next: path2.join(nextRoot, "index.ts"),
+    "next/cache": path2.join(nextRoot, target === "client" ? "client-cache.ts" : "cache.ts"),
+    "next/config": path2.join(nextRoot, "config.ts"),
+    "next/constants": path2.join(nextRoot, "constants.cjs"),
+    "next/dynamic": path2.join(nextRoot, "dynamic.tsx"),
+    "next/error": path2.join(nextRoot, "error.tsx"),
+    "next/font": path2.join(nextRoot, "font", "index.ts"),
+    "next/font/google": path2.join(nextRoot, "font", "google.ts"),
+    "next/font/local": path2.join(nextRoot, "font", "local.ts"),
+    "next/form": path2.join(nextRoot, "form.tsx"),
+    "next/head": path2.join(nextRoot, "head.tsx"),
+    "next/headers": path2.join(nextRoot, "headers.ts"),
+    "next/image": path2.join(nextRoot, "image.tsx"),
+    "next/legacy/image": path2.join(nextRoot, "legacy-image.tsx"),
+    "next/link": path2.join(nextRoot, "link.tsx"),
+    "next/navigation": path2.join(nextRoot, target === "client" ? "client-navigation.ts" : "navigation.ts"),
+    "next/offline": path2.join(nextRoot, "offline.ts"),
+    "next/og": path2.join(nextRoot, "og.ts"),
+    "@vercel/og": path2.join(nextRoot, "og.ts"),
+    "next/root-params": path2.join(nextRoot, "root-params.ts"),
+    "next/router": path2.join(nextRoot, "router.ts"),
+    "next/script": path2.join(nextRoot, target === "client" ? "client-script.tsx" : "script.tsx"),
+    "next/web-vitals": path2.join(nextRoot, "web-vitals.ts"),
+    "next/server": path2.join(nextRoot, target === "client" ? "client-server.ts" : "server.ts"),
+    ...target === "server" ? { "server-only": path2.join(nextRoot, "server-only.ts") } : {},
+    "client-only": path2.join(nextRoot, "client-only.ts"),
+    "styled-jsx": path2.join(nextRoot, "..", "css", "styled-jsx-runtime.ts"),
+    "next/dist/client/components/app-router-headers": path2.join(nextRoot, "dist", "client", "components", "app-router-headers.ts"),
+    "next/dist/server/web/spec-extension/unstable-cache": path2.join(nextRoot, "dist", "server", "web", "spec-extension", "unstable-cache.ts"),
+    "next/dist/server/web/spec-extension/unstable-no-store": path2.join(nextRoot, "dist", "server", "web", "spec-extension", "unstable-no-store.ts"),
+    "next/dist/server/web/spec-extension/revalidate": path2.join(nextRoot, "dist", "server", "web", "spec-extension", "revalidate.ts"),
+    ...target === "server" ? {
+      "next/dist/server/app-render/work-unit-async-storage.external": path2.join(nextRoot, "dist", "server", "app-render", "work-unit-async-storage.external.cjs")
+    } : {}
+  });
+}
+function withJsExtensionAliases(aliases) {
+  const entries = { ...aliases };
+  for (const [specifier, target] of Object.entries(aliases)) {
+    if (specifier !== "next")
+      entries[`${specifier}.js`] = target;
+  }
+  return entries;
+}
+function compatAliasPlugin(config) {
+  const aliases = compatAliases(config, "client");
+  const specifiers = Object.keys(aliases);
+  return {
+    name: "pnext-compat-alias",
+    setup(build) {
+      if (nextCompatEnabled(config) && hasClientActionModules()) {
+        actionClientStubPlugin().setup(build);
+      }
+      build.onResolve({ filter: /^(?:react(?:-dom)?|next)(?:\/|$)/ }, (args) => {
+        if (aliases[args.path])
+          return;
+        const message = missingCompatImportError(config, args.path);
+        return message ? { errors: [{ text: message }] } : undefined;
+      });
+      if (specifiers.length === 0)
+        return;
+      build.onResolve({ filter: new RegExp(`^(${specifiers.map(escapeRegex).join("|")})$`) }, async (args) => {
+        const target = aliases[args.path];
+        if (!target)
+          return;
+        if (path2.isAbsolute(target))
+          return { path: target };
+        return build.resolve(target, {
+          kind: args.kind,
+          importer: args.importer,
+          namespace: args.namespace,
+          resolveDir: args.resolveDir
+        });
+      });
+    }
+  };
+}
+var compatSuspense;
+async function ensureCompatSuspense(config) {
+  if (compatSuspense !== undefined || !reactCompatEnabled(config))
+    return;
+  compatSuspense = (await import("preact/compat")).Suspense;
+}
+function compatSuspenseType() {
+  return compatSuspense;
+}
+var fontRuntimePaths = {
+  server: path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/compat", "next", "font", "runtime.ts"),
+  client: path2.join(__PNEXT_PACKAGE_ROOT__ + "/src/compat", "next", "font", "runtime-client.ts")
+};
+function rewriteNextFontSource(source, file, target = "server", root) {
+  if (!source.includes("next/font") && !source.includes("next/root-params"))
+    return source;
+  source = rewriteRootParamsSource(source);
+  const runtimePath = fontRuntimePaths[target];
+  let next = rewriteNextGoogleFontImports(source, runtimePath);
+  const localFontNames = nextLocalFontImportNames(next);
+  if (localFontNames.size === 0)
+    return next;
+  const absoluteCaller = localFontCallerFile(file, root);
+  const callerFile = isReleaseCompile() && root && path2.isAbsolute(absoluteCaller) ? toPosixPath(path2.relative(root, absoluteCaller)) : absoluteCaller;
+  for (const name of localFontNames) {
+    next = next.replace(new RegExp(`(?<![.$\\w])${escapeRegex(name)}\\s*\\(`, "g"), `${name}.withFile(${JSON.stringify(callerFile)})(`);
+  }
+  for (const name of localFontNames) {
+    next = next.replace(new RegExp(`((?:export\\s+)?(?:const|let|var)\\s+)([A-Za-z_$][\\w$]*)(\\s*=\\s*)${escapeRegex(name)}\\.withFile\\(([^)]*)\\)\\(`, "g"), (_statement, declaration, binding, equals, caller) => `${declaration}${binding}${equals}${name}.withFile(${caller}, ${JSON.stringify(binding)})(`);
+  }
+  next = next.replace(/^[ \t]*import\s+([A-Za-z_$][\w$]*)\s+from\s+(['"])([^'"]+)\2\s*;?[ \t]*$/gm, (statement, name, _quote, specifier) => {
+    if (!isNextLocalFontSpecifier(specifier))
+      return statement;
+    return `import { localFont as ${name} } from ${JSON.stringify(runtimePath)};`;
+  });
+  return next;
+}
+function rewriteNextGoogleFontImports(source, runtimePath) {
+  const statements = [];
+  const helperName = uniqueIdentifier(source, "__pnextGoogleFont");
+  const namespaceHelperName = uniqueIdentifier(source, "__pnextGoogleFonts", helperName);
+  const rewritten = source.replace(/^[ \t]*import\s+(?!type\b)((?:[^\n;]|\n(?![ \t]*(?:import|export)\b))*?)\s+from\s+['"]next\/font\/google['"]\s*;?[ \t]*(?:\r?\n)?/gm, (_statement, clause) => {
+    const bindings = nextGoogleFontBindings(clause);
+    if (bindings.length === 0)
+      return "";
+    statements.push(...bindings.map((binding) => googleFontBindingSource(binding, helperName, namespaceHelperName)));
+    return "";
+  });
+  if (statements.length === 0)
+    return source;
+  return [
+    `import { googleFont as ${helperName} } from ${JSON.stringify(runtimePath)};`,
+    `const ${namespaceHelperName} = new Proxy({}, { get: (_target, key) => typeof key === 'string' ? ${helperName}(key.replace(/_/g, ' ')) : undefined });`,
+    ...statements,
+    rewritten
+  ].join(`
+`);
+}
+function nextGoogleFontBindings(clause) {
+  const trimmed = clause.trim();
+  const namespace = /^\*\s+as\s+([A-Za-z_$][\w$]*)$/.exec(trimmed)?.[1];
+  if (namespace)
+    return [{ imported: namespace, local: namespace, namespace: true }];
+  const named = /\{([\s\S]*)\}/.exec(trimmed)?.[1];
+  if (!named)
+    return [];
+  return named.split(",").map((part) => part.trim()).filter(Boolean).flatMap((part) => {
+    if (part.startsWith("type "))
+      return [];
+    const [importedRaw, localRaw] = part.split(/\s+as\s+/);
+    const imported = importedRaw?.trim();
+    const local = (localRaw ?? importedRaw)?.trim();
+    if (!imported || !local || !isIdentifier(imported) || !isIdentifier(local))
+      return [];
+    return [{ imported, local }];
+  });
+}
+function googleFontBindingSource(binding, helperName, namespaceHelperName) {
+  if (binding.namespace)
+    return `const ${binding.local} = ${namespaceHelperName};`;
+  return `const ${binding.local} = ${helperName}(${JSON.stringify(googleFontFamily(binding.imported))});`;
+}
+function googleFontFamily(exportName) {
+  return exportName.replace(/_/g, " ");
+}
+function nextLocalFontImportNames(source) {
+  const names = new Set;
+  const pattern = /\bimport\s+([A-Za-z_$][\w$]*)\s+from\s+(['"])([^'"]+)\2/g;
+  let match;
+  while (match = pattern.exec(source)) {
+    if (match[1] && match[3] && isNextLocalFontSpecifier(match[3]))
+      names.add(match[1]);
+  }
+  return names;
+}
+function isNextLocalFontSpecifier(specifier) {
+  if (specifier === "next/font/local" || specifier === "next/font/local.js")
+    return true;
+  const normalized = specifier.replace(/^file:\/\//, "").replace(/\\/g, "/");
+  return /\/compat\/next\/font\/local\.[jt]s$/.test(normalized);
+}
+function localFontCallerFile(file, root) {
+  if (path2.isAbsolute(file))
+    return file;
+  if (file.startsWith("."))
+    return path2.resolve(root ?? process.cwd(), file);
+  if (!root)
+    return file;
+  try {
+    return createRequire(path2.join(root, "pnext-resolve.cjs")).resolve(file);
+  } catch {
+    return file;
+  }
+}
+
+export { setClientActionModules, canonical, clearClientActionModules, isClientActionModule, clientActionModulesRoot, clientActionModuleFiles, actionStubSourceFor, actionClientStubPlugin, loadClientActionSource, canonicalActionId, reactCompatEnabled, reactCompilerOptions, nextCompatEnabled, SHIMMED_NEXT_DIST_PATHS, missingCompatImportError, compatAliases, reactServerLayerAliases, reactCompatAliases, nextCompatAliases, nextCompatAliasEntries, compatAliasPlugin, ensureCompatSuspense, compatSuspenseType, rewriteNextFontSource };

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

@@ -0,0 +1,101 @@
+// @bun
+import {
+  compileSource,
+  evaluateConditions,
+  loadNextConfig,
+  loadResolvedNextConfig,
+  parseConditions,
+  substitute
+} from "./index-z84ab1w0.js";
+
+// src/compat/next/config-headers.ts
+async function loadCompatHeaders(root) {
+  let config = await loadResolvedNextConfig(root);
+  if (typeof config?.headers !== "function")
+    config = await loadNextConfig(root);
+  const producer = config?.headers;
+  if (typeof producer !== "function")
+    return [];
+  let value;
+  try {
+    value = await producer();
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(value))
+    return [];
+  const rules = [];
+  for (const entry of value) {
+    if (!entry?.source || !Array.isArray(entry.headers))
+      continue;
+    const headers = parseHeaderPairs(entry.headers);
+    if (headers.length === 0)
+      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;
+    rules.push({
+      ...compiled,
+      headers,
+      has,
+      missing,
+      outsideBasePath: entry.basePath === false
+    });
+  }
+  return rules;
+}
+function parseHeaderPairs(value) {
+  const pairs = [];
+  for (const raw of value) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const { key, value: headerValue } = raw;
+    if (typeof key !== "string" || typeof headerValue !== "string")
+      continue;
+    pairs.push({ key, value: headerValue });
+  }
+  return pairs;
+}
+function resolveCompatHeaders(rules, pathname, ctx) {
+  const context = ctx ?? {
+    host: "",
+    headers: new Headers,
+    cookies: {},
+    query: new URLSearchParams
+  };
+  const resolved = [];
+  for (const rule of rules) {
+    const match = rule.regex.exec(pathname);
+    if (!match)
+      continue;
+    const params = {};
+    rule.paramNames.forEach((name, index) => {
+      params[name] = match[index + 1] ?? "";
+    });
+    const conditionParams = evaluateConditions(rule, context);
+    if (conditionParams === null)
+      continue;
+    Object.assign(params, conditionParams);
+    const hasParams = Object.keys(params).length > 0;
+    for (const pair of rule.headers) {
+      resolved.push(hasParams ? {
+        key: substitute(pair.key, params).pathname,
+        value: substitute(pair.value, params).pathname
+      } : pair);
+    }
+  }
+  return resolved;
+}
+function appPathname(pathname, basePath) {
+  if (!basePath)
+    return pathname;
+  if (pathname === basePath)
+    return "/";
+  return pathname.startsWith(`${basePath}/`) ? pathname.slice(basePath.length) : undefined;
+}
+
+export { loadCompatHeaders, resolveCompatHeaders, appPathname };

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

@@ -0,0 +1,22 @@
+// @bun
+import {
+  getWorkUnit
+} from "./index-grta8ap3.js";
+
+// src/compat/next/canonical-url.ts
+var CANONICAL_URL_KEY = Symbol.for("pnext.compat.navigation.canonicalUrl");
+function recordCanonicalUrl(from) {
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  const compat = unit.compat ??= {};
+  if (typeof compat[CANONICAL_URL_KEY] === "string")
+    return;
+  compat[CANONICAL_URL_KEY] = from.href;
+}
+function canonicalUrlHref() {
+  const value = getWorkUnit()?.compat?.[CANONICAL_URL_KEY];
+  return typeof value === "string" ? value : undefined;
+}
+
+export { recordCanonicalUrl, canonicalUrlHref };

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

@@ -0,0 +1,88 @@
+// @bun
+import {
+  readSourceSync
+} from "./index-fp8r0sqs.js";
+
+// src/compat/next/usage.ts
+import { existsSync, readdirSync } from "fs";
+import path from "path";
+var skipDirs = new Set(["node_modules", "dist", "build", "out", "coverage", "public", "target"]);
+var sourceFile = /\.(?:[cm]?[jt]sx?|mdx)$/;
+var imageApi = /next\/(?:legacy\/)?image|getImageProps|unstable_getImgProps/;
+var literalBlur = /\bplaceholder\s*[=:]\s*\{?\s*['"`]blur['"`]/;
+var opaquePlaceholder = /\bplaceholder\s*[=:]\s*(?!\{?\s*['"`])/;
+var opaqueProps = /\{\s*\.\.\.|export\s[^;]*from\s*['"]next\/(?:legacy\/)?image/;
+var cache = new Map;
+function scanRoots(root) {
+  const roots = [root];
+  for (let dir = path.dirname(root);dir !== path.dirname(dir); dir = path.dirname(dir)) {
+    if (!existsSync(path.join(dir, "pnpm-workspace.yaml")) && !existsSync(path.join(dir, "lerna.json"))) {
+      continue;
+    }
+    const packages = path.join(dir, "packages");
+    if (existsSync(packages))
+      roots.push(packages);
+    break;
+  }
+  return roots;
+}
+function appUsesBlurPlaceholder(root) {
+  const cached = cache.get(root);
+  if (cached !== undefined)
+    return cached;
+  const used = scanFirstPartySource(root, blurSource);
+  cache.set(root, used);
+  return used;
+}
+function blurSource(source) {
+  if (!imageApi.test(source))
+    return false;
+  return literalBlur.test(source) || opaquePlaceholder.test(source) || opaqueProps.test(source);
+}
+function scanFirstPartySource(root, match) {
+  return scanRoots(root).some((dir) => scan(dir, match));
+}
+function scan(dir, match) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith("."))
+      continue;
+    const file = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (skipDirs.has(entry.name))
+        continue;
+      if (scan(file, match))
+        return true;
+      continue;
+    }
+    if (!sourceFile.test(entry.name))
+      continue;
+    let source;
+    try {
+      source = readSourceSync(file);
+    } catch {
+      continue;
+    }
+    if (match(source))
+      return true;
+  }
+  return false;
+}
+var legacyProp = /\blegacyBehavior\b/;
+var reexportedLink = /export\s[^;]*from\s*['"]next\/link['"]/;
+var legacyLinkCache = new Map;
+function appUsesLegacyLink(root) {
+  const cached = legacyLinkCache.get(root);
+  if (cached !== undefined)
+    return cached;
+  const used = scanFirstPartySource(root, (source) => legacyProp.test(source) || reexportedLink.test(source));
+  legacyLinkCache.set(root, used);
+  return used;
+}
+
+export { appUsesBlurPlaceholder, scanFirstPartySource, appUsesLegacyLink };