@wular/pnext 0.1.6 → 0.1.8

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

@@ -0,0 +1,12 @@
+// @bun
+// src/utils/resource-query.ts
+function splitResourceQuery(specifier) {
+  const offset = specifier.startsWith("#") ? 1 : 0;
+  const match = /[?#]/.exec(specifier.slice(offset));
+  if (!match)
+    return { path: specifier, query: "" };
+  const index = offset + match.index;
+  return { path: specifier.slice(0, index), query: specifier.slice(index) };
+}
+
+export { splitResourceQuery };

package/dist/server/_chunks/index-kdhxpwyq.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-0yjv5v47.js";
+import {
+  actionId,
+  moduleActionExports,
+  moduleLevelUseCache,
+  moduleLevelUseServer
+} from "./index-6q7zvrap.js";
+import {
+  readText,
+  toPosixPath
+} from "./index-4da76t62.js";
+import {
+  frameworkRuntimeAliasEntries,
+  pnextAliases
+} from "./index-71885zaq.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-knp0s912.js

@@ -0,0 +1,7 @@
+// @bun
+// src/dev/restart/enabled.ts
+function restartCacheEnabled() {
+  return process.env.PNEXT_DEV_RESTART_CACHE !== "0";
+}
+
+export { restartCacheEnabled };

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

@@ -0,0 +1,50 @@
+// @bun
+// src/compat/react/style-values.ts
+import { options } from "preact";
+var UNITLESS = " animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex" + " boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative" + " flexOrder fontWeight gridArea gridColumn gridColumnEnd gridColumnSpan gridColumnStart gridRow" + " gridRowEnd gridRowSpan gridRowStart lineClamp lineHeight opacity order orphans scale tabSize widows" + " zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit" + " strokeOpacity strokeWidth ";
+var VENDOR_PREFIX = /^(?:Webkit|Moz|ms|O)(?=[A-Z])/;
+function unitless(name) {
+  if (UNITLESS.includes(` ${name} `))
+    return true;
+  const base = name.replace(VENDOR_PREFIX, "");
+  return base !== name && UNITLESS.includes(` ${base[0].toLowerCase()}${base.slice(1)} `);
+}
+function reactStyleValue(name, value) {
+  if (typeof value === "boolean")
+    return "";
+  if (typeof value !== "number")
+    return;
+  if (value !== 0 && !name.startsWith("--") && !unitless(name))
+    return;
+  return String(value);
+}
+function applyReactStyleValues(vnode) {
+  if (typeof vnode.type !== "string")
+    return;
+  const props = vnode.props;
+  const style = props?.style;
+  if (!style || typeof style !== "object" || Array.isArray(style))
+    return;
+  let normalized;
+  for (const name in style) {
+    const resolved = reactStyleValue(name, style[name]);
+    if (resolved === undefined)
+      continue;
+    normalized ??= { ...style };
+    normalized[name] = resolved;
+  }
+  if (normalized)
+    props.style = normalized;
+}
+var installed = Symbol.for("pnext.react-style-values-installed");
+var styleOptions = options;
+if (!styleOptions[installed]) {
+  const previousVNode = options.vnode?.bind(options);
+  options.vnode = (vnode) => {
+    previousVNode?.(vnode);
+    applyReactStyleValues(vnode);
+  };
+  styleOptions[installed] = true;
+}
+
+export { reactStyleValue, applyReactStyleValues };