@wular/pnext 0.1.6 → 0.1.8

package/dist/server/_chunks/index-7wc9n8be.js

@@ -0,0 +1,25 @@
+// @bun
+// src/utils/native-require.ts
+import realProcess from "process";
+function loadNative(load) {
+  const globalObject = globalThis;
+  if (globalObject.process === realProcess)
+    return load();
+  const previous = Object.getOwnPropertyDescriptor(globalObject, "process");
+  Object.defineProperty(globalObject, "process", {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: realProcess
+  });
+  try {
+    return load();
+  } finally {
+    if (previous)
+      Object.defineProperty(globalObject, "process", previous);
+    else
+      delete globalObject.process;
+  }
+}
+
+export { loadNative };

package/dist/server/_chunks/index-8ct7rqy3.js

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

package/dist/server/_chunks/index-8kcxdfya.js

@@ -0,0 +1,206 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+// src/compat/next/custom-server.ts
+import { existsSync, lstatSync, readFileSync } from "fs";
+import { mkdir, rm, writeFile } from "fs/promises";
+import path from "path";
+var SERVER_ENTRY_NAMES = ["server.js", "server.mjs", "server.cjs", "server.ts"];
+var SHIM_VERSION = "0.0.0-pnext-custom-server";
+function hasCustomServerEntry(root) {
+  for (const name of SERVER_ENTRY_NAMES) {
+    const file = path.join(root, name);
+    if (!existsSync(file))
+      continue;
+    try {
+      const source = readFileSync(file, "utf8");
+      if (/(?:require\(\s*['"]next['"]\s*\)|from\s+['"]next['"])/.test(source))
+        return true;
+    } catch {}
+  }
+  return false;
+}
+async function emitCustomServerShim(config) {
+  if (!hasCustomServerEntry(config.root))
+    return;
+  const target = path.join(config.root, "node_modules", "next");
+  try {
+    const stat = lstatSync(target);
+    if (!stat.isSymbolicLink() && !isEmittedShim(target))
+      return;
+    await rm(target, { recursive: true, force: true });
+  } catch {}
+  await mkdir(target, { recursive: true });
+  await writeFile(path.join(target, "package.json"), `${JSON.stringify({ name: "next", version: SHIM_VERSION, main: "index.cjs" }, null, 2)}
+`);
+  await writeFile(path.join(target, "index.cjs"), customServerShimSource());
+}
+function isEmittedShim(target) {
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(target, "package.json"), "utf8"));
+    return pkg.version === SHIM_VERSION;
+  } catch {
+    return false;
+  }
+}
+function customServerShimSource() {
+  const cliPath = path.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/compat/next", "..", "..", "cli", "index.ts");
+  return `'use strict';
+// pnext custom-server shim for require('next') / import next from 'next'.
+// Generated by pnext build; see src/compat/next/custom-server.ts.
+const { spawn } = require('node:child_process');
+
+const PNEXT_CLI = ${JSON.stringify(cliPath)};
+const HOP_BY_HOP = new Set([
+  'connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization',
+  'te', 'trailer', 'transfer-encoding', 'upgrade', 'host', 'accept-encoding',
+]);
+
+function createServer(options = {}) {
+  const dev = Boolean(options.dev);
+  const hostname = options.hostname || 'localhost';
+  const port = options.port || 3000;
+  let child;
+  let childExited;
+  let internalPort;
+
+  async function prepare() {
+    if (internalPort) return;
+    child = spawn(
+      'bun',
+      ['--conditions=react-server', PNEXT_CLI, dev ? 'dev' : 'start', '--port', '0', '--hostname', '127.0.0.1'],
+      {
+        cwd: process.cwd(),
+        env: { ...process.env, BROWSER: 'none', NODE_ENV: dev ? 'development' : 'production' },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      }
+    );
+    childExited = new Promise((resolve) => child.once('exit', resolve));
+    internalPort = await new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new Error('pnext custom-server: timed out waiting for the pnext server to start')),
+        60000
+      );
+      let buffer = '';
+      // Echo the child's logs line by line, relabelling its "- Local: <internal>"
+      // ready banner: log scanners on THIS process's stdout (the Next e2e harness
+      // parses that exact line for the app URL) must not pick up the internal
+      // port, or every request would bypass the custom server. Line buffering
+      // keeps a coalesced/split chunk from slipping the raw banner through.
+      const echoLines = (out) => {
+        let tail = '';
+        const write = (text) => {
+          const merged = tail + text;
+          const cut = merged.lastIndexOf('\\n') + 1;
+          tail = merged.slice(cut);
+          if (cut === 0) return;
+          out.write(merged.slice(0, cut).replace(/-(\\s*)(Local|Network):/g, '[pnext internal]$1$2:'));
+        };
+        child.once('exit', () => { if (tail) { const rest = tail; tail = ''; out.write(rest); } });
+        return write;
+      };
+      const echoOut = echoLines(process.stdout);
+      const echoErr = echoLines(process.stderr);
+      const scan = (chunk, echo) => {
+        const text = chunk.toString('utf8');
+        echo(text);
+        if (internalPort) return;
+        buffer = (buffer + text).slice(-4096);
+        const match = /-\\s*Local:\\s+https?:\\/\\/[^:\\s]+:(\\d+)/.exec(buffer);
+        if (match) {
+          clearTimeout(timer);
+          resolve(Number(match[1]));
+        }
+      };
+      child.stdout.on('data', (chunk) => scan(chunk, echoOut));
+      child.stderr.on('data', (chunk) => scan(chunk, echoErr));
+      child.once('exit', (code) => {
+        clearTimeout(timer);
+        reject(new Error('pnext custom-server: the pnext server exited during startup (code ' + code + ')'));
+      });
+    });
+  }
+
+  async function handleRequest(req, res) {
+    if (!internalPort) throw new Error('pnext custom-server: prepare() must complete before handling requests');
+    const target = new URL(req.url || '/', 'http://127.0.0.1:' + internalPort);
+    const headers = {};
+    for (const [name, value] of Object.entries(req.headers)) {
+      if (value === undefined || HOP_BY_HOP.has(name)) continue;
+      headers[name] = Array.isArray(value) ? value.join(', ') : value;
+    }
+    if (req.headers.host) headers['x-forwarded-host'] = req.headers.host;
+    headers['x-forwarded-proto'] = 'http';
+    const method = (req.method || 'GET').toUpperCase();
+    const hasBody = method !== 'GET' && method !== 'HEAD';
+    const response = await fetch(target, {
+      method,
+      headers,
+      body: hasBody ? req : undefined,
+      duplex: hasBody ? 'half' : undefined,
+      redirect: 'manual',
+    });
+    res.statusCode = response.status;
+    for (const [name, value] of response.headers) {
+      if (['content-encoding', 'content-length', 'transfer-encoding', 'set-cookie'].includes(name)) continue;
+      if (name === 'location') {
+        // Rewrite child-origin absolute redirects back to a relative target so
+        // the browser stays on the custom server's host/port.
+        try {
+          const url = new URL(value);
+          if (url.hostname === '127.0.0.1' && Number(url.port) === internalPort) {
+            res.setHeader(name, url.pathname + url.search + url.hash);
+            continue;
+          }
+        } catch {}
+      }
+      res.setHeader(name, value);
+    }
+    const setCookies = typeof response.headers.getSetCookie === 'function' ? response.headers.getSetCookie() : [];
+    if (setCookies.length > 0) {
+      const existing = res.getHeader('set-cookie');
+      const merged = existing === undefined ? setCookies : [].concat(existing, setCookies);
+      res.setHeader('set-cookie', merged);
+    }
+    if (response.body) {
+      for await (const chunk of response.body) res.write(chunk);
+    }
+    res.end();
+  }
+
+  async function close() {
+    if (!child || child.exitCode !== null) return;
+    // Graceful: the pnext server stops accepting connections, drains pending
+    // after() callbacks, then exits 0. Escalate to SIGKILL only on a hang.
+    child.kill('SIGTERM');
+    await Promise.race([
+      childExited,
+      new Promise((resolve) => setTimeout(resolve, 15000).unref()),
+    ]);
+    if (child.exitCode === null) child.kill('SIGKILL');
+  }
+
+  return {
+    hostname,
+    port,
+    prepare,
+    close,
+    getRequestHandler: () => (req, res) => handleRequest(req, res).catch((error) => {
+      console.error('pnext custom-server: request failed:', error);
+      if (!res.headersSent) res.statusCode = 500;
+      res.end('Internal Server Error');
+    }),
+    getUpgradeHandler: () => (_req, socket) => { socket.destroy(); },
+    setAssetPrefix: () => {},
+    logError: (...args) => console.error(...args),
+    render: async (req, res) => { await handleRequest(req, res); },
+    renderToHTML: async () => { throw new Error('renderToHTML is not supported by the pnext custom server'); },
+  };
+}
+
+module.exports = createServer;
+module.exports.default = createServer;
+`;
+}
+
+export { hasCustomServerEntry, emitCustomServerShim };

package/dist/server/_chunks/index-9ch50vtq.js

@@ -0,0 +1,18 @@
+// @bun
+// src/compat/react/view-transition.ts
+import { Fragment, h } from "preact";
+function ViewTransition({ children }) {
+  return h(Fragment, null, children);
+}
+ViewTransition.displayName = "ViewTransition";
+var pendingTransitionTypes = [];
+function addTransitionType(type) {
+  if (typeof type !== "string" || pendingTransitionTypes.includes(type))
+    return;
+  pendingTransitionTypes.push(type);
+}
+function takeTransitionTypes() {
+  return pendingTransitionTypes.splice(0, pendingTransitionTypes.length);
+}
+
+export { ViewTransition, addTransitionType, takeTransitionTypes };

package/dist/server/_chunks/index-9f49w76j.js

@@ -0,0 +1,213 @@
+// @bun
+import {
+  escapeHtml
+} from "./index-ye9hmsvf.js";
+import {
+  getNextConfig
+} from "./index-m63czgq5.js";
+import {
+  clearRenderBuffer,
+  registerResourceHint,
+  renderBuffer,
+  takeRenderBuffer
+} from "./index-yhxkxghe.js";
+
+// src/compat/next/script.tsx
+import { jsx } from "preact/jsx-runtime";
+function Script({
+  strategy = "afterInteractive",
+  children,
+  stylesheets,
+  ...scriptProps
+}) {
+  const src = typeof scriptProps.src === "string" ? scriptProps.src : undefined;
+  const dedupKey = typeof scriptProps.id === "string" && scriptProps.id || src;
+  if (dedupKey) {
+    const keys = executedScriptKeys();
+    if (keys.has(dedupKey))
+      return null;
+    keys.add(dedupKey);
+  }
+  const manualNonce = typeof scriptProps.nonce === "string" ? scriptProps.nonce : undefined;
+  if (src && strategy !== "lazyOnload") {
+    registerResourceHint({
+      rel: "preload",
+      url: src,
+      as: "script",
+      ...manualNonce ? { nonce: manualNonce } : {},
+      ...typeof scriptProps.crossOrigin === "string" ? { crossOrigin: scriptProps.crossOrigin } : {}
+    });
+  }
+  if (stylesheets) {
+    for (const url of stylesheets) {
+      registerResourceHint({ rel: "stylesheet", url });
+    }
+  }
+  if (strategy === "beforeInteractive") {
+    headScripts().push({
+      props: { "data-nscript": "beforeInteractive", ...scriptProps },
+      content: inlineScriptContent(scriptProps, children)
+    });
+    return null;
+  }
+  if (strategy === "worker" && nextScriptWorkersEnabled()) {
+    const partytownProps = {
+      ...scriptProps,
+      type: "text/partytown",
+      "data-nscript": "worker"
+    };
+    const workerInline = typeof children === "string" ? { dangerouslySetInnerHTML: { __html: children } } : {};
+    return /* @__PURE__ */ jsx("script", {
+      ...partytownProps,
+      ...workerInline
+    });
+  }
+  const deferredContent = inlineScriptContent(scriptProps, children);
+  deferredScripts().push({
+    strategy: strategy === "lazyOnload" ? "lazyOnload" : "afterInteractive",
+    attrs: deferredAttrs({ ...scriptProps, ...manualNonce ? { nonce: manualNonce } : {} }),
+    ...typeof scriptProps.id === "string" ? { id: scriptProps.id } : {},
+    ...src ? { src } : {},
+    ...deferredContent !== undefined ? { content: deferredContent } : {}
+  });
+  return null;
+}
+function nextScriptWorkersEnabled() {
+  const experimental = getNextConfig().experimental;
+  return experimental?.nextScriptWorkers === true;
+}
+var PARTYTOWN_LIB_PATH = "/_next/static/~partytown/";
+function partytownHeadScripts() {
+  const config = getNextConfig();
+  if (config.experimental?.nextScriptWorkers !== true)
+    return [];
+  const partytownConfig = {
+    lib: PARTYTOWN_LIB_PATH,
+    ...config.partytown ?? {}
+  };
+  return [
+    {
+      props: { "data-partytown-config": "" },
+      content: `partytown = ${JSON.stringify(partytownConfig)};`
+    },
+    {
+      props: { "data-partytown": "" },
+      content: partytownSnippet(partytownConfig.lib)
+    }
+  ];
+}
+function renderPartytownHeadScripts() {
+  return partytownHeadScripts().map(renderHeadScript).join("");
+}
+function partytownSnippet(lib) {
+  return `!(function(w,p,f,c){` + `c=w[p]=Object.assign(w[p]||{},{lib:${JSON.stringify(lib)}});` + `c.forward=c.forward||[];` + `f=document.createElement('script');` + `f.async=!0;f.src=c.lib+'partytown.js';` + `document.head.appendChild(f);` + `})(window,'partytown');`;
+}
+function deferredScripts() {
+  return renderBuffer("deferred");
+}
+function clearDeferredScripts() {
+  clearRenderBuffer("deferred");
+}
+function takeDeferredScripts() {
+  return takeRenderBuffer("deferred");
+}
+var DEFERRED_SKIP_PROPS = new Set(["src", "strategy", "dangerouslysetinnerhtml", "id"]);
+function deferredAttrs(props) {
+  const attrs = {};
+  for (const [key, value] of Object.entries(props)) {
+    const name = attrName(key);
+    if (!isAttrName(name) || DEFERRED_SKIP_PROPS.has(name) || name.startsWith("on"))
+      continue;
+    if (value == null || value === false || typeof value === "function")
+      continue;
+    if (value === true) {
+      attrs[name] = "";
+      continue;
+    }
+    if (name === "class" && Array.isArray(value)) {
+      const className = value.filter((item) => typeof item === "string" || typeof item === "number").join(" ");
+      if (className)
+        attrs[name] = className;
+      continue;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+      attrs[name] = String(value);
+    }
+  }
+  return attrs;
+}
+var scriptDedupRegistry = new WeakMap;
+function executedScriptKeys() {
+  const arr = renderBuffer("hints");
+  let keys = scriptDedupRegistry.get(arr);
+  if (!keys) {
+    keys = new Set;
+    scriptDedupRegistry.set(arr, keys);
+  }
+  return keys;
+}
+function headScripts() {
+  return renderBuffer("head");
+}
+function clearHeadScripts() {
+  clearRenderBuffer("head");
+}
+function takeHeadScripts() {
+  return takeRenderBuffer("head");
+}
+function renderHeadScripts() {
+  return takeHeadScripts().map(renderHeadScript).join(`
+    `);
+}
+function renderHeadScript(script) {
+  const attrs = scriptAttrs(script.props);
+  const open = attrs ? `<script ${attrs}>` : "<script>";
+  return script.content === undefined ? `${open}</script>` : `${open}${escapeScriptText(script.content)}</script>`;
+}
+function inlineScriptContent(props, children) {
+  if (typeof children === "string")
+    return children;
+  const dangerous = props.dangerouslySetInnerHTML;
+  if (dangerous && typeof dangerous === "object" && typeof dangerous.__html === "string") {
+    return dangerous.__html;
+  }
+  return;
+}
+function scriptAttrs(props) {
+  const attrs = Object.entries(props).flatMap(([key, value]) => scriptAttr(attrName(key), value));
+  return attrs.join(" ");
+}
+function scriptAttr(name, value) {
+  if (!isAttrName(name))
+    return [];
+  if (value == null || value === false || typeof value === "function")
+    return [];
+  if (name === "strategy" || name === "dangerouslysetinnerhtml" || name.startsWith("on"))
+    return [];
+  if (value === true)
+    return [name];
+  if (name === "class" && Array.isArray(value)) {
+    const className = value.filter((item) => typeof item === "string" || typeof item === "number").join(" ");
+    return className ? [`class="${escapeHtml(className)}"`] : [];
+  }
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint") {
+    return [];
+  }
+  return [`${name}="${escapeHtml(value)}"`];
+}
+function attrName(key) {
+  if (key === "className")
+    return "class";
+  if (key === "htmlFor")
+    return "for";
+  return key.toLowerCase();
+}
+function isAttrName(name) {
+  return /^[a-zA-Z_:][a-zA-Z0-9:._-]*$/.test(name);
+}
+var scriptTerminator = /(<\/|<)(s)(cript)/gi;
+function escapeScriptText(text) {
+  return text.replace(scriptTerminator, (_, prefix, s, suffix) => `${prefix}${s === "s" ? "\\u0073" : "\\u0053"}${suffix}`);
+}
+
+export { Script, PARTYTOWN_LIB_PATH, partytownHeadScripts, renderPartytownHeadScripts, clearDeferredScripts, takeDeferredScripts, clearHeadScripts, takeHeadScripts, renderHeadScripts };