@nuxt/scripts 1.0.0-beta.24 → 1.0.0-beta.26

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { useNuxt, addDevServerHandler, extendRouteRules, tryUseNuxt, extendViteConfig, useLogger, addPluginTemplate, addServerHandler, logger as logger$1, addTypeTemplate, defineNuxtModule, createResolver, hasNuxtModule, addImports, addComponentsDir, addTemplate, addBuildPlugin } from '@nuxt/kit';
+import { useLogger, addServerHandler, addPluginTemplate, useNuxt, addDevServerHandler, extendRouteRules, tryUseNuxt, extendViteConfig, logger as logger$1, addTypeTemplate, defineNuxtModule, createResolver, hasNuxtModule, addImports, addComponentsDir, addTemplate, addBuildPlugin } from '@nuxt/kit';
 import { defu } from 'defu';
 import { join, resolve, relative } from 'pathe';
 import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
@@ -18,170 +18,11 @@ import fsp from 'node:fs/promises';
 import { colors } from 'consola/utils';
 import MagicString from 'magic-string';
 import { hash } from 'ohash';
-import { g as getAllProxyConfigs, r as routesToInterceptRules, a as getProxyConfig } from './shared/scripts.Crpn87WB.mjs';
 import { registry } from './registry.mjs';
-
-const renderedScript = /* @__PURE__ */ new Map();
-const ONE_YEAR_IN_SECONDS = 60 * 60 * 24 * 365;
-function bundleStorage() {
-  const nuxt = tryUseNuxt();
-  return createStorage({
-    driver: fsDriver({
-      base: resolve(nuxt?.options.rootDir || "", "node_modules/.cache/nuxt/scripts")
-    })
-  });
-}
-function setupPublicAssetStrategy(options = {}) {
-  const assetsBaseURL = options.prefix || "/_scripts/assets";
-  const nuxt = useNuxt();
-  const storage = bundleStorage();
-  addDevServerHandler({
-    route: assetsBaseURL,
-    handler: lazyEventHandler(async () => {
-      return eventHandler(async (event) => {
-        const filename = event.path.slice(1);
-        const scriptDescriptor = renderedScript.get(join(assetsBaseURL, event.path.slice(1)));
-        if (!scriptDescriptor || scriptDescriptor instanceof Error)
-          throw createError({ statusCode: 404 });
-        if (scriptDescriptor.content) {
-          return scriptDescriptor.content;
-        }
-        const key = `bundle:${filename}`;
-        let res = await storage.getItemRaw(key);
-        if (!res) {
-          res = await fetch(scriptDescriptor.src).then((r) => r.arrayBuffer()).then((r) => Buffer.from(r));
-          await storage.setItemRaw(key, res);
-        }
-        return res;
-      });
-    })
-  });
-  if (nuxt.options.dev) {
-    extendRouteRules(joinURL(assetsBaseURL, "**"), {
-      cache: {
-        maxAge: ONE_YEAR_IN_SECONDS
-      }
-    });
-  }
-  const cacheDir = join(nuxt.options.buildDir, "cache", "scripts");
-  nuxt.hook("nitro:config", (nitroConfig) => {
-    nitroConfig.publicAssets ||= [];
-    nitroConfig.publicAssets.push({
-      dir: cacheDir,
-      maxAge: ONE_YEAR_IN_SECONDS,
-      baseURL: assetsBaseURL
-    });
-    nitroConfig.prerender ||= {};
-    nitroConfig.prerender.ignore ||= [];
-    nitroConfig.prerender.ignore.push(assetsBaseURL);
-  });
-  return {
-    renderedScript
-  };
-}
-
-const DEVTOOLS_UI_ROUTE = "/__nuxt-scripts";
-const DEVTOOLS_UI_LOCAL_PORT = 3300;
-
-async function setupDevToolsUI(options, resolve, nuxt = useNuxt()) {
-  const clientPath = await resolve("./client");
-  const isProductionBuild = existsSync(clientPath);
-  if (isProductionBuild) {
-    nuxt.hook("vite:serverCreated", async (server) => {
-      const sirv = await import('sirv').then((r) => r.default || r);
-      server.middlewares.use(
-        DEVTOOLS_UI_ROUTE,
-        sirv(clientPath, { dev: true, single: true })
-      );
-    });
-  } else {
-    extendViteConfig((config) => {
-      config.server = config.server || {};
-      config.server.proxy = config.server.proxy || {};
-      config.server.proxy[DEVTOOLS_UI_ROUTE] = {
-        target: `http://localhost:${DEVTOOLS_UI_LOCAL_PORT}${DEVTOOLS_UI_ROUTE}`,
-        changeOrigin: true,
-        followRedirects: true,
-        rewrite: (path) => path.replace(DEVTOOLS_UI_ROUTE, "")
-      };
-    });
-  }
-  addCustomTab({
-    // unique identifier
-    name: "nuxt-scripts",
-    // title to display in the tab
-    title: "Scripts",
-    // any icon from Iconify, or a URL to an image
-    icon: "carbon:script",
-    // iframe view
-    view: {
-      type: "iframe",
-      src: DEVTOOLS_UI_ROUTE
-    }
-  });
-}
+import { g as getAllProxyConfigs, r as routesToInterceptRules } from './shared/scripts.ViOoYQXH.mjs';
 
 const logger = useLogger("@nuxt/scripts");
 
