@storybook/nextjs 10.1.0-alpha.10 → 10.1.0-alpha.11

package/dist/preset.js

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_1wy8hqz8e24 from 'node:url';
-import CJS_COMPAT_NODE_PATH_1wy8hqz8e24 from 'node:path';
-import CJS_COMPAT_NODE_MODULE_1wy8hqz8e24 from "node:module";
+import CJS_COMPAT_NODE_URL_h9mxauk5xyo from 'node:url';
+import CJS_COMPAT_NODE_PATH_h9mxauk5xyo from 'node:path';
+import CJS_COMPAT_NODE_MODULE_h9mxauk5xyo from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_1wy8hqz8e24.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_1wy8hqz8e24.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_1wy8hqz8e24.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_h9mxauk5xyo.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_h9mxauk5xyo.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_h9mxauk5xyo.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
@@ -13,11 +13,8 @@ import {
   addScopedAlias,
   isNextVersionGte,
   resolveNextConfig
-} from "./_node-chunks/chunk-EVMWO5FG.js";
-import "./_node-chunks/chunk-RSBRC6AY.js";
-import {
-  __name
-} from "./_node-chunks/chunk-Z2RESD5M.js";
+} from "./_node-chunks/chunk-KG2CEDQ6.js";
+import "./_node-chunks/chunk-NVSKNSJK.js";
 
 // src/preset.ts
 import { existsSync } from "node:fs";
@@ -37,27 +34,14 @@ function AmpAttributePatcher() {
   return {
     visitor: {
       JSXOpeningElement(path) {
-        const openingElement = path.node;
-        const { name, attributes } = openingElement;
-        if (!(name && name.type === "JSXIdentifier")) {
-          return;
-        }
-        if (!name.name.startsWith("amp-")) {
-          return;
-        }
-        for (const attribute of attributes) {
-          if (attribute.type !== "JSXAttribute") {
-            continue;
-          }
-          if (attribute.name.name === "className") {
-            attribute.name.name = "class";
-          }
-        }
+        let openingElement = path.node, { name, attributes } = openingElement;
+        if (name && name.type === "JSXIdentifier" && name.name.startsWith("amp-"))
+          for (let attribute of attributes)
+            attribute.type === "JSXAttribute" && attribute.name.name === "className" && (attribute.name.name = "class");
       }
     }
   };
 }
-__name(AmpAttributePatcher, "AmpAttributePatcher");
 
 // src/babel/plugins/jsx-pragma.ts
 import jsx from "next/dist/compiled/babel/plugin-syntax-jsx.js";
