@wular/coder 0.3.18 → 0.4.1

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-XUUIDXY5.js

@@ -0,0 +1,627 @@
+import { createRequire as __coderRequire } from "node:module";
+const __pnextRoot = __coderRequire(import.meta.url).resolve("@wular/pnext").replace(/\/src\/index\.ts$/, "");
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire(("file://" + __pnextRoot + "/package.json"));
+import {
+  frameworkRuntimeAliasEntries,
+  pnextAliases
+} from "./chunk-JESFYECC.js";
+import {
+  readText
+} from "./chunk-2HFY3DQT.js";
+import {
+  escapeRegex,
+  isIdentifier,
+  uniqueIdentifier
+} from "./chunk-4P5CMIYT.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/aliases.ts
+import path3 from "node:path";
+import { createRequire } from "node:module";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/actions/client-plugin.ts
+import path2 from "node:path";
+import { realpathSync } from "node:fs";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/actions/ids.ts
+import { createHash } from "node:crypto";
+import path from "node:path";
+function actionId(filePath, exportName, root) {
+  const key = workspaceRelative(filePath, root);
+  return createHash("sha256").update(key).update("\0").update(exportName).digest("hex").slice(0, 12);
+}
+function workspaceRelative(filePath, root) {
+  const rel = root ? path.relative(root, filePath) : filePath;
+  return toPosix(rel);
+}
+function toPosix(value) {
+  return value.split(path.sep).join("/");
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/actions/detect.ts
+var DIRECTIVE = /^(['"])use server\1\s*;?$/;
+var CACHE_DIRECTIVE = /^(['"])use cache\1\s*;?$/;
+function moduleLevelUseServer(source) {
+  const first = firstStatementText(stripLeading(source));
+  return first !== void 0 && DIRECTIVE.test(first.trim());
+}
+function moduleLevelUseCache(source) {
+  const first = firstStatementText(stripLeading(source));
+  return first !== void 0 && CACHE_DIRECTIVE.test(first.trim());
+}
+function inlineUseServerFunctions(source) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const fnDecl = /(\bexport\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*\{\s*(['"])use server\3\s*;?/g;
+  collect(fnDecl, source, found, seen, { nameGroup: 2, exportGroup: 1, dirGroup: 3 });
+  const arrowOrExpr = /(\bexport\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[A-Za-z_$][\w$]*|function\s*\*?\s*\([^)]*\))\s*(?:=>\s*)?\{\s*(['"])use server\3\s*;?/g;
+  collect(arrowOrExpr, source, found, seen, { nameGroup: 2, exportGroup: 1, dirGroup: 3 });
+  return found.sort((a, b) => a.start - b.start);
+}
+function collect(pattern, source, out, seen, groups) {
+  let match;
+  while (match = pattern.exec(source)) {
+    const name = match[groups.nameGroup];
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    out.push({
+      name,
+      exported: Boolean(match[groups.exportGroup]),
+      start: match.index,
+      directiveEnd: match.index + match[0].length
+    });
+  }
+}
+function moduleActionExports(source) {
+  const names = /* @__PURE__ */ new Set();
+  const declRe = /\bexport\s+(?:async\s+)?(?:function\s*\*?\s+|const\s+|let\s+|var\s+|class\s+)([A-Za-z_$][\w$]*)/g;
+  for (let m; m = declRe.exec(source); ) if (m[1]) names.add(m[1]);
+  if (/\bexport\s+default\b/.test(source)) names.add("default");
+  const listRe = /\bexport\s+(?!type\b)\{([^}]*)\}/g;
+  for (let m; m = listRe.exec(source); ) {
+    for (const part of (m[1] ?? "").split(",")) {
+      const trimmed = part.trim();
+      if (!trimmed || trimmed.startsWith("type ")) continue;
+      const exportedName = /\bas\s+([A-Za-z_$][\w$]*)\s*$/.exec(trimmed)?.[1];
+      const name = exportedName ?? trimmed;
+      if (/^[A-Za-z_$][\w$]*$/.test(name)) names.add(name);
+    }
+  }
+  return [...names];
+}
+function stripLeading(source) {
+  let s = source.replace(/^\uFEFF/, "");
+  if (s.startsWith("#!")) {
+    const nl = s.indexOf("\n");
+    s = nl === -1 ? "" : s.slice(nl + 1);
+  }
+  return s;
+}
+function firstStatementText(source) {
+  let i = 0;
+  const n = source.length;
+  while (i < n) {
+    const ch = source[i];
+    if (ch === " " || ch === "	" || ch === "\r" || ch === "\n") {
+      i++;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "/") {
+      const nl = source.indexOf("\n", i);
+      if (nl === -1) return void 0;
+      i = nl + 1;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "*") {
+      const end2 = source.indexOf("*/", i + 2);
+      if (end2 === -1) return void 0;
+      i = end2 + 2;
+      continue;
+    }
+    break;
+  }
+  if (i >= n) return void 0;
+  let j = i;
+  while (j < n && source[j] !== "\n" && source[j] !== ";") j++;
+  const end = source[j] === ";" ? j + 1 : j;
+  return source.slice(i, end);
+}
+function opensWithUseServerDirective(fn) {
+  if (typeof fn !== "function") return false;
+  let source;
+  try {
+    source = String(fn);
+  } catch {
+    return false;
+  }
+  const body = source.indexOf("{", source.indexOf(")") + 1);
+  if (body === -1) return false;
+  return /^\s*(['"])use server\1/.test(source.slice(body + 1));
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/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("\n") + "\n";
+}
+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, " ");
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/actions/client-plugin.ts
+var clientActionState;
+function setClientActionModules(root, files) {
+  const originals = /* @__PURE__ */ new Set();
+  const canonicalFiles = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    originals.add(path2.resolve(file));
+    canonicalFiles.add(canonical(file));
+  }
+  clientActionState = originals.size > 0 ? { root, files: originals, canonicalFiles } : void 0;
+}
+function canonical(file) {
+  const abs = path2.resolve(file);
+  try {
+    return realpathSync.native(abs);
+  } catch {
+    return abs;
+  }
+}
+function clearClientActionModules() {
+  clientActionState = void 0;
+}
+function isActionModule(file) {
+  if (!clientActionState) return false;
+  return clientActionState.files.has(path2.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 void 0;
+        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);
+  return clientStubSource({ modulePath: file, 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) : void 0);
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/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("\n");
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/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 void 0;
+  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((path4) => `  - ${path4}`).join("\n") + `
+See https://pnext.dev/docs/compat ("Smaller surfaces") and report the library that needs a new shim.`;
+      }
+    }
+    return void 0;
+  }
+  if (/^react(-dom)?(\/|$)/.test(specifier) && !reactCompatEnabled(config)) {
+    return `'${specifier}' requires React compatibility. Enable compat.react (or compat.next) in pnext.config.ts.`;
+  }
+  return void 0;
+}
+function compatAliases(config, target) {
+  return {
+    ...frameworkRuntimeAliasEntries(),
+    ...pnextAliases(target),
+    ...reactCompatAliases(config, target),
+    ...nextCompatAliases(config, target)
+  };
+}
+function reactServerLayerAliases(config) {
+  if (!reactCompatEnabled(config)) return {};
+  const reactRoot = path3.resolve((__pnextRoot + "/src/compat"), "react");
+  return {
+    react: path3.join(reactRoot, "react-server.ts"),
+    "react-dom": path3.join(reactRoot, "dom-react-server.ts")
+  };
+}
+function reactCompatAliases(config, target) {
+  if (!reactCompatEnabled(config)) return {};
+  const reactRoot = path3.resolve((__pnextRoot + "/src/compat"), "react");
+  const runtime = frameworkRuntimeAliasEntries();
+  return {
+    react: path3.join(reactRoot, target === "client" ? "client.ts" : "server.ts"),
+    // dom.ts wraps preact/compat with the form-action hooks react-dom ships
+    // (useFormState/useFormStatus/requestFormReset).
+    "react-dom": path3.join(reactRoot, "dom.ts"),
+    "react-dom/client": runtime["preact/compat/client"],
+    // react-dom/server (+ .edge/.browser entrypoints) shimmed over
+    // preact-render-to-string for the synchronous string renderers.
+    "react-dom/server": path3.join(reactRoot, "dom-server.ts"),
+    "react-dom/server.edge": path3.join(reactRoot, "dom-server.ts"),
+    "react-dom/server.browser": path3.join(reactRoot, "dom-server.ts"),
+    "react/jsx-runtime": runtime["preact/jsx-runtime"],
+    "react/jsx-dev-runtime": runtime["preact/jsx-dev-runtime"],
+    // React Compiler memo-cache runtime. Both the React 19 built-in specifier
+    // (`react/compiler-runtime`) and the standalone npm package name
+    // (`react-compiler-runtime`, emitted for a React 17/18 compiler target, and
+    // imported by pre-compiled libraries) map to a preact-backed shim. The npm
+    // package's own `require('react').useMemo` throws under preact SSR.
+    "react/compiler-runtime": path3.join(reactRoot, "compiler-runtime.ts"),
+    "react-compiler-runtime": path3.join(reactRoot, "compiler-runtime.ts")
+  };
+}
+function nextCompatAliases(config, target) {
+  if (!nextCompatEnabled(config)) return {};
+  return nextCompatAliasEntries(target);
+}
+function nextCompatAliasEntries(target) {
+  const nextRoot = path3.resolve((__pnextRoot + "/src/compat"), "next");
+  return withJsExtensionAliases({
+    next: path3.join(nextRoot, "index.ts"),
+    // Client variant avoids node:async_hooks (render cache-meta collector) in
+    // browser bundles; the APIs are server-only in Next anyway.
+    "next/cache": path3.join(nextRoot, target === "client" ? "client-cache.ts" : "cache.ts"),
+    "next/config": path3.join(nextRoot, "config.ts"),
+    // CJS so an app `require('next/constants')` loads a genuine CommonJS module: the server runtime's
+    // onLoad transform only intercepts `[jt]sx?`, so a `.cjs` external is left to Bun's native loader
+    // and stays synchronously requirable - an ESM `.ts` external forced through that transform becomes
+    // async and require() returns undefined for every named export.
+    "next/constants": path3.join(nextRoot, "constants.cjs"),
+    "next/dynamic": path3.join(nextRoot, "dynamic.tsx"),
+    "next/error": path3.join(nextRoot, "error.tsx"),
+    "next/font": path3.join(nextRoot, "font", "index.ts"),
+    "next/font/google": path3.join(nextRoot, "font", "google.ts"),
+    "next/font/local": path3.join(nextRoot, "font", "local.ts"),
+    "next/form": path3.join(nextRoot, "form.tsx"),
+    "next/head": path3.join(nextRoot, "head.tsx"),
+    "next/headers": path3.join(nextRoot, "headers.ts"),
+    "next/image": path3.join(nextRoot, "image.tsx"),
+    // The legacy component blanks a lazy image's `src` until it is near the
+    // viewport — its own module, not an alias of the modern one.
+    "next/legacy/image": path3.join(nextRoot, "legacy-image.tsx"),
+    "next/link": path3.join(nextRoot, "link.tsx"),
+    "next/navigation": path3.join(
+      nextRoot,
+      target === "client" ? "client-navigation.ts" : "navigation.ts"
+    ),
+    "next/offline": path3.join(nextRoot, "offline.ts"),
+    "next/og": path3.join(nextRoot, "og.ts"),
+    "@vercel/og": path3.join(nextRoot, "og.ts"),
+    "next/root-params": path3.join(nextRoot, "root-params.ts"),
+    "next/router": path3.join(nextRoot, "router.ts"),
+    "next/script": path3.join(nextRoot, target === "client" ? "client-script.tsx" : "script.tsx"),
+    "next/web-vitals": path3.join(nextRoot, "web-vitals.ts"),
+    // Client variant avoids node:async_hooks (request scope / ppr / revalidate)
+    // in browser bundles; the request-scope APIs are server-only in Next anyway.
+    "next/server": path3.join(nextRoot, target === "client" ? "client-server.ts" : "server.ts"),
+    // Server compiles accept the marker (react-server condition equivalent);
+    // client bundles keep the package's own error behavior.
+    ...target === "server" ? { "server-only": path3.join(nextRoot, "server-only.ts") } : {},
+    // client-only must resolve on both targets: a 'use client' page importing it
+    // is legitimately SSR'd (server compile) as well as browser-bundled.
+    "client-only": path3.join(nextRoot, "client-only.ts"),
+    // The styled-jsx source transform (css/styled-jsx.ts) rewrites <style jsx>
+    // blocks to import from this specifier; apps never install styled-jsx.
+    "styled-jsx": path3.join(nextRoot, "..", "css", "styled-jsx-runtime.ts"),
+    // Deep next/dist imports that show up in real Next apps and e2e fixtures.
+    // Exact-match aliases only; unknown next/dist paths keep failing through
+    // missingCompatImportError / normal resolution.
+    "next/dist/client/components/app-router-headers": path3.join(
+      nextRoot,
+      "dist",
+      "client",
+      "components",
+      "app-router-headers.ts"
+    ),
+    "next/dist/server/web/spec-extension/unstable-cache": path3.join(
+      nextRoot,
+      "dist",
+      "server",
+      "web",
+      "spec-extension",
+      "unstable-cache.ts"
+    ),
+    "next/dist/server/web/spec-extension/unstable-no-store": path3.join(
+      nextRoot,
+      "dist",
+      "server",
+      "web",
+      "spec-extension",
+      "unstable-no-store.ts"
+    ),
+    "next/dist/server/web/spec-extension/revalidate": path3.join(
+      nextRoot,
+      "dist",
+      "server",
+      "web",
+      "spec-extension",
+      "revalidate.ts"
+    ),
+    // Direct import of the work-unit store (see the shim's header). Server-only;
+    // a browser bundle never reaches request context. CJS for the same reason as
+    // next/constants above: apps `require()` this deep internal, and a `.ts`
+    // external would become an async module through the onLoad transform, making
+    // the require() throw outright.
+    ...target === "server" ? {
+      "next/dist/server/app-render/work-unit-async-storage.external": path3.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;
+}
+var compatSuspense;
+async function ensureCompatSuspense(config) {
+  if (compatSuspense !== void 0 || !reactCompatEnabled(config)) return;
+  compatSuspense = (await import("preact/compat")).Suspense;
+}
+function compatSuspenseType() {
+  return compatSuspense;
+}
+var fontRuntimePaths = {
+  server: path3.join((__pnextRoot + "/src/compat"), "next", "font", "runtime.ts"),
+  client: path3.join((__pnextRoot + "/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 callerFile = localFontCallerFile(file, root);
+  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("\n");
+}
+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 = /* @__PURE__ */ 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 (path3.isAbsolute(file)) return file;
+  if (file.startsWith(".")) return path3.resolve(root ?? process.cwd(), file);
+  if (!root) return file;
+  try {
+    return createRequire(path3.join(root, "pnext-resolve.cjs")).resolve(file);
+  } catch {
+    return file;
+  }
+}
+
+export {
+  actionId,
+  workspaceRelative,
+  moduleLevelUseServer,
+  moduleLevelUseCache,
+  inlineUseServerFunctions,
+  moduleActionExports,
+  opensWithUseServerDirective,
+  setClientActionModules,
+  canonical,
+  clearClientActionModules,
+  isClientActionModule,
+  clientActionModulesRoot,
+  clientActionModuleFiles,
+  actionStubSourceFor,
+  actionClientStubPlugin,
+  loadClientActionSource,
+  canonicalActionId,
+  reactCompatEnabled,
+  reactCompilerOptions,
+  nextCompatEnabled,
+  missingCompatImportError,
+  compatAliases,
+  reactServerLayerAliases,
+  nextCompatAliases,
+  ensureCompatSuspense,
+  compatSuspenseType,
+  rewriteNextFontSource
+};