-const AUTO_INJECT_DEFS = [
-  {
-    registryKey: "posthog",
-    configField: "apiHost",
-    computeValue: (collectPrefix, config) => {
-      const region = config.region || "us";
-      return region === "eu" ? `${collectPrefix}/ph-eu` : `${collectPrefix}/ph`;
-    }
-  },
-  {
-    registryKey: "plausibleAnalytics",
-    configField: "endpoint",
-    computeValue: (collectPrefix) => `${collectPrefix}/plausible/api/event`
-  },
-  {
-    registryKey: "umamiAnalytics",
-    configField: "hostUrl",
-    computeValue: (collectPrefix) => `${collectPrefix}/umami`
-  },
-  {
-    registryKey: "rybbitAnalytics",
-    configField: "analyticsHost",
-    computeValue: (collectPrefix) => `${collectPrefix}/rybbit/api`
-  },
-  {
-    registryKey: "databuddyAnalytics",
-    configField: "apiUrl",
-    computeValue: (collectPrefix) => `${collectPrefix}/databuddy-api`
-  }
-];
-function autoInjectProxyEndpoints(registry, runtimeConfig, collectPrefix) {
-  for (const def of AUTO_INJECT_DEFS) {
-    const entry = registry[def.registryKey];
-    if (!entry)
-      continue;
-    const rtScripts = runtimeConfig.public?.scripts;
-    const rtEntry = rtScripts?.[def.registryKey];
-    const rtConfig = rtEntry && typeof rtEntry === "object" ? Array.isArray(rtEntry) ? rtEntry[0] : rtEntry : void 0;
-    let config;
-    if (entry === true || entry === "mock") {
-      if (!rtConfig)
-        continue;
-      config = rtConfig;
-    } else if (typeof entry === "object") {
-      config = Array.isArray(entry) ? entry[0] : entry;
-    }
-    if (!config || config[def.configField])
-      continue;
-    const value = def.computeValue(collectPrefix, config);
-    if (typeof entry === "object") {
-      config[def.configField] = value;
-      if (rtConfig)
-        rtConfig[def.configField] = value;
-    } else {
-      config[def.configField] = value;
-    }
-  }
-}
-
 function generateInterceptPluginContents(interceptRules) {
   const rulesJson = JSON.stringify(interceptRules);
   return `export default defineNuxtPlugin({
@@ -244,65 +85,123 @@ function generateInterceptPluginContents(interceptRules) {
 `;
 }
 
