@storybook/web-components 11.0.0-alpha.6 → 11.0.0-alpha.8

package/dist/preset.js

@@ -1,24 +1,24 @@
-import CJS_COMPAT_NODE_URL_3ov4ld79bt3 from 'node:url';
-import CJS_COMPAT_NODE_PATH_3ov4ld79bt3 from 'node:path';
-import CJS_COMPAT_NODE_MODULE_3ov4ld79bt3 from "node:module";
+import CJS_COMPAT_NODE_URL_f6rwsm0jxpo from 'node:url';
+import CJS_COMPAT_NODE_PATH_f6rwsm0jxpo from 'node:path';
+import CJS_COMPAT_NODE_MODULE_f6rwsm0jxpo from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_3ov4ld79bt3.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_3ov4ld79bt3.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_3ov4ld79bt3.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_f6rwsm0jxpo.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_f6rwsm0jxpo.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_f6rwsm0jxpo.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
-  DEFAULT_TYPE_PROPERTY,
   parseStoryFile,
   resolveStoryComponent
-} from "./_node-chunks/chunk-GDY64HEP.js";
+} from "./_node-chunks/chunk-A2ZEEPU6.js";
 
 // src/preset.ts
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/docgen/preset.ts
+import { loadPreviewOrConfigFile } from "storybook/internal/common";
 import { fileURLToPath } from "node:url";
 
 // src/docgen/component-docgen/config/resolve-manifest-paths.ts
@@ -46,7 +46,7 @@ var experimental_docgenProvider = async (existing = [], options) => {
     moduleSpecifier: fileURLToPath(import.meta.resolve(DOCGEN_WORKER_SPECIFIER)),
     options: {
       manifestPaths: resolveManifestPaths(options.configDir, frameworkOptions),
-      typeProperty: frameworkOptions.docgen?.typeProperty ?? DEFAULT_TYPE_PROPERTY
+      previewFilePath: loadPreviewOrConfigFile({ configDir: options.configDir })
     }
   };
   return [...existing, descriptor];
@@ -68,7 +68,6 @@ import { createWorkerGatedStoryDocsProvider, getService } from "storybook/intern
 import { logger } from "storybook/internal/node-logger";
 
 // src/docgen/story-docs/build-story-docs.ts
