@storybook/web-components 11.0.0-alpha.0 → 11.0.0-alpha.2

package/dist/_node-chunks/chunk-FABV47GL.js

@@ -0,0 +1,925 @@
+import CJS_COMPAT_NODE_URL_rucz8cqr0ps from 'node:url';
+import CJS_COMPAT_NODE_PATH_rucz8cqr0ps from 'node:path';
+import CJS_COMPAT_NODE_MODULE_rucz8cqr0ps from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_rucz8cqr0ps.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_rucz8cqr0ps.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_rucz8cqr0ps.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  deprecationMessage,
+  errorMessage,
+  firstValue,
+  isRecord,
+  namedItems,
+  readCssPropertySyntax,
+  readTypeText,
+  trimmedOrUndefined
+} from "./chunk-36BPTBR5.js";
+
+// src/docgen/docgen-worker.ts
+import { createLazyDocgenMiddleware } from "storybook/internal/common";
+import { logger as logger2 } from "storybook/internal/node-logger";
+
+// src/docgen/component-docgen/build-docgen.ts
+import { getComponentIdFromEntry, getStoryImportPathFromEntry } from "storybook/internal/common";
+import { extractComponentDescription, extractDescription } from "storybook/internal/csf-tools";
+import { resolve } from "node:path";
+
+// src/arg-keys.ts
+var DEFAULT_SLOT_NAME = "default";
+function toArgKey(category, name) {
+  return category === "cssProperties" ? name : `${name}${ARG_KEY_SUFFIXES[category]}`;
+}
+var ARG_KEY_SUFFIXES = {
+  events: "-event",
+  methods: "-method",
+  slots: "-slot",
+  cssParts: "-part",
+  cssStates: "-state"
+};
+
+// src/docgen/component-docgen/manifest/members.ts
+function isPublicField(member) {
+  return isField(member) && isPublicMember(member);
+}
+function isPublicMethod(member) {
+  return isMethod(member) && isPublicMember(member);
+}
+function formatParameters(method) {
+  return (method.parameters ?? []).map(formatParameter).join(", ");
+}
+function isField(member) {
+  return member.kind === "field";
+}
+function isPublicMember(member) {
+  return member.privacy !== "private" && member.privacy !== "protected" && member.static !== !0 && !member.name.startsWith("#");
+}
+function isMethod(member) {
+  return member.kind === "method";
+}
+function formatParameter(parameter) {
+  let restPrefix = parameter.rest ? "..." : "", optionalSuffix = parameter.optional ? "?" : "", typeText = parameter.type?.text ? `: ${parameter.type.text}` : "", defaultText = parameter.default !== void 0 ? ` = ${parameter.default}` : "";
+  return `${restPrefix}${parameter.name}${optionalSuffix}${typeText}${defaultText}`;
+}
+
+// src/docgen/component-docgen/manifest/declaration-api.ts
+function classifyDeclaration(declaration) {
+  let members = namedItems(declaration.members), fields = members.filter(isField);
+  return {
+    attributes: namedItems(declaration.attributes).flatMap((attribute) => {
+      let field = backingField(attribute, fields);
+      return field && !isPublicField(field) ? [] : [{ attribute, field }];
+    }),
+    fields: fields.filter(isPublicField),
+    methods: members.filter(isPublicMethod),
+    events: namedItems(declaration.events),
+    slots: namedItems(declaration.slots),
+    cssProperties: namedItems(declaration.cssProperties),
+    cssParts: namedItems(declaration.cssParts),
+    cssStates: namedItems(declaration.cssStates)
+  };
+}
+function isBackedByAttribute(field, attributes) {
+  return attributes.some(
+    (attribute) => attribute.field === field || attribute.attribute.name === field.name
+  );
+}
+function backingField(attribute, fields) {
+  return attribute.fieldName === void 0 ? void 0 : fields.find((field) => field.name === attribute.fieldName);
+}
+
+// src/docgen/component-docgen/api-description.ts
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+function buildApiDescription(declaration, typeProperty) {
+  let api = classifyDeclaration(declaration), attributes = api.attributes.map((attribute) => attributeDoc(attribute, typeProperty)), properties = api.fields.filter((field) => !isBackedByAttribute(field, api.attributes));
+  if (attributes.length === 0 && properties.length === 0 && api.events.length === 0 && api.methods.length === 0 && api.slots.length === 0 && api.cssProperties.length === 0 && api.cssParts.length === 0 && api.cssStates.length === 0)
+    return;
+  let typePrefix = declaration.name.replace(/\W+/g, "");
+  return [
+    attributesSection(typePrefix, attributes),
+    propertiesSection(typePrefix, properties, typeProperty),
+    eventsSection(typePrefix, api.events, typeProperty),
+    methodsSection(typePrefix, api.methods, typeProperty),
+    listSection(
+      "Slots",
+      api.slots.map((slot) => listItem(slot.name || DEFAULT_SLOT_NAME, memberDoc(slot)))
+    ),
+    listSection(
+      "CSS Custom Properties",
+      api.cssProperties.map((property) => cssPropertyListItem(property, typeProperty))
+    ),
+    listSection(
+      "CSS Parts",
+      api.cssParts.map((part) => listItem(part.name, memberDoc(part)))
+    ),
+    listSection(
+      "CSS States",
+      api.cssStates.map((state) => listItem(state.name, memberDoc(state)))
+    )
+  ].filter((section) => section !== void 0).join(`
+
+`).trim();
+}
+function attributesSection(typePrefix, attributes) {
+  if (attributes.length !== 0)
+    return typeSection(
+      "Attributes",
+      `${typePrefix}Attributes`,
+      attributes.flatMap(({ attribute, field, type, doc }) => {
+        let suffix = field && field.name !== attribute.name ? ` // property: ${field.name}` : "";
+        return [
+          ...docComment(doc),
+          `  ${memberName(attribute.name)}?: ${type}${memberDefault(doc)};${suffix}`
+        ];
+      })
+    );
+}
+function propertiesSection(typePrefix, properties, typeProperty) {
+  if (properties.length !== 0)
+    return typeSection(
+      "Properties",
+      `${typePrefix}Properties`,
+      properties.flatMap((property) => {
+        let doc = memberDoc(property), type = fieldType(property, typeProperty);
+        return [
+          ...docComment(doc),
+          property.readonly === !0 ? `  readonly ${memberName(property.name)}: ${type}${memberDefault(doc)};` : `  ${memberName(property.name)}?: ${type}${memberDefault(doc)};`
+        ];
+      })
+    );
+}
+function eventsSection(typePrefix, events, typeProperty) {
+  if (events.length !== 0)
+    return typeSection(
+      "Events",
+      `${typePrefix}Events`,
+      events.flatMap((event) => [
+        ...docComment(memberDoc(event)),
+        `  ${memberName(event.name)}: ${readTypeText(event, typeProperty) ?? "Event"};`
+      ])
+    );
+}
+function methodsSection(typePrefix, methods, typeProperty) {
+  if (methods.length !== 0)
+    return typeSection(
+      "Methods",
+      `${typePrefix}Methods`,
+      methods.flatMap((method) => [
+        ...docComment(memberDoc(method)),
+        `  ${memberName(method.name)}(${formatParameters(method)}): ${methodReturnType(
+          method,
+          typeProperty
+        )};`
+      ])
+    );
+}
+function typeSection(heading, typeName, lines) {
+  return [`## ${heading}`, "", "```", `export type ${typeName} = {`, ...lines, "}", "```"].join(
+    `
+`
+  );
+}
+function listSection(heading, items) {
+  if (items.length !== 0)
+    return [`## ${heading}`, "", ...items].join(`
+`);
+}
+function cssPropertyListItem(property, typeProperty) {
+  let syntax = readCssPropertySyntax(property, typeProperty), name = property.name, syntaxText = syntax ? ` \`${syntax}\`` : "";
+  return listItemPrefix(`${name}${syntaxText}`, memberDoc(property));
+}
+function listItem(name, doc) {
+  return listItemPrefix(name, doc);
+}
+function listItemPrefix(prefix, doc) {
+  let text = doc.text ? `: ${doc.text}` : "", defaultText = doc.defaultValue === void 0 ? "" : ` Default: ${doc.defaultValue}.`, deprecatedText = doc.deprecated === void 0 ? "" : doc.deprecated === "deprecated" ? " Deprecated." : ` Deprecated: ${doc.deprecated}.`;
+  return `- ${prefix}${text}${defaultText}${deprecatedText}`;
+}
+function attributeDoc(attribute, typeProperty) {
+  let { field } = attribute;
+  return {
+    ...attribute,
+    type: attributeType(attribute, typeProperty),
+    doc: memberDoc(field, attribute.attribute)
+  };
+}
+function attributeType({ attribute, field }, typeProperty) {
+  return firstValue(
+    [field, attribute],
+    (source) => source ? trimmedOrUndefined(readTypeText(source, typeProperty)) : void 0
+  ) ?? "string";
+}
+function fieldType(field, typeProperty) {
+  return trimmedOrUndefined(readTypeText(field, typeProperty)) ?? "unknown";
+}
+function methodReturnType(method, typeProperty) {
+  return method.return ? readTypeText(method.return, typeProperty) ?? "void" : "void";
+}
+function memberDoc(...sources) {
+  return {
+    text: firstValue(
+      sources,
+      (source) => trimmedOrUndefined(source?.description) ?? trimmedOrUndefined(source?.summary)
+    ),
+    deprecated: firstValue(sources, (source) => deprecationMessage(source?.deprecated)),
+    defaultValue: firstValue(sources, (source) => defaultValue(source?.default))
+  };
+}
+function defaultValue(value) {
+  return value === void 0 || value === "undefined" ? void 0 : value.replace(/\s*\n\s*/g, " ").trim();
+}
+function memberDefault(doc) {
+  return doc.defaultValue === void 0 ? "" : ` = ${doc.defaultValue}`;
+}
+function docComment(doc) {
+  let body = doc.text ? commentLines(doc.text) : [], tags = [];
+  return doc.deprecated !== void 0 && tags.push(
+    ...commentLines(
+      doc.deprecated === "deprecated" ? "@deprecated" : `@deprecated ${doc.deprecated}`
+    )
+  ), tags.length > 0 && (body.length > 0 && body.push(""), body.push(...tags)), body.length === 0 ? [] : body.length === 1 ? [`  /** ${body[0]} */`] : ["  /**", ...body.map((line) => line ? `   * ${line}` : "   *"), "   */"];
+}
+function commentLines(text) {
+  return text.replace(/\*\//g, "*\\/").split(`
+`).map((line) => line.trimEnd());
+}
+function memberName(name) {
+  return IDENTIFIER.test(name) ? name : `'${name.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+
+// src/docgen/component-docgen/arg-types/parse-type-text.ts
+var ARRAY_RE = /^(?:Array<(.+)>|(.+)\[\])$/, DROPPED_MEMBERS = /* @__PURE__ */ new Set([
+  "undefined",
+  "null",
+  "void",
+  "any",
+  "unknown",
+  "never",
+  "string & {}",
+  "(string & {})"
+]), FUNCTION_RE = /^(new\s+)?(<.*>\s*)?\(.*\)\s*=>/, UNKNOWN_ARRAY_ELEMENT_TYPE = { name: "other", value: "" }, MAX_ARRAY_DEPTH = 8;
+function parseTypeText(text, depth = 0) {
+  let trimmed = text?.trim() ?? "", members = normalizeMembers(trimmed);
+  if (members.length === 0)
+    return;
+  let literalValues = members.map(parseLiteral).filter((literal) => literal !== void 0);
+  if (literalValues.length === members.length)
+    return { type: { name: "enum", value: literalValues } };
+  if (literalValues.length > 0 && members.includes("string"))
+    return { type: { name: "string" } };
+  if (literalValues.length > 0)
+    return {
+      type: { name: "other", value: members.join(" | ") },
+      ...members.some(isCallable) ? { control: !1 } : {}
+    };
+  let scalar = pickScalar(members);
+  if (scalar !== void 0)
+    return scalar;
+  if (members.length === 1) {
+    let member = stripWrappingParens(members[0]), array = ARRAY_RE.exec(member);
+    if (array) {
+      let element = depth >= MAX_ARRAY_DEPTH ? UNKNOWN_ARRAY_ELEMENT_TYPE : parseTypeText(stripWrappingParens(array[1] ?? array[2] ?? ""), depth + 1)?.type ?? UNKNOWN_ARRAY_ELEMENT_TYPE;
+      return element.name === "enum" ? {
+        type: { name: "array", value: element },
+        control: { type: "multi-select" },
+        options: element.value
+      } : { type: { name: "array", value: element } };
+    }
+    if (member === "Date")
+      return { type: { name: "date" }, control: { type: "date" } };
+    if (isBareObjectType(member))
+      return { type: { name: "object", value: {} } };
+    if (isBareArrayType(member))
+      return { type: { name: "array", value: UNKNOWN_ARRAY_ELEMENT_TYPE } };
+    if (isCallable(member))
+      return { type: { name: "function" } };
+    if (isObjectLike(member))
+      return { type: { name: "object", value: {} } };
+  }
+  return {
+    type: { name: "other", value: members.join(" | ") },
+    control: !1
+  };
+}
+function normalizeMembers(text) {
+  return text ? flattenMembers(text).filter((member) => member && !DROPPED_MEMBERS.has(member)) : [];
+}
+function flattenMembers(text) {
+  return splitTopLevel(text).flatMap((part) => {
+    let member = stripWrappingParens(part);
+    return splitTopLevel(member).length > 1 ? flattenMembers(member) : [member];
+  });
+}
+function parseLiteral(text) {
+  let stringLiteral = /^(['"])(.*)\1$/.exec(text);
+  if (stringLiteral)
+    return stringLiteral[2];
+  if (/^-?(?:\d+|\d*\.\d+)$/.test(text))
+    return Number(text);
+}
+function pickScalar(members) {
+  if (members.includes("string"))
+    return { type: { name: "string" } };
+  let hasBoolean = members.some(
+    (member) => member === "boolean" || member === "true" || member === "false"
+  ), hasNumber = members.some((member) => member === "number" || member === "bigint");
+  if (hasBoolean && hasNumber)
+    return { type: { name: "other", value: members.join(" | ") } };
+  if (hasBoolean)
+    return { type: { name: "boolean" } };
+  if (hasNumber)
+    return { type: { name: "number" } };
+}
+function isCallable(text) {
+  return text === "Function" || FUNCTION_RE.test(text) || /^\([^)]*\)\s*:/.test(text);
+}
+function isBareArrayType(text) {
+  return text.toLowerCase() === "array";
+}
+function isBareObjectType(text) {
+  return text.toLowerCase() === "object";
+}
+function isObjectLike(text) {
+  return /^\{.*\}$/.test(text) || /^\[.*\]$/.test(text) || text.includes("<");
+}
+function stripWrappingParens(text) {
+  let trimmed = text.trim();
+  if (!trimmed.startsWith("("))
+    return trimmed;
+  let depth = 0;
+  for (let index = 0; index < trimmed.length; index += 1) {
+    let char = trimmed[index];
+    if (char === "(")
+      depth += 1;
+    else if (char === ")" && (depth -= 1, depth === 0))
+      return index === trimmed.length - 1 ? trimmed.slice(1, -1).trim() : trimmed;
+  }
+  return trimmed;
+}
+function splitTopLevel(text) {
+  let members = [], current = "", depth = 0, hasTopLevelArrow = !1, quote;
+  for (let index = 0; index < text.length; index += 1) {
+    let char = text[index], previous = text[index - 1];
+    if (quote) {
+      current += char, char === quote && previous !== "\\" && (quote = void 0);
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char, current += char;
+      continue;
+    }
+    if (char === "=" && text[index + 1] === ">" && depth === 0 && (hasTopLevelArrow = !0), "<{[(".includes(char) ? depth += 1 : ">}])".includes(char) && !(char === ">" && previous === "=") && (depth = Math.max(0, depth - 1)), char === "|" && depth === 0 && !hasTopLevelArrow) {
+      members.push(current.trim()), current = "";
+      continue;
+    }
+    current += char;
+  }
+  return members.push(current.trim()), members;
+}
+
+// src/docgen/component-docgen/arg-types/map-arg-types.ts
+var NAMED_ENTRY_CATEGORIES = {
+  slots: "slots",
+  cssParts: "css shadow parts",
+  cssStates: "css states"
+};
+function mapArgTypes(declaration, typeProperty) {
+  let api = classifyDeclaration(declaration);
+  return {
+    ...Object.fromEntries([
+      ...api.events.flatMap((event) => eventEntries(event, typeProperty)),
+      ...api.methods.map(methodEntry),
+      ...api.slots.map((slot) => namedEntry(slot, "slots")),
+      ...api.cssParts.map((part) => namedEntry(part, "cssParts")),
+      ...api.cssStates.map((state) => namedEntry(state, "cssStates")),
+      ...api.cssProperties.map((property) => cssPropertyEntry(property, typeProperty))
+    ]),
+    ...mapAttributesAndProperties(api, typeProperty)
+  };
+}
+function mapAttributesAndProperties(api, typeProperty) {
+  let argTypes = {}, properties = api.fields.filter(
+    (field) => !api.attributes.some(({ attribute }) => attribute.name === field.name)
+  );
+  for (let field of properties) {
+    let attribute = api.attributes.find(({ field: backingField2 }) => backingField2 === field);
+    argTypes[field.name] = toArgType({
+      key: field.name,
+      category: "properties",
+      sources: attribute ? [field, attribute.attribute] : [field],
+      typeProperty
+    });
+  }
+  for (let { attribute, field } of api.attributes)
+    argTypes[attribute.name] = toArgType({
+      key: attribute.name,
+      category: "attributes",
+      sources: field ? [field, attribute] : [attribute],
+      typeProperty
+    });
+  return argTypes;
+}
+function toArgType({ key, category, sources, typeProperty }) {
+  let rawTypeText = firstValue(
+    sources,
+    (source) => typeof source.type?.text == "string" ? source.type.text : void 0
+  ), text = firstValue(
+    sources,
+    (source) => trimmedOrUndefined(readTypeText(source, typeProperty))
+  ), parsed = parseTypeText(text) ?? (category === "attributes" ? { type: { name: "string" } } : { type: { name: "other", value: text ?? "" }, control: !1 }), readonly = firstValue(
+    sources,
+    (source) => "readonly" in source && source.readonly === !0 ? !0 : void 0
+  );
+  return memberArgType(key, sources, category, {
+    ...parsed,
+    ...readonly ? { control: !1 } : {},
+    table: {
+      type: { summary: rawTypeText },
+      defaultValue: { summary: firstValue(sources, (source) => source.default) }
+    }
+  });
+}
+function eventEntries(event, typeProperty) {
+  let text = readTypeText(event, typeProperty) ?? "CustomEvent";
+  return [
+    [
+      toArgKey("events", event.name),
+      memberArgType(event.name, [event], "events", {
+        type: { name: "other", value: text },
+        control: !1,
+        table: { type: { summary: text } }
+      })
+    ]
+  ];
+}
+function methodEntry(method) {
+  return [
+    toArgKey("methods", method.name),
+    memberArgType(method.name, [method], "methods", {
+      type: { name: "function" },
+      table: { type: { summary: methodSignature(method) } }
+    })
+  ];
+}
+function namedEntry(item, category) {
+  let name = item.name || DEFAULT_SLOT_NAME;
+  return [
+    toArgKey(category, name),
+    memberArgType(name, [item], NAMED_ENTRY_CATEGORIES[category], { type: { name: "string" } })
+  ];
+}
+function cssPropertyEntry(property, typeProperty) {
+  let syntax = readCssPropertySyntax(property, typeProperty);
+  return [
+    toArgKey("cssProperties", property.name),
+    memberArgType(property.name, [property], "css custom properties", {
+      ...cssCustomPropertyControl(syntax),
+      table: {
+        type: { summary: syntax },
+        defaultValue: { summary: property.default }
+      }
+    })
+  ];
+}
+function memberArgType(name, sources, category, rest) {
+  let { table, ...input } = rest, { deprecated, ...fields } = docFields(sources);
+  return {
+    name,
+    ...fields,
+    ...input,
+    table: {
+      ...table,
+      category,
+      ...deprecated ? { jsDocTags: { deprecated } } : {}
+    }
+  };
+}
+function docFields(sources) {
+  return {
+    description: firstValue(
+      sources,
+      (source) => trimmedOrUndefined(source.summary ?? source.description)
+    ),
+    deprecated: firstValue(sources, (source) => deprecationMessage(source.deprecated))
+  };
+}
+function methodSignature(method) {
+  let params = formatParameters(method), returnType = method.return?.type?.text;
+  return returnType ? `(${params}) => ${returnType}` : `(${params})`;
+}
+function cssCustomPropertyControl(syntax) {
+  let lowerSyntax = syntax?.toLowerCase();
+  return lowerSyntax === "<color>" ? { type: { name: "string" }, control: { type: "color" } } : lowerSyntax === "<number>" || lowerSyntax === "<integer>" ? { type: { name: "number" } } : { type: { name: "string" } };
+}
+
+// src/docgen/component-docgen/resolve-component/resolve-component.ts
+import { loadCsf, unwrapExpression } from "storybook/internal/csf-tools";
+import { recast, types as t } from "storybook/internal/babel";
+import { readFileSync } from "node:fs";
+function parseStoryFile(storyFilePath, title) {
+  try {
+    let source = readFileSync(storyFilePath, "utf8");
+    return loadCsf(source, { makeTitle: () => title }).parse();
+  } catch {
+    return;
+  }
+}
+var expressionFor = (node) => recast.print(node).code;
+function tagFromNode(node) {
+  let expression = expressionFor(node), unwrapped = unwrapExpression(node);
+  if (t.isStringLiteral(unwrapped) && unwrapped.value !== "")
+    return { tag: unwrapped.value };
+  if (t.isTemplateLiteral(unwrapped) && unwrapped.expressions.length === 0) {
+    let tag = unwrapped.quasis[0]?.value.cooked;
+    if (tag)
+      return { tag };
+  }
+  return { reason: "component-not-a-tag", expression };
+}
+function resolveStoryComponent(csf) {
+  let component = csf._metaAnnotations.component;
+  return component ? tagFromNode(component) : { reason: "no-meta-component" };
+}
+
+// src/docgen/component-docgen/build-docgen.ts
+function buildDocgenPayload(input, context) {
+  let storyImportPath = getStoryImportPathFromEntry(input.entry);
+  if (!storyImportPath)
+    return;
+  let id = getComponentIdFromEntry(input.entry), path = storyImportPath, fail = (name, error) => ({
+    id,
+    name,
+    path,
+    jsDocTags: {},
+    error
+  }), storyFilePath = resolve(process.cwd(), storyImportPath), csf = parseStoryFile(storyFilePath, input.entry.title);
+  if (!csf)
+    return;
+  let resolved = resolveStoryComponent(csf);
+  if ("reason" in resolved) {
+    if (resolved.reason === "no-meta-component")
+      return;
+    let componentName = input.entry.title.slice(input.entry.title.lastIndexOf("/") + 1);
+    return fail(componentName, {
+      name: "component-not-a-tag",
+      message: `\`meta.component\` must be the element's tag name as a string, got \`${resolved.expression}\``
+    });
+  }
+  let { tag } = resolved, found = context.cem.tags.get(tag);
+  if (!found)
+    return fail(
+      tag,
+      context.cem.errors[0] ?? {
+        name: "tag-not-found",
+        message: `No declaration for "${tag}" was found in ${context.cem.paths.join(", ")}. If the element is new, rerun the custom elements manifest analyzer.`
+      }
+    );
+  let { description, summary, jsDocTags } = extractComponentDescription(
+    extractDescription(csf._metaStatement) || void 0,
+    found.declaration.description,
+    declarationTags(found.declaration)
+  );
+  return {
+    id,
+    name: tag,
+    path,
+    description,
+    summary,
+    jsDocTags,
+    argTypes: mapArgTypes(found.declaration, context.typeProperty),
+    apiDescription: buildApiDescription(found.declaration, context.typeProperty),
+    renderer: "web-components",
+    ...found.warning ? { warning: found.warning } : {},
+    customElementsManifest: {
+      manifestPath: found.manifestPath,
+      declaration: found.declaration
+    }
+  };
+}
+function declarationTags(declaration) {
+  let tags = {}, summary = trimmedOrUndefined(declaration.summary);
+  summary && (tags.summary = [summary]);
+  let deprecated = deprecationMessage(declaration.deprecated);
+  return deprecated && (tags.deprecated = [deprecated]), tags;
+}
+
+// src/docgen/component-docgen/manifest/cem-manager.ts
+import { logger } from "storybook/internal/node-logger";
+import { stat } from "node:fs/promises";
+import { relative as relative2 } from "node:path";
+
+// src/docgen/component-docgen/manifest/build-tag-index.ts
+function buildTagIndex(manifest) {
+  let tags = /* @__PURE__ */ new Map();
+  for (let module of manifest.modules)
+    if (!(!isRecord(module) || !Array.isArray(module.declarations)))
+      for (let declaration of module.declarations)
+        isManifestDeclaration(declaration) && declaration.tagName && !tags.has(declaration.tagName) && tags.set(declaration.tagName, declaration);
+  for (let module of manifest.modules)
+    if (!(!isRecord(module) || !Array.isArray(module.exports)))
+      for (let definition of module.exports) {
+        if (!isRecord(definition) || definition.kind !== "custom-element-definition" || typeof definition.name != "string" || tags.has(definition.name) || !isRecord(definition.declaration) || typeof definition.declaration.name != "string")
+          continue;
+        let modulePath = typeof definition.declaration.module == "string" ? definition.declaration.module : typeof module.path == "string" ? module.path : void 0;
+        if (modulePath === void 0)
+          continue;
+        let declaration = findDeclarationByName(manifest, definition.declaration.name, modulePath);
+        declaration && tags.set(definition.name, declaration);
+      }
+  return tags;
+}
+function findDeclarationByName(manifest, name, modulePath) {
+  for (let module of manifest.modules) {
+    if (!isRecord(module) || !Array.isArray(module.declarations) || module.path !== modulePath)
+      continue;
+    let declaration = module.declarations?.find(
+      (candidate) => isManifestDeclaration(candidate) && candidate.name === name
+    );
+    if (declaration)
+      return declaration;
+  }
+}
+function isManifestDeclaration(candidate) {
+  return isRecord(candidate) && (candidate.kind === "class" || candidate.kind === "mixin") && "customElement" in candidate && candidate.customElement === !0;
+}
+
+// src/docgen/component-docgen/manifest/flatten-inheritance.ts
+var INHERITED_FIELDS = [
+  "description",
+  "summary",
+  "deprecated",
+  "default",
+  "type",
+  "attribute",
+  "fieldName"
+], LIST_KEYS = [
+  "members",
+  "attributes",
+  "events",
+  "slots",
+  "cssParts",
+  "cssProperties",
+  "cssStates"
+];
+function flattenInheritance(manifest) {
+  let index = indexDeclarations(manifest), flatten = createInheritanceResolver(index);
+  return {
+    ...manifest,
+    modules: manifest.modules.map((module) => flattenModule(module, index, flatten))
+  };
+}
+function indexDeclarations(manifest) {
+  let byKey = /* @__PURE__ */ new Map();
+  for (let module of manifest.modules) {
+    if (!isRecord(module) || !Array.isArray(module.declarations))
+      continue;
+    let modulePath = modulePathOf(module);
+    for (let declaration of module.declarations) {
+      if (!isManifestClassLike(declaration))
+        continue;
+      let key = keyFor(modulePath, declaration.name);
+      byKey.has(key) || byKey.set(key, { declaration, modulePath, references: referencesOf(declaration) });
+    }
+  }
+  return (modulePath, name) => byKey.get(keyFor(modulePath, name));
+}
+function isManifestClassLike(candidate) {
+  return isRecord(candidate) && (candidate.kind === "class" || candidate.kind === "mixin") && typeof candidate.name == "string";
+}
+function referencesOf(declaration) {
+  return [
+    ...Array.isArray(declaration.mixins) ? declaration.mixins : [],
+    declaration.superclass
+  ].filter(isReference);
+}
+function isReference(candidate) {
+  return isRecord(candidate) && typeof candidate.name == "string" && (candidate.module === void 0 || typeof candidate.module == "string") && (candidate.package === void 0 || typeof candidate.package == "string");
+}
+function createInheritanceResolver(index) {
+  let flattened = /* @__PURE__ */ new Map();
+  function flatten(entry) {
+    let cached = flattened.get(entry.declaration);
+    if (cached !== void 0)
+      return cached;
+    flattened.set(entry.declaration, entry.declaration);
+    let parents = entry.references.flatMap((reference) => {
+      let parent = resolveReference(reference, index, entry.modulePath);
+      return parent ? [
+        {
+          declaration: flatten(parent),
+          from: {
+            name: parent.declaration.name,
+            ...parent.modulePath ? { module: parent.modulePath } : {}
+          }
+        }
+      ] : [];
+    }), merged = mergeInherited(entry.declaration, parents);
+    return flattened.set(entry.declaration, merged), merged;
+  }
+  return flatten;
+}
+function flattenModule(module, index, flatten) {
+  if (!isRecord(module) || !Array.isArray(module.declarations))
+    return module;
+  let modulePath = modulePathOf(module), declarations = module.declarations.map((declaration) => {
+    if (!isManifestClassLike(declaration))
+      return declaration;
+    let entry = index(modulePath, declaration.name);
+    return entry?.declaration === declaration ? flatten(entry) : declaration;
+  });
+  return { ...module, declarations };
+}
+function mergeInherited(declaration, parents) {
+  let lists = {};
+  for (let key of LIST_KEYS) {
+    let own = namedItems(listOf(declaration, key)), items = /* @__PURE__ */ new Map();
+    for (let item of own) {
+      let existing = items.get(item.name);
+      (!existing || existing.inheritedFrom && !item.inheritedFrom) && items.set(item.name, item);
+    }
+    for (let parent of parents)
+      for (let item of namedItems(listOf(parent.declaration, key))) {
+        let existing = items.get(item.name);
+        existing ? existing.inheritedFrom || items.set(item.name, mergeOverride(existing, item)) : items.set(item.name, { ...item, inheritedFrom: item.inheritedFrom ?? parent.from });
+      }
+    items.size > 0 && (lists[key] = [...items.values()]);
+  }
+  return { ...declaration, ...lists };
+}
+function mergeOverride(own, inherited) {
+  let merged = { ...own };
+  for (let field of INHERITED_FIELDS)
+    !(field in merged) && field in inherited && (merged[field] = inherited[field]);
+  return merged;
+}
+function listOf(declaration, key) {
+  let list = declaration[key];
+  return Array.isArray(list) ? list : void 0;
+}
+function resolveReference(reference, index, modulePath) {
+  if (reference.module !== void 0)
+    return index(reference.module, reference.name);
+  if (reference.package === void 0)
+    return index(modulePath, reference.name);
+}
+function keyFor(modulePath, name) {
+  return `${modulePath.replace(/^\.?\//, "")}#${name}`;
+}
+function modulePathOf(module) {
+  return typeof module.path == "string" ? module.path : "";
+}
+
+// src/docgen/component-docgen/manifest/load-manifest.ts
+import { readFile } from "node:fs/promises";
+import { relative } from "node:path";
+var isFailedManifest = (result) => "error" in result, isCustomElementsManifest = (value) => isRecord(value) && Array.isArray(value.modules), unsupportedMessage = (path) => `${path} uses the web-component-analyzer manifest shape. The Storybook docgen server reads Custom Elements Manifests only; generate one with @custom-elements-manifest/analyzer.`, invalidMessage = (path, detail) => detail ? `Invalid Custom Elements Manifest at ${path}: ${detail}` : `Invalid Custom Elements Manifest at ${path}: expected a top-level modules array.`;
+function classifyManifest(path, parsed) {
+  return isRecord(parsed) ? isCustomElementsManifest(parsed) ? { path, manifest: parsed } : parsed.version === "experimental" || Array.isArray(parsed.tags) ? { path, error: { name: "manifest-unsupported", message: unsupportedMessage(path) } } : { path, error: { name: "manifest-invalid", message: invalidMessage(path) } } : { path, error: { name: "manifest-invalid", message: invalidMessage(path) } };
+}
+async function loadManifest(absolutePath) {
+  let path = relative(process.cwd(), absolutePath);
+  try {
+    return classifyManifest(path, JSON.parse(await readFile(absolutePath, "utf8")));
+  } catch (error) {
+    return {
+      path,
+      error: {
+        name: "manifest-invalid",
+        message: invalidMessage(path, errorMessage(error))
+      }
+    };
+  }
+}
+
+// src/docgen/component-docgen/manifest/cem-manager.ts
+var CemManager = class {
+  constructor(absolutePaths) {
+    this.states = absolutePaths.map((absolutePath) => ({
+      absolutePath,
+      path: relative2(process.cwd(), absolutePath)
+    }));
+  }
+  refresh() {
+    return this.current ? (this.next ??= this.current.then(
+      () => (this.next = void 0, this.refresh()),
+      () => (this.next = void 0, this.refresh())
+    ), this.next) : (this.current = this.refreshStates().finally(() => {
+      this.current = void 0;
+    }), this.current);
+  }
+  async refreshStates() {
+    return this.states = await Promise.all(this.states.map((state) => this.refreshState(state))), buildSnapshot(this.states);
+  }
+  async refreshState(state) {
+    try {
+      let stats = await stat(state.absolutePath);
+      return state.mtimeMs === stats.mtimeMs ? state : await this.loadChangedManifest(state, stats.mtimeMs);
+    } catch (error) {
+      if (isNotFound(error)) {
+        let notFound = missingManifestError(state.path), nextState = {
+          ...state,
+          mtimeMs: void 0,
+          entry: void 0,
+          error: notFound
+        };
+        return this.warnOnce(nextState, notFound.message), nextState;
+      }
+      return this.failedState(state, failureFromError(state.path, error), void 0);
+    }
+  }
+  async loadChangedManifest(state, mtimeMs) {
+    let loaded = await loadManifest(state.absolutePath);
+    if (isFailedManifest(loaded))
+      return this.failedState(state, loaded.error, mtimeMs);
+    let entry = {
+      path: loaded.path,
+      tags: buildTagIndex(flattenInheritance(loaded.manifest))
+    }, nextState = {
+      ...state,
+      mtimeMs,
+      entry,
+      error: void 0,
+      lastWarning: void 0
+    };
+    return logger.debug(`Loaded Custom Elements Manifest ${loaded.path}`), nextState;
+  }
+  failedState(state, error, mtimeMs) {
+    let nextState = {
+      ...state,
+      mtimeMs,
+      error
+    };
+    return this.warnOnce(nextState, state.entry ? staleWarning(error) : error.message), nextState;
+  }
+  warnOnce(state, message) {
+    state.lastWarning !== message && (state.lastWarning = message, logger.warn(message));
+  }
+};
+function buildSnapshot(states) {
+  let tags = /* @__PURE__ */ new Map(), errors = [], paths = states.map(({ path }) => path);
+  for (let state of states) {
+    if (state.entry) {
+      let warning = state.error ? staleWarning(state.error) : void 0;
+      for (let [tag, declaration] of state.entry.tags)
+        tags.has(tag) || tags.set(tag, {
+          declaration,
+          manifestPath: state.entry.path,
+          ...warning ? { warning } : {}
+        });
+      continue;
+    }
+    state.error && errors.push(state.error);
+  }
+  return {
+    tags,
+    errors,
+    paths
+  };
+}
+function failureFromError(path, error) {
+  return {
+    name: "manifest-invalid",
+    message: `Invalid Custom Elements Manifest at ${path}: ${errorMessage(error)}`
+  };
+}
+function isNotFound(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function missingManifestError(path) {
+  return {
+    name: "manifest-not-found",
+    message: `Custom Elements Manifest ${path} not found yet; docs load once the analyzer writes it`
+  };
+}
+function staleWarning(error) {
+  return `${error.message}; using the last valid version`;
+}
+
+// src/docgen/docgen-worker.ts
+var createDocgenProvider = ({
+  manifestPaths,
+  typeProperty
+}) => createLazyDocgenMiddleware({
+  createManager: async () => {
+    if (manifestPaths.length === 0) {
+      logger2.warn(
+        "No Custom Elements Manifest was configured; web-components server docgen is skipped. Set the `customElementsManifest` framework option or `customElements` in package.json."
+      );
+      return;
+    }
+    return new CemManager(manifestPaths);
+  },
+  extract: async (manager, input) => buildDocgenPayload(input, {
+    cem: await manager.refresh(),
+    typeProperty
+  })
+});
+
+export {
+  buildDocgenPayload,
+  createDocgenProvider
+};