-function resolveFirstPartyConfig(config) {
+async function setupFirstParty(config, resolvePath) {
   const enabled = !!config.firstParty;
-  const prefix = typeof config.firstParty === "object" ? config.firstParty.prefix : void 0;
-  const collectPrefix = typeof config.firstParty === "object" ? config.firstParty.collectPrefix || "/_scripts/c" : "/_scripts/c";
+  const proxyPrefix = typeof config.firstParty === "object" ? config.firstParty.proxyPrefix || "/_scripts/p" : "/_scripts/p";
   const privacy = typeof config.firstParty === "object" ? config.firstParty.privacy : void 0;
-  const assetsPrefix = prefix || config.assets?.prefix || "/_scripts/assets";
-  return { enabled, prefix, collectPrefix, privacy, assetsPrefix };
+  const assetsPrefix = config.assets?.prefix || "/_scripts/assets";
+  const proxyConfigs = enabled ? getAllProxyConfigs(proxyPrefix) : {};
+  const firstParty = { enabled, proxyPrefix, privacy, assetsPrefix, proxyConfigs };
+  if (enabled) {
+    const proxyHandlerPath = await resolvePath("./runtime/server/proxy-handler");
+    logger.debug("[nuxt-scripts] Registering proxy handler:", `${proxyPrefix}/**`, "->", proxyHandlerPath);
+    addServerHandler({
+      route: `${proxyPrefix}/**`,
+      handler: proxyHandlerPath
+    });
+  }
+  return firstParty;
 }
-async function setupFirstPartyHandlers(firstParty, resolvePath) {
-  const interceptRules = [];
-  addPluginTemplate({
-    filename: "nuxt-scripts-intercept.client.mjs",
-    getContents() {
-      return generateInterceptPluginContents(interceptRules);
-    }
-  });
-  const proxyHandlerPath = await resolvePath("./runtime/server/proxy-handler");
-  logger.debug("[nuxt-scripts] Registering proxy handler:", `${firstParty.collectPrefix}/**`, "->", proxyHandlerPath);
-  addServerHandler({
-    route: `${firstParty.collectPrefix}/**`,
-    handler: proxyHandlerPath
-  });
-  return interceptRules;
+function applyAutoInject(registry, runtimeConfig, proxyPrefix, registryKey, autoInject) {
+  const entry = registry[registryKey];
+  if (!entry)
+    return;
+  const input = entry[0];
+  const rtScripts = runtimeConfig.public?.scripts;
+  const rtEntry = rtScripts?.[registryKey];
+  const config = rtEntry && typeof rtEntry === "object" ? rtEntry : input;
+  if (!config || config[autoInject.configField])
+    return;
+  const value = autoInject.computeValue(proxyPrefix, config);
+  input[autoInject.configField] = value;
+  if (rtEntry && typeof rtEntry === "object" && rtEntry !== input)
+    rtEntry[autoInject.configField] = value;
+}
+const DOMAIN_RE = /^https?:\/\/([^/]+)/;
+function extractDomains(routes) {
+  const domains = /* @__PURE__ */ new Set();
+  for (const { proxy } of Object.values(routes)) {
+    const match = proxy.match(DOMAIN_RE);
+    if (match?.[1])
+      domains.add(match[1]);
+  }
+  return [...domains].sort();
+}
+function computePrivacyLevel(privacy) {
+  const flags = Object.values(privacy);
+  if (flags.every(Boolean))
+    return "full";
+  if (flags.some(Boolean))
+    return "partial";
+  return "none";
 }
 function finalizeFirstParty(opts) {
-  const { firstParty, interceptRules, registryScripts, registryScriptsWithImport, nuxtOptions } = opts;
-  const proxyConfigs = getAllProxyConfigs(firstParty.collectPrefix);
+  const { firstParty, registryScripts, nuxtOptions } = opts;
+  const { proxyConfigs, proxyPrefix } = firstParty;
   const registryKeys = Object.keys(opts.registry || {});
   const scriptByKey = /* @__PURE__ */ new Map();
   for (const script of registryScripts) {
-    if (script.registryKey) {
+    if (script.registryKey)
       scriptByKey.set(script.registryKey, script);
-    }
   }
   const neededRoutes = {};
   const routePrivacyOverrides = {};
   const unsupportedScripts = [];
   const unmatchedScripts = [];
+  const devtoolsScripts = [];
   for (const key of registryKeys) {
-    const script = scriptByKey.get(key) || registryScriptsWithImport.find((s) => s.import.name.toLowerCase() === `usescript${key.toLowerCase()}`);
+    const script = scriptByKey.get(key);
     if (!script) {
       unmatchedScripts.push(key);
       continue;
     }
-    const proxyKey = script?.proxy || void 0;
-    if (proxyKey) {
-      const proxyConfig = proxyConfigs[proxyKey];
-      if (proxyConfig?.routes) {
-        Object.assign(neededRoutes, proxyConfig.routes);
-        for (const routePath of Object.keys(proxyConfig.routes)) {
-          routePrivacyOverrides[routePath] = proxyConfig.privacy;
-        }
-      } else {
+    if (script.proxy === false)
+      continue;
+    const configKey = script.proxy || key;
+    const proxyConfig = proxyConfigs[configKey];
+    if (!proxyConfig) {
+      if (script.scriptBundling !== false)
         unsupportedScripts.push(key);
-      }
+      continue;
+    }
+    const scriptRoutes = proxyConfig.routes || {};
+    if (proxyConfig.routes) {
+      Object.assign(neededRoutes, proxyConfig.routes);
+      for (const routePath of Object.keys(proxyConfig.routes))
+        routePrivacyOverrides[routePath] = proxyConfig.privacy;
+    }
+    if (proxyConfig.autoInject && opts.registry)
+      applyAutoInject(opts.registry, nuxtOptions.runtimeConfig, proxyPrefix, key, proxyConfig.autoInject);
+    if (nuxtOptions.dev) {
+      const privacy = proxyConfig.privacy;
+      const normalizedPrivacy = {
+        ip: !!privacy.ip,
+        userAgent: !!privacy.userAgent,
+        language: !!privacy.language,
+        screen: !!privacy.screen,
+        timezone: !!privacy.timezone,
+        hardware: !!privacy.hardware
+      };
+      const logo = script.logo;
+      const logoStr = typeof logo === "object" ? logo.dark || logo.light : logo || "";
+      const interceptRules2 = routesToInterceptRules(scriptRoutes);
+      devtoolsScripts.push({
+        registryKey: key,
+        label: script.label || key,
+        logo: logoStr,
+        category: script.category || "unknown",
+        configKey,
+        mechanism: script.src === false ? "config-injection-proxy" : "bundle-rewrite-intercept",
+        hasAutoInject: !!proxyConfig.autoInject,
+        autoInjectField: proxyConfig.autoInject?.configField,
+        hasPostProcess: !!proxyConfig.postProcess,
+        privacy: normalizedPrivacy,
+        privacyLevel: computePrivacyLevel(normalizedPrivacy),
+        domains: extractDomains(scriptRoutes),
+        routes: Object.entries(scriptRoutes).map(([local, { proxy }]) => ({ local, target: proxy })),
+        interceptRules: interceptRules2
+      });
     }
-  }
-  if (opts.registry) {
-    autoInjectProxyEndpoints(opts.registry, nuxtOptions.runtimeConfig, firstParty.collectPrefix);
   }
   if (unmatchedScripts.length) {
     logger.warn(
@@ -316,28 +215,32 @@ These scripts will not have proxy routes registered. Check that the registry key
 They will load directly from third-party servers. Request support at https://github.com/nuxt/scripts/issues`
     );
   }
-  interceptRules.push(...routesToInterceptRules(neededRoutes));
+  const interceptRules = routesToInterceptRules(neededRoutes);
+  addPluginTemplate({
+    filename: "nuxt-scripts-intercept.client.mjs",
+    getContents() {
+      return generateInterceptPluginContents(interceptRules);
+    }
+  });
   const flatRoutes = {};
-  for (const [path, config] of Object.entries(neededRoutes)) {
+  for (const [path, config] of Object.entries(neededRoutes))
     flatRoutes[path] = config.proxy;
-  }
   nuxtOptions.runtimeConfig["nuxt-scripts-proxy"] = {
     routes: flatRoutes,
     privacy: firstParty.privacy,
     routePrivacy: routePrivacyOverrides
   };
+  const privacyLabel = firstParty.privacy === void 0 ? "per-script" : typeof firstParty.privacy === "boolean" ? firstParty.privacy ? "anonymize" : "passthrough" : "custom";
   if (Object.keys(neededRoutes).length && nuxtOptions.dev) {
     const routeCount = Object.keys(neededRoutes).length;
     const scriptsCount = registryKeys.length;
-    const privacyLabel = firstParty.privacy === void 0 ? "per-script" : typeof firstParty.privacy === "boolean" ? firstParty.privacy ? "anonymize" : "passthrough" : "custom";
     logger.success(`First-party mode enabled for ${scriptsCount} script(s), ${routeCount} proxy route(s) configured (privacy: ${privacyLabel})`);
     if (logger.level >= 4) {
-      for (const [path, config] of Object.entries(neededRoutes)) {
+      for (const [path, config] of Object.entries(neededRoutes))
         logger.debug(`  ${path} \u2192 ${config.proxy}`);
-      }
     }
   }
-  const staticPresets = ["static", "github-pages", "cloudflare-pages-static"];
+  const staticPresets = ["static", "github-pages", "cloudflare-pages-static", "netlify-static", "azure-static", "firebase-static"];
   const preset = process.env.NITRO_PRESET || "";
   if (staticPresets.includes(preset)) {
     logger.warn(
@@ -352,6 +255,121 @@ Options:
 See: https://scripts.nuxt.com/docs/guides/first-party#static-hosting`
     );
   }
+  if (nuxtOptions.dev) {
+    const allDomains = /* @__PURE__ */ new Set();
+    for (const s of devtoolsScripts) {
+      for (const d of s.domains)
+        allDomains.add(d);
+    }
+    return {
+      enabled: true,
+      proxyPrefix,
+      privacyMode: privacyLabel,
+      scripts: devtoolsScripts,
+      totalRoutes: Object.keys(neededRoutes).length,
+      totalDomains: allDomains.size
+    };
+  }
+}
+
+const renderedScript = /* @__PURE__ */ new Map();
+const ONE_YEAR_IN_SECONDS = 60 * 60 * 24 * 365;
+function bundleStorage() {
+  const nuxt = tryUseNuxt();
+  return createStorage({
+    driver: fsDriver({
+      base: resolve(nuxt?.options.rootDir || "", "node_modules/.cache/nuxt/scripts")
+    })
+  });
+}
+function setupPublicAssetStrategy(options = {}) {
+  const assetsBaseURL = options.prefix || "/_scripts/assets";
+  const nuxt = useNuxt();
+  const storage = bundleStorage();
+  addDevServerHandler({
+    route: assetsBaseURL,
+    handler: lazyEventHandler(async () => {
+      return eventHandler(async (event) => {
+        const filename = event.path.slice(1);
+        const scriptDescriptor = renderedScript.get(join(assetsBaseURL, event.path.slice(1)));
+        if (!scriptDescriptor || scriptDescriptor instanceof Error)
+          throw createError({ statusCode: 404 });
+        if (scriptDescriptor.content) {
+          return scriptDescriptor.content;
+        }
+        const key = `bundle:${filename}`;
+        let res = await storage.getItemRaw(key);
+        if (!res) {
+          res = await fetch(scriptDescriptor.src).then((r) => r.arrayBuffer()).then((r) => Buffer.from(r));
+          await storage.setItemRaw(key, res);
+        }
+        return res;
+      });
+    })
+  });
+  if (nuxt.options.dev) {
+    extendRouteRules(joinURL(assetsBaseURL, "**"), {
+      cache: {
+        maxAge: ONE_YEAR_IN_SECONDS
+      }
+    });
+  }
+  const cacheDir = join(nuxt.options.buildDir, "cache", "scripts");
+  nuxt.hook("nitro:config", (nitroConfig) => {
+    nitroConfig.publicAssets ||= [];
+    nitroConfig.publicAssets.push({
+      dir: cacheDir,
+      maxAge: ONE_YEAR_IN_SECONDS,
+      baseURL: assetsBaseURL
+    });
+    nitroConfig.prerender ||= {};
+    nitroConfig.prerender.ignore ||= [];
+    nitroConfig.prerender.ignore.push(assetsBaseURL);
+  });
+  return {
+    renderedScript
+  };
+}
+
+const DEVTOOLS_UI_ROUTE = "/__nuxt-scripts";
+const DEVTOOLS_UI_LOCAL_PORT = 3300;
+
+async function setupDevToolsUI(options, resolve, nuxt = useNuxt()) {
+  const clientPath = await resolve("./client");
+  const isProductionBuild = existsSync(clientPath);
+  if (isProductionBuild) {
+    nuxt.hook("vite:serverCreated", async (server) => {
+      const sirv = await import('sirv').then((r) => r.default || r);
+      server.middlewares.use(
+        DEVTOOLS_UI_ROUTE,
+        sirv(clientPath, { dev: true, single: true })
+      );
+    });
+  } else {
+    extendViteConfig((config) => {
+      config.server = config.server || {};
+      config.server.proxy = config.server.proxy || {};
+      config.server.proxy[DEVTOOLS_UI_ROUTE] = {
+        target: `http://localhost:${DEVTOOLS_UI_LOCAL_PORT}${DEVTOOLS_UI_ROUTE}`,
+        changeOrigin: true,
+        followRedirects: true,
+        rewrite: (path) => path.replace(DEVTOOLS_UI_ROUTE, "")
+      };
+    });
+  }
+  addCustomTab({
+    // unique identifier
+    name: "nuxt-scripts",
+    // title to display in the tab
+    title: "Scripts",
+    // any icon from Iconify, or a URL to an image
+    icon: "carbon:script",
+    // iframe view
+    view: {
+      type: "iframe",
+      src: DEVTOOLS_UI_ROUTE
+    }
+  });
 }
 
 const isStackblitz = provider === "stackblitz";
@@ -394,6 +412,32 @@ function installNuxtModule(name, options) {
   }, { rootDir: nuxt.options.rootDir, searchPaths: nuxt.options.modulesDir, ...options });
 }
 
+function normalizeRegistryConfig(registry) {
+  for (const key of Object.keys(registry)) {
+    const entry = registry[key];
+    if (!entry) {
+      delete registry[key];
+      continue;
+    }
+    if (entry === true) {
+      registry[key] = [{}];
+    } else if (entry === "mock") {
+      registry[key] = [{}, { trigger: "manual", skipValidation: true }];
+    } else if (Array.isArray(entry)) {
+      if (!entry[0] && !entry[1]) {
+        delete registry[key];
+        continue;
+      }
+      if (!entry[0])
+        entry[0] = {};
+    } else if (typeof entry === "object") {
+      registry[key] = [entry];
+    } else {
+      delete registry[key];
+    }
+  }
+}
+
 function isVue(id, opts = {}) {
   const { search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
   if (id.endsWith(".vue") && !search) {
@@ -479,9 +523,6 @@ function NuxtScriptsCheckScripts() {
 
 const WORD_OR_DOLLAR_RE = /[\w$]/;
 const BLANK_CANVAS_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQIHWNgAAIABQABNjN9GQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAAA0lEQVQI12NgYGBgAAAABQABXvMqOgAAAABJRU5ErkJggg==";
-const GA_COLLECT_RE = /([\w$])?"https:\/\/"\+\(.*?\)\+"\.google-analytics\.com\/g\/collect"/g;
-const GA_ANALYTICS_COLLECT_RE = /([\w$])?"https:\/\/"\+\(.*?\)\+"\.analytics\.google\.com\/g\/collect"/g;
-const FATHOM_SELF_HOSTED_RE = /\.src\.indexOf\("cdn\.usefathom\.com"\)\s*<\s*0/;
 function isPropertyKeyAST(parent, ctx) {
   return parent?.type === "Property" && ctx.key === "key" || parent?.type === "SwitchCase" && ctx.key === "test";
 }
@@ -598,7 +639,7 @@ function resolveCalleeTarget(callee, scopeTracker) {
     return "Image";
   return null;
 }
-function rewriteScriptUrlsAST(content, filename, rewrites) {
+function rewriteScriptUrlsAST(content, filename, rewrites, postProcess) {
   const s = new MagicString(content);
   function needsLeadingSpace(start) {
     const prev = content[start - 1];
@@ -622,9 +663,10 @@ function rewriteScriptUrlsAST(content, filename, rewrites) {
           s.overwrite(node.start, node.end, `${needsLeadingSpace(node.start)}self.location.origin+${quote}${rewritten}${quote}`);
         }
       }
-      if (node.type === "TemplateLiteral" && node.expressions?.length === 0) {
+      if (node.type === "TemplateLiteral") {
         const quasis = node.quasis;
-        if (quasis?.length === 1) {
+        const expressions = node.expressions;
+        if (expressions?.length === 0 && quasis?.length === 1) {
           const value = quasis[0].value?.cooked ?? quasis[0].value?.raw;
           if (typeof value !== "string")
             return;
@@ -636,6 +678,15 @@ function rewriteScriptUrlsAST(content, filename, rewrites) {
           } else {
             s.overwrite(node.start, node.end, `${needsLeadingSpace(node.start)}self.location.origin+\`${rewritten}\``);
           }
+        } else if (expressions?.length > 0 && quasis?.length > 0) {
+          const firstQuasi = quasis[0];
+          const value = firstQuasi.value?.cooked ?? firstQuasi.value?.raw;
+          if (typeof value !== "string" || isPropertyKeyAST(parent, ctx))
+            return;
+          const rewritten = matchAndRewrite(value, rewrites);
+          if (rewritten === null)
+            return;
+          s.overwrite(node.start, firstQuasi.end, `${needsLeadingSpace(node.start)}self.location.origin+\`${rewritten}`);
         }
       }
       if (node.type === "CallExpression") {
@@ -708,22 +759,8 @@ function rewriteScriptUrlsAST(content, filename, rewrites) {
     }
   });
   let output = s.toString();
-  const gaRewrite = rewrites.find((r) => r.from.includes("google-analytics.com/g/collect"));
-  if (gaRewrite) {
-    output = output.replace(
-      GA_COLLECT_RE,
-      (_, prevChar) => `${prevChar ? `${prevChar} ` : ""}self.location.origin+"${gaRewrite.to}"`
-    );
-    output = output.replace(
-      GA_ANALYTICS_COLLECT_RE,
-      (_, prevChar) => `${prevChar ? `${prevChar} ` : ""}self.location.origin+"${gaRewrite.to}"`
-    );
-  }
-  if (rewrites.some((r) => r.from === "cdn.usefathom.com")) {
-    output = output.replace(
-      FATHOM_SELF_HOSTED_RE,
-      '.src.indexOf("cdn.usefathom.com")<-1'
-    );
+  if (postProcess) {
+    output = postProcess(output, rewrites);
   }
   return output;
 }
@@ -761,7 +798,7 @@ function normalizeScriptData(src, assetsBaseURL = "/_scripts/assets") {
   return { url: src };
 }
 async function downloadScript(opts, renderedScript, fetchOptions, cacheMaxAge) {
-  const { src, url, filename, forceDownload, integrity, proxyRewrites } = opts;
+  const { src, url, filename, forceDownload, integrity, proxyRewrites, postProcess } = opts;
   if (src === url || !filename) {
     return;
   }
@@ -799,7 +836,7 @@ async function downloadScript(opts, renderedScript, fetchOptions, cacheMaxAge) {
     await storage.setItemRaw(`bundle:${filename}`, res);
     if (proxyRewrites?.length && res) {
       const content = res.toString("utf-8");
-      const rewritten = rewriteScriptUrlsAST(content, filename || "script.js", proxyRewrites);
+      const rewritten = rewriteScriptUrlsAST(content, filename || "script.js", proxyRewrites, postProcess);
       res = Buffer.from(rewritten, "utf-8");
       logger.debug(`Rewrote ${proxyRewrites.length} URL patterns in ${filename}`);
     }
@@ -999,11 +1036,13 @@ function NuxtScriptBundleTransformer(options = {
                     const { url: _url, filename } = normalizeScriptData(src, options.assetsBaseURL);
                     const script = options.scripts?.find((s2) => s2.import.name === fnName);
                     const proxyConfigKey = script?.proxy !== false ? script?.proxy || registryKey : void 0;
-                    const proxyRewrites = options.firstPartyEnabled && !firstPartyOptOut && proxyConfigKey && options.firstPartyCollectPrefix ? getProxyConfig(proxyConfigKey, options.firstPartyCollectPrefix)?.rewrite : void 0;
+                    const proxyConfig = !firstPartyOptOut && proxyConfigKey ? options.proxyConfigs?.[proxyConfigKey] : void 0;
+                    const proxyRewrites = proxyConfig?.rewrite;
+                    const postProcess = proxyConfig?.postProcess;
                     deferredOps.push(async () => {
                       let url = _url;
                       try {
-                        await downloadScript({ src, url, filename, forceDownload, proxyRewrites, integrity: options.integrity }, renderedScript, options.fetchOptions, options.cacheMaxAge);
+                        await downloadScript({ src, url, filename, forceDownload, proxyRewrites, postProcess, integrity: options.integrity }, renderedScript, options.fetchOptions, options.cacheMaxAge);
                       } catch (e) {
                         if (options.fallbackOnSrcOnBundleFail) {
                           logger.warn(`[Nuxt Scripts: Bundle Transformer] Failed to bundle ${src}. Fallback to remote loading.`);
@@ -1176,18 +1215,18 @@ function templatePlugin(config, registry) {
   let needsInteractionImport = false;
   let needsServiceWorkerImport = false;
   for (const [k, c] of Object.entries(config.registry || {})) {
+    if (c === false)
+      continue;
     const importDefinition = registry.find((i) => i.import.name.toLowerCase() === `usescript${k.toLowerCase()}`);
     if (importDefinition) {
       resolvedRegistryKeys.push(k);
       imports.unshift(`import { ${importDefinition.import.name} } from '${importDefinition.import.from}'`);
-      if (c === "mock") {
-        inits.push(`const ${k} = ${importDefinition.import.name}({ scriptOptions: { trigger: 'manual', skipValidation: true } })`);
-      } else if (Array.isArray(c) && c.length === 2) {
-        const input = c[0] || {};
-        const scriptOptions = { ...c[1] };
-        const triggerResolved = resolveTriggerForTemplate(scriptOptions?.trigger);
+      const [input, scriptOptions] = c;
+      if (scriptOptions) {
+        const opts = { ...scriptOptions };
+        const triggerResolved = resolveTriggerForTemplate(opts.trigger);
         if (triggerResolved) {
-          scriptOptions.trigger = "__TRIGGER_PLACEHOLDER__";
+          opts.trigger = "__TRIGGER_PLACEHOLDER__";
           if (triggerResolved.includes("useScriptTriggerIdleTimeout"))
             needsIdleTimeoutImport = true;
           if (triggerResolved.includes("useScriptTriggerInteraction"))
@@ -1195,12 +1234,11 @@ function templatePlugin(config, registry) {
           if (triggerResolved.includes("useScriptTriggerServiceWorker"))
             needsServiceWorkerImport = true;
         }
-        const args = { ...input, scriptOptions };
+        const args = { ...input, scriptOptions: opts };
         const argsJson = triggerResolved ? JSON.stringify(args).replace(TRIGGER_PLACEHOLDER_RE, triggerResolved) : JSON.stringify(args);
         inits.push(`const ${k} = ${importDefinition.import.name}(${argsJson})`);
       } else {
-        const args = (typeof c !== "object" ? {} : c) || {};
-        inits.push(`const ${k} = ${importDefinition.import.name}(${JSON.stringify(args)})`);
+        inits.push(`const ${k} = ${importDefinition.import.name}(${JSON.stringify(input)})`);
       }
     }
   }
@@ -1321,6 +1359,7 @@ function fixSelfClosingScriptComponents(nuxt) {
   }
 }
 const REGISTRY_ENV_DEFAULTS = {
+  bingUet: { id: "" },
   clarity: { id: "" },
   cloudflareWebAnalytics: { token: "" },
   crisp: { id: "" },
@@ -1335,6 +1374,7 @@ const REGISTRY_ENV_DEFAULTS = {
   hotjar: { id: "" },
   intercom: { app_id: "" },
   matomoAnalytics: { matomoUrl: "" },
+  mixpanelAnalytics: { token: "" },
   metaPixel: { id: "" },
   paypal: { clientId: "" },
   plausibleAnalytics: { domain: "" },
@@ -1350,12 +1390,14 @@ const REGISTRY_ENV_DEFAULTS = {
   xPixel: { id: "" }
 };
 const PARTYTOWN_FORWARDS = {
+  bingUet: ["uetq.push"],
   googleAnalytics: ["dataLayer.push", "gtag"],
-  plausible: ["plausible"],
-  fathom: ["fathom", "fathom.trackEvent", "fathom.trackPageview"],
-  umami: ["umami", "umami.track"],
-  matomo: ["_paq.push"],
+  plausibleAnalytics: ["plausible"],
+  fathomAnalytics: ["fathom", "fathom.trackEvent", "fathom.trackPageview"],
+  umamiAnalytics: ["umami", "umami.track"],
+  matomoAnalytics: ["_paq.push"],
   segment: ["analytics", "analytics.track", "analytics.page", "analytics.identify"],
+  mixpanelAnalytics: ["mixpanel", "mixpanel.init", "mixpanel.track", "mixpanel.identify", "mixpanel.people.set", "mixpanel.reset", "mixpanel.register"],
   metaPixel: ["fbq"],
   xPixel: ["twq"],
   tiktokPixel: ["ttq.track", "ttq.page", "ttq.identify"],
@@ -1423,23 +1465,15 @@ const module$1 = defineNuxtModule({
       googleStaticMapsProxy: googleMapsEnabled ? { enabled: true, cacheMaxAge: config.googleStaticMapsProxy?.cacheMaxAge ?? 3600 } : void 0
     };
     if (config.registry) {
+      normalizeRegistryConfig(config.registry);
       nuxt.options.runtimeConfig.public = nuxt.options.runtimeConfig.public || {};
       const registryWithDefaults = {};
-      for (const [key, value] of Object.entries(config.registry)) {
-        if (value && REGISTRY_ENV_DEFAULTS[key]) {
-          const envDefaults = REGISTRY_ENV_DEFAULTS[key];
-          if (value === true || value === "mock") {
-            registryWithDefaults[key] = { ...envDefaults };
-          } else if (typeof value === "object" && !Array.isArray(value)) {
-            registryWithDefaults[key] = defu(value, envDefaults);
-          } else if (Array.isArray(value)) {
-            registryWithDefaults[key] = defu(value[0] || {}, envDefaults);
-          } else {
-            registryWithDefaults[key] = value;
-          }
-        } else {
-          registryWithDefaults[key] = value;
-        }
+      for (const [key, entry] of Object.entries(config.registry)) {
+        if (entry === false)
+          continue;
+        const input = entry[0];
+        const envDefaults = REGISTRY_ENV_DEFAULTS[key];
+        registryWithDefaults[key] = envDefaults ? defu(input, envDefaults) : input;
       }
       nuxt.options.runtimeConfig.public.scripts = defu(
         nuxt.options.runtimeConfig.public.scripts || {},
@@ -1451,7 +1485,7 @@ const module$1 = defineNuxtModule({
         "`scripts.defaultScriptOptions.bundle` is deprecated. Use `scripts.firstParty: true` instead. First-party mode is now enabled by default."
       );
     }
-    const firstParty = resolveFirstPartyConfig(config);
+    const firstParty = await setupFirstParty(config, resolvePath);
     const assetsPrefix = firstParty.assetsPrefix;
     if (config.partytown?.length) {
       config.registry = config.registry || {};
@@ -1465,12 +1499,8 @@ const module$1 = defineNuxtModule({
         }
         const reg = config.registry;
         const existing = reg[scriptKey];
-        if (Array.isArray(existing)) {
+        if (existing) {
           existing[1] = { ...existing[1], partytown: true };
-        } else if (existing && typeof existing === "object" && existing !== true && existing !== "mock") {
-          reg[scriptKey] = [existing, { partytown: true }];
-        } else if (existing === true || existing === "mock") {
-          reg[scriptKey] = [{}, { partytown: true }];
         } else {
           reg[scriptKey] = [{}, { partytown: true }];
         }
@@ -1512,10 +1542,6 @@ const module$1 = defineNuxtModule({
       }
     });
     logger.debug("[nuxt-scripts] First-party config:", firstParty);
-    let interceptRules = [];
-    if (firstParty.enabled) {
-      interceptRules = await setupFirstPartyHandlers(firstParty, resolvePath);
-    }
     const scripts = await registry(resolvePath);
     for (const script of scripts) {
       if (script.import?.name) {
@@ -1544,14 +1570,15 @@ const module$1 = defineNuxtModule({
       }
       const { renderedScript } = setupPublicAssetStrategy(config.assets);
       if (firstParty.enabled) {
-        finalizeFirstParty({
+        const devtoolsData = finalizeFirstParty({
           firstParty,
-          interceptRules,
           registry: config.registry,
           registryScripts,
-          registryScriptsWithImport,
           nuxtOptions: nuxt.options
         });
+        if (devtoolsData) {
+          nuxt.options.runtimeConfig.public["nuxt-scripts-devtools"] = devtoolsData;
+        }
       }
       const moduleInstallPromises = /* @__PURE__ */ new Map();
       addBuildPlugin(NuxtScriptsCheckScripts(), {
@@ -1561,8 +1588,7 @@ const module$1 = defineNuxtModule({
         scripts: registryScriptsWithImport,
         registryConfig: nuxt.options.runtimeConfig.public.scripts,
         defaultBundle: firstParty.enabled || config.defaultScriptOptions?.bundle,
-        firstPartyEnabled: firstParty.enabled,
-        firstPartyCollectPrefix: firstParty.collectPrefix,
+        proxyConfigs: firstParty.proxyConfigs,
         moduleDetected(module) {
           if (nuxt.options.dev && module !== "@nuxt/scripts" && !moduleInstallPromises.has(module) && !hasNuxtModule(module))
             moduleInstallPromises.set(module, () => installNuxtModule(module));
@@ -1596,7 +1622,7 @@ const module$1 = defineNuxtModule({
         });
       }
       if (script.registryKey === "gravatar") {
-        const gravatarConfig = typeof config.registry?.gravatar === "object" && !Array.isArray(config.registry.gravatar) ? config.registry.gravatar : {};
+        const gravatarConfig = config.registry?.gravatar?.[0] || {};
         nuxt.options.runtimeConfig.public["nuxt-scripts"] = defu(
           { gravatarProxy: { cacheMaxAge: gravatarConfig.cacheMaxAge ?? 3600 } },
           nuxt.options.runtimeConfig.public["nuxt-scripts"]