-import { types as t7 } from "storybook/internal/babel";
 import { getComponentIdFromEntry, getStoryImportPathFromEntry } from "storybook/internal/common";
 import { storyNameFromExport } from "storybook/internal/csf";
 import {
@@ -77,38 +76,41 @@ import {
   createStoryReferenceResolver,
   extractStoryJSDocInfo,
   noSnippetWarning,
-  sourceOf as sourceOf6,
-  unwrapExpression as unwrapExpression5,
+  resolveEffectiveRender,
+  oneLineTextOf as oneLineTextOf5,
+  unwrapExpression as unwrapExpression4,
   unresolvedWarning
 } from "storybook/internal/csf-tools";
 import { resolve as resolve2 } from "node:path";
 
 // src/docgen/story-docs/arg-values.ts
-import { types as t } from "storybook/internal/babel";
-import { keyOf, sourceOf, templateParts, unwrapExpression } from "storybook/internal/csf-tools";
-var FAILED = /* @__PURE__ */ Symbol("failed");
+import {
+  staticKey,
+  oneLineTextOf,
+  templateParts,
+  unwrapExpression
+} from "storybook/internal/csf-tools";
+var FAILED = /* @__PURE__ */ Symbol("failed"), isFunctionNode = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration", primitiveLiteralValue = (node) => node.type !== "Literal" ? FAILED : ["string", "number", "boolean"].includes(typeof node.value) ? node.value : node.value === null && !("regex" in node) && !("bigint" in node) ? null : FAILED;
 function evaluateArgValue(node) {
   let value = evaluate(node);
   if (value === FAILED) {
     let unwrapped = unwrapExpression(node);
-    return t.isFunction(unwrapped) ? { kind: "function" } : { kind: "unresolved", source: sourceOf(node) };
+    return isFunctionNode(unwrapped) ? { kind: "function" } : { kind: "unresolved", source: oneLineTextOf(node) };
   }
   return value === void 0 ? { kind: "unset" } : { kind: "value", value };
 }
 var evaluate = (node) => {
-  let unwrapped = unwrapExpression(node);
-  if (t.isStringLiteral(unwrapped) || t.isNumericLiteral(unwrapped) || t.isBooleanLiteral(unwrapped))
-    return unwrapped.value;
-  if (t.isNullLiteral(unwrapped)) return null;
-  if (t.isIdentifier(unwrapped, { name: "undefined" }) || t.isUnaryExpression(unwrapped) && unwrapped.operator === "void") return;
-  if (t.isUnaryExpression(unwrapped) && (unwrapped.operator === "-" || unwrapped.operator === "+") && t.isNumericLiteral(unwrapped.argument))
+  let unwrapped = unwrapExpression(node), literal = primitiveLiteralValue(unwrapped);
+  if (literal !== FAILED) return literal;
+  if (unwrapped.type === "Identifier" && unwrapped.name === "undefined" || unwrapped.type === "UnaryExpression" && unwrapped.operator === "void") return;
+  if (unwrapped.type === "UnaryExpression" && (unwrapped.operator === "-" || unwrapped.operator === "+") && unwrapped.argument.type === "Literal" && typeof unwrapped.argument.value == "number")
     return unwrapped.operator === "-" ? -unwrapped.argument.value : unwrapped.argument.value;
   let parts = templateParts(unwrapped);
-  return parts && parts.expressions.length === 0 ? parts.quasis[0] ?? FAILED : t.isFunction(unwrapped) ? FAILED : t.isArrayExpression(unwrapped) ? evaluateArray(unwrapped) : t.isObjectExpression(unwrapped) ? evaluateObject(unwrapped) : FAILED;
+  return parts && parts.expressions.length === 0 ? parts.quasis[0] ?? FAILED : isFunctionNode(unwrapped) ? FAILED : unwrapped.type === "ArrayExpression" ? evaluateArray(unwrapped) : unwrapped.type === "ObjectExpression" ? evaluateObject(unwrapped) : FAILED;
 }, evaluateArray = (node) => {
   let values = [];
   for (let element of node.elements) {
-    if (element === null || t.isSpreadElement(element))
+    if (element === null || element.type === "SpreadElement")
       return FAILED;
     let value = evaluate(element);
     if (value === FAILED)
@@ -119,10 +121,10 @@ var evaluate = (node) => {
 }, evaluateObject = (node) => {
   let values = {};
   for (let property of node.properties) {
-    if (!t.isObjectProperty(property) || property.computed || t.isSpreadElement(property))
+    if (property.type !== "Property" || property.method || property.kind !== "init" || property.computed)
       return FAILED;
-    let key = keyOf(property), value = evaluate(property.value);
-    if (key === null || value === FAILED)
+    let key = staticKey(property), value = evaluate(property.value);
+    if (key === void 0 || value === FAILED)
       return FAILED;
     values[key] = value;
   }
@@ -162,15 +164,15 @@ function classifyArg(key, isFunction, argTypes, declaration) {
       case "attributes":
         return attributeBinding(
           name,
-          attributeViaField(key, name, declaration),
-          attributeDefault(key, name, declaration)
+          attributeViaField(name, declaration),
+          attributeDefault(name, declaration)
         );
       case "properties": {
         let attribute = pairedAttribute(name, declaration);
         return attribute ? attributeBinding(
           attribute,
           !0,
-          fieldDefault(name, declaration) ?? attributeDefault(name, attribute, declaration)
+          fieldDefault(name, declaration) ?? attributeDefault(attribute, declaration)
         ) : { kind: "property", name };
       }
       case "events":
@@ -201,8 +203,8 @@ var fieldDefault = (fieldName, declaration) => fieldDeclaration(fieldName, decla
   ...defaultValue === void 0 ? {} : { defaultValue }
 }), fieldDeclaration = (fieldName, declaration) => declaration.members?.find(
   (member) => member.kind === "field" && member.name === fieldName
-), attributeDeclaration = (attributeName, declaration) => declaration.attributes?.find((attribute) => attribute.name === attributeName), attributeViaField = (key, attributeName, declaration) => pairedAttribute(key, declaration) === attributeName, attributeDefault = (key, attributeName, declaration) => {
-  let attribute = attributeDeclaration(attributeName, declaration), fieldName = attribute?.fieldName === key || pairedAttribute(key, declaration) === attributeName ? key : void 0;
+), attributeDeclaration = (attributeName, declaration) => declaration.attributes?.find((attribute) => attribute.name === attributeName), attributeViaField = (attributeName, declaration) => pairedAttribute(attributeName, declaration) === attributeName, attributeDefault = (attributeName, declaration) => {
+  let attribute = attributeDeclaration(attributeName, declaration), fieldName = attribute?.fieldName ?? (attributeViaField(attributeName, declaration) ? attributeName : void 0);
   return (fieldName ? fieldDefault(fieldName, declaration) : void 0) ?? attribute?.default;
 }, eventForArg = (key, declaration) => {
   let matches = declaration.events?.filter(
@@ -609,82 +611,82 @@ var printCssProperties = (properties) => {
   ];
 }, hasSlotAttribute = (node) => node.attributes.some((attribute) => attribute.name === "slot"), escapeScriptString = (value) => value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/</g, "\\x3C"), sanitizeScriptHandler = (value) => value.replace(/<!--/g, "<\\!--").replace(/<script/gi, "<\\script").replace(/<\/script/gi, "<\\/script");
 
-// src/docgen/story-docs/template-print.ts
-import { sourceOf as sourceOf4 } from "storybook/internal/csf-tools";
-
 // src/docgen/story-docs/template-holes.ts
-import { types as t3 } from "storybook/internal/babel";
-import { sourceOf as sourceOf3, unwrapExpression as unwrapExpression3 } from "storybook/internal/csf-tools";
+import {
+  oneLineTextOf as oneLineTextOf3,
+  reindent,
+  textOf,
+  unwrapExpression as unwrapExpression3,
+  walk
+} from "storybook/internal/csf-tools";
 
 // src/docgen/story-docs/template-scope.ts
-import { types as t2 } from "storybook/internal/babel";
 import {
   collectImportBindings,
-  keyOf as keyOf2,
-  returnedExpressionPath,
-  sourceOf as sourceOf2,
+  isStringLiteral,
+  staticKey as staticKey2,
+  returnedExpression,
+  oneLineTextOf as oneLineTextOf2,
   unwrapExpression as unwrapExpression2
 } from "storybook/internal/csf-tools";
 var TEMPLATE_TAG_SOURCES = ["lit", "lit-html", "lit-element"];
 function resolveHtmlTemplate(renderFunction, csf) {
-  let bindings = collectImportBindings(csf._file.path), returned = returnedTemplateExpression(renderFunction, bindings);
+  let bindings = collectImportBindings(csf.program), returned = returnedTemplateExpression(renderFunction, bindings);
   return returned ? templateFromExpression(unwrapExpression2(returned.node), bindings, returned.scope) : void 0;
 }
 function templateFromExpression(expression, bindings, scope) {
-  if (t2.isStringLiteral(expression))
+  if (isStringLiteral(expression))
     return {
       bindings,
       expressions: [],
       lit: !1,
       quasis: [expression.value],
       scope,
-      source: sourceOf2(expression)
+      source: oneLineTextOf2(expression)
     };
-  if (t2.isTemplateLiteral(expression))
-    return templateFromLiteral(expression, bindings, !1, scope, sourceOf2(expression));
-  if (!(!t2.isTaggedTemplateExpression(expression) || !t2.isIdentifier(expression.tag)))
-    return isImported(expression.tag.name, "html", TEMPLATE_TAG_SOURCES, bindings) || isImported(expression.tag.name, "default", TEMPLATE_TAG_SOURCES, bindings) ? templateFromLiteral(expression.quasi, bindings, !0, scope, sourceOf2(expression)) : void 0;
+  if (expression.type === "TemplateLiteral")
+    return templateFromLiteral(expression, bindings, !1, scope, oneLineTextOf2(expression));
+  if (!(expression.type !== "TaggedTemplateExpression" || expression.tag.type !== "Identifier"))
+    return isImported(expression.tag.name, "html", TEMPLATE_TAG_SOURCES, bindings) || isImported(expression.tag.name, "default", TEMPLATE_TAG_SOURCES, bindings) ? templateFromLiteral(expression.quasi, bindings, !0, scope, oneLineTextOf2(expression)) : void 0;
 }
 function aliasValueForIdentifier(expression, scope) {
   return scope.aliases.get(expression.name);
 }
 function argReferenceForExpression(expression, scope) {
   let unwrapped = unwrapExpression2(expression);
-  if (t2.isIdentifier(unwrapped)) {
+  if (unwrapped.type === "Identifier") {
     let alias = aliasValueForIdentifier(unwrapped, scope);
     return alias?.kind === "arg" ? { name: alias.name, path: alias.path } : parameterArgReference(unwrapped, scope);
   }
-  if (!t2.isMemberExpression(unwrapped))
+  if (unwrapped.type !== "MemberExpression")
     return;
   let property = memberPropertyName(unwrapped);
   if (property === void 0)
     return;
-  if (scope.args && t2.isIdentifier(unwrapped.object, { name: scope.args }))
+  if (scope.args && unwrapped.object.type === "Identifier" && unwrapped.object.name === scope.args)
     return { name: property, path: [] };
-  if (!t2.isExpression(unwrapped.object))
-    return;
   let object = argReferenceForExpression(unwrapped.object, scope);
   return object ? { name: object.name, path: [...object.path, property] } : void 0;
 }
 var returnedTemplateExpression = (renderFunction, bindings) => {
-  let baseScope = scopeForRenderFunction(renderFunction), strict = returnedExpressionPath(renderFunction);
+  let baseScope = scopeForRenderFunction(renderFunction), strict = returnedExpression(renderFunction);
   if (strict)
-    return { node: strict.node, scope: baseScope };
-  if (!t2.isBlockStatement(renderFunction.node.body))
+    return { node: strict, scope: baseScope };
+  if (renderFunction.body?.type !== "BlockStatement")
     return;
-  let statements = renderFunction.node.body.body, returned = statements.at(-1);
-  if (!t2.isReturnStatement(returned) || !t2.isExpression(returned.argument))
+  let statements = renderFunction.body.body, returned = statements.at(-1);
+  if (returned?.type !== "ReturnStatement" || !returned.argument)
     return;
   let scope = copyScope(baseScope);
   for (let statement of statements.slice(0, -1))
-    if (!t2.isVariableDeclaration(statement) || statement.kind !== "const" && statement.kind !== "let" || !addVariableAliases(statement, scope, bindings))
+    if (statement.type !== "VariableDeclaration" || statement.kind !== "const" && statement.kind !== "let" || !addVariableAliases(statement, scope, bindings))
       return;
   return { node: returned.argument, scope };
 }, scopeForRenderFunction = (renderFunction) => {
-  let [first] = renderFunction.node.params, scope = { aliases: /* @__PURE__ */ new Map(), destructured: /* @__PURE__ */ new Map() };
-  if (t2.isIdentifier(first))
+  let [first] = renderFunction.params, scope = { aliases: /* @__PURE__ */ new Map(), destructured: /* @__PURE__ */ new Map() };
+  if (first?.type === "Identifier")
     return scope.args = first.name, scope;
-  if (!t2.isObjectPattern(first))
+  if (first?.type !== "ObjectPattern")
     return scope;
   let destructured = destructuredAliases(first, { name: "", path: [] });
   if (!destructured)
@@ -694,16 +696,16 @@ var returnedTemplateExpression = (renderFunction, bindings) => {
   return scope;
 }, addVariableAliases = (declaration, scope, bindings) => {
   for (let declarator of declaration.declarations) {
-    if (!t2.isExpression(declarator.init))
+    if (!declarator.init)
       return !1;
-    if (t2.isIdentifier(declarator.id)) {
+    if (declarator.id.type === "Identifier") {
       let alias = aliasForExpression(declarator.init, scope, bindings);
       if (!alias)
         return !1;
       scope.aliases.set(declarator.id.name, alias);
       continue;
     }
-    if (t2.isObjectPattern(declarator.id)) {
+    if (declarator.id.type === "ObjectPattern") {
       let source = destructureSourceForExpression(declarator.init, scope);
       if (!source)
         return !1;
@@ -718,28 +720,28 @@ var returnedTemplateExpression = (renderFunction, bindings) => {
   return !0;
 }, destructureSourceForExpression = (expression, scope) => {
   let unwrapped = unwrapExpression2(expression);
-  return scope.args && t2.isIdentifier(unwrapped, { name: scope.args }) ? { name: "", path: [] } : argReferenceForExpression(expression, scope);
+  return scope.args && unwrapped.type === "Identifier" && unwrapped.name === scope.args ? { name: "", path: [] } : argReferenceForExpression(expression, scope);
 }, aliasForExpression = (expression, scope, bindings) => {
-  let unwrapped = unwrapExpression2(expression), arg = t2.isExpression(unwrapped) ? argReferenceForExpression(unwrapped, scope) : void 0;
+  let unwrapped = unwrapExpression2(expression), arg = argReferenceForExpression(unwrapped, scope);
   if (arg)
-    return { kind: "arg", source: sourceOf2(expression), ...arg };
+    return { kind: "arg", source: oneLineTextOf2(expression), ...arg };
   if (isStaticLiteral(unwrapped))
     return { kind: "value", value: literalValue(unwrapped) };
   let template = templateFromExpression(unwrapped, bindings, copyScope(scope));
   if (template)
-    return { kind: "template", source: sourceOf2(expression), template };
+    return { kind: "template", source: oneLineTextOf2(expression), template };
 }, destructuredAliases = (pattern, source) => {
   let aliases = /* @__PURE__ */ new Map();
   for (let property of pattern.properties) {
-    if (!t2.isObjectProperty(property) || property.computed)
+    if (property.type !== "Property" || property.computed)
       return;
-    let key = keyOf2(property);
+    let key = staticKey2(property);
     if (!key)
       return;
     let root = source.name === "" ? { name: key, path: [] } : { name: source.name, path: [...source.path, key] };
-    if (t2.isIdentifier(property.value))
+    if (property.value.type === "Identifier")
       aliases.set(property.value.name, { kind: "arg", ...root });
-    else if (t2.isObjectPattern(property.value)) {
+    else if (property.value.type === "ObjectPattern") {
       let nested = destructuredAliases(property.value, root);
       if (!nested)
         return;
@@ -751,11 +753,9 @@ var returnedTemplateExpression = (renderFunction, bindings) => {
 }, parameterArgReference = (expression, scope) => {
   let arg = scope.destructured.get(expression.name);
   return arg ? { name: arg, path: [] } : void 0;
-}, memberPropertyName = (expression) => !expression.computed && t2.isIdentifier(expression.property) ? expression.property.name : expression.computed && t2.isStringLiteral(expression.property) ? expression.property.value : void 0, templateFromLiteral = (literal, bindings, lit, scope, source) => ({
+}, memberPropertyName = (expression) => !expression.computed && expression.property.type === "Identifier" ? expression.property.name : expression.computed && isStringLiteral(expression.property) ? expression.property.value : void 0, templateFromLiteral = (literal, bindings, lit, scope, source) => ({
   bindings,
-  expressions: literal.expressions.filter(
-    (expression) => t2.isExpression(expression)
-  ),
+  expressions: literal.expressions,
   lit,
   quasis: literal.quasis.map((quasi) => quasi.value.raw),
   scope,
@@ -767,36 +767,47 @@ var returnedTemplateExpression = (renderFunction, bindings) => {
 }), isImported = (local, importName, sources, bindings) => {
   let binding = bindings.get(local);
   return !!binding && sources.includes(binding.importId) && binding.importName === importName;
-}, isStaticLiteral = (expression) => t2.isStringLiteral(expression) || t2.isNumericLiteral(expression) || t2.isBooleanLiteral(expression) || t2.isTemplateLiteral(expression) && expression.expressions.length === 0, literalValue = (expression) => {
-  if (t2.isStringLiteral(expression) || t2.isNumericLiteral(expression) || t2.isBooleanLiteral(expression))
-    return expression.value;
-  if (t2.isTemplateLiteral(expression))
+}, isStaticLiteral = (expression) => {
+  let value = primitiveLiteralValue(expression);
+  return value !== FAILED && value !== null || expression.type === "TemplateLiteral" && expression.expressions.length === 0;
+}, literalValue = (expression) => {
+  if (expression.type === "TemplateLiteral")
     return expression.quasis[0]?.value.cooked ?? expression.quasis[0]?.value.raw ?? "";
+  let value = primitiveLiteralValue(expression);
+  return value === FAILED ? void 0 : value;
 };
 
 // src/docgen/story-docs/template-holes.ts
-var TEMPLATE_TAG_SOURCES2 = ["lit", "lit-html", "lit-element"], IF_DEFINED_SOURCES = ["lit/directives/if-defined.js", "lit-html/directives/if-defined.js"], resolveHoleValue = (expression, context) => {
-  let expressionNode = unwrapExpression3(expression), alias = t3.isIdentifier(expressionNode) ? aliasValueForIdentifier(expressionNode, context.scope) : void 0;
+var handlerText = (node) => {
+  let code = textOf(node), closingIndent = /^[ \t]*/.exec(code.slice(code.lastIndexOf(`
+`) + 1))[0];
+  return reindent(code, closingIndent, "    ");
+}, TEMPLATE_TAG_SOURCES2 = ["lit", "lit-html", "lit-element"], IF_DEFINED_SOURCES = ["lit/directives/if-defined.js", "lit-html/directives/if-defined.js"], resolveHoleValue = (expression, context) => {
+  let expressionNode = unwrapExpression3(expression), alias = expressionNode.type === "Identifier" ? aliasValueForIdentifier(expressionNode, context.scope) : void 0;
   if (alias)
-    return resolveAlias(alias, context, sourceOf3(expression));
+    return resolveAlias(alias, context, oneLineTextOf3(expression));
   let arg = argReferenceForExpression(expression, context.scope);
   if (arg)
-    return resolveArgReference(arg, context.storyArgs[arg.name], sourceOf3(expression));
+    return resolveArgReference(arg, context.storyArgs[arg.name], oneLineTextOf3(expression));
   let unwrapped = expressionNode;
   if (isNothingExpression(unwrapped, context.bindings))
     return { kind: "nothing" };
   if (isStaticLiteral2(unwrapped))
     return { kind: "value", value: literalValue2(unwrapped) };
-  if (t3.isFunction(unwrapped))
-    return { handler: sourceOf3(expression), kind: "function" };
+  if (isFunctionNode(unwrapped))
+    return {
+      handler: handlerText(expression),
+      kind: "function",
+      source: oneLineTextOf3(expression)
+    };
   let nested = templateFromExpression(unwrapped, context.bindings, context.scope);
   if (nested)
-    return { kind: "template", source: sourceOf3(expression), template: nested };
+    return { kind: "template", source: oneLineTextOf3(expression), template: nested };
   if (isIfDefinedCall(unwrapped, context.bindings)) {
     let value = resolveHoleValue(unwrapped.arguments[0], context);
     return value.kind === "value" && value.value !== null && value.value !== void 0 ? value : { kind: "nothing", ...value.arg ? { arg: value.arg } : {} };
   }
-  if (t3.isConditionalExpression(unwrapped)) {
+  if (unwrapped.type === "ConditionalExpression") {
     let test = resolveConditionalTest(unwrapped.test, context);
     if (test.kind === "unresolved")
       return test;
@@ -806,24 +817,14 @@ var TEMPLATE_TAG_SOURCES2 = ["lit", "lit-html", "lit-element"], IF_DEFINED_SOURC
     );
     return test.arg && !branch.arg ? { ...branch, arg: test.arg } : branch;
   }
-  return { kind: "unresolved", source: sourceOf3(expression) };
+  return { kind: "unresolved", source: oneLineTextOf3(expression) };
 }, collectReferencedArgs = (expression, scope) => {
-  let referenced = /* @__PURE__ */ new Set(), visit = (node) => {
-    if (t3.isExpression(node)) {
-      let args = referencedArgsForExpression(node, scope);
-      for (let arg of args)
-        referenced.add(arg);
-    }
-    for (let key of t3.VISITOR_KEYS[node.type] ?? []) {
-      if (skipsReferenceChild(node, key))
-        continue;
-      let child = node[key];
-      Array.isArray(child) ? child.forEach((entry) => {
-        t3.isNode(entry) && visit(entry);
-      }) : t3.isNode(child) && visit(child);
-    }
-  };
-  return visit(expression), referenced;
+  let referenced = /* @__PURE__ */ new Set();
+  return walk(expression, (node, parent) => {
+    if (isStaticName(node, parent))
+      return !1;
+    referencedArgsForExpression(node, scope).forEach((arg) => referenced.add(arg));
+  }), referenced;
 }, isTruthyAttributeValue = (value) => value.kind === "value" ? !!value.value : value.kind === "template" || value.kind === "function", attributeValue = (value, context, referenced) => {
   if (value.kind === "empty" || value.kind === "function" || value.kind === "nothing")
     return { kind: "value", value: void 0 };
@@ -839,7 +840,7 @@ var TEMPLATE_TAG_SOURCES2 = ["lit", "lit-html", "lit-element"], IF_DEFINED_SOURC
   let value = evaluateArgValue(node);
   switch (value.kind) {
     case "function":
-      return { handler: sourceOf3(node), kind: "function", arg };
+      return { handler: handlerText(node), kind: "function", arg, source: oneLineTextOf3(node) };
     case "unset":
       return { kind: "value", arg, value: void 0 };
     case "unresolved":
@@ -875,7 +876,7 @@ var TEMPLATE_TAG_SOURCES2 = ["lit", "lit-html", "lit-element"], IF_DEFINED_SOURC
   }
   return current2 === void 0 ? missingPathSource ? { arg: reference.name, kind: "unresolved", source: missingPathSource } : { arg: reference.name, kind: "empty" } : { arg: reference.name, kind: "value", value: current2 };
 }, referencedArgsForExpression = (expression, scope) => {
-  let alias = t3.isIdentifier(expression) ? aliasValueForIdentifier(expression, scope) : void 0;
+  let alias = expression.type === "Identifier" ? aliasValueForIdentifier(expression, scope) : void 0;
   if (alias)
     return referencedArgsForAlias(alias);
   let arg = argReferenceForExpression(expression, scope);
@@ -897,24 +898,22 @@ var TEMPLATE_TAG_SOURCES2 = ["lit", "lit-html", "lit-element"], IF_DEFINED_SOURC
     default:
       return alias;
   }
-}, skipsReferenceChild = (node, key) => t3.isMemberExpression(node) && key === "property" && !node.computed || (t3.isObjectProperty(node) || t3.isObjectMethod(node)) && key === "key" && !node.computed, isNothingExpression = (expression, bindings) => t3.isIdentifier(expression) && isImported2(expression.name, "nothing", TEMPLATE_TAG_SOURCES2, bindings), isStaticLiteral2 = (expression) => t3.isNullLiteral(expression) || t3.isStringLiteral(expression) || t3.isNumericLiteral(expression) || t3.isBooleanLiteral(expression) || t3.isIdentifier(expression, { name: "undefined" }) || t3.isUnaryExpression(expression) && expression.operator === "void" || t3.isTemplateLiteral(expression) && expression.expressions.length === 0, literalValue2 = (expression) => {
-  if (t3.isNullLiteral(expression))
-    return null;
-  if (t3.isStringLiteral(expression) || t3.isNumericLiteral(expression) || t3.isBooleanLiteral(expression))
-    return expression.value;
-  if (!t3.isIdentifier(expression, { name: "undefined" }) && !(t3.isUnaryExpression(expression) && expression.operator === "void") && t3.isTemplateLiteral(expression))
+}, isStaticName = (node, parent) => parent?.type === "MemberExpression" && parent.property === node && !parent.computed || parent?.type === "Property" && parent.key === node && parent.value !== node && !parent.computed, isNothingExpression = (expression, bindings) => expression.type === "Identifier" && isImported2(expression.name, "nothing", TEMPLATE_TAG_SOURCES2, bindings), isStaticLiteral2 = (expression) => primitiveLiteralValue(expression) !== FAILED || expression.type === "Identifier" && expression.name === "undefined" || expression.type === "UnaryExpression" && expression.operator === "void" || expression.type === "TemplateLiteral" && expression.expressions.length === 0, literalValue2 = (expression) => {
+  if (expression.type === "TemplateLiteral")
     return expression.quasis[0]?.value.cooked ?? expression.quasis[0]?.value.raw ?? "";
-}, isIfDefinedCall = (expression, bindings) => t3.isCallExpression(expression) && expression.arguments.length === 1 && t3.isExpression(expression.arguments[0]) && t3.isIdentifier(expression.callee) && isImported2(expression.callee.name, "ifDefined", IF_DEFINED_SOURCES, bindings), resolveConditionalTest = (expression, context) => {
+  let value = primitiveLiteralValue(expression);
+  return value === FAILED ? void 0 : value;
+}, isIfDefinedCall = (expression, bindings) => expression.type === "CallExpression" && expression.arguments.length === 1 && expression.arguments[0].type !== "SpreadElement" && expression.callee.type === "Identifier" && isImported2(expression.callee.name, "ifDefined", IF_DEFINED_SOURCES, bindings), resolveConditionalTest = (expression, context) => {
   let arg = argReferenceForExpression(expression, context.scope);
   if (arg) {
-    let value = resolveArgReference(arg, context.storyArgs[arg.name], sourceOf3(expression));
+    let value = resolveArgReference(arg, context.storyArgs[arg.name], oneLineTextOf3(expression));
     return value.kind === "value" || value.kind === "empty" ? { arg: arg.name, kind: "value", truthy: value.kind === "value" && !!value.value } : {
       kind: "unresolved",
-      source: value.kind === "unresolved" ? value.source : sourceOf3(expression)
+      source: value.kind === "unresolved" ? value.source : oneLineTextOf3(expression)
     };
   }
   let unwrapped = unwrapExpression3(expression);
-  return isNothingExpression(unwrapped, context.bindings) ? { kind: "value", truthy: !1 } : isStaticLiteral2(unwrapped) ? { kind: "value", truthy: !!literalValue2(unwrapped) } : { kind: "unresolved", source: sourceOf3(expression) };
+  return isNothingExpression(unwrapped, context.bindings) ? { kind: "value", truthy: !1 } : isStaticLiteral2(unwrapped) ? { kind: "value", truthy: !!literalValue2(unwrapped) } : { kind: "unresolved", source: oneLineTextOf3(expression) };
 }, templateAttributeText = (template, context, referenced) => {
   let scopedContext = { ...context, bindings: template.bindings, scope: template.scope }, text = "";
   for (let index = 0; index < template.expressions.length; index += 1) {
@@ -935,6 +934,7 @@ var TEMPLATE_TAG_SOURCES2 = ["lit", "lit-html", "lit-element"], IF_DEFINED_SOURC
 };
 
 // src/docgen/story-docs/template-print.ts
+import { oneLineTextOf as oneLineTextOf4 } from "storybook/internal/csf-tools";
 function printHtmlTemplate(template, storyArgs, declaration) {
   return printTemplate(template, {
     bindings: template.bindings,
@@ -1055,7 +1055,7 @@ ${script}` : snippet,
       continue;
     let value = resolveMarkerValue(expression, state);
     if (value.kind === "function") {
-      state.unresolved.add(sourceOf4(expression));
+      state.unresolved.add(oneLineTextOf4(expression));
       return;
     }
     if (value.kind === "nothing")
@@ -1121,15 +1121,15 @@ ${script}` : snippet,
   let next = text;
   for (let marker of markersIn(text, state)) {
     let expression = state.markers.get(marker);
-    expression && state.unresolved.add(sourceOf4(expression)), next = next.replace(marker, "");
+    expression && state.unresolved.add(oneLineTextOf4(expression)), next = next.replace(marker, "");
   }
   return next;
 }, unresolvedMarkers = (text, state) => {
   for (let marker of markersIn(text, state)) {
     let expression = state.markers.get(marker);
-    expression && state.unresolved.add(sourceOf4(expression));
+    expression && state.unresolved.add(oneLineTextOf4(expression));
   }
-}, containsMarker = (text, state) => markersIn(text, state).length > 0, markersIn = (text, state) => [...state.markers.keys()].filter((marker) => text.includes(marker)), markerSources = (markers, state) => markers.map((marker) => state.markers.get(marker)).filter((expression) => expression !== void 0).map(sourceOf4).join(", "), attributeFromPrinted = (attribute) => {
+}, containsMarker = (text, state) => markersIn(text, state).length > 0, markersIn = (text, state) => [...state.markers.keys()].filter((marker) => text.includes(marker)), markerSources = (markers, state) => markers.map((marker) => state.markers.get(marker)).filter((expression) => expression !== void 0).map(oneLineTextOf4).join(", "), attributeFromPrinted = (attribute) => {
   if (!attribute)
     return;
   let [node] = parseHtml(`<x ${attribute}></x>`);
@@ -1143,434 +1143,6 @@ ${script}` : snippet,
   attributes[index] = next;
 };
 
-// ../../core/src/csf-tools/story-shape/utils.ts
-import { types as t4 } from "storybook/internal/babel";
-var unwrapExpression4 = (node) => t4.isTSAsExpression(node) || t4.isTSSatisfiesExpression(node) || t4.isTSNonNullExpression(node) || t4.isTSTypeAssertion(node) || t4.isParenthesizedExpression(node) ? unwrapExpression4(node.expression) : node, isCanonicalCsf2BindCall = (node) => t4.isCallExpression(node) && t4.isMemberExpression(node.callee) && !node.callee.computed && t4.isIdentifier(node.callee.object) && t4.isIdentifier(node.callee.property, { name: "bind" }) && (node.arguments.length === 0 || node.arguments.length === 1 && t4.isObjectExpression(node.arguments[0]) && node.arguments[0].properties.length === 0), withoutTypeCalls = (object) => t4.isCallExpression(object) && object.arguments.length === 0 && t4.isMemberExpression(object.callee) && !object.callee.computed && t4.isIdentifier(object.callee.property, { name: "type" }) ? withoutTypeCalls(object.callee.object) : object, isCsfFactoryCall = (node) => t4.isCallExpression(node) && t4.isMemberExpression(node.callee) && !node.callee.computed && t4.isIdentifier(withoutTypeCalls(node.callee.object)) && t4.isIdentifier(node.callee.property) && (node.callee.property.name === "story" || node.callee.property.name === "extend"), csfFactoryReceiver = (node) => withoutTypeCalls(node.callee.object);
-var keyOf3 = (p) => t4.isStringLiteral(p.key) ? p.key.value : !p.computed && t4.isIdentifier(p.key) ? p.key.name : null;
-function resolveIdentifierInit(storyPath, identifier) {
-  let programPath = storyPath.findParent((p) => p.isProgram());
-  if (!programPath)
-    return null;
-  for (let stmt of programPath.get("body")) {
-    if (stmt.isFunctionDeclaration() && stmt.node.id?.name === identifier.node.name)
-      return stmt;
-    if (stmt.isExportNamedDeclaration()) {
-      let decl = stmt.get("declaration");
-      if (decl.isFunctionDeclaration() && decl.node.id?.name === identifier.node.name)
-        return decl;
-    }
-  }
-  let match = programPath.get("body").flatMap((stmt) => {
-    if (stmt.isVariableDeclaration())
-      return stmt.get("declarations");
-    if (stmt.isExportNamedDeclaration()) {
-      let decl = stmt.get("declaration");
-      if (decl && decl.isVariableDeclaration())
-        return decl.get("declarations");
-    }
-    return [];
-  }).find((d) => {
-    let id = d.get("id");
-    return id.isIdentifier() && id.node.name === identifier.node.name;
-  });
-  if (!match)
-    return null;
-  let init = match.get("init");
-  return init && init.isExpression() ? init : null;
-}
-function pathForNode(program, target) {
-  if (!target)
-    return;
-  let found;
-  return program.traverse({
-    enter(p) {
-      p.node && p.node === target && (found = p, p.stop());
-    }
-  }), found;
-}
-function metaObjectPath(csf) {
-  let metaPath = pathForNode(csf._file.path, csf._metaNode);
-  return metaPath?.isObjectExpression() ? metaPath : void 0;
-}
-
-// ../../core/src/csf-tools/story-shape/normalize-story.ts
-function normalizeStoryDeclaration(storyDeclaration) {
-  let storyPath = declarationExpression(storyDeclaration), normalizedPath = bindInitializer(storyDeclaration, storyPath) ?? factoryArgumentExpression(storyPath), unwrappedPath = unwrapTypeExpression(normalizedPath);
-  return classifyStoryPath(unwrappedPath);
-}
-function declarationExpression(storyDeclaration) {
-  if (storyDeclaration.isFunctionDeclaration())
-    return storyDeclaration;
-  if (storyDeclaration.isVariableDeclarator()) {
-    let init = storyDeclaration.get("init");
-    if (!init.isExpression())
-      throw storyDeclaration.buildCodeFrameError("Expected story initializer to be an expression");
-    return init;
-  }
-  throw storyDeclaration.buildCodeFrameError(
-    "Expected story to be a function or variable declaration"
-  );
-}
-function bindInitializer(storyDeclaration, storyPath) {
-  if (!storyPath.isCallExpression() || !isCanonicalCsf2BindCall(storyPath.node))
-    return null;
-  let callee = storyPath.get("callee");
-  if (!callee.isMemberExpression())
-    return null;
-  let obj = callee.get("object");
-  return obj.isIdentifier() ? resolveIdentifierInit(storyDeclaration, obj) : null;
-}
-function factoryArgumentExpression(storyPath) {
-  if (!storyPath.isCallExpression() || !isCsfFactoryCall(storyPath.node))
-    return storyPath;
-  let args = storyPath.get("arguments");
-  if (args.length === 0)
-    return storyPath;
-  if (args.length !== 1 || !args[0].isExpression())
-    throw storyPath.buildCodeFrameError("Could not evaluate story expression");
-  return args[0];
-}
-function unwrapTypeExpression(storyPath) {
-  return storyPath.isTSSatisfiesExpression() || storyPath.isTSAsExpression() ? storyPath.get("expression") : storyPath;
-}
-function classifyStoryPath(storyPath) {
-  if (storyPath.isObjectExpression())
-    return { type: "config", path: storyPath };
-  if (storyPath.isArrowFunctionExpression() || storyPath.isFunctionExpression() || storyPath.isFunctionDeclaration())
-    return { type: "fn", path: storyPath };
-  if (storyPath.isCallExpression() && isCsfFactoryCall(storyPath.node) && storyPath.node.arguments.length === 0)
-    return { type: "emptyConfig", path: storyPath };
-  throw storyPath.buildCodeFrameError(
-    "Expected story to be csf factory, function or an object expression"
-  );
-}
-
-// ../../core/src/csf-tools/story-shape/resolve-members.ts
-import { generate, types as t6 } from "storybook/internal/babel";
-
-// ../../core/src/csf-tools/story-shape/imports.ts
-import { types as t5 } from "storybook/internal/babel";
-var isTypeSpecifier = (s) => t5.isImportSpecifier(s) && s.importKind === "type", importedName = (im) => t5.isIdentifier(im) ? im.name : im.value;
-
-// ../../core/src/csf-tools/story-shape/resolve-members.ts
-var sourceOf5 = (node) => generate(node, { concise: !0, comments: !1 }).code, complete = (properties = {}) => ({
-  properties,
-  shadowed: [],
-  unresolved: []
-}), resolveObjectMembers = (object, ctx) => membersOf(object, ctx, /* @__PURE__ */ new Set());
-var membersOf = (object, ctx, visited) => {
-  let properties = {}, unresolved = [], shadowed = /* @__PURE__ */ new Set(), shadowKnownMembers = (source) => {
-    unresolved.push(source);
-    for (let key of Object.keys(properties))
-      shadowed.add(key);
-  };
-  for (let property of object.properties) {
-    if (t6.isSpreadElement(property)) {
-      let spread = spreadMembers(ctx, property, visited);
-      if (spread === void 0 || spread.unresolved.length > 0) {
-        shadowKnownMembers(sourceOf5(property));
-        continue;
-      }
-      for (let [key2, value] of Object.entries(spread.properties))
-        properties[key2] = value, shadowed.delete(key2);
-      continue;
-    }
-    let key = keyOf3(property);
-    if (key === null) {
-      shadowKnownMembers(sourceOf5(property));
-      continue;
-    }
-    if (t6.isObjectMethod(property) && (property.kind !== "method" || property.generator)) {
-      delete properties[key], shadowed.delete(key), unresolved.push(sourceOf5(property));
-      continue;
-    }
-    properties[key] = t6.isObjectMethod(property) ? property : property.value, shadowed.delete(key);
-  }
-  return { properties, shadowed: [...shadowed], unresolved };
-}, spreadMembers = (ctx, spread, visited) => {
-  let argument = unwrapExpression4(spread.argument);
-  return t6.isObjectExpression(argument) ? membersOf(argument, ctx, visited) : resolveReference(ctx, argument, spread.start ?? void 0, visited);
-}, memberChain = (node) => {
-  let path = [], current2 = unwrapExpression4(node);
-  for (; t6.isMemberExpression(current2); ) {
-    let key = t6.isIdentifier(current2.property) && !current2.computed ? current2.property.name : t6.isStringLiteral(current2.property) ? current2.property.value : void 0;
-    if (key === void 0)
-      return;
-    path.unshift(key), current2 = unwrapExpression4(current2.object);
-  }
-  return t6.isIdentifier(current2) ? { root: current2.name, path } : void 0;
-}, resolveReference = (ctx, expression, position, visited) => {
-  let chain = memberChain(expression);
-  if (!chain)
-    return;
-  let key = `ref:${ctx.filePath}#${chain.root}.${chain.path.join(".")}`;
-  if (!visited.has(key)) {
-    visited.add(key);
-    try {
-      return unguardedResolveReference(ctx, chain, position, visited);
-    } finally {
-      visited.delete(key);
-    }
-  }
-}, unguardedResolveReference = (ctx, chain, position, visited) => {
-  let located = locate(ctx, chain, position, visited);
-  if (!located)
-    return;
-  let members = located.members, scope = located.ctx;
-  for (let [index, key] of located.path.entries()) {
-    if (members.unresolved.length > 0)
-      return;
-    let value = members.properties[key];
-    if (value === void 0)
-      return index === located.path.length - 1 ? complete() : void 0;
-    let unwrapped = unwrapExpression4(value);
-    if (!t6.isObjectExpression(unwrapped))
-      return;
-    members = membersOf(unwrapped, scope, visited);
-  }
-  return located.external ? externalized(members, scope) : members;
-}, locate = (ctx, chain, position, visited) => {
-  let binding = bindingMembers(ctx, chain.root, position, visited);
-  if (!binding)
-    return;
-  if (binding.kind === "namespace") {
-    let [exportName, ...path] = chain.path;
-    if (exportName === void 0)
-      return;
-    let exported = bindingMembers(binding.ctx, exportName, void 0, visited);
-    if (exported === void 0 || exported.kind === "namespace")
-      return;
-    let located2 = withAccessor(exported, path);
-    return located2 === void 0 ? void 0 : { ...located2, external: !0 };
-  }
-  let located = withAccessor(binding, chain.path);
-  return located === void 0 ? void 0 : { ...located, external: binding.external };
-}, withAccessor = (binding, path) => binding.accessor === void 0 ? { members: binding.members, ctx: binding.ctx, path } : path[0] === binding.accessor ? { members: binding.members, ctx: binding.ctx, path: path.slice(1) } : void 0, externalized = (members, ctx) => {
-  if (!ctx.externalize)
-    return members;
-  let properties = {};
-  for (let [key, node] of Object.entries(members.properties)) {
-    let value = ctx.externalize(node);
-    if (value === void 0)
-      return;
-    properties[key] = value;
-  }
-  return {
-    properties,
-    shadowed: members.shadowed,
-    unresolved: members.unresolved
-  };
-}, bindingMembers = (ctx, name, position, visited) => {
-  let key = `${ctx.filePath}#${name}`;
-  if (!visited.has(key)) {
-    visited.add(key);
-    try {
-      return unguardedBindingMembers(ctx, name, position, visited);
-    } finally {
-      visited.delete(key);
-    }
-  }
-}, unguardedBindingMembers = (ctx, name, position, visited) => {
-  let binding = ctx.program.scope.getBinding(name);
-  if (!binding)
-    return;
-  if (binding.kind === "module")
-    return importedBinding(ctx, binding.path, visited);
-  if (!binding.constant)
-    return;
-  let declared = declaredBindingMembers(ctx, binding.path.node, position, visited);
-  if (declared === void 0)
-    return;
-  let assigned = assignedMembers(ctx, name, position);
-  return {
-    kind: "members",
-    ctx,
-    external: !1,
-    ...declared.accessor ? { accessor: declared.accessor } : {},
-    members: {
-      properties: { ...declared.members.properties, ...assigned.properties },
-      shadowed: declared.members.shadowed.filter((key) => !(key in assigned.properties)),
-      unresolved: [...declared.members.unresolved, ...assigned.unresolved]
-    }
-  };
-}, declaredBindingMembers = (ctx, node, position, visited) => {
-  if (t6.isFunctionDeclaration(node))
-    return { members: complete() };
-  if (t6.isVariableDeclarator(node) && !(position !== void 0 && (node.start ?? Number.POSITIVE_INFINITY) > position))
-    return node.init ? declaredMembers(ctx, node.init, position, visited) : { members: complete() };
-}, declaredMembers = (ctx, init, position, visited) => {
-  let unwrapped = unwrapExpression4(init);
-  if (t6.isObjectExpression(unwrapped))
-    return { members: membersOf(unwrapped, ctx, visited) };
-  let factory = factoryCall(unwrapped);
-  if (factory === void 0 && (t6.isFunction(unwrapped) || isCanonicalCsf2BindCall(unwrapped)))
-    return { members: complete() };
-  if (factory === void 0)
-    return {
-      members: { properties: {}, shadowed: [], unresolved: [sourceOf5(unwrapped)] }
-    };
-  let config = factory.config ? membersOf(factory.config, ctx, visited) : complete();
-  if (factory.method === "story")
-    return { members: config, accessor: "input" };
-  let parent = bindingMembers(ctx, factory.parent, position, visited);
-  return parent === void 0 || parent.kind === "namespace" || parent.accessor !== "input" || parent.external ? void 0 : {
-    members: {
-      properties: mergedAnnotations(parent.members, config).properties,
-      shadowed: [
-        ...parent.members.shadowed.filter((key) => !(key in config.properties)),
-        ...config.shadowed
-      ],
-      unresolved: [...parent.members.unresolved, ...config.unresolved]
-    },
-    accessor: "input"
-  };
-}, MERGED_ANNOTATIONS = ["args", "argTypes", "parameters", "globals"], mergedAnnotations = (parent, child) => {
-  let properties = { ...parent.properties, ...child.properties };
-  for (let key of MERGED_ANNOTATIONS) {
-    let from = parent.properties[key], over = child.properties[key];
-    from === void 0 || over === void 0 || !t6.isExpression(from) || !t6.isExpression(over) || (properties[key] = t6.objectExpression([t6.spreadElement(from), t6.spreadElement(over)]));
-  }
-  return { properties };
-}, factoryCall = (node) => {
-  if (!isCsfFactoryCall(node))
-    return;
-  let method = node.callee.property.name;
-  if (method !== "story" && method !== "extend")
-    return;
-  let [argument] = node.arguments, config = argument && unwrapExpression4(argument);
-  if (!(argument !== void 0 && (config === void 0 || !t6.isObjectExpression(config))))
-    return {
-      method,
-      parent: csfFactoryReceiver(node).name,
-      ...config && t6.isObjectExpression(config) ? { config } : {}
-    };
-}, assignedMembers = (ctx, name, position) => {
-  let properties = {}, unresolved = [];
-  for (let statement of ctx.program.node.body) {
-    if (!t6.isExpressionStatement(statement) || !t6.isAssignmentExpression(statement.expression))
-      continue;
-    let assignment = statement.expression, target = assignment.left, depth = 0, outermost;
-    for (; t6.isMemberExpression(target); )
-      depth += 1, outermost = t6.isIdentifier(target.property) && !target.computed ? target.property.name : t6.isStringLiteral(target.property) ? target.property.value : void 0, target = target.object;
-    if (!(depth === 0 || !t6.isIdentifier(target) || target.name !== name) && !(position !== void 0 && (assignment.start ?? 0) > position)) {
-      if (depth > 1 || outermost === void 0 || assignment.operator !== "=") {
-        unresolved.push(sourceOf5(assignment));
-        continue;
-      }
-      properties[outermost] = assignment.right;
-    }
-  }
-  return { properties, unresolved };
-}, importedBinding = (ctx, specifierPath, visited) => {
-  let specifier = specifierPath.node, declaration = specifierPath.parent;
-  if (!t6.isImportDeclaration(declaration) || declaration.importKind === "type" || !(t6.isImportSpecifier(specifier) || t6.isImportDefaultSpecifier(specifier) || t6.isImportNamespaceSpecifier(specifier)) || isTypeSpecifier(specifier))
-    return;
-  let target = resolveTargetModule(ctx, declaration.source.value);
-  if (!target)
-    return;
-  if (t6.isImportNamespaceSpecifier(specifier))
-    return { kind: "namespace", ctx: target };
-  let exportName = t6.isImportDefaultSpecifier(specifier) ? "default" : importedName(specifier.imported);
-  return exportedBinding(target, exportName, visited);
-}, resolveTargetModule = (ctx, specifier) => {
-  let target = ctx.resolveModule?.(ctx.filePath, specifier);
-  return target ? { ...ctx, ...target } : void 0;
-}, exportedBinding = (ctx, exportName, visited) => {
-  let asExternal = (bound) => bound === void 0 || bound.kind === "namespace" ? bound : { ...bound, external: !0 };
-  for (let statement of ctx.program.node.body) {
-    if (t6.isExportDefaultDeclaration(statement) && exportName === "default") {
-      let declaration = unwrapExpression4(statement.declaration);
-      return t6.isIdentifier(declaration) ? asExternal(bindingMembers(ctx, declaration.name, void 0, visited)) : t6.isObjectExpression(declaration) ? {
-        kind: "members",
-        ctx,
-        external: !0,
-        members: membersOf(declaration, ctx, visited)
-      } : void 0;
-    }
-    if (!t6.isExportNamedDeclaration(statement) || statement.exportKind === "type")
-      continue;
-    let specifier = statement.specifiers.find(
-      (candidate) => t6.isExportSpecifier(candidate) && candidate.exportKind !== "type" && importedName(candidate.exported) === exportName
-    );
-    if (!specifier)
-      continue;
-    if (!statement.source)
-      return asExternal(bindingMembers(ctx, specifier.local.name, void 0, visited));
-    let target = resolveTargetModule(ctx, statement.source.value);
-    return target ? exportedBinding(target, specifier.local.name, visited) : void 0;
-  }
-  return exportName === "default" ? void 0 : asExternal(bindingMembers(ctx, exportName, void 0, visited));
-};
-
-// ../../core/src/csf-tools/story-shape/render.ts
-var isRenderFunction = (path) => path.isArrowFunctionExpression() || path.isFunctionExpression() || path.isFunctionDeclaration();
-function resolveEffectiveRender(csf, exportName, references) {
-  let declaration = csf._storyDeclarationPath[exportName], normalized = normalizeStoryDeclarationForRender(declaration);
-  if (normalized.type === "fn")
-    return { kind: "resolved", path: normalized.path };
-  let storyRender = readRender(
-    normalized.type === "config" ? normalized.path : void 0,
-    declaration,
-    references
-  );
-  if (storyRender.kind === "invalid")
-    return { kind: "unresolved" };
-  if (storyRender.kind !== "missing")
-    return storyRender;
-  let metaRender = readRender(metaObjectPath(csf), declaration, references);
-  return metaRender.kind === "invalid" ? { kind: "unresolved" } : metaRender;
-}
-var normalizeStoryDeclarationForRender = normalizeStoryDeclaration, readRender = (config, storyDeclaration, references) => {
-  let properties = config?.get("properties") ?? [], renderIndex = -1;
-  for (let index = properties.length - 1; index >= 0; index -= 1) {
-    let property = properties[index];
-    if ((property.isObjectProperty() || property.isObjectMethod()) && keyOf3(property.node) === "render") {
-      renderIndex = index;
-      break;
-    }
-  }
-  let throughSpreads = () => config && references ? renderFromMembers(
-    resolveObjectMembers(config.node, references),
-    references,
-    storyDeclaration
-  ) : { kind: "unresolved" };
-  if (renderIndex === -1)
-    return properties.some((property) => property.isSpreadElement()) ? throughSpreads() : { kind: "missing" };
-  let resolved = readRenderProperty(properties[renderIndex], storyDeclaration);
-  if (properties.some((property, index) => index > renderIndex && property.isSpreadElement())) {
-    let read = throughSpreads();
-    return read.kind !== "unresolved" ? read : resolved.kind === "resolved" ? { kind: "unresolved", shadowedRender: resolved.path } : { kind: "unresolved" };
-  }
-  return resolved;
-};
-function renderFromMembers(members, references, storyDeclaration) {
-  if (members.unresolved.length > 0)
-    return { kind: "unresolved" };
-  let node = members.properties.render;
-  if (node === void 0)
-    return { kind: "missing" };
-  let path = pathForNode(references.program, node);
-  if (!path)
-    return { kind: "unresolved" };
-  if (path.isObjectMethod())
-    return path.node.kind === "method" && !path.node.generator ? { kind: "resolved", path } : { kind: "unresolved" };
-  if (path.isIdentifier()) {
-    let resolved = resolveIdentifierInit(storyDeclaration, path);
-    return resolved && isRenderFunction(resolved) ? { kind: "resolved", path: resolved } : { kind: "unresolved" };
-  }
-  return isRenderFunction(path) ? { kind: "resolved", path } : { kind: "unresolved" };
-}
-function readRenderProperty(renderProperty, storyDeclaration) {
-  if (renderProperty.isObjectMethod())
-    return renderProperty.node.kind === "method" && !renderProperty.node.generator ? { kind: "resolved", path: renderProperty } : { kind: "unresolved" };
-  let renderPath = renderProperty.get("value");
-  if (renderPath.isIdentifier()) {
-    let resolved = resolveIdentifierInit(storyDeclaration, renderPath);
-    return resolved && isRenderFunction(resolved) ? { kind: "resolved", path: resolved } : { kind: "unresolved" };
-  }
-  return isRenderFunction(renderPath) ? { kind: "resolved", path: renderPath } : { kind: "invalid", path: renderPath };
-}
-
 // src/docgen/story-docs/build-story-docs.ts
 var NO_COMPONENT_WARNING = "No static snippet: `meta.component` is not set.", openStoryReferences = createStoryReferenceResolver();
 async function buildStoryDocsPayload(input, context) {
@@ -1625,7 +1197,10 @@ var buildPayload = (input, storyImportPath, csf, snippetFor, name) => {
   filePath: storyFilePath,
   resolveModule: openStoryReferences().resolveModule
 }), baseStoryDoc = (csf, exportName, story, result) => {
-  let { description, summary } = extractStoryJSDocInfo(csf._storyStatements[exportName]);
+  let { description, summary } = extractStoryJSDocInfo(
+    csf._storyStatements[exportName],
+    csf.editor
+  );
   return {
     id: story.id,
     name: story.name ?? storyNameFromExport(exportName),
@@ -1664,7 +1239,7 @@ var buildPayload = (input, storyImportPath, csf, snippetFor, name) => {
 }, renderedArgsSnippet = (exportName, resolved, deps) => {
   let warnings = [], render = resolveEffectiveRender(deps.csf, exportName, deps.resolveStoryArgs.ctx);
   if (render.kind === "resolved") {
-    let template = resolveHtmlTemplate(render.path, deps.csf);
+    let template = resolveHtmlTemplate(render.node, deps.csf);
     if (template) {
       let printed = printHtmlTemplate(template, resolved.args, deps.declaration), unresolved = [...resolved.unresolved, ...printed.unresolved];
       warnings.push(unresolvedWarning(unresolved)), warnings.push(incompleteList(printed.properties, "properties without an attribute")), warnings.push(
@@ -1676,7 +1251,7 @@ var buildPayload = (input, storyImportPath, csf, snippetFor, name) => {
         ...joinWarnings(hasSnippet ? warnings : [...warnings, noSnippetWarning(unresolved)])
       };
     }
-    warnings.push(unresolvedWarning([sourceOf6(render.path.node)]));
+    warnings.push(unresolvedWarning([oneLineTextOf5(render.node)]));
   } else render.kind === "unresolved" && warnings.push(unresolvedWarning(unresolvedRenderSource(render, resolved)));
   let args = argsSnippet(
     resolved.args,
@@ -1693,8 +1268,8 @@ var buildPayload = (input, storyImportPath, csf, snippetFor, name) => {
   let bound = new Set(referenced), unbound = Object.entries(args).filter(([name, node]) => !bound.has(name) && evaluateArgValue(node).kind !== "unset").map(([name]) => name);
   return incompleteList(unbound, "args not bound by the render template");
 }, unresolvedRenderSource = (render, resolved) => {
-  let node = resolved.storyMembers.properties.render ?? resolved.metaMembers.properties.render ?? render.shadowedRender?.node;
-  return node ? [sourceOf6(node)] : [];
+  let node = resolved.storyMembers.properties.render ?? resolved.metaMembers.properties.render ?? render.shadowedRender;
+  return node ? [oneLineTextOf5(node)] : [];
 }, argsSnippet = (args, declaration, argTypes, tag, unresolvedArgs) => {
   let snippet = {
     tag,
@@ -1788,10 +1363,7 @@ var buildPayload = (input, storyImportPath, csf, snippetFor, name) => {
     return;
   }
   items[index] = next;
-}, falseDefaultAttributes = (snippet) => snippet.attributes.filter(({ value, defaultValue }) => value === !1 && defaultValue === "true").map(({ source, name }) => source ?? name), hasSnippetContent = (snippet) => snippet.attributes.length > 0 || snippet.cssProperties.length > 0 || snippet.listeners.length > 0 || snippet.slots.length > 0 || snippet.styleRules.length > 0, listenerHandler2 = (node) => {
-  let unwrapped = t7.isExpression(node) ? unwrapExpression5(node) : node;
-  return t7.isFunction(unwrapped) ? sourceOf6(node) : "() => {}";
-}, incompleteList = (names, suffix) => names.length === 0 ? void 0 : `Incomplete snippet: ${suffix}: ${names.map((name) => `\`${name}\``).join(", ")}.`, joinWarnings = (parts) => {
+}, falseDefaultAttributes = (snippet) => snippet.attributes.filter(({ value, defaultValue }) => value === !1 && defaultValue === "true").map(({ source, name }) => source ?? name), hasSnippetContent = (snippet) => snippet.attributes.length > 0 || snippet.cssProperties.length > 0 || snippet.listeners.length > 0 || snippet.slots.length > 0 || snippet.styleRules.length > 0, listenerHandler2 = (node) => isFunctionNode(unwrapExpression4(node)) ? handlerText(node) : "() => {}", incompleteList = (names, suffix) => names.length === 0 ? void 0 : `Incomplete snippet: ${suffix}: ${names.map((name) => `\`${name}\``).join(", ")}.`, joinWarnings = (parts) => {
   let warning = [...new Set(parts.filter((part) => part !== void 0))].join(`
 `);
   return warning === "" ? {} : { warning };