@storybook/web-components 11.0.0-alpha.4 → 11.0.0-alpha.5

package/dist/preset.js

@@ -1,20 +1,22 @@
-import CJS_COMPAT_NODE_URL_ntm93oozfz from 'node:url';
-import CJS_COMPAT_NODE_PATH_ntm93oozfz from 'node:path';
-import CJS_COMPAT_NODE_MODULE_ntm93oozfz from "node:module";
+import CJS_COMPAT_NODE_URL_kx3y04w7glc from 'node:url';
+import CJS_COMPAT_NODE_PATH_kx3y04w7glc from 'node:path';
+import CJS_COMPAT_NODE_MODULE_kx3y04w7glc from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_ntm93oozfz.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_ntm93oozfz.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_ntm93oozfz.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_kx3y04w7glc.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_kx3y04w7glc.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_kx3y04w7glc.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
-  DEFAULT_TYPE_PROPERTY
-} from "./_node-chunks/chunk-3OPBLV6G.js";
+  DEFAULT_TYPE_PROPERTY,
+  parseStoryFile,
+  resolveStoryComponent
+} from "./_node-chunks/chunk-RKWQNNM2.js";
 
 // src/preset.ts
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/docgen/preset.ts
 import { fileURLToPath } from "node:url";
@@ -38,8 +40,6 @@ var DOCGEN_WORKER_SPECIFIER = "@storybook/web-components/internal/docgen-worker"
 
 // src/docgen/preset.ts
 var experimental_docgenProvider = async (existing = [], options) => {
-  if (!(await options.presets.apply("features", {}))?.experimentalDocgenServer)
-    return existing;
   let frameworkOptions = await options.presets.apply(
     "frameworkOptions"
   ) ?? {}, descriptor = {
@@ -52,7 +52,7 @@ var experimental_docgenProvider = async (existing = [], options) => {
   return [...existing, descriptor];
 }, experimental_manifests = async (existingManifests = {}, options) => {
   let features = await options.presets.apply("features", {});
-  return !features?.experimentalDocgenServer || !features?.componentsManifest ? existingManifests : {
+  return !features?.docgenServer || !features?.componentsManifest ? existingManifests : {
     ...existingManifests,
     components: {
       v: 0,
@@ -62,18 +62,1787 @@ var experimental_docgenProvider = async (existing = [], options) => {
   };
 };
 
+// src/docgen/story-docs-preset.ts
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { STORY_FILE_TEST_REGEXP, getStoryImportPathFromEntry as getStoryImportPathFromEntry2 } from "storybook/internal/common";
+import { getService } from "storybook/internal/core-server";
+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 {
+  authoredSource,
+  createStoryArgsResolver,
+  createStoryReferenceResolver,
+  extractStoryJSDocInfo,
+  noSnippetWarning,
+  sourceOf as sourceOf6,
+  unwrapExpression as unwrapExpression5,
+  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");
+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 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))
+    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;
+}, evaluateArray = (node) => {
+  let values = [];
+  for (let element of node.elements) {
+    if (element === null || t.isSpreadElement(element))
+      return FAILED;
+    let value = evaluate(element);
+    if (value === FAILED)
+      return FAILED;
+    values.push(value);
+  }
+  return values;
+}, evaluateObject = (node) => {
+  let values = {};
+  for (let property of node.properties) {
+    if (!t.isObjectProperty(property) || property.computed || t.isSpreadElement(property))
+      return FAILED;
+    let key = keyOf(property), value = evaluate(property.value);
+    if (key === null || value === FAILED)
+      return FAILED;
+    values[key] = value;
+  }
+  return values;
+};
+
+// ../../../node_modules/es-toolkit/dist/string/capitalize.mjs
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+
+// ../../../node_modules/es-toolkit/dist/string/words.mjs
+var CASE_SPLIT_PATTERN = new RegExp("\\p{Lu}?\\p{Ll}+|[0-9]+|\\p{Lu}+(?!\\p{Ll})|\\p{Emoji_Presentation}|\\p{Extended_Pictographic}|\\p{L}+", "gu");
+function words(str) {
+  return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);
+}
+
+// ../../../node_modules/es-toolkit/dist/string/pascalCase.mjs
+function pascalCase(str) {
+  return words(str).map((word) => capitalize(word)).join("");
+}
+
+// src/docgen/component-docgen/arg-types/event-action-name.ts
+function eventActionName(name) {
+  return `on${pascalCase(name)}`;
+}
+
+// src/docgen/story-docs/classify-args.ts
+function classifyArg(key, isFunction, argTypes, declaration) {
+  let row = argTypes[key];
+  if (row) {
+    let event = row.table?.category === "events" ? row.name ?? key : eventForArg(key, declaration);
+    if (isFunction || row.action)
+      return { event, kind: "listener" };
+    let name = row.name ?? key;
+    switch (row.table?.category) {
+      case "attributes":
+        return attributeBinding(
+          name,
+          attributeViaField(key, name, declaration),
+          attributeDefault(key, name, declaration)
+        );
+      case "properties": {
+        let attribute = pairedAttribute(name, declaration);
+        return attribute ? attributeBinding(
+          attribute,
+          !0,
+          fieldDefault(name, declaration) ?? attributeDefault(name, attribute, declaration)
+        ) : { kind: "property", name };
+      }
+      case "events":
+        return { event: name, kind: "listener" };
+      case "methods":
+        return { kind: "method" };
+      case "slots":
+        return { kind: "slot", name };
+      case "css shadow parts":
+        return { kind: "cssPart", name };
+      case "css states":
+        return { kind: "cssState", name };
+      case "css custom properties":
+        return { kind: "cssProperty", name };
+      default:
+        break;
+    }
+  }
+  return isFunction ? { event: eventForArg(key, declaration), kind: "listener" } : { kind: "unknown" };
+}
+var fieldDefault = (fieldName, declaration) => fieldDeclaration(fieldName, declaration)?.default, pairedAttribute = (fieldName, declaration) => {
+  let field = fieldDeclaration(fieldName, declaration);
+  return field?.attribute ? field.attribute : declaration.attributes?.find((attribute) => attribute.fieldName === fieldName)?.name;
+}, attributeBinding = (name, viaField, defaultValue) => ({
+  kind: "attribute",
+  name,
+  viaField,
+  ...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;
+  return (fieldName ? fieldDefault(fieldName, declaration) : void 0) ?? attribute?.default;
+}, eventForArg = (key, declaration) => {
+  let matches = declaration.events?.filter(
+    (event) => key === event.name || key === eventActionName(event.name)
+  ) ?? [];
+  return matches.length === 1 ? matches[0].name : void 0;
+};
+
+// src/docgen/story-docs/html-tree.ts
+var INLINE_LIMIT = 80, INDENT = "  ", RAW_TEXT_ELEMENTS = /* @__PURE__ */ new Set(["pre", "script", "style", "textarea", "title"]), VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "source",
+  "track",
+  "wbr"
+]);
+function parseHtml(source) {
+  let root = { children: [] }, stack = [root], offset = 0;
+  for (; offset < source.length; ) {
+    let read = readToken(source, offset);
+    if (!read) {
+      current(stack).children.push({ kind: "malformed", text: source.slice(offset) });
+      break;
+    }
+    offset = read.end;
+    let token = read.token;
+    switch (token.kind) {
+      case "comment":
+      case "text":
+        current(stack).children.push(token);
+        break;
+      case "start": {
+        let node = {
+          attributes: token.attributes,
+          children: [],
+          closed: token.selfClosing || VOID_ELEMENTS.has(token.name.toLowerCase()),
+          kind: "element",
+          name: token.name,
+          selfClosing: token.selfClosing
+        };
+        current(stack).children.push(node), node.closed || stack.push(node);
+        break;
+      }
+      case "raw":
+        current(stack).children.push({
+          attributes: token.attributes,
+          closed: !0,
+          kind: "rawText",
+          name: token.name,
+          text: token.text
+        });
+        break;
+      case "end": {
+        let top = stack.at(-1);
+        if (VOID_ELEMENTS.has(token.name))
+          break;
+        if (!("kind" in top) || top.kind !== "element" || top.name.toLowerCase() !== token.name)
+          return current(stack).children.push({ kind: "malformed", text: source.slice(read.start) }), root.children;
+        top.closed = !0, stack.pop();
+        break;
+      }
+      default:
+        return token;
+    }
+  }
+  return root.children;
+}
+function printHtml(nodes) {
+  return printableChildren(nodes).map((node) => printNode(node, 0)).join(`
+`);
+}
+var current = (stack) => stack[stack.length - 1], readToken = (source, start) => {
+  if (source[start] !== "<") {
+    let next = source.indexOf("<", start), end2 = next === -1 ? source.length : next;
+    return { end: end2, start, token: { kind: "text", text: source.slice(start, end2) } };
+  }
+  if (source.startsWith("<!--", start)) {
+    let end2 = source.indexOf("-->", start + 4);
+    return end2 === -1 ? void 0 : { end: end2 + 3, start, token: { kind: "comment", text: source.slice(start, end2 + 3) } };
+  }
+  let end = findTagEnd(source, start);
+  if (end === void 0)
+    return;
+  let raw = source.slice(start, end), endMatch = /^<\/\s*([^\s>]+)\s*>$/.exec(raw);
+  if (endMatch)
+    return { end, start, token: { kind: "end", name: endMatch[1].toLowerCase() } };
+  let startMatch = /^<\s*([^\s/>]+)([\s\S]*?)>$/.exec(raw);
+  if (!startMatch)
+    return { end, start, token: { kind: "text", text: raw } };
+  let name = startMatch[1], rest = startMatch[2], selfClosing = hasSelfClosingSlash(rest), attrs = selfClosing ? rest.replace(/\/\s*$/, "") : rest, attributes = parseAttributes(attrs.trim());
+  if (!selfClosing && RAW_TEXT_ELEMENTS.has(name.toLowerCase())) {
+    let rawEnd = findRawTextEnd(source, end, name);
+    if (rawEnd)
+      return {
+        end: rawEnd.end,
+        start,
+        token: { attributes, kind: "raw", name, text: source.slice(end, rawEnd.start) }
+      };
+  }
+  return { end, start, token: { attributes, kind: "start", name, selfClosing } };
+}, parseAttributes = (source) => {
+  let attributes = [], index = 0;
+  for (; index < source.length; ) {
+    for (; /\s/.test(source[index] ?? ""); )
+      index += 1;
+    if (index >= source.length)
+      break;
+    let nameStart = index;
+    for (; index < source.length && !/[\s=]/.test(source[index]); )
+      index += 1;
+    let name = source.slice(nameStart, index);
+    for (; /\s/.test(source[index] ?? ""); )
+      index += 1;
+    if (source[index] !== "=") {
+      attributes.push({ name, value: void 0 });
+      continue;
+    }
+    for (index += 1; /\s/.test(source[index] ?? ""); )
+      index += 1;
+    let quote = source[index] === '"' || source[index] === "'" ? source[index] : void 0;
+    if (quote) {
+      index += 1;
+      let valueStart2 = index;
+      for (; index < source.length && source[index] !== quote; )
+        index += 1;
+      attributes.push({
+        name,
+        quoted: !0,
+        value: decodeAttribute(source.slice(valueStart2, index))
+      }), source[index] === quote && (index += 1);
+      continue;
+    }
+    let valueStart = index;
+    for (; index < source.length && !/\s/.test(source[index]); )
+      index += 1;
+    attributes.push({ name, value: decodeAttribute(source.slice(valueStart, index)) });
+  }
+  return attributes;
+}, printNode = (node, depth) => {
+  let indent = INDENT.repeat(depth);
+  switch (node.kind) {
+    case "comment":
+      return `${indent}${node.text}`;
+    case "element":
+      return printElement(node, depth);
+    case "malformed":
+      return node.text;
+    case "rawText":
+      return printRawTextElement(node, depth);
+    case "text":
+      return `${indent}${collapseText(node.text)}`;
+    default:
+      return node;
+  }
+}, printElement = (node, depth) => {
+  let indent = INDENT.repeat(depth), startTag = printStartTag(node, depth);
+  if (VOID_ELEMENTS.has(node.name.toLowerCase()))
+    return startTag;
+  if (node.selfClosing)
+    return `${startTag}</${node.name}>`;
+  if (printableChildren(node.children).length === 0)
+    return node.closed ? `${startTag}</${node.name}>` : startTag;
+  let inline = inlineElementText(node, !0)?.text;
+  if (inline && indent.length + inline.length <= INLINE_LIMIT)
+    return `${indent}${inline}`;
+  let body = printChildLines(node.children, depth + 1).join(`
+`);
+  return node.closed ? `${startTag}
+${body}
+${indent}</${node.name}>` : `${startTag}
+${body}`;
+}, printChildLines = (children, depth) => {
+  let lines = [], group = [], flushGroup = () => {
+    if (group.length === 0)
+      return;
+    let inline = inlineChildrenText(group), indent = INDENT.repeat(depth);
+    inline && inline.hasText && indent.length + inline.text.length <= INLINE_LIMIT ? lines.push(`${indent}${inline.text}`) : group.forEach((child) => lines.push(printNode(child, depth))), group = [];
+  };
+  for (let child of children) {
+    if (child.kind === "text" && collapseText(child.text) === "") {
+      flushGroup();
+      continue;
+    }
+    if (inlineChildText(child)) {
+      group.push(child);
+      continue;
+    }
+    flushGroup(), lines.push(printNode(child, depth));
+  }
+  return flushGroup(), lines;
+}, inlineElementText = (node, requireText = !0) => {
+  let lowerName = node.name.toLowerCase();
+  if (VOID_ELEMENTS.has(lowerName))
+    return { hasText: !1, text: printCompactStartTag(node) };
+  if (node.selfClosing)
+    return { hasText: !1, text: `${printCompactStartTag(node)}</${node.name}>` };
+  if (printableChildren(node.children).length === 0)
+    return { hasText: !1, text: node.closed ? `${printCompactStartTag(node)}</${node.name}>` : printCompactStartTag(node) };
+  let childrenText = inlineChildrenText(node.children);
+  return childrenText === void 0 || requireText && !childrenText.hasText ? void 0 : {
+    hasText: childrenText.hasText,
+    text: `${printCompactStartTag(node)}${childrenText.text}</${node.name}>`
+  };
+}, inlineChildrenText = (children) => {
+  let parts = [], hasText = !1;
+  for (let index = 0; index < children.length; index += 1) {
+    let child = children[index], part = inlineChildText(child);
+    if (part === void 0)
+      return;
+    part.text !== "" && parts.push(
+      child.kind === "text" ? inlineText(child.text, index === 0, index === children.length - 1) : part.text
+    ), hasText ||= part.hasText;
+  }
+  return { hasText, text: parts.join("") };
+}, inlineChildText = (node) => {
+  switch (node.kind) {
+    case "text":
+      return collapseText(node.text) === "" ? void 0 : { hasText: !0, text: node.text };
+    case "element": {
+      if (!isInlineChildElement(node))
+        return;
+      let inline = inlineElementText(node, !1);
+      return inline ? { hasText: !1, text: inline.text } : void 0;
+    }
+    case "comment":
+    case "malformed":
+    case "rawText":
+      return;
+    default:
+      return node;
+  }
+}, isInlineChildElement = (node) => !VOID_ELEMENTS.has(node.name.toLowerCase()) && printableChildren(node.children).every((child) => child.kind === "text"), printRawTextElement = (node, depth) => {
+  let startTag = printStartTag({ attributes: node.attributes, name: node.name }, depth);
+  return node.closed ? `${startTag}${node.text}</${node.name}>` : `${startTag}${node.text}`;
+}, printStartTag = (node, depth) => {
+  let indent = INDENT.repeat(depth), compact = printCompactStartTag(node);
+  return indent.length + compact.length <= INLINE_LIMIT ? `${indent}${compact}` : node.attributes.length === 0 ? `${indent}<${node.name}>` : [
+    `${indent}<${node.name}`,
+    ...node.attributes.map((attr) => `${indent}${INDENT}${printHtmlAttribute(attr)}`),
+    `${indent}>`
+  ].join(`
+`);
+}, printCompactStartTag = (node) => {
+  let attrs = node.attributes.map(printHtmlAttribute).join(" "), suffix = attrs ? ` ${attrs}` : "";
+  return `<${node.name}${suffix}>`;
+}, printHtmlAttribute = ({ name, value }) => value === void 0 ? name : `${name}="${escapeAttribute(value)}"`, decodeAttribute = (value) => value.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&lt;/g, "<").replace(/&amp;/g, "&"), printableChildren = (children) => children.filter((child) => child.kind !== "text" || collapseText(child.text) !== ""), collapseText = (text) => text.trim().replace(/\s+/g, " "), inlineText = (text, first, last) => {
+  let collapsed = text.replace(/\s+/g, " ");
+  return first && (collapsed = collapsed.trimStart()), last && (collapsed = collapsed.trimEnd()), collapsed;
+}, hasSelfClosingSlash = (rest) => {
+  let index = rest.length - 1;
+  for (; index >= 0 && /\s/.test(rest[index]); )
+    index -= 1;
+  return rest[index] !== "/" ? !1 : index === 0 || /\s/.test(rest[index - 1]);
+}, findTagEnd = (source, start) => {
+  let quote, canOpenQuote = !1;
+  for (let index = start + 1; index < source.length; index += 1) {
+    let char = source[index];
+    if (quote) {
+      char === quote && (quote = void 0);
+      continue;
+    }
+    if ((char === '"' || char === "'") && canOpenQuote) {
+      quote = char;
+      continue;
+    }
+    if (/\s|=/.test(char) && (canOpenQuote = !0), char === ">")
+      return index + 1;
+  }
+}, findRawTextEnd = (source, start, name) => {
+  let lower = source.toLowerCase(), close = `</${name.toLowerCase()}`, index = start;
+  for (; index < source.length; ) {
+    let found = lower.indexOf(close, index);
+    if (found === -1)
+      return;
+    let boundary = source[found + close.length];
+    if (boundary !== void 0 && /[\s>]/.test(boundary)) {
+      let end = findTagEnd(source, found);
+      return end === void 0 ? void 0 : { end, start: found };
+    }
+    index = found + close.length;
+  }
+};
+
+// src/docgen/story-docs/print-element.ts
+function escapeAttribute(value, quote = '"') {
+  let escaped = value.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+  return quote === "'" ? escaped.replace(/'/g, "&#39;") : escaped.replace(/"/g, "&quot;");
+}
+function printElementSnippet(snippet) {
+  let nodes = [
+    ...styleNodes(snippet.styleRules),
+    {
+      attributes: elementAttributes(snippet),
+      children: slotNodes(snippet.slots),
+      closed: !0,
+      kind: "element",
+      name: snippet.tag,
+      selfClosing: !1
+    }
+  ], element = printHtml(nodes), listenerScript = printListenerScript(snippet.tag, snippet.listeners);
+  return listenerScript ? `${element}
+${listenerScript}` : element;
+}
+function printListenerScript(tag, listeners) {
+  let uniqueListeners = uniqueListenersByEvent(
+    listeners.filter((listener) => listener.tag === tag)
+  );
+  return uniqueListeners.length === 0 ? void 0 : `<script>
+  {
+    const host = document.currentScript.previousElementSibling;
+${uniqueListeners.map(({ event, handler }) => `    host.addEventListener('${escapeScriptString(
+    event
+  )}', ${sanitizeScriptHandler(handler)});`).join(`
+`)}
+  }
+</script>`;
+}
+function printRootListenerScript(listeners) {
+  let uniqueListeners = uniqueListenersByEvent(listeners);
+  return uniqueListeners.length === 0 ? void 0 : `<script>
+  {
+    const host = document.currentScript.previousElementSibling;
+${uniqueListeners.map(
+    ({ event, handler }) => `    host.addEventListener('${escapeScriptString(event)}', ${sanitizeScriptHandler(handler)});`
+  ).join(`
+`)}
+  }
+</script>`;
+}
+var uniqueListenersByEvent = (listeners) => {
+  let events = /* @__PURE__ */ new Set();
+  return listeners.filter(({ event }) => events.has(event) ? !1 : (events.add(event), !0));
+}, styleNodes = (rules) => rules.length === 0 ? [] : [
+  {
+    attributes: [],
+    closed: !0,
+    kind: "rawText",
+    name: "style",
+    text: `
+${rules.map(({ selector, declarations }) => `  ${selector} { ${declarations} }`).join(`
+`)}
+`
+  }
+], elementAttributes = (snippet) => {
+  let attributes = snippet.attributes.map(attributeNode).filter((attribute) => attribute !== void 0), style = printCssProperties(snippet.cssProperties);
+  return [...attributes, ...style ? [{ name: "style", value: style }] : []];
+};
+function printAttribute({
+  name,
+  value,
+  viaField
+}) {
+  if (value === !0)
+    return name;
+  if (value === "")
+    return viaField ? `${name}=""` : void 0;
+  if (value === !1 || value === null || value === void 0)
+    return;
+  let text = typeof value == "object" ? JSON.stringify(value) : String(value);
+  return `${name}="${escapeAttribute(text)}"`;
+}
+var printCssProperties = (properties) => {
+  let declarations = properties.filter(({ value }) => value != null && value !== "").map(({ name, value }) => `${name}: ${String(value)};`);
+  return declarations.length === 0 ? void 0 : declarations.join(" ");
+}, attributeNode = ({
+  name,
+  value,
+  viaField
+}) => {
+  if (value === !0)
+    return { name, value: void 0 };
+  if (value === "")
+    return viaField ? { name, value: "" } : void 0;
+  if (value === !1 || value === null || value === void 0)
+    return;
+  let text = typeof value == "object" ? JSON.stringify(value) : String(value);
+  return { name, value: text };
+}, hasSlotContent = ({ html }) => html != null && html !== "", slotNodes = (slots) => slots.filter(hasSlotContent).flatMap(({ name, html }, index) => [
+  ...index === 0 ? [] : [slotSeparatorNode()],
+  ...nodesForSlot(name, String(html))
+]), slotSeparatorNode = () => ({ kind: "text", text: `
+` }), nodesForSlot = (name, content) => {
+  let nodes = parseHtml(content);
+  if (name === "default")
+    return nodes;
+  let [only] = nodes;
+  return nodes.length === 1 && only?.kind === "element" && !only.selfClosing && !hasSlotAttribute(only) ? (only.attributes.push({ name: "slot", value: name }), nodes) : [
+    {
+      attributes: [{ name: "slot", value: name }],
+      children: nodes,
+      closed: !0,
+      kind: "element",
+      name: "span",
+      selfClosing: !1
+    }
+  ];
+}, 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";
+
+// src/docgen/story-docs/template-scope.ts
+import { types as t2 } from "storybook/internal/babel";
+import {
+  collectImportBindings,
+  keyOf as keyOf2,
+  returnedExpressionPath,
+  sourceOf as sourceOf2,
+  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);
+  return returned ? templateFromExpression(unwrapExpression2(returned.node), bindings, returned.scope) : void 0;
+}
+function templateFromExpression(expression, bindings, scope) {
+  if (t2.isStringLiteral(expression))
+    return {
+      bindings,
+      expressions: [],
+      lit: !1,
+      quasis: [expression.value],
+      scope,
+      source: sourceOf2(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;
+}
+function aliasValueForIdentifier(expression, scope) {
+  return scope.aliases.get(expression.name);
+}
+function argReferenceForExpression(expression, scope) {
+  let unwrapped = unwrapExpression2(expression);
+  if (t2.isIdentifier(unwrapped)) {
+    let alias = aliasValueForIdentifier(unwrapped, scope);
+    return alias?.kind === "arg" ? { name: alias.name, path: alias.path } : parameterArgReference(unwrapped, scope);
+  }
+  if (!t2.isMemberExpression(unwrapped))
+    return;
+  let property = memberPropertyName(unwrapped);
+  if (property === void 0)
+    return;
+  if (scope.args && t2.isIdentifier(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);
+  if (strict)
+    return { node: strict.node, scope: baseScope };
+  if (!t2.isBlockStatement(renderFunction.node.body))
+    return;
+  let statements = renderFunction.node.body.body, returned = statements.at(-1);
+  if (!t2.isReturnStatement(returned) || !t2.isExpression(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))
+      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))
+    return scope.args = first.name, scope;
+  if (!t2.isObjectPattern(first))
+    return scope;
+  let destructured = destructuredAliases(first, { name: "", path: [] });
+  if (!destructured)
+    return scope;
+  for (let [local, value] of destructured)
+    scope.aliases.set(local, value), value.kind === "arg" && value.path.length === 0 && scope.destructured.set(local, value.name);
+  return scope;
+}, addVariableAliases = (declaration, scope, bindings) => {
+  for (let declarator of declaration.declarations) {
+    if (!t2.isExpression(declarator.init))
+      return !1;
+    if (t2.isIdentifier(declarator.id)) {
+      let alias = aliasForExpression(declarator.init, scope, bindings);
+      if (!alias)
+        return !1;
+      scope.aliases.set(declarator.id.name, alias);
+      continue;
+    }
+    if (t2.isObjectPattern(declarator.id)) {
+      let source = destructureSourceForExpression(declarator.init, scope);
+      if (!source)
+        return !1;
+      let aliases = destructuredAliases(declarator.id, source);
+      if (!aliases)
+        return !1;
+      aliases.forEach((alias, name) => scope.aliases.set(name, alias));
+      continue;
+    }
+    return !1;
+  }
+  return !0;
+}, destructureSourceForExpression = (expression, scope) => {
+  let unwrapped = unwrapExpression2(expression);
+  return scope.args && t2.isIdentifier(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;
+  if (arg)
+    return { kind: "arg", source: sourceOf2(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 };
+}, destructuredAliases = (pattern, source) => {
+  let aliases = /* @__PURE__ */ new Map();
+  for (let property of pattern.properties) {
+    if (!t2.isObjectProperty(property) || property.computed)
+      return;
+    let key = keyOf2(property);
+    if (!key)
+      return;
+    let root = source.name === "" ? { name: key, path: [] } : { name: source.name, path: [...source.path, key] };
+    if (t2.isIdentifier(property.value))
+      aliases.set(property.value.name, { kind: "arg", ...root });
+    else if (t2.isObjectPattern(property.value)) {
+      let nested = destructuredAliases(property.value, root);
+      if (!nested)
+        return;
+      nested.forEach((alias, name) => aliases.set(name, alias));
+    } else
+      return;
+  }
+  return aliases;
+}, 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) => ({
+  bindings,
+  expressions: literal.expressions.filter(
+    (expression) => t2.isExpression(expression)
+  ),
+  lit,
+  quasis: literal.quasis.map((quasi) => quasi.value.raw),
+  scope,
+  source
+}), copyScope = (scope) => ({
+  ...scope,
+  aliases: new Map(scope.aliases),
+  destructured: new Map(scope.destructured)
+}), 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))
+    return expression.quasis[0]?.value.cooked ?? expression.quasis[0]?.value.raw ?? "";
+};
+
+// 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;
+  if (alias)
+    return resolveAlias(alias, context, sourceOf3(expression));
+  let arg = argReferenceForExpression(expression, context.scope);
+  if (arg)
+    return resolveArgReference(arg, context.storyArgs[arg.name], sourceOf3(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" };
+  let nested = templateFromExpression(unwrapped, context.bindings, context.scope);
+  if (nested)
+    return { kind: "template", source: sourceOf3(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)) {
+    let test = resolveConditionalTest(unwrapped.test, context);
+    if (test.kind === "unresolved")
+      return test;
+    let branch = resolveHoleValue(
+      test.truthy ? unwrapped.consequent : unwrapped.alternate,
+      context
+    );
+    return test.arg && !branch.arg ? { ...branch, arg: test.arg } : branch;
+  }
+  return { kind: "unresolved", source: sourceOf3(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;
+}, 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 };
+  if (value.kind === "value")
+    return { kind: "value", value: value.value };
+  if (value.template.lit)
+    return { kind: "unresolved", source: value.source ?? value.template.source };
+  let resolved = templateAttributeText(value.template, context, referenced);
+  return resolved.kind === "unresolved" ? resolved : { kind: "value", value: resolved.text };
+}, listenerHandler = (value) => value.kind === "function" ? value.handler : "() => {}", escapeText = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"), resolveArg = (arg, node) => {
+  if (!node)
+    return { kind: "value", arg, value: void 0 };
+  let value = evaluateArgValue(node);
+  switch (value.kind) {
+    case "function":
+      return { handler: sourceOf3(node), kind: "function", arg };
+    case "unset":
+      return { kind: "value", arg, value: void 0 };
+    case "unresolved":
+      return { arg, kind: "unresolved", source: value.source };
+    case "value":
+      return { kind: "value", arg, value: value.value };
+    default:
+      return value;
+  }
+}, resolveAlias = (alias, context, source) => {
+  switch (alias.kind) {
+    case "arg":
+      return resolveArgReference(alias, context.storyArgs[alias.name], source ?? alias.source);
+    case "template":
+      return { kind: "template", source: source ?? alias.source, template: alias.template };
+    case "value":
+      return { kind: "value", value: alias.value };
+    default:
+      return alias;
+  }
+}, resolveArgReference = (reference, node, missingPathSource) => {
+  let value = resolveArg(reference.name, node);
+  if (value.kind === "function" && missingPathSource)
+    return { ...value, source: missingPathSource };
+  if (value.kind !== "value" || reference.path.length === 0)
+    return value;
+  let current2 = value.value;
+  for (let part of reference.path) {
+    let object = current2 == null ? void 0 : Object(current2);
+    if (object === void 0 || !(part in object))
+      return missingPathSource ? { arg: reference.name, kind: "unresolved", source: missingPathSource } : { arg: reference.name, kind: "empty" };
+    current2 = object[part];
+  }
+  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;
+  if (alias)
+    return referencedArgsForAlias(alias);
+  let arg = argReferenceForExpression(expression, scope);
+  return arg ? /* @__PURE__ */ new Set([arg.name]) : /* @__PURE__ */ new Set();
+}, referencedArgsForAlias = (alias) => {
+  switch (alias.kind) {
+    case "arg":
+      return /* @__PURE__ */ new Set([alias.name]);
+    case "template": {
+      let referenced = /* @__PURE__ */ new Set();
+      for (let expression of alias.template.expressions)
+        collectReferencedArgs(expression, alias.template.scope).forEach(
+          (arg) => referenced.add(arg)
+        );
+      return referenced;
+    }
+    case "value":
+      return /* @__PURE__ */ new Set();
+    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))
+    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 arg = argReferenceForExpression(expression, context.scope);
+  if (arg) {
+    let value = resolveArgReference(arg, context.storyArgs[arg.name], sourceOf3(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)
+    };
+  }
+  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) };
+}, templateAttributeText = (template, context, referenced) => {
+  let scopedContext = { ...context, bindings: template.bindings, scope: template.scope }, text = "";
+  for (let index = 0; index < template.expressions.length; index += 1) {
+    text += template.quasis[index] ?? "";
+    let expression = template.expressions[index], value = resolveHoleValue(expression, scopedContext);
+    if (value.kind === "unresolved")
+      return { kind: "unresolved", source: value.source };
+    value.arg && referenced?.add(value.arg);
+    let resolved = attributeValue(value, scopedContext, referenced);
+    if (resolved.kind === "unresolved")
+      return resolved;
+    text += resolved.value === void 0 ? "" : String(resolved.value);
+  }
+  return text += template.quasis.at(-1) ?? "", { kind: "text", text };
+}, isImported2 = (local, importName, sources, bindings) => {
+  let binding = bindings.get(local);
+  return !!binding && sources.includes(binding.importId) && binding.importName === importName;
+};
+
+// src/docgen/story-docs/template-print.ts
+function printHtmlTemplate(template, storyArgs, declaration) {
+  return printTemplate(template, {
+    bindings: template.bindings,
+    declaration,
+    scope: template.scope,
+    storyArgs
+  });
+}
+var printTemplate = (template, context) => printTemplateWithListeners(template, context, !0), printTemplateWithListeners = (template, context, allowRootListeners) => {
+  let scopedContext = { ...context, bindings: template.bindings, scope: template.scope }, nonce = `${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`, markers = /* @__PURE__ */ new Map(), source = template.quasis.reduce((html, quasi, index) => {
+    let expression = template.expressions[index];
+    if (!expression)
+      return html + quasi;
+    let marker = `__STORYBOOK_HOLE_${nonce}_${index}__`;
+    return markers.set(marker, expression), `${html}${quasi}${marker}`;
+  }, ""), state = {
+    context: scopedContext,
+    falseDefaults: /* @__PURE__ */ new Set(),
+    listeners: [],
+    listenersNotShown: /* @__PURE__ */ new Set(),
+    lit: template.lit,
+    markers,
+    properties: /* @__PURE__ */ new Set(),
+    referenced: /* @__PURE__ */ new Set(),
+    unresolved: /* @__PURE__ */ new Set()
+  };
+  for (let expression of template.expressions)
+    collectReferencedArgs(expression, scopedContext.scope).forEach(
+      (arg) => state.referenced.add(arg)
+    );
+  let nodes = resolveTemplateNodes(parseHtml(source), state, 0), hostRoots = nodes.filter((node) => node.kind === "element" && node.name !== "style"), rootElements = nodes.filter((node) => node.kind === "element" || node.kind === "rawText");
+  !(allowRootListeners && hostRoots.length === 1 && rootElements.at(-1) === hostRoots[0]) && state.listeners.length > 0 && (state.listeners.forEach((listener) => state.listenersNotShown.add(`@${listener.event}`)), state.listeners = []);
+  let script = printRootListenerScript(state.listeners), snippet = printHtml(nodes);
+  return {
+    ...state.falseDefaults.size === 0 ? {} : { falseDefaults: [...state.falseDefaults] },
+    listeners: state.listeners,
+    ...state.listenersNotShown.size === 0 ? {} : { listenersNotShown: [...state.listenersNotShown] },
+    properties: [...state.properties],
+    referenced: [...state.referenced],
+    snippet: script ? `${snippet}
+${script}` : snippet,
+    unresolved: [...state.unresolved]
+  };
+}, resolveTemplateNodes = (nodes, state, depth) => nodes.flatMap((node) => resolveTemplateNode(node, state, depth)), resolveTemplateNode = (node, state, depth) => {
+  switch (node.kind) {
+    case "element":
+      return [
+        {
+          ...node,
+          attributes: resolveAttributes(node.name, node.attributes, state, depth),
+          children: resolveTemplateNodes(node.children, state, depth + 1)
+        }
+      ];
+    case "text":
+      return resolveTextNode(node.text, state);
+    case "comment":
+      return [{ ...node, text: removeUnsupportedMarkers(node.text, state) }];
+    case "rawText":
+      return [{ ...node, text: removeUnsupportedMarkers(node.text, state) }];
+    case "malformed":
+      return [{ ...node, text: removeUnsupportedMarkers(node.text, state) }];
+    default:
+      return node;
+  }
+}, resolveAttributes = (tag, attributes, state, depth) => {
+  let resolved = [];
+  for (let attribute of attributes) {
+    let next = resolveAttribute(tag, attribute, state, depth);
+    next && upsertAttribute(resolved, next);
+  }
+  return resolved;
+}, resolveAttribute = (tag, attribute, state, depth) => {
+  if (containsMarker(attribute.name, state)) {
+    unresolvedMarkers(attribute.name, state);
+    return;
+  }
+  if (attribute.value === void 0 || !containsMarker(attribute.value, state))
+    return attribute;
+  let prefix = state.lit ? attribute.name[0] : void 0;
+  if (prefix === "?") {
+    let value = resolveFirstMarker(attribute.value, state);
+    return value && isTruthyAttributeValue(value) ? { name: attribute.name.slice(1), value: void 0 } : void 0;
+  }
+  if (prefix === "@") {
+    let value = resolveFirstMarker(attribute.value, state), event = attribute.name.slice(1);
+    depth === 0 ? state.listeners.push({
+      event,
+      handler: value ? listenerHandler(value) : "() => {}"
+    }) : state.listenersNotShown.add(`@${event}`);
+    return;
+  }
+  if (prefix === ".") {
+    let property = attribute.name.slice(1), paired = pairedAttribute(property, state.context.declaration);
+    if (!paired) {
+      state.properties.add(property);
+      return;
+    }
+    let markers2 = markersIn(attribute.value, state), value = markers2.length === 1 && attribute.value === markers2[0] ? resolveFirstMarker(attribute.value, state) : void 0;
+    if (!value || value.kind === "unresolved") {
+      state.unresolved.add(
+        value?.kind === "unresolved" ? value.source : markerSources(markers2, state)
+      );
+      return;
+    }
+    let resolved = attributeValue(value, state.context, state.referenced);
+    if (resolved.kind === "unresolved") {
+      state.unresolved.add(resolved.source);
+      return;
+    }
+    return resolved.value === !1 && fieldDefault(property, state.context.declaration) === "true" && state.falseDefaults.add(property), attributeFromPrinted(
+      printAttribute({ name: paired, value: resolved.value, viaField: !0 })
+    );
+  }
+  let markers = markersIn(attribute.value, state), singleDynamicValue = markers.length === 1 && attribute.value === markers[0], text = attribute.value;
+  for (let marker of markers) {
+    let expression = state.markers.get(marker);
+    if (!expression)
+      continue;
+    let value = resolveMarkerValue(expression, state);
+    if (value.kind === "function") {
+      state.unresolved.add(sourceOf4(expression));
+      return;
+    }
+    if (value.kind === "nothing")
+      return;
+    if (value.kind === "unresolved") {
+      state.unresolved.add(value.source);
+      return;
+    }
+    let resolved = attributeValue(value, state.context, state.referenced);
+    if (resolved.kind === "unresolved") {
+      state.unresolved.add(resolved.source);
+      return;
+    }
+    if (!attribute.quoted && !singleDynamicValue && resolved.value === void 0 && text.startsWith(marker))
+      return;
+    let valueText = resolved.value === null || resolved.value === void 0 ? "" : String(resolved.value);
+    text = text.replace(marker, valueText);
+  }
+  return { name: attribute.name, value: text };
+}, resolveTextNode = (text, state) => {
+  let markers = markersIn(text, state);
+  if (markers.length === 0)
+    return [{ kind: "text", text }];
+  let nodes = [], rest = text;
+  for (let marker of markers) {
+    let [before, after] = rest.split(marker);
+    before && nodes.push({ kind: "text", text: before });
+    let expression = state.markers.get(marker);
+    expression && nodes.push(...nodesForChildValue(resolveMarkerValue(expression, state), state)), rest = after ?? "";
+  }
+  return rest && nodes.push({ kind: "text", text: rest }), nodes;
+}, nodesForChildValue = (value, state) => {
+  switch (value.kind) {
+    case "empty":
+    case "nothing":
+      return [];
+    case "function":
+      return state.unresolved.add(value.source ?? value.handler), [];
+    case "template": {
+      let nested = printTemplateWithListeners(value.template, state.context, !1);
+      return nested.properties.forEach((property) => state.properties.add(property)), nested.referenced.forEach((arg) => state.referenced.add(arg)), nested.unresolved.forEach((source) => state.unresolved.add(source)), nested.listenersNotShown?.forEach((listener) => state.listenersNotShown.add(listener)), parseHtml(nested.snippet.replace(/<script>[\s\S]*<\/script>$/, ""));
+    }
+    case "unresolved":
+      return state.unresolved.add(value.source), [];
+    case "value":
+      if (value.value === null || value.value === void 0 || value.value === "")
+        return [];
+      if (Array.isArray(value.value)) {
+        let text = value.value.map((item) => item ?? "").join("");
+        return state.lit ? [{ kind: "text", text: escapeText(text) }] : parseHtml(text);
+      }
+      return state.lit ? [{ kind: "text", text: escapeText(String(value.value)) }] : parseHtml(String(value.value));
+    default:
+      return value;
+  }
+}, resolveMarkerValue = (expression, state) => {
+  let value = resolveHoleValue(expression, state.context);
+  return value.arg && state.referenced.add(value.arg), value;
+}, resolveFirstMarker = (text, state) => {
+  let marker = markersIn(text, state)[0], expression = marker ? state.markers.get(marker) : void 0;
+  return expression ? resolveMarkerValue(expression, state) : void 0;
+}, removeUnsupportedMarkers = (text, state) => {
+  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, "");
+  }
+  return next;
+}, unresolvedMarkers = (text, state) => {
+  for (let marker of markersIn(text, state)) {
+    let expression = state.markers.get(marker);
+    expression && state.unresolved.add(sourceOf4(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) => {
+  if (!attribute)
+    return;
+  let [node] = parseHtml(`<x ${attribute}></x>`);
+  return node?.kind === "element" ? node.attributes[0] : void 0;
+}, upsertAttribute = (attributes, next) => {
+  let index = attributes.findIndex((attribute) => attribute.name === next.name);
+  if (index === -1) {
+    attributes.push(next);
+    return;
+  }
+  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) {
+  let storyImportPath = getStoryImportPathFromEntry(input.entry);
+  if (!storyImportPath)
+    return;
+  let storyFilePath = (context.resolvePath ?? ((importPath) => resolve2(process.cwd(), importPath)))(storyImportPath), csf = parseStoryFile(storyFilePath, input.entry.title);
+  if (!csf)
+    return;
+  let resolved = resolveStoryComponent(csf);
+  if ("reason" in resolved && resolved.reason === "no-meta-component") {
+    let titleName = input.entry.title.slice(input.entry.title.lastIndexOf("/") + 1);
+    return buildPayload(
+      input,
+      storyImportPath,
+      csf,
+      authoredSnippetFactory(csf, storyFilePath, () => ({ warning: NO_COMPONENT_WARNING })),
+      titleName
+    );
+  }
+  let docgenPayload = await context.getDocgenPayload(getComponentIdFromEntry(input.entry));
+  if (!docgenPayload)
+    return;
+  let declaration = docgenPayload?.customElementsManifest?.declaration, snippetFor = declaration ? renderedSnippetFactory(csf, declaration, docgenPayload, storyFilePath) : authoredSnippetFactory(csf, storyFilePath, () => ({
+    warning: `No static snippet: ${docgenPayload.error?.message ?? "no Custom Elements Manifest declaration for this component."}`
+  }));
+  return buildPayload(input, storyImportPath, csf, snippetFor, docgenPayload.name);
+}
+var buildPayload = (input, storyImportPath, csf, snippetFor, name) => {
+  let stories = Object.fromEntries(
+    Object.entries(csf._stories).map(([exportName, story]) => [
+      story.id,
+      buildStoryDoc(exportName, story, csf, snippetFor)
+    ])
+  );
+  return {
+    id: getComponentIdFromEntry(input.entry),
+    name,
+    path: storyImportPath,
+    stories
+  };
+}, renderedSnippetFactory = (csf, declaration, docgenPayload, storyFilePath) => {
+  let references = storyReferences(storyFilePath), deps = {
+    csf,
+    declaration,
+    docgenPayload,
+    resolveStoryArgs: createStoryArgsResolver(csf, references),
+    tag: declaration.tagName ?? docgenPayload.name
+  };
+  return (exportName) => renderedSnippet(exportName, deps);
+}, storyReferences = (storyFilePath) => ({
+  filePath: storyFilePath,
+  resolveModule: openStoryReferences().resolveModule
+}), baseStoryDoc = (csf, exportName, story, result) => {
+  let { description, summary } = extractStoryJSDocInfo(csf._storyStatements[exportName]);
+  return {
+    id: story.id,
+    name: story.name ?? storyNameFromExport(exportName),
+    ...result.snippet === void 0 ? {} : { snippet: result.snippet },
+    ...result.warning === void 0 ? {} : { warning: result.warning },
+    ...description ? { description } : {},
+    ...summary === void 0 ? {} : { summary }
+  };
+}, buildStoryDoc = (exportName, story, csf, snippetFor) => {
+  try {
+    return baseStoryDoc(csf, exportName, story, snippetFor(exportName));
+  } catch (e) {
+    let err = e instanceof Error ? e : void 0;
+    return {
+      id: story.id,
+      name: story.name ?? storyNameFromExport(exportName),
+      error: { name: err?.name ?? "Error", message: err?.message ?? String(e) }
+    };
+  }
+}, renderedSnippet = (exportName, deps) => authoredOrFallback(
+  exportName,
+  deps.resolveStoryArgs,
+  (resolved) => renderedArgsSnippet(exportName, resolved, deps)
+), authoredSnippetFactory = (csf, storyFilePath, fallback) => {
+  let resolveStoryArgs = createStoryArgsResolver(csf, storyReferences(storyFilePath));
+  return (exportName) => authoredOrFallback(exportName, resolveStoryArgs, fallback);
+}, authoredOrFallback = (exportName, resolveStoryArgs, fallback) => {
+  let resolved = resolveStoryArgs.resolve(exportName), warnings = [], authored = authoredSource(resolved, resolveStoryArgs.ctx);
+  if (authored.kind === "code")
+    return { snippet: authored.code };
+  if (authored.kind === "disabled")
+    return {};
+  authored.kind === "unresolvable" && warnings.push(unresolvedWarning([authored.source]));
+  let result = fallback(resolved);
+  return { ...result, ...joinWarnings([...warnings, result.warning]) };
+}, 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);
+    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(
+        incompleteList(printed.falseDefaults ?? [], "false values that HTML cannot express")
+      ), warnings.push(incompleteList(printed.listenersNotShown ?? [], "listeners not shown")), warnings.push(unboundTemplateArgs(resolved.args, printed.referenced));
+      let hasFailedHole = unresolved.length > 0 || printed.properties.length > 0, hasSnippet = printed.snippet !== "" || !hasFailedHole;
+      return {
+        ...hasSnippet ? { snippet: printed.snippet } : {},
+        ...joinWarnings(hasSnippet ? warnings : [...warnings, noSnippetWarning(unresolved)])
+      };
+    }
+    warnings.push(unresolvedWarning([sourceOf6(render.path.node)]));
+  } else render.kind === "unresolved" && warnings.push(unresolvedWarning(unresolvedRenderSource(render, resolved)));
+  let args = argsSnippet(
+    resolved.args,
+    deps.declaration,
+    deps.docgenPayload.argTypes ?? {},
+    deps.tag,
+    resolved.unresolved
+  );
+  return warnings.push(args.warning), {
+    ...args.snippet ? { snippet: args.snippet } : {},
+    ...joinWarnings(warnings)
+  };
+}, unboundTemplateArgs = (args, referenced) => {
+  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)] : [];
+}, argsSnippet = (args, declaration, argTypes, tag, unresolvedArgs) => {
+  let snippet = {
+    tag,
+    attributes: [],
+    cssProperties: [],
+    listeners: [],
+    slots: [],
+    styleRules: []
+  }, unresolved = [], listeners = [], properties = [], unknown = [];
+  for (let [key, node] of Object.entries(args)) {
+    let value = evaluateArgValue(node);
+    if (value.kind === "unset")
+      continue;
+    let binding = classifyArg(key, value.kind === "function", argTypes ?? {}, declaration);
+    switch (binding.kind) {
+      case "listener":
+        binding.event ? snippet.listeners.push({ event: binding.event, handler: listenerHandler2(node), tag }) : listeners.push(key);
+        break;
+      case "property":
+        properties.push(key);
+        break;
+      case "method":
+        break;
+      case "unknown":
+        unknown.push(key);
+        break;
+      case "attribute":
+      case "cssProperty":
+      case "slot":
+      case "cssPart":
+      case "cssState":
+        value.kind === "value" ? addBoundValue(snippet, binding, key, value.value, tag) : value.kind === "unresolved" && unresolved.push(value.source);
+        break;
+      default:
+        return binding;
+    }
+  }
+  let warnings = [
+    incompleteList(listeners, "listeners the HTML snippet cannot express"),
+    incompleteList(properties, "properties without an attribute"),
+    incompleteList(unknown, `args not declared by \`${tag}\``),
+    incompleteList(falseDefaultAttributes(snippet), "false values that HTML cannot express")
+  ], allUnresolved = [...unresolvedArgs, ...unresolved], printed = hasSnippetContent(snippet) || allUnresolved.length === 0;
+  return warnings.push(printed ? unresolvedWarning(allUnresolved) : noSnippetWarning(allUnresolved)), {
+    ...printed ? { snippet: printElementSnippet(snippet) } : {},
+    ...joinWarnings(warnings)
+  };
+}, addBoundValue = (snippet, binding, source, value, tag) => {
+  switch (binding.kind) {
+    case "attribute":
+      upsertByName(snippet.attributes, {
+        name: binding.name,
+        value,
+        viaField: binding.viaField,
+        defaultValue: binding.defaultValue,
+        source
+      });
+      break;
+    case "cssProperty":
+      upsertByName(snippet.cssProperties, { name: binding.name, value });
+      break;
+    case "slot":
+      upsertByName(snippet.slots, { name: binding.name, html: value });
+      break;
+    case "cssPart":
+      upsertBySelector(snippet.styleRules, {
+        selector: `${tag}::part(${binding.name})`,
+        declarations: String(value)
+      });
+      break;
+    case "cssState":
+      upsertBySelector(snippet.styleRules, {
+        selector: `${tag}:state(${binding.name})`,
+        declarations: String(value)
+      });
+      break;
+    default:
+      return binding;
+  }
+}, upsertByName = (items, next) => {
+  let index = items.findIndex((item) => item.name === next.name);
+  if (index === -1) {
+    items.push(next);
+    return;
+  }
+  items[index] = next;
+}, upsertBySelector = (items, next) => {
+  let index = items.findIndex((item) => item.selector === next.selector);
+  if (index === -1) {
+    items.push(next);
+    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) => {
+  let warning = [...new Set(parts.filter((part) => part !== void 0))].join(`
+`);
+  return warning === "" ? {} : { warning };
+};
+
+// src/docgen/story-docs-preset.ts
+var warnedMissingDocgenService = !1, getDocgenPayload = async (componentId) => {
+  try {
+    return await getService("core/docgen", { internal: !0 }).queries.docgen.loaded({ id: componentId });
+  } catch (error) {
+    warnedMissingDocgenService || (warnedMissingDocgenService = !0, logger.warn(
+      `Web Components story snippets are unavailable: querying core/docgen failed. ${error instanceof Error ? error.message : String(error)}`
+    ));
+    return;
+  }
+}, experimental_storyDocsProvider = async (nextStoryDocs, options) => {
+  let descriptors = await options.presets.apply(
+    "experimental_docgenProvider",
+    []
+  ), worker = fileURLToPath2(import.meta.resolve(DOCGEN_WORKER_SPECIFIER));
+  return descriptors.some((descriptor) => descriptor.moduleSpecifier === worker) ? async (input) => {
+    let storyImportPath = getStoryImportPathFromEntry2(input.entry);
+    if (!storyImportPath || !STORY_FILE_TEST_REGEXP.test(storyImportPath))
+      return nextStoryDocs(input);
+    let ours;
+    try {
+      ours = await buildStoryDocsPayload(input, { getDocgenPayload });
+    } catch (error) {
+      return logger.debug(
+        `Web Components story snippets are unavailable for ${storyImportPath}: ${error instanceof Error ? error.message : String(error)}`
+      ), nextStoryDocs(input);
+    }
+    return ours ? { ...await nextStoryDocs(input), ...ours } : nextStoryDocs(input);
+  } : nextStoryDocs;
+};
+
 // src/preset.ts
-var previewAnnotations = async (input = [], options) => {
+var isDocgenProviderEnabled = !0, previewAnnotations = async (input = [], options) => {
   let docsEnabled = Object.keys(await options.presets.apply("docs", {}, options)).length > 0;
   return [].concat(input).concat([
-    fileURLToPath2(import.meta.resolve("@storybook/web-components/entry-preview")),
-    fileURLToPath2(import.meta.resolve("@storybook/web-components/entry-preview-argtypes"))
+    fileURLToPath3(import.meta.resolve("@storybook/web-components/entry-preview")),
+    fileURLToPath3(import.meta.resolve("@storybook/web-components/entry-preview-argtypes"))
   ]).concat(
-    docsEnabled ? [fileURLToPath2(import.meta.resolve("@storybook/web-components/entry-preview-docs"))] : []
+    docsEnabled ? [fileURLToPath3(import.meta.resolve("@storybook/web-components/entry-preview-docs"))] : []
   );
 };
 export {
   experimental_docgenProvider,
   experimental_manifests,
+  experimental_storyDocsProvider,
+  isDocgenProviderEnabled,
   previewAnnotations
 };