@@ -66,44 +50,33 @@ function jsxPragma({ types: t }) {
     inherits: jsx,
     visitor: {
       JSXElement(_path, state) {
-        state.set("jsx", true);
+        state.set("jsx", !0);
       },
       // Fragment syntax is still JSX since it compiles to createElement(),
       // but JSXFragment is not a JSXElement
       JSXFragment(_path, state) {
-        state.set("jsx", true);
+        state.set("jsx", !0);
       },
       Program: {
         exit(path, state) {
           if (state.get("jsx")) {
-            const pragma = t.identifier(state.opts.pragma);
-            let importAs = pragma;
-            const existingBinding = state.opts.reuseImport !== false && state.opts.importAs && path.scope.getBinding(state.opts.importAs);
+            let pragma = t.identifier(state.opts.pragma), importAs = pragma, existingBinding = state.opts.reuseImport !== !1 && state.opts.importAs && path.scope.getBinding(state.opts.importAs);
             if (state.opts.property) {
-              if (state.opts.importAs) {
-                importAs = t.identifier(state.opts.importAs);
-              } else {
-                importAs = path.scope.generateUidIdentifier("pragma");
-              }
-              const mapping = t.variableDeclaration("var", [
+              state.opts.importAs ? importAs = t.identifier(state.opts.importAs) : importAs = path.scope.generateUidIdentifier("pragma");
+              let mapping = t.variableDeclaration("var", [
                 t.variableDeclarator(
                   pragma,
                   t.memberExpression(importAs, t.identifier(state.opts.property))
                 )
-              ]);
-              let newPath;
-              if (existingBinding && t.isVariableDeclarator(existingBinding.path.node) && t.isCallExpression(existingBinding.path.node.init) && t.isIdentifier(existingBinding.path.node.init.callee) && existingBinding.path.node.init.callee.name === "require") {
-                [newPath] = existingBinding.path.parentPath.insertAfter(mapping);
-              } else {
-                [newPath] = path.unshiftContainer("body", mapping);
-              }
-              for (const declar of newPath.get("declarations")) {
-                const kind = ["var", "let", "const"].find((k) => newPath.node.kind === k) || "const";
+              ]), newPath;
+              existingBinding && t.isVariableDeclarator(existingBinding.path.node) && t.isCallExpression(existingBinding.path.node.init) && t.isIdentifier(existingBinding.path.node.init.callee) && existingBinding.path.node.init.callee.name === "require" ? [newPath] = existingBinding.path.parentPath.insertAfter(mapping) : [newPath] = path.unshiftContainer("body", mapping);
+              for (let declar of newPath.get("declarations")) {
+                let kind = ["var", "let", "const"].find((k) => newPath.node.kind === k) || "const";
                 path.scope.registerBinding(kind, declar);
               }
             }
             if (!existingBinding) {
-              const importSpecifier = t.importDeclaration(
+              let importSpecifier = t.importDeclaration(
                 [
                   state.opts.import ? (
                     // import { $import as _pragma } from '$module'
@@ -114,11 +87,9 @@ function jsxPragma({ types: t }) {
                   )
                 ],
                 t.stringLiteral(state.opts.module || "react")
-              );
-              const [newPath] = path.unshiftContainer("body", importSpecifier);
-              for (const specifier of newPath.get("specifiers")) {
+              ), [newPath] = path.unshiftContainer("body", importSpecifier);
+              for (let specifier of newPath.get("specifiers"))
                 path.scope.registerBinding("module", specifier);
-              }
             }
           }
         }
@@ -126,46 +97,29 @@ function jsxPragma({ types: t }) {
     }
   };
 }
-__name(jsxPragma, "jsxPragma");
 
 // src/babel/plugins/optimize-hook-destructuring.ts
-var isHook = /^use[A-Z]/;
-var isBuiltInHook = /^use(Callback|Context|DebugValue|Effect|ImperativeHandle|LayoutEffect|Memo|Reducer|Ref|State)$/;
+var isHook = /^use[A-Z]/, isBuiltInHook = /^use(Callback|Context|DebugValue|Effect|ImperativeHandle|LayoutEffect|Memo|Reducer|Ref|State)$/;
 function optimizeHookDestructuring({
   types: t
 }) {
-  const visitor = {
+  let visitor = {
     CallExpression(path, state) {
-      const { onlyBuiltIns } = state.opts;
-      const libs = state.opts.lib && (state.opts.lib === true ? ["react", "preact/hooks"] : [].concat(state.opts.lib));
-      if (!t.isVariableDeclarator(path.parent)) {
+      let { onlyBuiltIns } = state.opts, libs = state.opts.lib && (state.opts.lib === !0 ? ["react", "preact/hooks"] : [].concat(state.opts.lib));
+      if (!t.isVariableDeclarator(path.parent) || !t.isArrayPattern(path.parent.id))
         return;
-      }
-      if (!t.isArrayPattern(path.parent.id)) {
-        return;
-      }
-      const hookName = path.node.callee.name;
+      let hookName = path.node.callee.name;
       if (libs) {
-        const binding = path.scope.getBinding(hookName);
-        if (!binding || binding.kind !== "module") {
+        let binding = path.scope.getBinding(hookName);
+        if (!binding || binding.kind !== "module")
           return;
-        }
-        const specifier = binding.path.parent.source.value;
-        if (!libs.some((lib) => lib === specifier)) {
+        let specifier = binding.path.parent.source.value;
+        if (!libs.some((lib) => lib === specifier))
           return;
-        }
-      }
-      if (!(onlyBuiltIns ? isBuiltInHook : isHook).test(hookName)) {
-        return;
       }
-      path.parent.id = t.objectPattern(
-        path.parent.id.elements.reduce((patterns, element, i) => {
-          if (element === null) {
-            return patterns;
-          }
-          return patterns.concat(t.objectProperty(t.numericLiteral(i), element));
-        }, [])
-      );
+      (onlyBuiltIns ? isBuiltInHook : isHook).test(hookName) && (path.parent.id = t.objectPattern(
+        path.parent.id.elements.reduce((patterns, element, i) => element === null ? patterns : patterns.concat(t.objectProperty(t.numericLiteral(i), element)), [])
+      ));
     }
   };
   return {
@@ -178,7 +132,6 @@ function optimizeHookDestructuring({
     }
   };
 }
-__name(optimizeHookDestructuring, "optimizeHookDestructuring");
 
 // src/babel/plugins/react-loadable-plugin.ts
 import { relative as relativePath } from "node:path";
@@ -186,95 +139,46 @@ function react_loadable_plugin_default({ types: t }) {
   return {
     visitor: {
       ImportDeclaration(path, state) {
-        const source = path.node.source.value;
-        if (source !== "next/dynamic") {
-          return;
-        }
-        const defaultSpecifier = path.get("specifiers").find((specifier) => {
-          return specifier.isImportDefaultSpecifier();
-        });
-        if (!defaultSpecifier) {
+        if (path.node.source.value !== "next/dynamic")
           return;
-        }
-        const bindingName = defaultSpecifier.node.local.name;
-        const binding = path.scope.getBinding(bindingName);
-        if (!binding) {
+        let defaultSpecifier = path.get("specifiers").find((specifier) => specifier.isImportDefaultSpecifier());
+        if (!defaultSpecifier)
           return;
-        }
-        binding.referencePaths.forEach((refPath) => {
+        let bindingName = defaultSpecifier.node.local.name, binding = path.scope.getBinding(bindingName);
+        binding && binding.referencePaths.forEach((refPath) => {
           let callExpression = refPath.parentPath;
-          if (callExpression.isMemberExpression() && callExpression.node.computed === false) {
-            const property = callExpression.get("property");
-            if (!Array.isArray(property) && property.isIdentifier({ name: "Map" })) {
-              callExpression = callExpression.parentPath;
-            }
+          if (callExpression.isMemberExpression() && callExpression.node.computed === !1) {
+            let property = callExpression.get("property");
+            !Array.isArray(property) && property.isIdentifier({ name: "Map" }) && (callExpression = callExpression.parentPath);
           }
-          if (!callExpression.isCallExpression()) {
+          if (!callExpression.isCallExpression())
             return;
-          }
-          const callExpression_ = callExpression;
-          let args = callExpression_.get("arguments");
-          if (args.length > 2) {
+          let callExpression_ = callExpression, args = callExpression_.get("arguments");
+          if (args.length > 2)
             throw callExpression_.buildCodeFrameError("next/dynamic only accepts 2 arguments");
-          }
-          if (!args[0]) {
+          if (!args[0])
             return;
-          }
-          let loader;
-          let options;
-          if (args[0].isObjectExpression()) {
-            options = args[0];
-          } else {
-            if (!args[1]) {
-              callExpression_.node.arguments.push(t.objectExpression([]));
-            }
-            args = callExpression_.get("arguments");
-            loader = args[0];
-            options = args[1];
-          }
-          if (!options.isObjectExpression()) {
+          let loader, options;
+          if (args[0].isObjectExpression() ? options = args[0] : (args[1] || callExpression_.node.arguments.push(t.objectExpression([])), args = callExpression_.get("arguments"), loader = args[0], options = args[1]), !options.isObjectExpression())
             return;
-          }
-          const options_ = options;
-          const properties = options_.get("properties");
-          const propertiesMap = {};
-          properties.forEach((property) => {
-            const key = property.get("key");
+          let properties = options.get("properties"), propertiesMap = {};
+          if (properties.forEach((property) => {
+            let key = property.get("key");
             propertiesMap[key.node.name] = property;
-          });
-          if (propertiesMap.loadableGenerated) {
-            return;
-          }
-          if (propertiesMap.loader) {
-            loader = propertiesMap.loader.get("value");
-          }
-          if (propertiesMap.modules) {
-            loader = propertiesMap.modules.get("value");
-          }
-          if (!loader || Array.isArray(loader)) {
+          }), propertiesMap.loadableGenerated || (propertiesMap.loader && (loader = propertiesMap.loader.get("value")), propertiesMap.modules && (loader = propertiesMap.modules.get("value")), !loader || Array.isArray(loader)))
             return;
-          }
-          const dynamicImports = [];
-          const dynamicKeys = [];
+          let dynamicImports = [], dynamicKeys = [];
           if (propertiesMap.ssr) {
-            const ssr = propertiesMap.ssr.get("value");
-            const nodePath = Array.isArray(ssr) ? void 0 : ssr;
-            if (nodePath) {
-              const nonSSR = nodePath.node.type === "BooleanLiteral" && nodePath.node.value === false;
-              if (nonSSR && loader && state.file.opts.caller?.isServer) {
-                loader.replaceWith(t.arrowFunctionExpression([], t.nullLiteral(), true));
-              }
-            }
+            let ssr = propertiesMap.ssr.get("value"), nodePath = Array.isArray(ssr) ? void 0 : ssr;
+            nodePath && nodePath.node.type === "BooleanLiteral" && nodePath.node.value === !1 && loader && state.file.opts.caller?.isServer && loader.replaceWith(t.arrowFunctionExpression([], t.nullLiteral(), !0));
           }
-          loader.traverse({
+          if (loader.traverse({
             Import(importPath) {
-              const importArguments = importPath.parentPath.get("arguments");
-              if (!Array.isArray(importArguments)) {
+              let importArguments = importPath.parentPath.get("arguments");
+              if (!Array.isArray(importArguments))
                 return;
-              }
-              const { node } = importArguments[0];
-              dynamicImports.push(node);
-              dynamicKeys.push(
+              let { node } = importArguments[0];
+              dynamicImports.push(node), dynamicKeys.push(
                 t.binaryExpression(
                   "+",
                   t.stringLiteral(
@@ -284,11 +188,7 @@ function react_loadable_plugin_default({ types: t }) {
                 )
               );
             }
-          });
-          if (!dynamicImports.length) {
-            return;
-          }
-          options.node.properties.push(
+          }), !!dynamicImports.length && (options.node.properties.push(
             t.objectProperty(
               t.identifier("loadableGenerated"),
               t.objectExpression(
@@ -298,24 +198,21 @@ function react_loadable_plugin_default({ types: t }) {
                     t.arrowFunctionExpression(
                       [],
                       t.arrayExpression(
-                        dynamicImports.map((dynamicImport) => {
-                          return t.callExpression(
-                            t.memberExpression(
-                              t.identifier("require"),
-                              t.identifier("resolveWeak")
-                            ),
-                            [dynamicImport]
-                          );
-                        })
+                        dynamicImports.map((dynamicImport) => t.callExpression(
+                          t.memberExpression(
+                            t.identifier("require"),
+                            t.identifier("resolveWeak")
+                          ),
+                          [dynamicImport]
+                        ))
                       )
                     )
                   )
                 ]
               )
             )
-          );
-          if (loader.isCallExpression()) {
-            const arrowFunction = t.arrowFunctionExpression([], loader.node);
+          ), loader.isCallExpression())) {
+            let arrowFunction = t.arrowFunctionExpression([], loader.node);
             loader.replaceWith(arrowFunction);
           }
         });
@@ -323,48 +220,30 @@ function react_loadable_plugin_default({ types: t }) {
     }
   };
 }
-__name(react_loadable_plugin_default, "default");
 
 // src/babel/preset.ts
-var isLoadIntentTest = process.env.NODE_ENV === "test";
-var isLoadIntentDevelopment = process.env.NODE_ENV === "development";
-var require2 = createRequire(import.meta.url);
+var isLoadIntentTest = process.env.NODE_ENV === "test", isLoadIntentDevelopment = process.env.NODE_ENV === "development", require2 = createRequire(import.meta.url);
 function styledJsxOptions(options) {
-  options = options || {};
-  options.styleModule = "styled-jsx/style";
-  if (!Array.isArray(options.plugins)) {
-    return options;
-  }
-  options.plugins = options.plugins.map((plugin) => {
+  return options = options || {}, options.styleModule = "styled-jsx/style", Array.isArray(options.plugins) && (options.plugins = options.plugins.map((plugin) => {
     if (Array.isArray(plugin)) {
-      const [name, pluginOptions] = plugin;
+      let [name, pluginOptions] = plugin;
       return [require2.resolve(name), pluginOptions];
     }
     return require2.resolve(plugin);
-  });
-  return options;
+  })), options;
 }
-__name(styledJsxOptions, "styledJsxOptions");
 function supportsStaticESM(caller) {
   return !!caller?.supportsStaticESM;
 }
-__name(supportsStaticESM, "supportsStaticESM");
-var preset_default = /* @__PURE__ */ __name((api, options = {}) => {
-  const supportsESM = api.caller(supportsStaticESM);
-  const isServer = api.caller((caller) => !!caller && caller.isServer);
-  const isCallerDevelopment = api.caller((caller) => caller?.isDev);
-  const isTest = isCallerDevelopment == null && isLoadIntentTest;
-  const isDevelopment = isCallerDevelopment === true || isCallerDevelopment == null && isLoadIntentDevelopment;
-  const isBabelLoader = api.caller(
+var preset_default = (api, options = {}) => {
+  let supportsESM = api.caller(supportsStaticESM), isServer = api.caller((caller) => !!caller && caller.isServer), isCallerDevelopment = api.caller((caller) => caller?.isDev), isTest = isCallerDevelopment == null && isLoadIntentTest, isDevelopment = isCallerDevelopment === !0 || isCallerDevelopment == null && isLoadIntentDevelopment, isBabelLoader = api.caller(
     (caller) => !!caller && (caller.name === "babel-loader" || caller.name === "next-babel-turbo-loader")
-  );
-  const useJsxRuntime = options["preset-react"]?.runtime === "automatic" || Boolean(api.caller((caller) => !!caller && caller.hasJsxRuntime)) && options["preset-react"]?.runtime !== "classic";
-  const presetEnvConfig = {
+  ), useJsxRuntime = options["preset-react"]?.runtime === "automatic" || !!api.caller((caller) => !!caller && caller.hasJsxRuntime) && options["preset-react"]?.runtime !== "classic", presetEnvConfig = {
     // In the test environment `modules` is often needed to be set to true, babel figures that out by itself using the `'auto'` option
     // In production/development this option is set to `false` so that webpack can handle import/export with tree-shaking
     modules: "auto",
     exclude: ["transform-typeof-symbol"],
-    bugfixes: true,
+    bugfixes: !0,
     targets: {
       chrome: 100,
       safari: 15,
@@ -372,15 +251,12 @@ var preset_default = /* @__PURE__ */ __name((api, options = {}) => {
     },
     ...options["preset-env"]
   };
-  if ((isServer || isTest) && (!presetEnvConfig.targets || !(typeof presetEnvConfig.targets === "object" && "node" in presetEnvConfig.targets))) {
-    presetEnvConfig.targets = {
-      // Targets the current process' version of Node. This requires apps be
-      // built and deployed on the same version of Node.
-      // This is the same as using "current" but explicit
-      node: process.versions.node
-    };
-  }
-  return {
+  return (isServer || isTest) && (!presetEnvConfig.targets || !(typeof presetEnvConfig.targets == "object" && "node" in presetEnvConfig.targets)) && (presetEnvConfig.targets = {
+    // Targets the current process' version of Node. This requires apps be
+    // built and deployed on the same version of Node.
+    // This is the same as using "current" but explicit
+    node: process.versions.node
+  }), {
     sourceType: "unambiguous",
     presets: [
       [require2("@babel/preset-env"), presetEnvConfig],
@@ -396,7 +272,7 @@ var preset_default = /* @__PURE__ */ __name((api, options = {}) => {
       ],
       [
         require2("@babel/preset-typescript"),
-        { allowNamespaces: true, ...options["preset-typescript"] }
+        { allowNamespaces: !0, ...options["preset-typescript"] }
       ]
     ],
     plugins: [
@@ -417,7 +293,7 @@ var preset_default = /* @__PURE__ */ __name((api, options = {}) => {
         optimizeHookDestructuring,
         {
           // only optimize hook functions imported from React/Preact
-          lib: true
+          lib: !0
         }
       ],
       require2("@babel/plugin-syntax-dynamic-import"),
@@ -427,15 +303,15 @@ var preset_default = /* @__PURE__ */ __name((api, options = {}) => {
       [
         require2("@babel/plugin-transform-object-rest-spread"),
         {
-          useBuiltIns: true
+          useBuiltIns: !0
         }
       ],
       !isServer && [
         require2("@babel/plugin-transform-runtime"),
         {
-          corejs: false,
-          helpers: true,
-          regenerator: true,
+          corejs: !1,
+          helpers: !0,
+          regenerator: !0,
           useESModules: supportsESM && presetEnvConfig.modules !== "commonjs",
           absoluteRuntime: isBabelLoader ? dirname(require2.resolve("@babel/runtime/package.json")) : void 0,
           ...options["transform-runtime"]
@@ -453,206 +329,128 @@ var preset_default = /* @__PURE__ */ __name((api, options = {}) => {
       require2("@babel/plugin-transform-export-namespace-from")
     ].filter(Boolean)
   };
-}, "default");
+};
 
 // src/config/webpack.ts
 import { fileURLToPath } from "node:url";
-var isNext16orNewer = isNextVersionGte("16.0.0");
-var tryResolve = /* @__PURE__ */ __name((path) => {
+var isNext16orNewer = isNextVersionGte("16.0.0"), tryResolve = (path) => {
   try {
-    return fileURLToPath(import.meta.resolve(path)) || false;
-  } catch (err) {
-    return false;
+    return fileURLToPath(import.meta.resolve(path)) || !1;
+  } catch {
+    return !1;
   }
-}, "tryResolve");
-var configureConfig = /* @__PURE__ */ __name(async ({
+}, configureConfig = async ({
   baseConfig,
   nextConfigPath
 }) => {
-  const nextConfig = await resolveNextConfig({ nextConfigPath });
-  if (!isNext16orNewer) {
-    addScopedAlias(baseConfig, "next/config");
-  }
-  if (baseConfig.resolve?.alias?.["react-dom"]) {
-    delete baseConfig.resolve.alias?.["react-dom"];
-  }
-  if (tryResolve("next/dist/compiled/react")) {
-    addScopedAlias(baseConfig, "react", "next/dist/compiled/react");
-  }
-  if (tryResolve("next/dist/compiled/react-dom/cjs/react-dom-test-utils.production.js")) {
-    addScopedAlias(
-      baseConfig,
-      "react-dom/test-utils",
-      "next/dist/compiled/react-dom/cjs/react-dom-test-utils.production.js"
-    );
-  }
-  if (tryResolve("next/dist/compiled/react-dom")) {
-    addScopedAlias(baseConfig, "react-dom$", "next/dist/compiled/react-dom");
-    addScopedAlias(baseConfig, "react-dom/client", "next/dist/compiled/react-dom/client");
-    addScopedAlias(baseConfig, "react-dom/server", "next/dist/compiled/react-dom/server");
-  }
-  await setupRuntimeConfig(baseConfig, nextConfig);
-  return nextConfig;
-}, "configureConfig");
-var setupRuntimeConfig = /* @__PURE__ */ __name(async (baseConfig, nextConfig) => {
-  const definePluginConfig = {};
-  if (!isNext16orNewer) {
-    definePluginConfig["process.env.__NEXT_RUNTIME_CONFIG"] = JSON.stringify({
-      serverRuntimeConfig: {},
-      publicRuntimeConfig: nextConfig.publicRuntimeConfig
-    });
-  }
-  const newNextLinkBehavior = nextConfig.experimental?.newNextLinkBehavior;
-  definePluginConfig["process.env.__NEXT_NEW_LINK_BEHAVIOR"] = newNextLinkBehavior;
-  baseConfig.plugins?.push(new (await import("webpack")).default.DefinePlugin(definePluginConfig));
-}, "setupRuntimeConfig");
+  let nextConfig = await resolveNextConfig({ nextConfigPath });
+  return isNext16orNewer || addScopedAlias(baseConfig, "next/config"), baseConfig.resolve?.alias?.["react-dom"] && delete baseConfig.resolve.alias?.["react-dom"], tryResolve("next/dist/compiled/react") && addScopedAlias(baseConfig, "react", "next/dist/compiled/react"), tryResolve("next/dist/compiled/react-dom/cjs/react-dom-test-utils.production.js") && addScopedAlias(
+    baseConfig,
+    "react-dom/test-utils",
+    "next/dist/compiled/react-dom/cjs/react-dom-test-utils.production.js"
+  ), tryResolve("next/dist/compiled/react-dom") && (addScopedAlias(baseConfig, "react-dom$", "next/dist/compiled/react-dom"), addScopedAlias(baseConfig, "react-dom/client", "next/dist/compiled/react-dom/client"), addScopedAlias(baseConfig, "react-dom/server", "next/dist/compiled/react-dom/server")), await setupRuntimeConfig(baseConfig, nextConfig), nextConfig;
+}, setupRuntimeConfig = async (baseConfig, nextConfig) => {
+  let definePluginConfig = {};
+  isNext16orNewer || (definePluginConfig["process.env.__NEXT_RUNTIME_CONFIG"] = JSON.stringify({
+    serverRuntimeConfig: {},
+    publicRuntimeConfig: nextConfig.publicRuntimeConfig
+  }));
+  let newNextLinkBehavior = nextConfig.experimental?.newNextLinkBehavior;
+  definePluginConfig["process.env.__NEXT_NEW_LINK_BEHAVIOR"] = newNextLinkBehavior, baseConfig.plugins?.push(new (await import("webpack")).default.DefinePlugin(definePluginConfig));
+};
 
 // src/font/babel/helpers.ts
 function convertNodeToJSON(types, node) {
-  if (types.isBooleanLiteral(node) || types.isStringLiteral(node) || types.isNumericLiteral(node)) {
+  if (types.isBooleanLiteral(node) || types.isStringLiteral(node) || types.isNumericLiteral(node))
     return node.value;
-  }
-  if (node.name === "undefined" && !node.value) {
-    return void 0;
-  }
-  if (types.isNullLiteral(node)) {
-    return null;
-  }
-  if (types.isObjectExpression(node)) {
-    return computeProps(types, node.properties);
-  }
-  if (types.isArrayExpression(node)) {
-    return node.elements.reduce(
+  if (!(node.name === "undefined" && !node.value))
+    return types.isNullLiteral(node) ? null : types.isObjectExpression(node) ? computeProps(types, node.properties) : types.isArrayExpression(node) ? node.elements.reduce(
       (acc, element) => [
         ...acc,
         ...element?.type === "SpreadElement" ? convertNodeToJSON(types, element.argument) : [convertNodeToJSON(types, element)]
       ],
       []
-    );
-  }
-  return {};
+    ) : {};
 }
-__name(convertNodeToJSON, "convertNodeToJSON");
 function computeProps(types, props) {
   return props.reduce((acc, prop) => {
-    if (prop.type === "SpreadElement") {
+    if (prop.type === "SpreadElement")
       return {
         ...acc,
         ...convertNodeToJSON(types, prop.argument)
       };
-    }
     if (prop.type !== "ObjectMethod") {
-      const val = convertNodeToJSON(types, prop.value);
-      if (val !== void 0 && types.isIdentifier(prop.key)) {
+      let val = convertNodeToJSON(types, prop.value);
+      if (val !== void 0 && types.isIdentifier(prop.key))
         return {
           ...acc,
           [prop.key.name]: val
         };
-      }
     }
     return acc;
   }, {});
 }
-__name(computeProps, "computeProps");
 function isDefined(value) {
   return value !== void 0;
 }
-__name(isDefined, "isDefined");
 function removeTransformedVariableDeclarations(path, types, metas) {
   path.parentPath.traverse({
     ExportNamedDeclaration(declaratorPath) {
-      if (!declaratorPath.parentPath?.isProgram()) {
-        return;
-      }
-      metas.forEach((meta) => {
-        if (types.isVariableDeclaration(declaratorPath.node.declaration) && declaratorPath.node.declaration.declarations.length === 1 && types.isVariableDeclarator(declaratorPath.node.declaration.declarations[0]) && types.isIdentifier(declaratorPath.node.declaration.declarations[0].id) && meta.identifierName === declaratorPath.node.declaration.declarations[0].id.name) {
-          declaratorPath.replaceWith(
-            types.exportNamedDeclaration(null, [
-              types.exportSpecifier(
-                types.identifier(meta.identifierName),
-                types.identifier(meta.identifierName)
-              )
-            ])
-          );
-        }
+      declaratorPath.parentPath?.isProgram() && metas.forEach((meta) => {
+        types.isVariableDeclaration(declaratorPath.node.declaration) && declaratorPath.node.declaration.declarations.length === 1 && types.isVariableDeclarator(declaratorPath.node.declaration.declarations[0]) && types.isIdentifier(declaratorPath.node.declaration.declarations[0].id) && meta.identifierName === declaratorPath.node.declaration.declarations[0].id.name && declaratorPath.replaceWith(
+          types.exportNamedDeclaration(null, [
+            types.exportSpecifier(
+              types.identifier(meta.identifierName),
+              types.identifier(meta.identifierName)
+            )
+          ])
+        );
       });
     },
     VariableDeclarator(declaratorPath) {
-      if (!declaratorPath.parentPath.parentPath?.isProgram()) {
-        return;
-      }
-      if (metas.some(
+      declaratorPath.parentPath.parentPath?.isProgram() && metas.some(
         (meta) => types.isIdentifier(declaratorPath.node.id) && meta.identifierName === declaratorPath.node.id.name
-      )) {
-        declaratorPath.remove();
-      }
+      ) && declaratorPath.remove();
     }
   });
 }
-__name(removeTransformedVariableDeclarations, "removeTransformedVariableDeclarations");
 function replaceImportWithParameterImport(path, types, source, metas, filename) {
   path.replaceWithMultiple([
-    ...metas.map((meta) => {
-      return types.importDeclaration(
-        [types.importDefaultSpecifier(types.identifier(meta.identifierName))],
-        types.stringLiteral(
-          `storybook-nextjs-font-loader?${JSON.stringify({
-            source: source.value,
-            props: meta.properties,
-            fontFamily: meta.functionName,
-            filename
-          })}!${source.value}`
-        )
-      );
-    })
+    ...metas.map((meta) => types.importDeclaration(
+      [types.importDefaultSpecifier(types.identifier(meta.identifierName))],
+      types.stringLiteral(
+        `storybook-nextjs-font-loader?${JSON.stringify({
+          source: source.value,
+          props: meta.properties,
+          fontFamily: meta.functionName,
+          filename
+        })}!${source.value}`
+      )
+    ))
   ]);
 }
-__name(replaceImportWithParameterImport, "replaceImportWithParameterImport");
 function getVariableMetasBySpecifier(program, types, specifier) {
   return program.node.body.map((statement) => {
-    if (!types.isVariableDeclaration(statement) && !types.isExportNamedDeclaration(statement)) {
-      return void 0;
-    }
-    const exportedNamedDeclaration = !types.isVariableDeclaration(statement) && types.isVariableDeclaration(statement.declaration) && statement.declaration.declarations.length === 1 ? statement.declaration.declarations[0] : null;
-    const declaration = types.isVariableDeclaration(statement) ? statement.declarations[0] : exportedNamedDeclaration;
-    if (!declaration) {
-      return void 0;
-    }
-    if (!types.isIdentifier(declaration.id)) {
-      return void 0;
-    }
-    if (!types.isCallExpression(declaration.init)) {
-      return void 0;
-    }
-    if (!types.isIdentifier(declaration.init.callee)) {
-      return void 0;
-    }
-    if ((specifier.type !== "ImportSpecifier" || specifier.imported.type !== "Identifier" || declaration.init.callee.name !== specifier.imported.name && declaration.init.callee.name !== specifier.local.name) && (specifier.type !== "ImportDefaultSpecifier" || declaration.init.callee.name !== specifier.local.name)) {
-      return void 0;
-    }
-    const options = declaration.init.arguments[0];
-    if (!types.isObjectExpression(options)) {
+    if (!types.isVariableDeclaration(statement) && !types.isExportNamedDeclaration(statement))
+      return;
+    let exportedNamedDeclaration = !types.isVariableDeclaration(statement) && types.isVariableDeclaration(statement.declaration) && statement.declaration.declarations.length === 1 ? statement.declaration.declarations[0] : null, declaration = types.isVariableDeclaration(statement) ? statement.declarations[0] : exportedNamedDeclaration;
+    if (!declaration || !types.isIdentifier(declaration.id) || !types.isCallExpression(declaration.init) || !types.isIdentifier(declaration.init.callee) || (specifier.type !== "ImportSpecifier" || specifier.imported.type !== "Identifier" || declaration.init.callee.name !== specifier.imported.name && declaration.init.callee.name !== specifier.local.name) && (specifier.type !== "ImportDefaultSpecifier" || declaration.init.callee.name !== specifier.local.name))
+      return;
+    let options = declaration.init.arguments[0];
+    if (!types.isObjectExpression(options))
       throw program.buildCodeFrameError(
         "Please pass an options object to the call expression of next/font functions"
       );
-    }
     options.properties.forEach((property) => {
-      if (types.isSpreadElement(property)) {
+      if (types.isSpreadElement(property))
         throw program.buildCodeFrameError(
           "Please do not use spread elements in the options object in next/font function calls"
         );
-      }
     });
-    const identifierName = declaration.id.name;
-    const properties = convertNodeToJSON(types, options);
-    let functionName = declaration.init.callee.name;
-    if (specifier.type === "ImportSpecifier" && specifier.imported && specifier.imported.type === "Identifier" && declaration.init.callee.name !== specifier.imported.name) {
-      functionName = specifier.imported.name;
-    }
-    return { identifierName, properties, functionName };
+    let identifierName = declaration.id.name, properties = convertNodeToJSON(types, options), functionName = declaration.init.callee.name;
+    return specifier.type === "ImportSpecifier" && specifier.imported && specifier.imported.type === "Identifier" && declaration.init.callee.name !== specifier.imported.name && (functionName = specifier.imported.name), { identifierName, properties, functionName };
   }).filter(isDefined);
 }
-__name(getVariableMetasBySpecifier, "getVariableMetasBySpecifier");
 
 // src/font/babel/index.ts
 function TransformFontImports({ types }) {
@@ -660,101 +458,66 @@ function TransformFontImports({ types }) {
     name: "storybook-nextjs-font-imports",
     visitor: {
       ImportDeclaration(path, state) {
-        const { node } = path;
-        const { source } = node;
-        const { filename = "" } = state;
+        let { node } = path, { source } = node, { filename = "" } = state;
         if (source.value === "next/font/local" || source.value === "@next/font/local") {
-          const { specifiers } = node;
-          const specifier = specifiers[0];
-          if (!path.parentPath.isProgram()) {
+          let { specifiers } = node, specifier = specifiers[0];
+          if (!path.parentPath.isProgram())
             return;
-          }
-          const program = path.parentPath;
-          const variableMetas = getVariableMetasBySpecifier(program, types, specifier);
-          removeTransformedVariableDeclarations(path, types, variableMetas);
-          replaceImportWithParameterImport(path, types, source, variableMetas, filename);
+          let program = path.parentPath, variableMetas = getVariableMetasBySpecifier(program, types, specifier);
+          removeTransformedVariableDeclarations(path, types, variableMetas), replaceImportWithParameterImport(path, types, source, variableMetas, filename);
         }
         if (source.value === "next/font/google" || source.value === "@next/font/google") {
-          const { specifiers } = node;
-          const variableMetas = specifiers.flatMap((specifier) => {
-            if (!path.parentPath.isProgram()) {
+          let { specifiers } = node, variableMetas = specifiers.flatMap((specifier) => {
+            if (!path.parentPath.isProgram())
               return [];
-            }
-            const program = path.parentPath;
+            let program = path.parentPath;
             return getVariableMetasBySpecifier(program, types, specifier);
           }).filter(isDefined);
-          removeTransformedVariableDeclarations(path, types, variableMetas);
-          replaceImportWithParameterImport(path, types, source, variableMetas, filename);
+          removeTransformedVariableDeclarations(path, types, variableMetas), replaceImportWithParameterImport(path, types, source, variableMetas, filename);
         }
       }
     }
   };
 }
-__name(TransformFontImports, "TransformFontImports");
 
 // src/preset.ts
 var addons = [
   fileURLToPath2(import.meta.resolve("@storybook/preset-react-webpack"))
-];
-var core = /* @__PURE__ */ __name(async (config, options) => {
-  const framework = await options.presets.apply("framework");
-  await configureConfig({
+], core = async (config, options) => {
+  let framework = await options.presets.apply("framework");
+  return await configureConfig({
     // Pass in a dummy webpack config object for now, since we don't want to
     // modify the real one yet. We pass in the real one in webpackFinal.
     baseConfig: {},
-    nextConfigPath: typeof framework === "string" ? void 0 : framework.options.nextConfigPath
-  });
-  return {
+    nextConfigPath: typeof framework == "string" ? void 0 : framework.options.nextConfigPath
+  }), {
     ...config,
     builder: {
       name: fileURLToPath2(import.meta.resolve("@storybook/builder-webpack5")),
       options: {
-        ...typeof framework === "string" ? {} : framework.options.builder || {}
+        ...typeof framework == "string" ? {} : framework.options.builder || {}
       }
     },
     renderer: fileURLToPath2(import.meta.resolve("@storybook/react/preset"))
   };
-}, "core");
-var previewAnnotations = /* @__PURE__ */ __name((entry = []) => {
-  const annotations = [...entry, fileURLToPath2(import.meta.resolve("@storybook/nextjs/preview"))];
-  const isNext16orNewer2 = isNextVersionGte("16.0.0");
-  if (!isNext16orNewer2) {
-    annotations.push(fileURLToPath2(import.meta.resolve("@storybook/nextjs/config/preview")));
-  }
-  return annotations;
-}, "previewAnnotations");
-var babel = /* @__PURE__ */ __name(async (baseConfig) => {
-  const configPartial = loadPartialConfig({
+}, previewAnnotations = (entry = []) => {
+  let annotations = [...entry, fileURLToPath2(import.meta.resolve("@storybook/nextjs/preview"))];
+  return isNextVersionGte("16.0.0") || annotations.push(fileURLToPath2(import.meta.resolve("@storybook/nextjs/config/preview"))), annotations;
+}, babel = async (baseConfig) => {
+  let options = loadPartialConfig({
     ...baseConfig,
     filename: `${getProjectRoot()}/__fake__.js`
-  });
-  const options = configPartial?.options;
-  const isPresetConfigItem = /* @__PURE__ */ __name((preset) => {
-    return typeof preset === "object" && preset !== null && "file" in preset;
-  }, "isPresetConfigItem");
-  const isNextBabelConfig = /* @__PURE__ */ __name((preset) => Array.isArray(preset) && preset[0] === "next/babel" || preset === "next/babel" || isPresetConfigItem(preset) && preset.file?.request === "next/babel", "isNextBabelConfig");
-  const hasNextBabelConfig = options?.presets?.find(isNextBabelConfig);
-  const presets = options?.presets?.filter(
+  })?.options, isPresetConfigItem = (preset) => typeof preset == "object" && preset !== null && "file" in preset, isNextBabelConfig = (preset) => Array.isArray(preset) && preset[0] === "next/babel" || preset === "next/babel" || isPresetConfigItem(preset) && preset.file?.request === "next/babel", hasNextBabelConfig = options?.presets?.find(isNextBabelConfig), presets = options?.presets?.filter(
     (preset) => !(isPresetConfigItem(preset) && preset.file?.request === fileURLToPath2(import.meta.resolve("@babel/preset-react")) || isNextBabelConfig(preset))
   ) ?? [];
-  if (hasNextBabelConfig) {
-    if (Array.isArray(hasNextBabelConfig) && hasNextBabelConfig[1]) {
-      presets.push([preset_default, hasNextBabelConfig[1]]);
-    } else if (isPresetConfigItem(hasNextBabelConfig) && hasNextBabelConfig.file?.request === "next/babel") {
-      presets.push([preset_default, hasNextBabelConfig.options]);
-    } else {
-      presets.push(preset_default);
-    }
-  } else {
-    presets.push(preset_default);
-  }
-  const plugins = [...options?.plugins ?? [], TransformFontImports];
+  hasNextBabelConfig ? Array.isArray(hasNextBabelConfig) && hasNextBabelConfig[1] ? presets.push([preset_default, hasNextBabelConfig[1]]) : isPresetConfigItem(hasNextBabelConfig) && hasNextBabelConfig.file?.request === "next/babel" ? presets.push([preset_default, hasNextBabelConfig.options]) : presets.push(preset_default) : presets.push(preset_default);
+  let plugins = [...options?.plugins ?? [], TransformFontImports];
   return {
     ...options,
     plugins,
     presets,
-    babelrc: false,
-    configFile: false,
+    babelrc: !1,
+    configFile: !1,
     overrides: [
       ...options?.overrides ?? [],
       // We need to re-apply the default storybook babel override from:
@@ -767,7 +530,7 @@ var babel = /* @__PURE__ */ __name(async (baseConfig) => {
           [
             "next/dist/compiled/babel/preset-env",
             {
-              bugfixes: true,
+              bugfixes: !0,
               targets: {
                 chrome: 100,
                 safari: 15,
@@ -779,55 +542,13 @@ var babel = /* @__PURE__ */ __name(async (baseConfig) => {
       }
     ]
   };
-}, "babel");
-var webpackFinal = /* @__PURE__ */ __name(async (baseConfig, options) => {
-  const { nextConfigPath } = await options.presets.apply("frameworkOptions");
-  const nextConfig = await configureConfig({
+}, webpackFinal = async (baseConfig, options) => {
+  let { nextConfigPath } = await options.presets.apply("frameworkOptions"), nextConfig = await configureConfig({
     baseConfig,
     nextConfigPath
-  });
-  const { configureNextFont } = await import("./_node-chunks/configureNextFont-ZETH4V45.js");
-  const { configureRuntimeNextjsVersionResolution, getNextjsVersion } = await import("./_node-chunks/utils-G77XBOCW.js");
-  const { configureImports } = await import("./_node-chunks/webpack-L5YFG573.js");
-  const { configureCss } = await import("./_node-chunks/webpack-4ZO2PLAG.js");
-  const { configureImages } = await import("./_node-chunks/webpack-QPCUFYIY.js");
-  const { configureStyledJsx } = await import("./_node-chunks/webpack-R5RMXZWI.js");
-  const { configureNodePolyfills } = await import("./_node-chunks/webpack-6QTUYRFB.js");
-  const { configureAliases } = await import("./_node-chunks/webpack-AIYB3HRJ.js");
-  const { configureFastRefresh } = await import("./_node-chunks/webpack-QCUACIS6.js");
-  const { configureRSC } = await import("./_node-chunks/webpack-KRJ4EWQZ.js");
-  const { configureSWCLoader } = await import("./_node-chunks/loader-UJGK53PP.js");
-  const { configureBabelLoader } = await import("./_node-chunks/loader-WPDBQYKQ.js");
-  const babelRCPath = join(getProjectRoot(), ".babelrc");
-  const babelConfigPath = join(getProjectRoot(), "babel.config.js");
-  const hasBabelConfig = existsSync(babelRCPath) || existsSync(babelConfigPath);
-  const nextjsVersion = getNextjsVersion();
-  const isDevelopment = options.configType !== "PRODUCTION";
-  const isNext14orNewer = semver.gte(nextjsVersion, "14.0.0");
-  const useSWC = isNext14orNewer && (nextConfig.experimental?.forceSwcTransforms || !hasBabelConfig);
-  configureNextFont(baseConfig, useSWC);
-  configureRuntimeNextjsVersionResolution(baseConfig);
-  configureImports({ baseConfig, configDir: options.configDir });
-  configureCss(baseConfig, nextConfig);
-  configureImages(baseConfig, nextConfig);
-  configureStyledJsx(baseConfig);
-  configureNodePolyfills(baseConfig);
-  configureAliases(baseConfig);
-  if (isDevelopment) {
-    configureFastRefresh(baseConfig);
-  }
-  if (options.features?.experimentalRSC) {
-    configureRSC(baseConfig);
-  }
-  if (useSWC) {
-    logger.info("=> Using SWC as compiler");
-    await configureSWCLoader(baseConfig, options, nextConfig);
-  } else {
-    logger.info("=> Using Babel as compiler");
-    await configureBabelLoader(baseConfig, options, nextConfig);
-  }
-  return baseConfig;
-}, "webpackFinal");
+  }), { configureNextFont } = await import("./_node-chunks/configureNextFont-QR356EAI.js"), { configureRuntimeNextjsVersionResolution, getNextjsVersion } = await import("./_node-chunks/utils-GFLYVHHC.js"), { configureImports } = await import("./_node-chunks/webpack-KEI74OHK.js"), { configureCss } = await import("./_node-chunks/webpack-S3SWBOVU.js"), { configureImages } = await import("./_node-chunks/webpack-YFKESEJQ.js"), { configureStyledJsx } = await import("./_node-chunks/webpack-HDYOTQDH.js"), { configureNodePolyfills } = await import("./_node-chunks/webpack-YOXZVRLP.js"), { configureAliases } = await import("./_node-chunks/webpack-K7FNPCWL.js"), { configureFastRefresh } = await import("./_node-chunks/webpack-O4VJM34G.js"), { configureRSC } = await import("./_node-chunks/webpack-A6CKSXQU.js"), { configureSWCLoader } = await import("./_node-chunks/loader-VIIL5HSY.js"), { configureBabelLoader } = await import("./_node-chunks/loader-GUPXITUF.js"), babelRCPath = join(getProjectRoot(), ".babelrc"), babelConfigPath = join(getProjectRoot(), "babel.config.js"), hasBabelConfig = existsSync(babelRCPath) || existsSync(babelConfigPath), nextjsVersion = getNextjsVersion(), isDevelopment = options.configType !== "PRODUCTION", useSWC = semver.gte(nextjsVersion, "14.0.0") && (nextConfig.experimental?.forceSwcTransforms || !hasBabelConfig);
+  return configureNextFont(baseConfig, useSWC), configureRuntimeNextjsVersionResolution(baseConfig), configureImports({ baseConfig, configDir: options.configDir }), configureCss(baseConfig, nextConfig), configureImages(baseConfig, nextConfig), configureStyledJsx(baseConfig), configureNodePolyfills(baseConfig), configureAliases(baseConfig), isDevelopment && configureFastRefresh(baseConfig), options.features?.experimentalRSC && configureRSC(baseConfig), useSWC ? (logger.info("=> Using SWC as compiler"), await configureSWCLoader(baseConfig, options, nextConfig)) : (logger.info("=> Using Babel as compiler"), await configureBabelLoader(baseConfig, options, nextConfig)), baseConfig;
+};
 export {
   addons,
   babel,