@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

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

@@ -0,0 +1,2700 @@
+import CJS_COMPAT_NODE_URL_ro17f80mg6k from 'node:url';
+import CJS_COMPAT_NODE_PATH_ro17f80mg6k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_ro17f80mg6k from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_ro17f80mg6k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_ro17f80mg6k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_ro17f80mg6k.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  Tag
+} from "./chunk-SVTBJ7Q3.js";
+import {
+  jsTsSourceExtensions
+} from "./chunk-TNJIXE37.js";
+
+// src/common/utils/module-resolver.ts
+import { ResolverFactory } from "oxc-resolver";
+var defaultResolveConditionNames = ["storybook", "import", "module", "default"];
+function createModuleResolver(options = {}) {
+  let factory = new ResolverFactory({
+    ...options,
+    conditionNames: options.conditionNames ?? defaultResolveConditionNames
+  }), unwrap = (result, specifier, from) => {
+    if (result.path)
+      return result.path;
+    throw new Error(result.error ?? `Cannot resolve module '${specifier}' from '${from}'`);
+  };
+  return {
+    resolveFileSync: (fromFile, specifier) => unwrap(factory.resolveFileSync(fromFile, specifier), specifier, fromFile),
+    resolveSync: (fromDirectory, specifier) => unwrap(factory.sync(fromDirectory, specifier), specifier, fromDirectory)
+  };
+}
+
+// src/csf-tools/story-shape/imports.ts
+import { types as t } from "@aussieljk/forkbook/internal/babel";
+var isTypeSpecifier = (s) => t.isImportSpecifier(s) && s.importKind === "type", importedName = (im) => t.isIdentifier(im) ? im.name : im.value;
+function collectImportBindings(program) {
+  let localToImport = /* @__PURE__ */ new Map();
+  for (let stmt of program.get("body")) {
+    if (!stmt.isImportDeclaration())
+      continue;
+    let decl = stmt.node;
+    if (decl.importKind !== "type")
+      for (let s of decl.specifiers ?? []) {
+        if (!("local" in s) || !s.local || isTypeSpecifier(s))
+          continue;
+        let importId = decl.source.value;
+        t.isImportDefaultSpecifier(s) ? localToImport.set(s.local.name, { importId, importName: "default" }) : t.isImportNamespaceSpecifier(s) ? localToImport.set(s.local.name, { importId, importName: "*" }) : t.isImportSpecifier(s) && localToImport.set(s.local.name, { importId, importName: importedName(s.imported) });
+      }
+  }
+  return localToImport;
+}
+
+// src/csf-tools/story-shape/import-statements.ts
+import { babelParse, babelPrint, types as t2 } from "@aussieljk/forkbook/internal/babel";
+function resolveComponentImport(componentName, bindings) {
+  let dot = componentName.indexOf("."), base = dot === -1 ? componentName : componentName.slice(0, dot), member = dot === -1 ? void 0 : componentName.slice(dot + 1), binding = bindings.get(base);
+  if (!binding)
+    return { componentName, ...member ? { member } : {} };
+  let isNamespace = binding.importName === "*";
+  return {
+    componentName,
+    ...member ? { member } : {},
+    localImportName: base,
+    importId: binding.importId,
+    importName: isNamespace && member ? member : binding.importName,
+    ...isNamespace ? { namespace: base } : {}
+  };
+}
+function parseImportOverride(code) {
+  let declaration;
+  try {
+    declaration = babelParse(code).program.body.find(
+      (node) => t2.isImportDeclaration(node)
+    );
+  } catch {
+    return;
+  }
+  if (!declaration)
+    return;
+  let source = declaration.source.value, specifier = (declaration.specifiers ?? []).find((s) => !isTypeSpecifier(s));
+  return t2.isImportNamespaceSpecifier(specifier) ? { source, specifier: { kind: "namespace", local: specifier.local.name } } : t2.isImportDefaultSpecifier(specifier) ? { source, specifier: { kind: "default" } } : t2.isImportSpecifier(specifier) ? { source, specifier: { kind: "named", imported: importedName(specifier.imported) } } : { source };
+}
+function addUniqueBy(list, item, eq) {
+  list.find(eq) || list.push(item);
+}
+function addNamed(bucket, local, imported) {
+  addUniqueBy(
+    bucket.named,
+    t2.importSpecifier(t2.identifier(local), t2.identifier(imported)),
+    (n) => n.local.name === local && importedName(n.imported) === imported
+  );
+}
+function addSingle(list, name) {
+  addUniqueBy(list, t2.identifier(name), (n) => n.name === name);
+}
+function collectSpecifier(bucket, ref, source, override) {
+  let rewritten = source !== ref.importId;
+  if (override?.specifier) {
+    let { specifier } = override;
+    if (specifier.kind === "namespace") {
+      addSingle(bucket.namespaces, specifier.local);
+      return;
+    }
+    if (!ref.localImportName)
+      return;
+    specifier.kind === "default" ? addSingle(bucket.defaults, ref.localImportName) : addNamed(bucket, ref.localImportName, specifier.imported);
+    return;
+  }
+  if (ref.namespace) {
+    let member = rewritten ? ref.importName : void 0;
+    member && member !== "*" && !member.includes(".") ? addNamed(bucket, member, member) : addSingle(bucket.namespaces, ref.namespace);
+    return;
+  }
+  if (ref.localImportName) {
+    if (ref.importName === "default") {
+      rewritten ? addNamed(bucket, ref.localImportName, ref.localImportName) : addSingle(bucket.defaults, ref.localImportName);
+      return;
+    }
+    ref.importName && addNamed(bucket, ref.localImportName, ref.importName);
+  }
+}
+function printBucket({ source, defaults, namespaces, named }) {
+  let print = (specifiers) => babelPrint(t2.importDeclaration(specifiers, source)), extraDefaults = defaults.slice(1).map((d) => print([t2.importDefaultSpecifier(d)]));
+  if (namespaces.length > 0) {
+    let first2 = [];
+    return defaults[0] && first2.push(t2.importDefaultSpecifier(defaults[0])), first2.push(t2.importNamespaceSpecifier(namespaces[0])), [
+      print(first2),
+      ...named.length > 0 ? [print(named)] : [],
+      ...extraDefaults,
+      ...namespaces.slice(1).map((ns) => print([t2.importNamespaceSpecifier(ns)]))
+    ];
+  }
+  if (defaults.length === 0 && named.length === 0)
+    return [];
+  let first = [];
+  return defaults[0] && first.push(t2.importDefaultSpecifier(defaults[0])), first.push(...named), [print(first), ...extraDefaults];
+}
+function buildImportStatements({
+  refs,
+  packageName
+}) {
+  let buckets = /* @__PURE__ */ new Map();
+  return refs.forEach((ref) => {
+    if (!ref.importId)
+      return;
+    let override = ref.importOverride ? parseImportOverride(ref.importOverride) : void 0, source = override?.source ?? (packageName && !ref.isPackage ? packageName : ref.importId), bucket = buckets.get(source);
+    bucket || (bucket = { source: t2.stringLiteral(source), defaults: [], namespaces: [], named: [] }, buckets.set(source, bucket)), collectSpecifier(bucket, ref, source, override);
+  }), Array.from(buckets.values()).flatMap(printBucket);
+}
+
+// src/csf-tools/story-shape/utils.ts
+import { types as t3 } from "@aussieljk/forkbook/internal/babel";
+var unwrapExpression = (node) => t3.isTSAsExpression(node) || t3.isTSSatisfiesExpression(node) || t3.isTSNonNullExpression(node) || t3.isTSTypeAssertion(node) || t3.isParenthesizedExpression(node) ? unwrapExpression(node.expression) : node, isCanonicalCsf2BindCall = (node) => t3.isCallExpression(node) && t3.isMemberExpression(node.callee) && !node.callee.computed && t3.isIdentifier(node.callee.object) && t3.isIdentifier(node.callee.property, { name: "bind" }) && (node.arguments.length === 0 || node.arguments.length === 1 && t3.isObjectExpression(node.arguments[0]) && node.arguments[0].properties.length === 0), withoutTypeCalls = (object) => t3.isCallExpression(object) && object.arguments.length === 0 && t3.isMemberExpression(object.callee) && !object.callee.computed && t3.isIdentifier(object.callee.property, { name: "type" }) ? withoutTypeCalls(object.callee.object) : object, isCsfFactoryCall = (node) => t3.isCallExpression(node) && t3.isMemberExpression(node.callee) && !node.callee.computed && t3.isIdentifier(withoutTypeCalls(node.callee.object)) && t3.isIdentifier(node.callee.property) && (node.callee.property.name === "story" || node.callee.property.name === "extend"), csfFactoryReceiver = (node) => withoutTypeCalls(node.callee.object), templateParts = (node) => {
+  if (t3.isTemplateLiteral(node))
+    return {
+      quasis: node.quasis.map((quasi) => quasi.value.cooked ?? ""),
+      expressions: node.expressions
+    };
+  if (!(!t3.isTaggedTemplateExpression(node) || !isStringRawTag(node.tag)))
+    return {
+      quasis: node.quasi.quasis.map((quasi) => quasi.value.raw),
+      expressions: node.quasi.expressions
+    };
+}, isStringRawTag = (tag) => t3.isMemberExpression(tag) && !tag.computed && t3.isIdentifier(tag.object, { name: "String" }) && t3.isIdentifier(tag.property, { name: "raw" }), keyOf = (p) => t3.isStringLiteral(p.key) ? p.key.value : !p.computed && t3.isIdentifier(p.key) ? p.key.name : null, propertyValue = (object, name) => object?.properties.find(
+  (candidate) => t3.isObjectProperty(candidate) && keyOf(candidate) === name
+)?.value, soleReturnedExpression = (body) => {
+  let [statement, ...rest] = body.body;
+  return rest.length === 0 && t3.isReturnStatement(statement) && t3.isExpression(statement.argument) ? statement.argument : void 0;
+}, returnedExpression = (fn) => {
+  if (t3.isFunction(fn))
+    return t3.isExpression(fn.body) ? fn.body : soleReturnedExpression(fn.body);
+}, returnedExpressionPath = (renderFunction) => {
+  if (!returnedExpression(renderFunction.node))
+    return;
+  let body = renderFunction.get("body");
+  if (body.isExpression())
+    return body;
+  let [statement] = body.isBlockStatement() ? body.get("body") : [], argument = statement?.isReturnStatement() ? statement.get("argument") : void 0;
+  return argument?.isExpression() ? argument : void 0;
+}, resolveReturnedObjectExpression = (renderFunction) => {
+  let returned = returnedExpressionPath(renderFunction);
+  if (returned?.isObjectExpression())
+    return returned.node;
+  if (!returned?.isIdentifier())
+    return;
+  let resolved = resolveIdentifierInit(renderFunction, returned);
+  return resolved?.isObjectExpression() ? resolved.node : void 0;
+};
+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;
+}
+
+// src/csf-tools/story-shape/resolve-members.ts
+import { generate, types as t4 } from "@aussieljk/forkbook/internal/babel";
+var sourceOf = (node) => generate(node, { concise: !0, comments: !1 }).code, complete = (properties = {}) => ({
+  properties,
+  shadowed: [],
+  unresolved: []
+}), resolveObjectMembers = (object, ctx) => membersOf(object, ctx, /* @__PURE__ */ new Set()), resolveArgsRecord = (node, ctx) => {
+  if (node === void 0)
+    return complete();
+  let unwrapped = unwrapExpression(node);
+  if (t4.isObjectExpression(unwrapped))
+    return asArgsRecord(membersOf(unwrapped, ctx, /* @__PURE__ */ new Set()));
+  let referenced = resolveReference(ctx, unwrapped, node.start ?? void 0, /* @__PURE__ */ new Set());
+  return referenced ? asArgsRecord(referenced) : { properties: {}, shadowed: [], unresolved: [`args: ${sourceOf(unwrapped)}`] };
+}, asArgsRecord = (members) => {
+  let methods = Object.entries(members.properties).filter(([, node]) => t4.isObjectMethod(node));
+  if (methods.length === 0)
+    return members;
+  let properties = { ...members.properties }, unresolved = [...members.unresolved];
+  for (let [key, node] of methods)
+    delete properties[key], unresolved.push(sourceOf(node));
+  return {
+    properties,
+    shadowed: members.shadowed.filter((key) => key in properties),
+    unresolved
+  };
+}, resolveBindingMembers = (ctx, name) => {
+  let bound = bindingMembers(ctx, name, void 0, /* @__PURE__ */ new Set());
+  return bound === void 0 || bound.kind === "namespace" ? void 0 : bound.members;
+}, resolveReferencedValue = (ctx, expression) => {
+  let chain = memberChain(expression);
+  if (!chain || chain.path.length === 0)
+    return;
+  let visited = /* @__PURE__ */ new Set(), located = locate(ctx, chain, void 0, visited);
+  if (!located || located.path.length === 0)
+    return;
+  let members = located.members, scope = located.ctx;
+  for (let [index, key] of located.path.entries()) {
+    if (members.shadowed.includes(key))
+      return;
+    let value = members.properties[key];
+    if (value === void 0)
+      return;
+    if (index === located.path.length - 1)
+      return { node: value, ctx: scope };
+    let unwrapped = unwrapExpression(value);
+    if (!t4.isObjectExpression(unwrapped))
+      return;
+    members = membersOf(unwrapped, scope, visited);
+  }
+}, 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 (t4.isSpreadElement(property)) {
+      let spread = spreadMembers(ctx, property, visited);
+      if (spread === void 0 || spread.unresolved.length > 0) {
+        shadowKnownMembers(sourceOf(property));
+        continue;
+      }
+      for (let [key2, value] of Object.entries(spread.properties))
+        properties[key2] = value, shadowed.delete(key2);
+      continue;
+    }
+    let key = keyOf(property);
+    if (key === null) {
+      shadowKnownMembers(sourceOf(property));
+      continue;
+    }
+    if (t4.isObjectMethod(property) && (property.kind !== "method" || property.generator)) {
+      delete properties[key], shadowed.delete(key), unresolved.push(sourceOf(property));
+      continue;
+    }
+    properties[key] = t4.isObjectMethod(property) ? property : property.value, shadowed.delete(key);
+  }
+  return { properties, shadowed: [...shadowed], unresolved };
+}, spreadMembers = (ctx, spread, visited) => {
+  let argument = unwrapExpression(spread.argument);
+  return t4.isObjectExpression(argument) ? membersOf(argument, ctx, visited) : resolveReference(ctx, argument, spread.start ?? void 0, visited);
+}, memberChain = (node) => {
+  let path = [], current = unwrapExpression(node);
+  for (; t4.isMemberExpression(current); ) {
+    let key = t4.isIdentifier(current.property) && !current.computed ? current.property.name : t4.isStringLiteral(current.property) ? current.property.value : void 0;
+    if (key === void 0)
+      return;
+    path.unshift(key), current = unwrapExpression(current.object);
+  }
+  return t4.isIdentifier(current) ? { root: current.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 = unwrapExpression(value);
+    if (!t4.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 rootName = localAliasRoot(ctx, name), rootBinding = ctx.program.scope.getBinding(rootName), declared = declaredBindingMembers(
+    ctx,
+    rootBinding?.path.node ?? binding.path.node,
+    position,
+    visited
+  );
+  if (declared === void 0)
+    return;
+  let assigned = assignedMembers(ctx, localAliases(ctx, rootName), 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 (t4.isFunctionDeclaration(node))
+    return { members: complete() };
+  if (t4.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 = unwrapExpression(init);
+  if (t4.isObjectExpression(unwrapped))
+    return { members: membersOf(unwrapped, ctx, visited) };
+  let factory = factoryCall(unwrapped);
+  if (factory === void 0 && (t4.isFunction(unwrapped) || isCanonicalCsf2BindCall(unwrapped)))
+    return { members: complete() };
+  if (t4.isIdentifier(unwrapped)) {
+    let referenced = bindingMembers(ctx, unwrapped.name, position, visited);
+    if (referenced?.kind === "members") {
+      let members = referenced.external ? ctx.externalize && externalized(referenced.members, referenced.ctx) : referenced.members;
+      if (members)
+        return { members, ...referenced.accessor ? { accessor: referenced.accessor } : {} };
+    }
+  }
+  if (factory === void 0)
+    return {
+      members: { properties: {}, shadowed: [], unresolved: [sourceOf(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"], localAliasRoot = (ctx, name) => {
+  let visited = /* @__PURE__ */ new Set(), current = name;
+  for (; !visited.has(current); ) {
+    visited.add(current);
+    let binding = ctx.program.scope.getBinding(current), node = binding?.path.node;
+    if (!binding?.constant || !t4.isVariableDeclarator(node) || !node.init)
+      break;
+    let init = unwrapExpression(node.init);
+    if (!t4.isIdentifier(init))
+      break;
+    let target = ctx.program.scope.getBinding(init.name);
+    if (!target?.constant || target.kind === "module")
+      break;
+    current = init.name;
+  }
+  return current;
+}, localAliases = (ctx, root) => {
+  let aliases = /* @__PURE__ */ new Map([[root, Number.NEGATIVE_INFINITY]]);
+  for (let [name, binding] of Object.entries(ctx.program.scope.bindings))
+    name !== root && binding.constant && localAliasRoot(ctx, name) === root && aliases.set(name, binding.path.node.start ?? Number.POSITIVE_INFINITY);
+  return aliases;
+}, 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 || !t4.isExpression(from) || !t4.isExpression(over) || (properties[key] = t4.objectExpression([t4.spreadElement(from), t4.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 && unwrapExpression(argument);
+  if (!(argument !== void 0 && (config === void 0 || !t4.isObjectExpression(config))))
+    return {
+      method,
+      parent: csfFactoryReceiver(node).name,
+      ...config && t4.isObjectExpression(config) ? { config } : {}
+    };
+}, assignedMembers = (ctx, aliases, position) => {
+  let properties = {}, unresolved = [];
+  for (let statement of ctx.program.node.body) {
+    if (!t4.isExpressionStatement(statement) || !t4.isAssignmentExpression(statement.expression))
+      continue;
+    let assignment = statement.expression, target = assignment.left, depth = 0, outermost;
+    for (; t4.isMemberExpression(target); )
+      depth += 1, outermost = t4.isIdentifier(target.property) && !target.computed ? target.property.name : t4.isStringLiteral(target.property) ? target.property.value : void 0, target = target.object;
+    if (!(depth === 0 || !t4.isIdentifier(target) || !aliases.has(target.name)) && !((assignment.start ?? 0) < aliases.get(target.name)) && !(position !== void 0 && (assignment.start ?? 0) > position)) {
+      if (depth > 1 || outermost === void 0 || assignment.operator !== "=") {
+        unresolved.push(sourceOf(assignment));
+        continue;
+      }
+      properties[outermost] = assignment.right;
+    }
+  }
+  return { properties, unresolved };
+}, importedBinding = (ctx, specifierPath, visited) => {
+  let specifier = specifierPath.node, declaration = specifierPath.parent;
+  if (!t4.isImportDeclaration(declaration) || declaration.importKind === "type" || !(t4.isImportSpecifier(specifier) || t4.isImportDefaultSpecifier(specifier) || t4.isImportNamespaceSpecifier(specifier)) || isTypeSpecifier(specifier))
+    return;
+  let target = resolveTargetModule(ctx, declaration.source.value);
+  if (!target)
+    return;
+  if (t4.isImportNamespaceSpecifier(specifier))
+    return { kind: "namespace", ctx: target };
+  let exportName = t4.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 (t4.isExportDefaultDeclaration(statement) && exportName === "default") {
+      let declaration = unwrapExpression(statement.declaration);
+      return t4.isIdentifier(declaration) ? asExternal(bindingMembers(ctx, declaration.name, void 0, visited)) : t4.isObjectExpression(declaration) ? {
+        kind: "members",
+        ctx,
+        external: !0,
+        members: membersOf(declaration, ctx, visited)
+      } : void 0;
+    }
+    if (!t4.isExportNamedDeclaration(statement) || statement.exportKind === "type")
+      continue;
+    let specifier = statement.specifiers.find(
+      (candidate) => t4.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));
+};
+
+// src/csf-tools/story-shape/resolve-arg-value.ts
+import { traverse, types as t5 } from "@aussieljk/forkbook/internal/babel";
+var resolveArgValue = (node, ctx) => {
+  let unresolved = [], resolved = inlineSpreads(
+    followValue(unwrapExpression(node), ctx, /* @__PURE__ */ new Set()),
+    ctx,
+    unresolved
+  ), bindings = importBindingsOf(ctx.program), imports = [];
+  for (let name of freeNames(resolved)) {
+    let imported = bindings.get(name);
+    if (imported) {
+      imports.push({
+        localImportName: name,
+        importId: imported.importId,
+        importName: imported.importName,
+        ...imported.importName === "*" ? { namespace: name } : {}
+      });
+      continue;
+    }
+    ctx.program.scope.getBinding(name) && unresolved.push(name);
+  }
+  return { node: resolved, imports, unresolved };
+}, isSelfContained = (node) => freeNames(node).size === 0, importBindings = /* @__PURE__ */ new WeakMap(), importBindingsOf = (program) => {
+  let bindings = importBindings.get(program.node);
+  return bindings === void 0 && (bindings = collectImportBindings(program), importBindings.set(program.node, bindings)), bindings;
+}, inlineSpreads = (node, ctx, unresolved) => {
+  if (!hasNamedSpread(node))
+    return node;
+  if (t5.isArrayExpression(node))
+    return t5.arrayExpression(
+      node.elements.map(
+        (element) => element && t5.isExpression(element) ? inlineSpreads(element, ctx, unresolved) : element
+      )
+    );
+  if (!t5.isObjectExpression(node))
+    return node;
+  if (!node.properties.some((property) => t5.isSpreadElement(property)))
+    return objectFrom(node.properties, ctx, unresolved) ?? node;
+  let members = resolveArgsRecord(node, ctx);
+  return members.unresolved.length > 0 ? (unresolved.push(...members.unresolved), node) : objectFrom(
+    Object.entries(members.properties).map(
+      ([key, value]) => t5.objectProperty(
+        t5.isValidIdentifier(key) ? t5.identifier(key) : t5.stringLiteral(key),
+        value
+      )
+    ),
+    ctx,
+    unresolved
+  ) ?? node;
+}, hasNamedSpread = (node) => t5.isArrayExpression(node) ? node.elements.some(
+  (element) => element !== null && t5.isExpression(element) && hasNamedSpread(element)
+) : t5.isObjectExpression(node) && node.properties.some(
+  (property) => t5.isSpreadElement(property) ? !t5.isObjectExpression(unwrapExpression(property.argument)) : t5.isObjectProperty(property) && t5.isExpression(property.value) && hasNamedSpread(property.value)
+), objectFrom = (properties, ctx, unresolved) => {
+  let rebuilt = [];
+  for (let property of properties) {
+    if (!t5.isObjectProperty(property) || !t5.isExpression(property.value))
+      return;
+    let value = inlineSpreads(property.value, ctx, unresolved);
+    rebuilt.push(
+      t5.objectProperty(
+        property.key,
+        value,
+        property.computed,
+        property.shorthand && value === property.value
+      )
+    );
+  }
+  return t5.objectExpression(rebuilt);
+}, followValue = (node, ctx, seen) => {
+  if (!t5.isIdentifier(node) || seen.has(node.name))
+    return node;
+  let binding = ctx.program.scope.getBinding(node.name);
+  return !binding || binding.kind === "module" || !binding.constant || !t5.isVariableDeclarator(binding.path.node) || !binding.path.node.init ? node : (seen.add(node.name), followValue(unwrapExpression(binding.path.node.init), ctx, seen));
+}, freeNames = (node) => {
+  let expression = t5.isExpression(node) ? node : t5.isObjectMethod(node) ? t5.objectExpression([node]) : void 0;
+  if (expression === void 0)
+    throw new Error(`Cannot read the names a ${node.type} depends on: it is not an expression`);
+  let wrapped = t5.file(
+    t5.program([t5.expressionStatement(t5.cloneNode(expression, !0))])
+  ), names = /* @__PURE__ */ new Set();
+  return traverse(wrapped, {
+    ReferencedIdentifier(path) {
+      path.scope.hasBinding(path.node.name) || names.add(path.node.name);
+    }
+  }), names;
+};
+
+// src/csf-tools/story-shape/authored-source.ts
+import { types as t6 } from "@aussieljk/forkbook/internal/babel";
+var authoredSource = (shape, ctx) => {
+  for (let members of [shape.storyMembers, shape.metaMembers]) {
+    let code = memberAt(members, ["parameters", "docs", "source", "code"], ctx);
+    if (code.kind === "missing")
+      continue;
+    if (code.kind === "masked")
+      return { kind: "missing" };
+    if (code.kind === "unresolvable")
+      return code;
+    let resolved = resolveArgValue(code.node, ctx), value = unwrapExpression(resolved.node);
+    if (t6.isIdentifier(value, { name: "undefined" }) || t6.isUnaryExpression(value, { operator: "void" }))
+      continue;
+    if (t6.isNullLiteral(value))
+      return { kind: "disabled" };
+    if (t6.isStringLiteral(value))
+      return { kind: "code", code: value.value };
+    let parts = templateParts(value);
+    return parts && parts.expressions.length === 0 ? { kind: "code", code: parts.quasis[0] ?? "" } : { kind: "unresolvable", source: sourceOf(code.node) };
+  }
+  return { kind: "missing" };
+}, memberAt = (members, path, ctx) => {
+  let result = memberOf(members, path[0]);
+  for (let [depth, key] of path.slice(1).entries()) {
+    if (result.kind !== "value")
+      return result;
+    let original = result.node, object = unwrapExpression(resolveArgValue(original, ctx).node);
+    if (!t6.isObjectExpression(object))
+      return t6.isIdentifier(object, { name: "undefined" }) || t6.isUnaryExpression(object, { operator: "void" }) ? { kind: "missing" } : isOpaqueValue(object) ? { kind: "unresolvable", source: sourceOf(original) } : depth === 0 ? { kind: "missing" } : { kind: "masked" };
+    result = memberOf(resolveObjectMembers(object, ctx), key);
+  }
+  return result;
+}, memberOf = (members, key) => {
+  let node = members.properties[key];
+  return node !== void 0 && !members.shadowed.includes(key) ? { kind: "value", node } : members.unresolved.length > 0 ? { kind: "unresolvable", source: members.unresolved.at(-1) } : { kind: "missing" };
+}, isOpaqueValue = (node) => !t6.isLiteral(node) && !t6.isArrayExpression(node) && !t6.isFunction(node);
+
+// src/csf-tools/enrichCsf.ts
+import { generate as generate2, types as t7 } from "@aussieljk/forkbook/internal/babel";
+var enrichCsfStory = (csf, csfSource, key, options) => {
+  let storyExport = csfSource.getStoryExport(key), source = !options?.disableSource && extractSource(storyExport), description = !options?.disableDescription && extractDescription(csfSource._storyStatements[key]), parameters = [], baseStoryObject = csfSource._metaIsFactory ? t7.memberExpression(t7.identifier(key), t7.identifier("input")) : t7.identifier(key), originalParameters = t7.memberExpression(baseStoryObject, t7.identifier("parameters"));
+  parameters.push(t7.spreadElement(originalParameters));
+  let optionalDocs = t7.optionalMemberExpression(
+    originalParameters,
+    t7.identifier("docs"),
+    !1,
+    !0
+  ), extraDocsParameters = [];
+  if (source) {
+    let optionalSource = t7.optionalMemberExpression(
+      optionalDocs,
+      t7.identifier("source"),
+      !1,
+      !0
+    );
+    extraDocsParameters.push(
+      t7.objectProperty(
+        t7.identifier("source"),
+        t7.objectExpression([
+          t7.objectProperty(t7.identifier("originalSource"), t7.stringLiteral(source)),
+          t7.spreadElement(optionalSource)
+        ])
+      )
+    );
+  }
+  if (description) {
+    let optionalDescription = t7.optionalMemberExpression(
+      optionalDocs,
+      t7.identifier("description"),
+      !1,
+      !0
+    );
+    extraDocsParameters.push(
+      t7.objectProperty(
+        t7.identifier("description"),
+        t7.objectExpression([
+          t7.objectProperty(t7.identifier("story"), t7.stringLiteral(description)),
+          t7.spreadElement(optionalDescription)
+        ])
+      )
+    );
+  }
+  if (extraDocsParameters.length > 0) {
+    parameters.push(
+      t7.objectProperty(
+        t7.identifier("docs"),
+        t7.objectExpression([t7.spreadElement(optionalDocs), ...extraDocsParameters])
+      )
+    );
+    let addParameter = t7.expressionStatement(
+      t7.assignmentExpression("=", originalParameters, t7.objectExpression(parameters))
+    );
+    csf._ast.program.body.push(addParameter);
+  }
+}, addComponentDescription = (node, path, value) => {
+  if (!path.length) {
+    node.properties.find(
+      (p) => t7.isObjectProperty(p) && t7.isIdentifier(p.key) && p.key.name === "component"
+    ) || node.properties.unshift(value);
+    return;
+  }
+  let [first, ...rest] = path, existing = node.properties.find(
+    (p) => t7.isObjectProperty(p) && t7.isIdentifier(p.key) && p.key.name === first && t7.isObjectExpression(p.value)
+  ), subNode;
+  existing ? subNode = existing.value : (subNode = t7.objectExpression([]), node.properties.push(t7.objectProperty(t7.identifier(first), subNode))), addComponentDescription(subNode, rest, value);
+}, enrichCsfMeta = (csf, csfSource, options) => {
+  let description = !options?.disableDescription && extractDescription(csfSource._metaStatement);
+  if (description) {
+    let metaNode = csf._metaNode;
+    metaNode && !csf._metaNodeIsSynthetic && t7.isObjectExpression(metaNode) && addComponentDescription(
+      metaNode,
+      ["parameters", "docs", "description"],
+      t7.objectProperty(t7.identifier("component"), t7.stringLiteral(description))
+    );
+  }
+}, enrichCsf = async (csf, csfSource, options) => {
+  enrichCsfMeta(csf, csfSource, options), await options?.enrichCsf?.(csf, csfSource), Object.keys(csf._storyExports).forEach((key) => {
+    enrichCsfStory(csf, csfSource, key, options);
+  });
+}, extractSource = (node) => {
+  let src = t7.isVariableDeclarator(node) ? node.init : node, { code } = generate2(src, {});
+  return code;
+}, extractDescription = (node) => node?.leadingComments ? node.leadingComments.map((comment) => comment.type === "CommentLine" || !comment.value.startsWith("*") ? null : comment.value.split(`
+`).map((line) => line.replace(/^(\s+)?(\*+)?(\s)?/, "")).join(`
+`).trim()).filter(Boolean).join(`
+`) : "";
+
+// ../../node_modules/comment-parser/es6/primitives.js
+var Markers;
+(function(Markers2) {
+  Markers2.start = "/**", Markers2.nostart = "/***", Markers2.delim = "*", Markers2.end = "*/";
+})(Markers || (Markers = {}));
+
+// ../../node_modules/comment-parser/es6/util.js
+function isSpace(source) {
+  return /^\s+$/.test(source);
+}
+function splitCR(source) {
+  let matches = source.match(/\r+$/);
+  return matches == null ? ["", source] : [source.slice(-matches[0].length), source.slice(0, -matches[0].length)];
+}
+function splitSpace(source) {
+  let matches = source.match(/^\s+/);
+  return matches == null ? ["", source] : [source.slice(0, matches[0].length), source.slice(matches[0].length)];
+}
+function splitLines(source) {
+  return source.split(/\n/);
+}
+function seedSpec(spec = {}) {
+  return Object.assign({ tag: "", name: "", type: "", optional: !1, description: "", problems: [], source: [] }, spec);
+}
+function seedTokens(tokens = {}) {
+  return Object.assign({ start: "", delimiter: "", postDelimiter: "", tag: "", postTag: "", name: "", postName: "", type: "", postType: "", description: "", end: "", lineEnd: "" }, tokens);
+}
+
+// ../../node_modules/comment-parser/es6/parser/block-parser.js
+var reTag = /^@[^\s/]+(?=\s|$)/;
+function getParser({ fence = "```" } = {}) {
+  let fencer = getFencer(fence), toggleFence = (source, isFenced) => fencer(source) ? !isFenced : isFenced;
+  return function(source) {
+    let sections = [[]], isFenced = !1;
+    for (let line of source)
+      reTag.test(line.tokens.description) && !isFenced ? sections.push([line]) : sections[sections.length - 1].push(line), isFenced = toggleFence(line.tokens.description, isFenced);
+    return sections;
+  };
+}
+function getFencer(fence) {
+  return typeof fence == "string" ? (source) => source.split(fence).length % 2 === 0 : fence;
+}
+
+// ../../node_modules/comment-parser/es6/parser/source-parser.js
+function getParser2({ startLine = 0, markers = Markers } = {}) {
+  let block = null, num = startLine;
+  return function(source) {
+    let rest = source, tokens = seedTokens();
+    if ([tokens.lineEnd, rest] = splitCR(rest), [tokens.start, rest] = splitSpace(rest), block === null && rest.startsWith(markers.start) && !rest.startsWith(markers.nostart) && (block = [], tokens.delimiter = rest.slice(0, markers.start.length), rest = rest.slice(markers.start.length), [tokens.postDelimiter, rest] = splitSpace(rest)), block === null)
+      return num++, null;
+    let isClosed = rest.trimEnd().endsWith(markers.end);
+    if (tokens.delimiter === "" && rest.startsWith(markers.delim) && !rest.startsWith(markers.end) && (tokens.delimiter = markers.delim, rest = rest.slice(markers.delim.length), [tokens.postDelimiter, rest] = splitSpace(rest)), isClosed) {
+      let trimmed = rest.trimEnd();
+      tokens.end = rest.slice(trimmed.length - markers.end.length), rest = trimmed.slice(0, -markers.end.length);
+    }
+    if (tokens.description = rest, block.push({ number: num, source, tokens }), num++, isClosed) {
+      let result = block.slice();
+      return block = null, result;
+    }
+    return null;
+  };
+}
+
+// ../../node_modules/comment-parser/es6/parser/spec-parser.js
+function getParser3({ tokenizers }) {
+  return function(source) {
+    var _a;
+    let spec = seedSpec({ source });
+    for (let tokenize of tokenizers)
+      if (spec = tokenize(spec), !((_a = spec.problems[spec.problems.length - 1]) === null || _a === void 0) && _a.critical)
+        break;
+    return spec;
+  };
+}
+
+// ../../node_modules/comment-parser/es6/parser/tokenizers/tag.js
+function tagTokenizer() {
+  return (spec) => {
+    let { tokens } = spec.source[0], match = tokens.description.match(/\s*(@(\S+))(\s*)/);
+    return match === null ? (spec.problems.push({
+      code: "spec:tag:prefix",
+      message: 'tag should start with "@" symbol',
+      line: spec.source[0].number,
+      critical: !0
+    }), spec) : (match[1].includes("/") || (tokens.tag = match[1], tokens.postTag = match[3], tokens.description = tokens.description.slice(match[0].length), spec.tag = match[2]), spec);
+  };
+}
+
+// ../../node_modules/comment-parser/es6/parser/tokenizers/type.js
+function typeTokenizer(spacing = "compact") {
+  let join2 = getJoiner(spacing);
+  return (spec) => {
+    let curlies = 0, lines = [], descriptionBegun = !1, firstTypeIteration = !0;
+    for (let { tokens } of spec.source.values()) {
+      let type = "";
+      if (!descriptionBegun && tokens.description.trim())
+        descriptionBegun = !0;
+      else if (!descriptionBegun)
+        continue;
+      if (firstTypeIteration && tokens.description[0] !== "{")
+        return spec;
+      firstTypeIteration = !1;
+      for (let ch of tokens.description)
+        if (ch === "{" && curlies++, ch === "}" && curlies--, type += ch, curlies === 0)
+          break;
+      if (lines.push([tokens, type]), curlies === 0)
+        break;
+    }
+    if (!descriptionBegun)
+      return spec;
+    if (curlies !== 0)
+      return spec.problems.push({
+        code: "spec:type:unpaired-curlies",
+        message: "unpaired curlies",
+        line: spec.source[0].number,
+        critical: !0
+      }), spec;
+    let parts = [], offset = lines[0][0].postDelimiter.length;
+    for (let [i, [tokens, type]] of lines.entries())
+      tokens.type = type, i > 0 && (tokens.type = tokens.postDelimiter.slice(offset) + type, tokens.postDelimiter = tokens.postDelimiter.slice(0, offset)), [tokens.postType, tokens.description] = splitSpace(tokens.description.slice(type.length)), parts.push(tokens.type);
+    return parts[0] = parts[0].slice(1), parts[parts.length - 1] = parts[parts.length - 1].slice(0, -1), spec.type = join2(parts), spec;
+  };
+}
+var trim = (x) => x.trim();
+function getJoiner(spacing) {
+  return spacing === "compact" ? (t13) => t13.map(trim).join("") : spacing === "preserve" ? (t13) => t13.join(`
+`) : spacing;
+}
+
+// ../../node_modules/comment-parser/es6/parser/tokenizers/name.js
+var isQuoted = (s) => s && s.startsWith('"') && s.endsWith('"');
+function nameTokenizer() {
+  let typeEnd = (num, { tokens }, i) => tokens.type === "" ? num : i;
+  return (spec) => {
+    let finalTypeLine = spec.source.reduce(typeEnd, 0), tokens;
+    if (spec.type)
+      do {
+        if ({ tokens } = spec.source[finalTypeLine], tokens.description.trim())
+          break;
+        finalTypeLine++;
+      } while (spec.source[finalTypeLine]);
+    else
+      ({ tokens } = spec.source[finalTypeLine]);
+    let source = tokens.description.trimStart(), quotedGroups = source.split('"');
+    if (quotedGroups.length > 1 && quotedGroups[0] === "" && quotedGroups.length % 2 === 1)
+      return spec.name = quotedGroups[1], tokens.name = `"${quotedGroups[1]}"`, [tokens.postName, tokens.description] = splitSpace(source.slice(tokens.name.length)), spec;
+    let brackets = 0, name = "", optional = !1, defaultValue;
+    for (let ch of source) {
+      if (brackets === 0 && isSpace(ch))
+        break;
+      ch === "[" && brackets++, ch === "]" && brackets--, name += ch;
+    }
+    if (brackets !== 0)
+      return spec.problems.push({
+        code: "spec:name:unpaired-brackets",
+        message: "unpaired brackets",
+        line: spec.source[0].number,
+        critical: !0
+      }), spec;
+    let nameToken = name;
+    if (name[0] === "[" && name[name.length - 1] === "]") {
+      optional = !0, name = name.slice(1, -1);
+      let parts = name.split("=");
+      if (name = parts[0].trim(), parts[1] !== void 0 && (defaultValue = parts.slice(1).join("=").trim()), name === "")
+        return spec.problems.push({
+          code: "spec:name:empty-name",
+          message: "empty name",
+          line: spec.source[0].number,
+          critical: !0
+        }), spec;
+      if (defaultValue === "")
+        return spec.problems.push({
+          code: "spec:name:empty-default",
+          message: "empty default value",
+          line: spec.source[0].number,
+          critical: !0
+        }), spec;
+      if (!isQuoted(defaultValue) && /=(?!>)/.test(defaultValue || ""))
+        return spec.problems.push({
+          code: "spec:name:invalid-default",
+          message: "invalid default value syntax",
+          line: spec.source[0].number,
+          critical: !0
+        }), spec;
+    }
+    if (!optional) {
+      let eqIndex = name.search(/=(?!>)/);
+      if (eqIndex !== -1) {
+        let preEqual = name.slice(0, eqIndex).trim(), postEqual = name.slice(eqIndex + 1).trim();
+        if (preEqual === "")
+          return spec.problems.push({
+            code: "spec:name:empty-name",
+            message: "empty name",
+            line: spec.source[0].number,
+            critical: !0
+          }), spec;
+        if (postEqual === "")
+          return spec.problems.push({
+            code: "spec:name:empty-default",
+            message: "empty default value",
+            line: spec.source[0].number,
+            critical: !0
+          }), spec;
+        if (/^[\p{ID_Start}$_\.][\p{ID_Continue}$_\u200c\u200d\.]*=/u.test(name)) {
+          if (!isQuoted(postEqual) && /=(?!>)/.test(postEqual))
+            return spec.problems.push({
+              code: "spec:name:invalid-default",
+              message: "invalid default value syntax",
+              line: spec.source[0].number,
+              critical: !0
+            }), spec;
+          name = preEqual, defaultValue = postEqual;
+        }
+      }
+    }
+    return spec.optional = optional, spec.name = name, tokens.name = nameToken, defaultValue !== void 0 && (spec.default = defaultValue), [tokens.postName, tokens.description] = splitSpace(source.slice(tokens.name.length)), spec;
+  };
+}
+
+// ../../node_modules/comment-parser/es6/parser/tokenizers/description.js
+function descriptionTokenizer(spacing = "compact", markers = Markers) {
+  let join2 = getJoiner2(spacing);
+  return (spec) => (spec.description = join2(spec.source, markers), spec);
+}
+function getJoiner2(spacing) {
+  return spacing === "compact" ? compactJoiner : spacing === "preserve" ? preserveJoiner : spacing;
+}
+function compactJoiner(lines, markers = Markers) {
+  return lines.map(({ tokens: { description } }) => description.trim()).filter((description) => description !== "").join(" ");
+}
+var lineNo = (num, { tokens }, i) => tokens.type === "" ? num : i, getDescription = ({ tokens }) => (tokens.delimiter === "" ? tokens.start : tokens.postDelimiter.slice(1)) + tokens.description;
+function preserveJoiner(lines, markers = Markers) {
+  if (lines.length === 0)
+    return "";
+  lines[0].tokens.description === "" && lines[0].tokens.delimiter === markers.start && (lines = lines.slice(1));
+  let lastLine = lines[lines.length - 1];
+  return lastLine !== void 0 && lastLine.tokens.description === "" && lastLine.tokens.end.endsWith(markers.end) && (lines = lines.slice(0, -1)), lines = lines.slice(lines.reduce(lineNo, 0)), lines.map(getDescription).join(`
+`);
+}
+
+// ../../node_modules/comment-parser/es6/parser/index.js
+function getParser4({ startLine = 0, fence = "```", spacing = "compact", markers = Markers, tokenizers = [
+  tagTokenizer(),
+  typeTokenizer(spacing),
+  nameTokenizer(),
+  descriptionTokenizer(spacing)
+] } = {}) {
+  if (startLine < 0 || startLine % 1 > 0)
+    throw new Error("Invalid startLine");
+  let parseSource = getParser2({ startLine, markers }), parseBlock = getParser({ fence }), parseSpec = getParser3({ tokenizers }), joinDescription = getJoiner2(spacing);
+  return function(source) {
+    let blocks = [];
+    for (let line of splitLines(source)) {
+      let lines = parseSource(line);
+      if (lines === null)
+        continue;
+      let sections = parseBlock(lines), specs = sections.slice(1).map(parseSpec);
+      blocks.push({
+        description: joinDescription(sections[0], markers),
+        tags: specs,
+        source: lines,
+        problems: specs.reduce((acc, spec) => acc.concat(spec.problems), [])
+      });
+    }
+    return blocks;
+  };
+}
+
+// ../../node_modules/comment-parser/es6/stringifier/index.js
+function join(tokens) {
+  return tokens.start + tokens.delimiter + tokens.postDelimiter + tokens.tag + tokens.postTag + tokens.type + tokens.postType + tokens.name + tokens.postName + tokens.description + tokens.end + tokens.lineEnd;
+}
+function getStringifier() {
+  return (block) => block.source.map(({ tokens }) => join(tokens)).join(`
+`);
+}
+
+// ../../node_modules/comment-parser/es6/stringifier/inspect.js
+var zeroWidth = {
+  line: 0,
+  start: 0,
+  delimiter: 0,
+  postDelimiter: 0,
+  tag: 0,
+  postTag: 0,
+  name: 0,
+  postName: 0,
+  type: 0,
+  postType: 0,
+  description: 0,
+  end: 0,
+  lineEnd: 0
+};
+var fields = Object.keys(zeroWidth);
+
+// ../../node_modules/comment-parser/es6/index.js
+function parse(source, options = {}) {
+  return getParser4(options)(source);
+}
+var stringify = getStringifier();
+
+// src/csf-tools/jsdoc.ts
+function groupByTag(specs) {
+  let groups = /* @__PURE__ */ new Map();
+  for (let spec of specs) {
+    let group = groups.get(spec.tag);
+    group ? group.push(spec) : groups.set(spec.tag, [spec]);
+  }
+  return groups;
+}
+function hasTags(tags) {
+  return !!tags && Object.keys(tags).length > 0;
+}
+function mergeTags(docgenJsDocTags, extractedTags) {
+  return hasTags(docgenJsDocTags) ? { ...extractedTags ?? {}, ...docgenJsDocTags } : extractedTags ?? {};
+}
+function extractJSDocInfo(jsdocComment) {
+  let jsDoc = ["/**", ...jsdocComment.split(`
+`).map((line) => ` * ${line}`), " */"].join(`
+`), description = parse(jsDoc, { spacing: "preserve" })[0].description, parsed = parse(jsDoc, { spacing: "compact" });
+  return {
+    description,
+    tags: Object.fromEntries(
+      Array.from(groupByTag(parsed[0].tags), ([tag, specs]) => [
+        tag,
+        specs.map(
+          (spec) => ((spec.type ? `{${spec.type}} ` : "") + `${spec.name} ${spec.description}`).trim()
+        )
+      ])
+    )
+  };
+}
+function extractComponentDescription(metaJsDoc, docgenDescription, docgenJsDocTags) {
+  let jsdocComment = metaJsDoc || docgenDescription, extracted = jsdocComment ? extractJSDocInfo(jsdocComment) : void 0, tags = mergeTags(docgenJsDocTags, extracted?.tags), description = extracted?.description;
+  return {
+    description: ((tags?.describe?.[0] || tags?.desc?.[0]) ?? description)?.trim(),
+    summary: tags.summary?.[0],
+    jsDocTags: tags
+  };
+}
+
+// src/csf-tools/story-shape/jsdoc.ts
+function jsDocTagsForPath(path) {
+  let statement = path?.getStatementParent(), jsdocComment = statement ? extractDescription(statement.node) : "";
+  return jsdocComment ? extractJSDocInfo(jsdocComment).tags ?? {} : {};
+}
+function extractStoryJSDocInfo(storyStatement) {
+  let { description, summary } = extractComponentDescription(
+    extractDescription(storyStatement) || void 0,
+    void 0
+  );
+  return { description, summary };
+}
+
+// src/csf-tools/story-shape/normalize-story.ts
+function normalizeStoryDeclaration(storyDeclaration) {
+  let storyPath = declarationExpression(storyDeclaration), resolvedStoryPath = resolveLocalStory(storyDeclaration, storyPath), normalizedPath = bindInitializer(storyDeclaration, resolvedStoryPath) ?? factoryArgumentExpression(resolvedStoryPath), unwrappedPath = unwrapTypeExpression(normalizedPath);
+  return classifyStoryPath(unwrappedPath);
+}
+function resolveLocalStory(declaration, expression) {
+  let visited = /* @__PURE__ */ new Set(), current = unwrapTypeExpression(expression);
+  for (; current.isIdentifier(); ) {
+    let name = current.node.name;
+    if (visited.has(name) || !current.scope.getBinding(name)?.constant)
+      break;
+    visited.add(name);
+    let resolved = resolveIdentifierInit(declaration, current);
+    if (!resolved)
+      break;
+    current = unwrapTypeExpression(resolved);
+  }
+  return current;
+}
+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"
+  );
+}
+
+// src/csf-tools/story-shape/resolve-story-args.ts
+import { types as t8 } from "@aussieljk/forkbook/internal/babel";
+function createStoryArgsResolver(csf, references) {
+  let ctx = {
+    program: csf._file.path,
+    filePath: csf._file.opts.filename ?? "",
+    ...references
+  }, metaNode = csf._metaNode, metaMembers = metaNode && t8.isObjectExpression(metaNode) ? resolveObjectMembers(metaNode, ctx) : { properties: {}, shadowed: [], unresolved: [] }, metaArgs = resolveArgsRecord(metaMembers.properties.args, ctx);
+  return {
+    ctx,
+    resolve: (storyExport) => {
+      let localName = csf._stories[storyExport]?.localName ?? storyExport, storyMembers = resolveBindingMembers(ctx, localName) ?? {
+        properties: {},
+        shadowed: [],
+        unresolved: [sourceOf(csf._storyStatements[storyExport] ?? t8.identifier(storyExport))]
+      }, storyArgs = resolveArgsRecord(storyMembers.properties.args, ctx), args = {}, imports = [], unresolved = [
+        ...metaMembers.unresolved,
+        ...metaArgs.unresolved,
+        ...storyMembers.unresolved,
+        ...storyArgs.unresolved
+      ];
+      for (let [key, node] of Object.entries({
+        ...metaArgs.properties,
+        ...storyArgs.properties
+      })) {
+        let value = resolveArgValue(node, ctx);
+        args[key] = value.node, imports.push(...value.imports), unresolved.push(...value.unresolved);
+      }
+      return { args, imports, unresolved, storyMembers, metaMembers };
+    }
+  };
+}
+var unresolvedWarning = (unresolved) => {
+  let sources = [...new Set(unresolved)];
+  return sources.length === 0 ? void 0 : `Incomplete snippet: ${sources.map((source) => `\`${source}\``).join(", ")} could not be resolved statically.`;
+}, noSnippetWarning = (unresolved) => {
+  let sources = [...new Set(unresolved)];
+  return sources.length === 0 ? void 0 : `No static snippet: ${sources.map((source) => `\`${source}\``).join(", ")} could not be resolved statically.`;
+};
+
+// src/csf-tools/story-shape/render.ts
+var isRenderFunction = (path) => path.isArrowFunctionExpression() || path.isFunctionExpression() || path.isFunctionDeclaration();
+function resolveRenderFunction(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()) && keyOf(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 (resolved.kind === "invalid")
+    throw resolved.path.buildCodeFrameError(
+      "Expected render to be an arrow function or function expression"
+    );
+  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 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()) && keyOf(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/csf-tools/story-shape/reference-context.ts
+import { readFileSync } from "node:fs";
+
+// src/csf-tools/CsfFile.ts
+import { readFile, writeFile } from "node:fs/promises";
+import {
+  BabelFileClass,
+  babelParse as babelParse2,
+  generate as generate3,
+  recast,
+  types as t12,
+  traverse as traverse2
+} from "@aussieljk/forkbook/internal/babel";
+import {
+  isExportStory,
+  storyNameFromExport,
+  toId,
+  toTestId
+} from "@aussieljk/forkbook/internal/csf/csf-utils";
+import { logger } from "@aussieljk/forkbook/internal/node-logger";
+import { dedent } from "ts-dedent";
+
+// src/csf-tools/CsfObjectDiscovery.ts
+import { types as t10 } from "@aussieljk/forkbook/internal/babel";
+
+// src/csf-tools/CsfObject.ts
+import { types as t9 } from "@aussieljk/forkbook/internal/babel";
+var UNRESOLVED = /* @__PURE__ */ Symbol("unresolved"), staticKey = (member) => {
+  if (t9.isStringLiteral(member.key))
+    return member.key.value;
+  if (t9.isNumericLiteral(member.key))
+    return String(member.key.value);
+  if (t9.isIdentifier(member.key) && !member.computed)
+    return member.key.name;
+  if (t9.isTemplateLiteral(member.key) && member.key.expressions.length === 0)
+    return member.key.quasis[0]?.value.cooked ?? member.key.quasis[0]?.value.raw;
+}, keyNode = (name) => t9.isValidIdentifier(name) ? t9.identifier(name) : t9.stringLiteral(name), unsafePath = (path) => path.includes("__proto__"), lookupProperty = (object, name, removing = !1) => {
+  let matches = [], unknown, unknownAfterMatch;
+  for (let member of object.properties) {
+    let key = t9.isSpreadElement(member) ? void 0 : staticKey(member);
+    if (key === void 0) {
+      unknown = {
+        code: t9.isSpreadElement(member) ? "spread-field" : "dynamic-key",
+        node: member
+      }, matches.length > 0 && (unknownAfterMatch = unknown);
+      continue;
+    }
+    if (key === name) {
+      if (!t9.isObjectProperty(member) && !t9.isObjectMethod(member, { kind: "method" }))
+        return { ok: !1, code: "unsupported-member", node: member };
+      matches.push(member);
+    }
+  }
+  if (matches.length > 1)
+    return { ok: !1, code: "duplicate-field", node: matches[1] };
+  let unproven = unknownAfterMatch ?? (removing || matches.length === 0 ? unknown : void 0);
+  return unproven ? { ok: !1, code: unproven.code, node: unproven.node } : { ok: !0, property: matches[0] };
+}, propertyExpression = (property) => {
+  if (t9.isObjectProperty(property))
+    return t9.isExpression(property.value) ? property.value : void 0;
+  let value = t9.functionExpression(
+    null,
+    property.params,
+    property.body,
+    property.generator,
+    property.async
+  );
+  return value.returnType = property.returnType, value.typeParameters = property.typeParameters, value;
+}, isEvaluationInert = (node) => {
+  let value = unwrapExpression(node);
+  return t9.isTemplateLiteral(value) ? value.expressions.length === 0 : t9.isLiteral(value) || t9.isFunctionExpression(value) || t9.isArrowFunctionExpression(value) ? !0 : t9.isUnaryExpression(value) ? ["!", "void", "typeof"].includes(value.operator) ? isEvaluationInert(value.argument) : t9.isNumericLiteral(unwrapExpression(value.argument)) : t9.isArrayExpression(value) ? value.elements.every((element) => element === null || isEvaluationInert(element)) : t9.isObjectExpression(value) ? value.properties.every(
+    (property) => t9.isObjectProperty(property) && !property.computed && staticKey(property) !== void 0 && isEvaluationInert(property.value)
+  ) : !1;
+}, CsfObjectEditor = class {
+  constructor(target, root, prefix, reportDiagnostic, markChanged) {
+    this.target = target;
+    this.root = root;
+    this.prefix = prefix;
+    this.reportDiagnostic = reportDiagnostic;
+    this.markChanged = markChanged;
+  }
+  #changed = !1;
+  get changed() {
+    return this.#changed;
+  }
+  get(path) {
+    let value = this.getExpression(path);
+    return value ? t9.cloneNode(value, !0) : void 0;
+  }
+  getValue(path) {
+    let expression = this.getExpression(path);
+    if (!expression)
+      return;
+    let value = this.readValue(expression);
+    if (value === UNRESOLVED) {
+      this.failure("unsupported-value", path, expression);
+      return;
+    }
+    return value;
+  }
+  getExpression(path) {
+    let logicalPath = this.normalizePath(path);
+    if (!logicalPath)
+      return;
+    if (logicalPath.length === 0)
+      return this.prefix.length > 0 ? this.root.node : void 0;
+    let found = this.inspect(logicalPath);
+    if (found.ok === !1) {
+      this.failure(found.code, path, found.node);
+      return;
+    }
+    return found.property && propertyExpression(found.property);
+  }
+  set(path, value) {
+    let logicalPath = this.normalizePath(path);
+    if (!logicalPath || logicalPath.length === 0 || unsafePath(logicalPath))
+      return this.failure("unsupported-member", path, this.root.node);
+    let inspected = this.inspect(logicalPath);
+    if (inspected.ok === !1)
+      return this.failure(inspected.code, path, inspected.node);
+    if (t9.isObjectProperty(inspected.property) && inspected.property.value === value)
+      return { ok: !0, changed: !1 };
+    let expression = t9.isNode(value) && t9.isExpression(value) ? t9.cloneNode(value, !0) : t9.valueToNode(value);
+    return inspected.property && inspected.parent ? this.replaceValue(inspected.property, inspected.parent, expression) : this.insert(logicalPath, t9.objectProperty(keyNode(logicalPath.at(-1)), expression)), this.success();
+  }
+  transform(path, derive) {
+    let logicalPath = this.normalizePath(path);
+    if (!logicalPath || logicalPath.length === 0 || unsafePath(logicalPath))
+      return this.failure("unsupported-member", path, this.root.node);
+    let inspected = this.inspect(logicalPath);
+    if (inspected.ok === !1)
+      return this.failure(inspected.code, path, inspected.node);
+    let { property, parent } = inspected, value = property && propertyExpression(property);
+    if (!property || !parent || !value)
+      return { ok: !0, changed: !1 };
+    let derived = derive(value);
+    return !derived || derived === value ? { ok: !0, changed: !1 } : (this.replaceValue(property, parent, derived), this.success());
+  }
+  remove(path) {
+    let logicalPath = this.normalizePath(path);
+    if (!logicalPath || logicalPath.length === 0 || unsafePath(logicalPath))
+      return this.failure("unsupported-member", path, this.root.node);
+    let inspected = this.inspect(logicalPath);
+    if (inspected.ok === !1)
+      return this.failure(inspected.code, path, inspected.node);
+    if (!inspected.property || !inspected.parent)
+      return { ok: !0, changed: !1 };
+    let removal = lookupProperty(inspected.parent, logicalPath.at(-1), !0);
+    return removal.ok ? (inspected.parent.properties.splice(inspected.parent.properties.indexOf(inspected.property), 1), this.removeEmptyParents(logicalPath), this.success()) : this.failure(removal.code, path, removal.node);
+  }
+  rename(path, name) {
+    let destination = [...path.slice(0, -1), name];
+    return this.move(path, destination);
+  }
+  move(from, to) {
+    let sourcePath = this.normalizePath(from), destinationPath = this.normalizePath(to);
+    if (!sourcePath || !destinationPath || sourcePath.length === 0 || destinationPath.length === 0 || unsafePath(sourcePath) || unsafePath(destinationPath))
+      return this.failure("unsupported-member", sourcePath ? to : from, this.root.node);
+    if (sourcePath.length === destinationPath.length && sourcePath.every((part, index) => destinationPath[index] === part))
+      return { ok: !0, changed: !1 };
+    if (destinationPath.length > sourcePath.length && sourcePath.every((part, index) => destinationPath[index] === part))
+      return this.failure("cyclic-move", to, this.root.node);
+    let source = this.inspect(sourcePath);
+    if (source.ok === !1)
+      return this.failure(source.code, from, source.node);
+    if (!source.property || !source.parent)
+      return { ok: !0, changed: !1 };
+    let removal = lookupProperty(source.parent, sourcePath.at(-1), !0);
+    if (!removal.ok)
+      return this.failure(removal.code, from, removal.node);
+    let destination = this.inspect(destinationPath);
+    if (destination.ok === !1)
+      return this.failure(destination.code, to, destination.node);
+    if (destination.property)
+      return this.failure("occupied-destination", to, destination.property);
+    let sourceParent = sourcePath.slice(0, -1), destinationParent = destinationPath.slice(0, -1);
+    return sourceParent.length === destinationParent.length && sourceParent.every((part, index) => destinationParent[index] === part) ? (t9.isObjectProperty(source.property) && (source.property.shorthand = !1), source.property.key = keyNode(destinationPath.at(-1)), source.property.computed = !1, this.success()) : (source.parent.properties.splice(source.parent.properties.indexOf(source.property), 1), t9.isObjectProperty(source.property) && (source.property.shorthand = !1), source.property.key = keyNode(destinationPath.at(-1)), source.property.computed = !1, this.insert(destinationPath, source.property), this.removeEmptyParents(sourcePath), this.success());
+  }
+  group(path, names) {
+    let logicalPath = this.normalizePath(path);
+    if (!logicalPath || logicalPath.length === 0 || unsafePath(logicalPath) || unsafePath(names))
+      return this.failure("unsupported-member", path, this.root.node);
+    let group = logicalPath.at(-1);
+    if (names.includes(group))
+      return this.failure("cyclic-move", path, this.root.node);
+    let parent = this.root.node;
+    if (logicalPath.length > 1) {
+      let inspected = this.inspect(logicalPath.slice(0, -1));
+      if (inspected.ok === !1)
+        return this.failure(inspected.code, path, inspected.node);
+      if (!inspected.property)
+        return { ok: !0, changed: !1 };
+      let value = t9.isObjectProperty(inspected.property) ? this.resolveExpression(inspected.property.value) : void 0;
+      if (!t9.isObjectExpression(value))
+        return this.failure("unsupported-member", path, inspected.property);
+      parent = value;
+    }
+    let moved = parent.properties.filter(
+      (property) => !t9.isSpreadElement(property) && names.includes(staticKey(property) ?? "")
+    );
+    if (moved.length === 0)
+      return { ok: !0, changed: !1 };
+    for (let property of parent.properties)
+      if (t9.isSpreadElement(property) || property.computed || staticKey(property) === void 0)
+        return this.failure(
+          t9.isSpreadElement(property) ? "spread-field" : "dynamic-key",
+          path,
+          property,
+          `the configuration contains ${t9.isSpreadElement(property) ? "a spread property" : "a computed property"}`
+        );
+    let sourceNames = /* @__PURE__ */ new Set();
+    for (let property of moved) {
+      let name = staticKey(property);
+      if (!t9.isObjectProperty(property) || !t9.isExpression(property.value))
+        return this.failure(
+          "unsupported-member",
+          path,
+          property,
+          `the top-level ${name} ${group} option is a method or accessor, not a movable value property`
+        );
+      if (sourceNames.has(name))
+        return this.failure("duplicate-field", path, property);
+      sourceNames.add(name);
+    }
+    let destination = lookupProperty(parent, group);
+    if (destination.ok === !1)
+      return this.failure(
+        destination.code,
+        path,
+        destination.node,
+        destination.code === "duplicate-field" ? `the configuration defines ${group} more than once` : `the existing ${group} value is not an object literal`
+      );
+    if (destination.property) {
+      let existing = destination.property, value = t9.isObjectProperty(existing) ? unwrapExpression(existing.value) : void 0;
+      if (!t9.isObjectExpression(value))
+        return this.failure(
+          "unsupported-member",
+          path,
+          existing,
+          `the existing ${group} value is not an object literal`
+        );
+      for (let property of value.properties) {
+        if (t9.isSpreadElement(property) || property.computed || staticKey(property) === void 0)
+          return this.failure(
+            t9.isSpreadElement(property) ? "spread-field" : "dynamic-key",
+            path,
+            property,
+            `the existing ${group} object contains ${t9.isSpreadElement(property) ? "a spread property" : "a computed property"}`
+          );
+        if (!t9.isObjectProperty(property) || !t9.isExpression(property.value))
+          return this.failure(
+            "unsupported-member",
+            path,
+            property,
+            `the existing ${group} object contains a method or accessor`
+          );
+      }
+      let existingNames = new Set(
+        value.properties.map(
+          (property) => t9.isSpreadElement(property) ? void 0 : staticKey(property)
+        )
+      );
+      for (let property of moved) {
+        let name = staticKey(property);
+        if (existingNames.has(name))
+          return this.failure(
+            "occupied-destination",
+            path,
+            property,
+            `the ${name} option exists at both top level and inside ${group}, where the nested value is authoritative`
+          );
+        if (!t9.isObjectProperty(property) || !isEvaluationInert(property.value))
+          return this.failure(
+            "evaluation-order",
+            path,
+            property,
+            `the ${name} option has a ${t9.isObjectProperty(property) ? unwrapExpression(property.value).type : "non-expression"} value whose relocation into the existing ${group} object could change expression evaluation order`
+          );
+      }
+      value.properties.unshift(...moved);
+      let movedSet = new Set(moved);
+      parent.properties = parent.properties.filter((property) => !movedSet.has(property));
+    } else {
+      if (parent === this.root.node && this.root.detached) {
+        let effectful = moved.find(
+          (property) => !t9.isObjectProperty(property) || !isEvaluationInert(property.value)
+        );
+        if (effectful)
+          return this.failure(
+            "evaluation-order",
+            path,
+            effectful,
+            "Grouping named config exports could change initializer evaluation order"
+          );
+      }
+      let first = parent.properties.indexOf(moved[0]);
+      if (parent.properties.indexOf(moved.at(-1)) - first + 1 !== moved.length)
+        return this.failure(
+          "evaluation-order",
+          path,
+          moved[1] ?? moved[0],
+          `the top-level ${group} options are not contiguous, so grouping them could change expression evaluation order`
+        );
+      parent.properties.splice(
+        first,
+        moved.length,
+        t9.objectProperty(keyNode(group), t9.objectExpression(moved))
+      );
+    }
+    return this.success();
+  }
+  replaceValue(property, parent, value) {
+    t9.isObjectProperty(property) ? (property.value = value, property.shorthand = !1) : t9.isFunctionExpression(value) && !value.id ? (property.params = value.params, property.body = value.body, property.async = value.async, property.generator = value.generator, property.returnType = value.returnType, property.typeParameters = value.typeParameters) : parent.properties.splice(
+      parent.properties.indexOf(property),
+      1,
+      t9.inheritsComments(t9.objectProperty(property.key, value, property.computed), property)
+    );
+  }
+  removeEmptyParents(path) {
+    for (let depth = path.length - 1; depth > 0; depth--) {
+      let ancestor = this.inspect(path.slice(0, depth));
+      if (ancestor.ok === !1 || !t9.isObjectProperty(ancestor.property) || !ancestor.parent)
+        return;
+      let value = this.resolveExpression(ancestor.property.value);
+      if (!t9.isObjectExpression(value) || value.properties.length > 0 || !lookupProperty(ancestor.parent, path[depth - 1], !0).ok)
+        return;
+      ancestor.parent.properties.splice(ancestor.parent.properties.indexOf(ancestor.property), 1);
+    }
+  }
+  normalizePath(path) {
+    if (this.prefix.length === 0)
+      return [...path];
+    if (!(path.length < this.prefix.length || this.prefix.some((part, index) => path[index] !== part)))
+      return path.slice(this.prefix.length);
+  }
+  readValue(node) {
+    let value = this.resolveExpression(node);
+    if (t9.isStringLiteral(value) || t9.isNumericLiteral(value) || t9.isBooleanLiteral(value))
+      return value.value;
+    if (t9.isNullLiteral(value))
+      return null;
+    if (t9.isIdentifier(value))
+      return value.name === "undefined" ? void 0 : UNRESOLVED;
+    if (t9.isTemplateLiteral(value) && value.expressions.length === 0)
+      return value.quasis[0].value.cooked ?? UNRESOLVED;
+    if (t9.isUnaryExpression(value)) {
+      let argument = this.readValue(value.argument);
+      return typeof argument != "number" ? UNRESOLVED : value.operator === "-" ? -argument : value.operator === "+" ? argument : UNRESOLVED;
+    }
+    if (t9.isArrayExpression(value)) {
+      let elements = [];
+      for (let element of value.elements) {
+        if (!element) {
+          elements.length++;
+          continue;
+        }
+        let item = this.readValue(t9.isSpreadElement(element) ? element.argument : element);
+        if (item === UNRESOLVED)
+          return UNRESOLVED;
+        if (t9.isSpreadElement(element)) {
+          if (!Array.isArray(item))
+            return UNRESOLVED;
+          elements.push(...item);
+        } else
+          elements.push(item);
+      }
+      return elements;
+    }
+    if (t9.isObjectExpression(value)) {
+      let entries = [];
+      for (let property of value.properties) {
+        if (t9.isSpreadElement(property)) {
+          let spread = this.readValue(property.argument);
+          if (typeof spread != "object" || spread === null || Array.isArray(spread))
+            return UNRESOLVED;
+          entries.push(...Object.entries(spread));
+          continue;
+        }
+        let key = staticKey(property);
+        if (!t9.isObjectProperty(property) || key === void 0 || key === "__proto__" && !property.computed)
+          return UNRESOLVED;
+        let item = this.readValue(property.value);
+        if (item === UNRESOLVED)
+          return UNRESOLVED;
+        entries.push([key, item]);
+      }
+      return Object.fromEntries(entries);
+    }
+    return UNRESOLVED;
+  }
+  resolveExpression(node) {
+    let program = this.root.scope.getProgramParent().path;
+    if (!program.isProgram())
+      return;
+    let value = unwrapExpression(node), visited = /* @__PURE__ */ new Set();
+    for (; t9.isIdentifier(value) && !visited.has(value); ) {
+      visited.add(value);
+      let reference = pathForNode(program, value), binding = reference?.scope.getBinding(value.name);
+      if (!binding && reference && value.name === "undefined")
+        return value;
+      if (!binding?.constant || binding.referencePaths.length !== 1 || binding.referencePaths[0].node !== value || !binding.path.isVariableDeclarator() || !binding.path.node.init)
+        return;
+      value = unwrapExpression(binding.path.node.init);
+    }
+    return value;
+  }
+  inspect(path) {
+    let object = this.root.node, parent, property;
+    for (let [index, name] of path.entries()) {
+      let lookup = lookupProperty(object, name);
+      if (lookup.ok === !1)
+        return lookup;
+      if (parent = object, property = lookup.property, !property || index === path.length - 1)
+        return { ok: !0, parent, property };
+      if (!t9.isObjectProperty(property))
+        return { ok: !1, code: "unsupported-member", node: property };
+      let value = this.resolveExpression(property.value);
+      if (!t9.isObjectExpression(value))
+        return { ok: !1, code: "unsupported-member", node: property.value };
+      object = value;
+    }
+    return { ok: !0, parent, property };
+  }
+  insert(path, property) {
+    let object = this.root.node;
+    for (let name of path.slice(0, -1)) {
+      let lookup = lookupProperty(object, name);
+      if (lookup.ok === !1)
+        throw this.root.buildCodeFrameError("CsfObject mutation preflight was invalidated");
+      if (lookup.property) {
+        let value = t9.isObjectProperty(lookup.property) ? this.resolveExpression(lookup.property.value) : void 0;
+        if (!t9.isObjectExpression(value))
+          throw this.root.buildCodeFrameError("CsfObject mutation preflight was invalidated");
+        object = value;
+      } else {
+        let child = t9.objectExpression([]);
+        object.properties.push(t9.objectProperty(keyNode(name), child)), object = child;
+      }
+    }
+    object.properties.push(property);
+  }
+  failure(code, path, node, message = `Cannot mutate ${path.join(".")} because the target contains ${code.replaceAll("-", " ")}`) {
+    let diagnostic = {
+      code,
+      target: this.target,
+      path: [...path],
+      message,
+      ...node.loc ? { loc: node.loc } : {}
+    };
+    return this.reportDiagnostic(diagnostic), { ok: !1, changed: !1, diagnostic };
+  }
+  success() {
+    return this.#changed = !0, this.markChanged(), this.root.scope.getProgramParent().crawl(), { ok: !0, changed: !0 };
+  }
+}, createCsfObject = (target, root, prefix, report, markChanged) => new CsfObjectEditor(target, root, prefix, report, markChanged);
+
+// src/csf-tools/CsfObjectDiscovery.ts
+var storyTarget = ({ exportName, localName }) => ({
+  kind: "story",
+  exportName,
+  localName
+}), reportBindingFailure = (exportName, localName, node, report) => report({
+  code: "ambiguous-binding",
+  target: { kind: "story", exportName, localName },
+  path: [],
+  message: `Cannot mutate ${exportName} because ${localName} is not a unique constant binding`,
+  ...node.loc ? { loc: node.loc } : {}
+}), addQualifiedBinding = (candidate, exportName, localName, bindings, report, isStory) => {
+  let binding = candidate.scope.getBinding(localName);
+  !binding?.constant || !binding.path.isVariableDeclarator() && !binding.path.isFunctionDeclaration() ? isStory && reportBindingFailure(exportName, localName, candidate.node, report) : bindings.set(`${localName}:${exportName}`, {
+    exportName,
+    localName,
+    declaration: binding.path
+  });
+}, addDirectBindings = (statement, bindings, report, csf) => {
+  let declaration = statement.get("declaration");
+  if (declaration.isVariableDeclaration())
+    for (let declarator of declaration.get("declarations")) {
+      let id = declarator.get("id");
+      id.isIdentifier() && addQualifiedBinding(
+        id,
+        id.node.name,
+        id.node.name,
+        bindings,
+        report,
+        id.node.name in csf._stories
+      );
+    }
+  else if (declaration.isFunctionDeclaration() && declaration.node.id) {
+    let name = declaration.node.id.name;
+    addQualifiedBinding(declaration, name, name, bindings, report, name in csf._stories);
+  }
+}, addAliasedBindings = (statement, bindings, report, csf) => {
+  if (statement.node.source) {
+    for (let specifier of statement.get("specifiers")) {
+      if (!specifier.isExportSpecifier() || !t10.isIdentifier(specifier.node.local))
+        continue;
+      let exportName = t10.isIdentifier(specifier.node.exported) ? specifier.node.exported.name : specifier.node.exported.value;
+      exportName !== "default" && exportName in csf._stories && report({
+        code: "unsupported-initializer",
+        target: { kind: "story", exportName, localName: specifier.node.local.name },
+        path: [],
+        message: `Cannot mutate re-exported story ${exportName} automatically`,
+        ...specifier.node.loc ? { loc: specifier.node.loc } : {}
+      });
+    }
+    return;
+  }
+  for (let specifier of statement.get("specifiers")) {
+    if (!specifier.isExportSpecifier() || !t10.isIdentifier(specifier.node.local))
+      continue;
+    let exportName = t10.isIdentifier(specifier.node.exported) ? specifier.node.exported.name : specifier.node.exported.value;
+    if (exportName === "default")
+      continue;
+    let localName = specifier.node.local.name;
+    addQualifiedBinding(
+      specifier,
+      exportName,
+      localName,
+      bindings,
+      report,
+      exportName in csf._stories
+    );
+  }
+}, factoryMember = (node) => {
+  let unwrapped = node && unwrapExpression(node);
+  if (!unwrapped || !t10.isCallExpression(unwrapped) || !t10.isMemberExpression(unwrapped.callee))
+    return;
+  let property = unwrapped.callee.property;
+  if (!(unwrapped.callee.computed || !t10.isIdentifier(property)))
+    return property.name === "story" || property.name === "extend" ? property.name : void 0;
+}, storyBindings = (csf, report) => {
+  let bindings = /* @__PURE__ */ new Map();
+  for (let statement of csf._file.path.get("body"))
+    !statement.isExportNamedDeclaration() || statement.node.exportKind === "type" || (addDirectBindings(statement, bindings, report, csf), addAliasedBindings(statement, bindings, report, csf));
+  let candidates = [...bindings.values()].filter((binding) => binding.exportName in csf._stories), unique = /* @__PURE__ */ new Map();
+  for (let candidate of candidates) {
+    let previous = unique.get(candidate.declaration.node);
+    (!previous || !(previous.exportName in csf._stories) && candidate.exportName in csf._stories) && unique.set(candidate.declaration.node, candidate);
+  }
+  return [...unique.values()];
+}, isFactoryMeta = (csf, name, seen = /* @__PURE__ */ new Set()) => {
+  let binding = csf._file.path.scope.getBinding(name);
+  if (seen.has(name) || !csf._metaFactoryCall || !binding?.constant || !binding.path.isVariableDeclarator() || !t10.isExpression(binding.path.node.init))
+    return !1;
+  seen.add(name);
+  let initializer = withoutTypeCalls(unwrapExpression(binding.path.node.init));
+  return initializer === csf._metaFactoryCall || t10.isIdentifier(initializer) && isFactoryMeta(csf, initializer.name, seen);
+}, isFactoryStory = (csf, node, seen = /* @__PURE__ */ new Set()) => {
+  if (!isCsfFactoryCall(node))
+    return !1;
+  let receiver = csfFactoryReceiver(node).name;
+  if (node.callee.property.name === "story")
+    return isFactoryMeta(csf, receiver);
+  if (seen.has(receiver))
+    return !1;
+  seen.add(receiver);
+  let binding = csf._file.path.scope.getBinding(receiver), initializer = binding?.constant && binding.path.isVariableDeclarator() ? binding.path.node.init : void 0;
+  return initializer ? isFactoryStory(csf, unwrapExpression(initializer), seen) : !1;
+}, factoryMetaConfigurationIsSafe = (csf) => {
+  let argument = csf._metaFactoryCall?.arguments[0];
+  if (!argument || !t10.isIdentifier(argument))
+    return !0;
+  let binding = csf._file.path.scope.getBinding(argument.name);
+  if (!binding?.constant || !binding.path.isVariableDeclarator() || !binding.path.parentPath?.isVariableDeclaration({ kind: "const" }))
+    return !1;
+  let initializer = binding.path.node.init;
+  return !initializer || !t10.isObjectExpression(unwrapExpression(initializer)) ? !1 : binding.referencePaths.length === 1 && binding.referencePaths[0].node === argument;
+}, discoverMeta = (csf, report, markChanged) => {
+  if (csf._metaIsFactory && csf._metaFactoryCall && !factoryMetaConfigurationIsSafe(csf))
+    return report({
+      code: "unsupported-initializer",
+      target: { kind: "meta" },
+      path: [],
+      message: "Cannot mutate CSF factory meta with an identifier-backed configuration",
+      ...csf._metaFactoryCall.loc ? { loc: csf._metaFactoryCall.loc } : {}
+    }), [];
+  let meta = metaObjectPath(csf);
+  if (meta) {
+    let binding = csf._metaVariableName ? meta.scope.getBinding(csf._metaVariableName) : void 0;
+    return binding && !binding.constant ? (report({
+      code: "ambiguous-binding",
+      target: { kind: "meta" },
+      path: [],
+      message: `Cannot mutate meta because ${csf._metaVariableName} is not a unique constant binding`,
+      ...binding.path.node.loc ? { loc: binding.path.node.loc } : {}
+    }), []) : [createCsfObject({ kind: "meta" }, meta, [], report, markChanged)];
+  }
+  return csf._metaIsFactory && csf._metaFactoryCall && report({
+    code: "unsupported-initializer",
+    target: { kind: "meta" },
+    path: [],
+    message: "Cannot mutate CSF factory meta automatically; move the field manually",
+    ...csf._metaFactoryCall.loc ? { loc: csf._metaFactoryCall.loc } : {}
+  }), [];
+}, discoverStories = (csf, bindings, report, markChanged) => bindings.flatMap((binding) => {
+  let declaration = binding.declaration, init = declaration.isVariableDeclarator() ? declaration.get("init") : declaration, node = init.node ? unwrapExpression(init.node) : void 0;
+  if (node && factoryMember(node)) {
+    let argument = t10.isCallExpression(node) ? node.arguments[0] : void 0, argumentNode = argument && t10.isExpression(argument) ? unwrapExpression(argument) : void 0;
+    if (t10.isCallExpression(node) && isFactoryStory(csf, node) && node.arguments.length === 1 && argumentNode && t10.isObjectExpression(argumentNode)) {
+      let root2 = pathForNode(csf._file.path, argumentNode);
+      return root2 ? [createCsfObject(storyTarget(binding), root2, [], report, markChanged)] : [];
+    }
+    return report({
+      code: "unsupported-initializer",
+      target: storyTarget(binding),
+      path: [],
+      message: `Cannot mutate CSF factory story ${binding.exportName} because its configuration is not an inline object literal`,
+      ...node.loc ? { loc: node.loc } : {}
+    }), [];
+  }
+  let expression = init.isExpression() ? init : void 0, unwrapped = expression && unwrapExpression(expression.node), root = unwrapped && t10.isObjectExpression(unwrapped) ? pathForNode(csf._file.path, unwrapped) : void 0;
+  return root ? [createCsfObject(storyTarget(binding), root, [], report, markChanged)] : [];
+}), annotationCandidates = (csf, statement, bindings) => {
+  if (!statement.isExpressionStatement())
+    return [];
+  let expression = statement.get("expression");
+  if (!expression.isAssignmentExpression())
+    return [];
+  let left = expression.get("left"), right = expression.get("right");
+  if (!left.isMemberExpression() || !right.isExpression())
+    return [];
+  let object = left.get("object"), property = left.get("property");
+  if (!object.isIdentifier())
+    return [];
+  let propertyName = !left.node.computed && property.isIdentifier() ? property.node.name : left.node.computed && property.isStringLiteral() ? property.node.value : void 0, binding = bindings.get(object.node.name);
+  if (!propertyName && left.node.computed && binding)
+    return [
+      {
+        target: {
+          kind: "story-annotation",
+          exportName: binding.exportName,
+          localName: binding.localName,
+          annotation: "parameters"
+        },
+        annotation: "parameters",
+        node: property.node,
+        message: `Cannot mutate ${binding.localName} annotation because its computed name is not a static string literal`
+      }
+    ];
+  if (!propertyName)
+    return [];
+  let annotation = propertyName === "parameters" || propertyName === "argTypes" ? propertyName : void 0;
+  if (!annotation || !binding)
+    return [];
+  let rootNode = unwrapExpression(right.node);
+  return [
+    {
+      target: {
+        kind: "story-annotation",
+        exportName: binding.exportName,
+        localName: binding.localName,
+        annotation
+      },
+      annotation,
+      root: expression.node.operator === "=" && t10.isObjectExpression(rootNode) ? pathForNode(csf._file.path, rootNode) : void 0,
+      node: right.node,
+      ...expression.node.operator === "=" ? {} : {
+        message: `Cannot mutate ${binding.localName}.${annotation} because it uses ${expression.node.operator} assignment`
+      }
+    }
+  ];
+}, reportOrCreateAnnotation = (matches, report, markChanged) => {
+  let [candidate] = matches;
+  return matches.length > 1 ? (report({
+    code: "ambiguous-binding",
+    target: candidate.target,
+    path: [candidate.annotation],
+    message: `Cannot mutate repeated ${candidate.target.localName}.${candidate.annotation} assignments`,
+    ...candidate.node.loc ? { loc: candidate.node.loc } : {}
+  }), []) : candidate.root ? [
+    createCsfObject(candidate.target, candidate.root, [candidate.annotation], report, markChanged)
+  ] : (report({
+    code: "unsupported-initializer",
+    target: candidate.target,
+    path: [candidate.annotation],
+    message: candidate.message ?? `Cannot mutate ${candidate.target.localName}.${candidate.annotation} because its value is not an object literal`,
+    ...candidate.node.loc ? { loc: candidate.node.loc } : {}
+  }), []);
+}, discoverAnnotations = (csf, storyBindings2, report, markChanged) => {
+  let bindings = new Map(storyBindings2.map((binding) => [binding.localName, binding])), candidates = /* @__PURE__ */ new Map();
+  for (let statement of csf._file.path.get("body"))
+    for (let candidate of annotationCandidates(csf, statement, bindings)) {
+      let identity = `${candidate.target.localName}:${candidate.annotation}`;
+      candidates.set(identity, [...candidates.get(identity) ?? [], candidate]);
+    }
+  return [...candidates.values()].flatMap(
+    (matches) => reportOrCreateAnnotation(matches, report, markChanged)
+  );
+}, discoverCsfObjects = (csf, options, report, markChanged) => {
+  let includeStories = options.stories ?? !0, bindings = includeStories ? storyBindings(csf, report) : [];
+  return [
+    ...options.meta ?? !0 ? discoverMeta(csf, report, markChanged) : [],
+    ...includeStories ? discoverStories(csf, bindings, report, markChanged) : [],
+    ...includeStories ? discoverAnnotations(csf, bindings, report, markChanged) : []
+  ];
+};
+
+// src/csf-tools/findVarInitialization.ts
+import { types as t11 } from "@aussieljk/forkbook/internal/babel";
+var findVarInitialization = (identifier, program) => {
+  let init = null, declarations = null;
+  return program.body.find((node) => (t11.isVariableDeclaration(node) ? declarations = node.declarations : t11.isExportNamedDeclaration(node) && t11.isVariableDeclaration(node.declaration) && (declarations = node.declaration.declarations), declarations && declarations.find((decl) => t11.isVariableDeclarator(decl) && t11.isIdentifier(decl.id) && decl.id.name === identifier ? (init = decl.init, !0) : !1))), init;
+};
+
+// src/csf-tools/CsfFile.ts
+var mutationStates = /* @__PURE__ */ new WeakMap(), PREVIEW_FILE_REGEX = /\/preview(.(js|jsx|mjs|ts|tsx))?$/, isValidPreviewPath = (filepath) => PREVIEW_FILE_REGEX.test(filepath);
+function parseIncludeExclude(prop) {
+  if (t12.isArrayExpression(prop))
+    return prop.elements.map((e) => {
+      if (t12.isStringLiteral(e))
+        return e.value;
+      throw new Error(`Expected string literal: ${e}`);
+    });
+  if (t12.isStringLiteral(prop))
+    return new RegExp(prop.value);
+  if (t12.isRegExpLiteral(prop))
+    return new RegExp(prop.pattern, prop.flags);
+  throw new Error(`Unknown include/exclude: ${prop}`);
+}
+function parseTags(prop) {
+  if (!t12.isArrayExpression(prop))
+    throw new Error("CSF: Expected tags array");
+  return prop.elements.map((e) => {
+    if (t12.isStringLiteral(e))
+      return e.value;
+    throw new Error("CSF: Expected tag to be string literal");
+  });
+}
+function parseTestTags(optionsNode, program) {
+  if (!optionsNode)
+    return [];
+  let node = optionsNode;
+  if (t12.isIdentifier(node) && (node = findVarInitialization(node.name, program)), t12.isObjectExpression(node)) {
+    let tagsProp = node.properties.find(
+      (property) => t12.isObjectProperty(property) && t12.isIdentifier(property.key) && property.key.name === "tags"
+    );
+    if (tagsProp) {
+      let tagsNode = tagsProp.value;
+      return t12.isIdentifier(tagsNode) && (tagsNode = findVarInitialization(tagsNode.name, program)), parseTags(tagsNode);
+    }
+  }
+  return [];
+}
+var formatLocation = (node, fileName) => {
+  let loc = "";
+  if (node.loc) {
+    let { line, column } = node.loc?.start || {};
+    loc = `(line ${line}, col ${column})`;
+  }
+  return `${fileName || ""} ${loc}`.trim();
+}, isModuleMock = (importPath) => MODULE_MOCK_REGEX.test(importPath), isArgsStory = (init, parent, csf) => {
+  let storyFn = init;
+  if (t12.isProgram(parent) && isCanonicalCsf2BindCall(init)) {
+    let boundIdentifier = init.callee.object.name, template = findVarInitialization(boundIdentifier, parent);
+    template && (csf._templates[boundIdentifier] = template, storyFn = template);
+  }
+  return t12.isArrowFunctionExpression(storyFn) || t12.isFunctionDeclaration(storyFn) ? storyFn.params.length > 0 : !1;
+}, parseExportsOrder = (init) => {
+  if (t12.isArrayExpression(init))
+    return init.elements.map((item) => {
+      if (t12.isStringLiteral(item))
+        return item.value;
+      throw new Error(`Expected string literal named export: ${item}`);
+    });
+  throw new Error(`Expected array of string literals: ${init}`);
+}, sortExports = (exportByName, order) => order.reduce(
+  (acc, name) => {
+    let namedExport = exportByName[name];
+    return namedExport && (acc[name] = namedExport), acc;
+  },
+  {}
+), hasMount = (play) => {
+  if (t12.isArrowFunctionExpression(play) || t12.isFunctionDeclaration(play) || t12.isObjectMethod(play)) {
+    let params = play.params;
+    if (params.length >= 1) {
+      let [arg] = params;
+      if (t12.isObjectPattern(arg))
+        return !!arg.properties.find((prop) => {
+          if (t12.isObjectProperty(prop) && t12.isIdentifier(prop.key))
+            return prop.key.name === "mount";
+        });
+    }
+  }
+  return !1;
+}, MODULE_MOCK_REGEX = /^[.\/#].*\.mock($|\.[^.]*$)/i, NoMetaError = class extends Error {
+  constructor(message, ast, fileName) {
+    let msg = message.trim();
+    super(dedent`
+      CSF: ${msg} ${formatLocation(ast, fileName)}
+      
+      More info: https://storybook.js.org/docs/writing-stories?ref=error#default-export
+    `), this.name = this.constructor.name;
+  }
+}, MultipleMetaError = class extends Error {
+  constructor(message, ast, fileName) {
+    let msg = `${message} ${formatLocation(ast, fileName)}`.trim();
+    super(dedent`
+      CSF: ${message} ${formatLocation(ast, fileName)}
+      
+      More info: https://storybook.js.org/docs/writing-stories?ref=error#default-export
+    `), this.name = this.constructor.name;
+  }
+}, MixedFactoryError = class extends Error {
+  constructor(message, ast, fileName) {
+    let msg = `${message} ${formatLocation(ast, fileName)}`.trim();
+    super(dedent`
+      CSF: ${message} ${formatLocation(ast, fileName)}
+      
+      More info: https://storybook.js.org/docs/writing-stories?ref=error#default-export
+    `), this.name = this.constructor.name;
+  }
+}, BadMetaError = class extends Error {
+  constructor(message, ast, fileName) {
+    let msg = "".trim();
+    super(dedent`
+      CSF: ${message} ${formatLocation(ast, fileName)}
+      
+      More info: https://storybook.js.org/docs/writing-stories?ref=error#default-export
+    `), this.name = this.constructor.name;
+  }
+}, CsfFile = class {
+  constructor(ast, options, file) {
+    this._stories = {};
+    this._metaAnnotations = {};
+    this._storyExports = {};
+    this._storyDeclarationPath = {};
+    this._storyPaths = {};
+    this._storyStatements = {};
+    this._storyAnnotations = {};
+    this._templates = {};
+    this._tests = [];
+    this._ast = ast, this._file = file, this._options = options, this.imports = [], mutationStates.set(this, { diagnostics: [], changed: !1 });
+  }
+  /**
+   * Read diagnostics from object discovery, reads, and mutations. Check them before writing
+   * because a file can contain both successful edits and unsupported targets.
+   *
+   * @example
+   * ```ts
+   * const [story] = csf.objects({ meta: false });
+   * story.set(['args', 'old'], 1);
+   * story.set(['args', 'current'], 2);
+   * story.rename(['args', 'old'], 'current');
+   * csf.mutationDiagnostics.map(({ code }) => code); // ['occupied-destination']
+   * ```
+   */
+  get mutationDiagnostics() {
+    return [...mutationStates.get(this).diagnostics];
+  }
+  /**
+   * Report whether any object editor has changed this story file.
+   *
+   * @example
+   * ```ts
+   * csf.changed; // false, before any edits
+   * const [story] = csf.objects({ meta: false });
+   * story.set(['args', 'disabled'], true);
+   * csf.changed; // true
+   * ```
+   */
+  get changed() {
+    return mutationStates.get(this).changed;
+  }
+  /**
+   * Discover editors for the meta and stories, including CSF2 parameter and argTypes assignments. Unsupported
+   * targets are skipped and reported in `mutationDiagnostics`.
+   *
+   * @example
+   * ```ts
+   * const csf = loadCsf('export default {}; export const Primary = {};', {
+   *   makeTitle: () => 'Example',
+   * }).parse();
+   * const [story] = csf.objects({ meta: false });
+   * story.set(['args', 'disabled'], true);
+   * story.getValue(['args']); // { disabled: true }
+   * csf.changed; // true
+   * ```
+   */
+  objects(options = {}) {
+    let state = mutationStates.get(this);
+    return discoverCsfObjects(
+      this,
+      options,
+      (diagnostic) => state.diagnostics.push(diagnostic),
+      () => {
+        state.changed = !0;
+      }
+    );
+  }
+  _parseTitle(value) {
+    let node = t12.isIdentifier(value) ? findVarInitialization(value.name, this._ast.program) : value;
+    if (t12.isStringLiteral(node))
+      return node.value;
+    if (t12.isTSSatisfiesExpression(node) && t12.isStringLiteral(node.expression))
+      return node.expression.value;
+    throw new Error(dedent`
+      CSF: unexpected dynamic title ${formatLocation(node, this._options.fileName)}
+
+      More info: https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#string-literal-titles
+    `);
+  }
+  _parseMeta(declaration, program) {
+    if (this._metaNode)
+      throw new MultipleMetaError("multiple meta objects", declaration, this._options.fileName);
+    this._metaNode = declaration;
+    let meta = {};
+    declaration.properties.forEach((p) => {
+      if (t12.isIdentifier(p.key)) {
+        let value = t12.isObjectMethod(p) ? p : p.value;
+        if (this._metaAnnotations[p.key.name] = value, p.key.name === "title")
+          meta.title = this._parseTitle(p.value);
+        else if (["includeStories", "excludeStories"].includes(p.key.name))
+          meta[p.key.name] = parseIncludeExclude(p.value);
+        else if (p.key.name === "component") {
+          let n = p.value;
+          if (t12.isIdentifier(n)) {
+            let id = n.name, importStmt = program.body.find(
+              (stmt) => t12.isImportDeclaration(stmt) && stmt.specifiers.find((spec) => spec.local.name === id)
+            );
+            if (importStmt) {
+              let { source } = importStmt, specifier = importStmt.specifiers.find((spec) => spec.local.name === id);
+              t12.isStringLiteral(source) && specifier && (this._rawComponentPath = source.value, (t12.isImportSpecifier(specifier) || t12.isImportDefaultSpecifier(specifier)) && (this._componentImportSpecifier = specifier));
+            }
+          }
+          let { code } = recast.print(p.value, {});
+          meta.component = code;
+        } else if (p.key.name === "tags") {
+          let node = p.value;
+          t12.isIdentifier(node) && (node = findVarInitialization(node.name, this._ast.program)), meta.tags = parseTags(node);
+        } else if (p.key.name === "id")
+          if (t12.isStringLiteral(p.value))
+            meta.id = p.value.value;
+          else
+            throw new Error(`Unexpected component id: ${p.value}`);
+      }
+    }), this._meta = meta;
+  }
+  getStoryExport(key) {
+    let node = this._storyExports[key];
+    return node = t12.isVariableDeclarator(node) ? node.init : node, isCanonicalCsf2BindCall(node) && (node = this._templates[node.callee.object.name]), node;
+  }
+  parse() {
+    let self = this;
+    if (traverse2(this._ast, {
+      ExportDefaultDeclaration: {
+        enter(path) {
+          let { node, parent } = path, isVariableReference = t12.isIdentifier(node.declaration) && t12.isProgram(parent);
+          if (self._options.transformInlineMeta && !isVariableReference && t12.isExpression(node.declaration)) {
+            let metaId = path.scope.generateUidIdentifier("meta");
+            self._metaVariableName = metaId.name;
+            let nodes = [
+              t12.variableDeclaration("const", [t12.variableDeclarator(metaId, node.declaration)]),
+              t12.exportDefaultDeclaration(metaId)
+            ];
+            nodes.forEach((_node) => _node.loc = path.node.loc), path.replaceWithMultiple(nodes);
+            return;
+          }
+          let metaNode, decl;
+          if (isVariableReference) {
+            let variableName = node.declaration.name;
+            self._metaVariableName = variableName;
+            let isMetaVariable = (declaration) => t12.isIdentifier(declaration.id) && declaration.id.name === variableName;
+            self._metaStatementPath = self._file.path.get("body").find(
+              (path2) => path2.isVariableDeclaration() && path2.node.declarations.some(isMetaVariable)
+            ), self._metaStatement = self._metaStatementPath?.node, decl = (self?._metaStatement?.declarations || []).find(
+              isMetaVariable
+            )?.init;
+          } else
+            self._metaStatement = node, self._metaStatementPath = path, decl = node.declaration;
+          if (t12.isObjectExpression(decl) ? metaNode = decl : /* export default { ... } as Meta<...> */ /* export default { ... } satisfies Meta<...> */ (t12.isTSAsExpression(decl) || t12.isTSSatisfiesExpression(decl)) && t12.isObjectExpression(decl.expression) ? metaNode = decl.expression : (
+            // export default { ... } satisfies Meta as Meta<...>
+            t12.isTSAsExpression(decl) && t12.isTSSatisfiesExpression(decl.expression) && t12.isObjectExpression(decl.expression.expression) && (metaNode = decl.expression.expression)
+          ), metaNode && t12.isProgram(parent) && self._parseMeta(metaNode, parent), self._metaStatement && !self._metaNode)
+            throw new NoMetaError(
+              "default export must be an object",
+              self._metaStatement,
+              self._options.fileName
+            );
+          self._metaPath = path;
+        }
+      },
+      ExportNamedDeclaration: {
+        enter(path) {
+          let { node, parent } = path, declaration = path.get("declaration"), declarations;
+          declaration.isVariableDeclaration() ? declarations = declaration.get("declarations").filter((d) => d.isVariableDeclarator()) : declaration.isFunctionDeclaration() && (declarations = [declaration]), declarations ? declarations.forEach((declPath) => {
+            let decl = declPath.node, id = declPath.node.id;
+            if (t12.isIdentifier(id)) {
+              let { name: exportName } = id;
+              if (exportName === "__namedExportsOrder" && declPath.isVariableDeclarator()) {
+                self._namedExportsOrder = parseExportsOrder(declPath.node.init);
+                return;
+              }
+              let storyNode;
+              t12.isVariableDeclarator(decl) ? t12.isTSAsExpression(decl.init) && t12.isTSSatisfiesExpression(decl.init.expression) ? storyNode = decl.init.expression.expression : t12.isTSAsExpression(decl.init) || t12.isTSSatisfiesExpression(decl.init) ? storyNode = decl.init.expression : storyNode = decl.init : storyNode = decl;
+              let storyIsFactory = !1;
+              if (storyNode && isCsfFactoryCall(storyNode) && (storyIsFactory = !0, storyNode = storyNode.arguments[0]), self._metaIsFactory && !storyIsFactory)
+                return;
+              if (!self._metaIsFactory && storyIsFactory)
+                throw self._metaNode ? new MixedFactoryError(
+                  "expected non-factory story",
+                  storyNode,
+                  self._options.fileName
+                ) : new BadMetaError(
+                  "meta() factory must be imported from .forkbook/preview configuration",
+                  storyNode,
+                  self._options.fileName
+                );
+              self._storyExports[exportName] = decl, self._storyDeclarationPath[exportName] = declPath, self._storyPaths[exportName] = path, self._storyStatements[exportName] = node;
+              let name = storyNameFromExport(exportName);
+              self._storyAnnotations[exportName] ? logger.warn(
+                `Unexpected annotations for "${exportName}" before story declaration`
+              ) : self._storyAnnotations[exportName] = {};
+              let parameters = {};
+              t12.isObjectExpression(storyNode) ? (parameters.__isArgsStory = !0, storyNode.properties.forEach((p) => {
+                if (t12.isIdentifier(p.key)) {
+                  let key = p.key.name;
+                  if (t12.isObjectMethod(p))
+                    self._storyAnnotations[exportName][key] = p;
+                  else {
+                    if (p.key.name === "render")
+                      parameters.__isArgsStory = isArgsStory(
+                        p.value,
+                        parent,
+                        self
+                      );
+                    else if (p.key.name === "name" && t12.isStringLiteral(p.value))
+                      name = p.value.value;
+                    else if (p.key.name === "storyName" && t12.isStringLiteral(p.value))
+                      logger.warn(
+                        `Unexpected usage of "storyName" in "${exportName}". Please use "name" instead.`
+                      );
+                    else if (p.key.name === "parameters" && t12.isObjectExpression(p.value)) {
+                      let idProperty = p.value.properties.find(
+                        (property) => t12.isObjectProperty(property) && t12.isIdentifier(property.key) && property.key.name === "__id"
+                      );
+                      idProperty && (parameters.__id = idProperty.value.value);
+                    }
+                    self._storyAnnotations[exportName][p.key.name] = p.value;
+                  }
+                }
+              })) : parameters.__isArgsStory = isArgsStory(storyNode, parent, self), self._stories[exportName] = {
+                id: "FIXME",
+                name,
+                parameters,
+                __stats: {
+                  factory: storyIsFactory
+                }
+              };
+            }
+          }) : node.specifiers.length > 0 && node.specifiers.forEach((specifier) => {
+            if (t12.isExportSpecifier(specifier) && (t12.isIdentifier(specifier.exported) || t12.isStringLiteral(specifier.exported))) {
+              let exportName = t12.isIdentifier(specifier.exported) ? specifier.exported.name : specifier.exported.value, { name: localName } = specifier.local, decl = t12.isProgram(parent) ? findVarInitialization(localName, parent) : specifier.local;
+              if (exportName === "default") {
+                self._metaVariableName = localName;
+                let metaNode;
+                t12.isObjectExpression(decl) ? metaNode = decl : /* export default { ... } as Meta<...> */ /* export default { ... } satisfies Meta<...> */ (t12.isTSAsExpression(decl) || t12.isTSSatisfiesExpression(decl)) && t12.isObjectExpression(decl.expression) ? metaNode = decl.expression : (
+                  // export default { ... } satisfies Meta as Meta<...>
+                  t12.isTSAsExpression(decl) && t12.isTSSatisfiesExpression(decl.expression) && t12.isObjectExpression(decl.expression.expression) && (metaNode = decl.expression.expression)
+                ), metaNode && t12.isProgram(parent) && self._parseMeta(metaNode, parent);
+              } else {
+                let annotations = {}, storyNode = decl;
+                t12.isObjectExpression(storyNode) && storyNode.properties.forEach((p) => {
+                  t12.isIdentifier(p.key) && (annotations[p.key.name] = p.value);
+                }), self._storyAnnotations[exportName] = annotations, self._storyStatements[exportName] = decl, self._storyPaths[exportName] = path, self._stories[exportName] = {
+                  id: "FIXME",
+                  name: exportName,
+                  localName,
+                  parameters: {},
+                  __stats: {}
+                };
+              }
+            }
+          });
+        }
+      },
+      ExpressionStatement: {
+        enter({ node, parent }) {
+          let { expression } = node;
+          if (t12.isProgram(parent) && t12.isAssignmentExpression(expression) && t12.isMemberExpression(expression.left) && t12.isIdentifier(expression.left.object) && t12.isIdentifier(expression.left.property)) {
+            let exportName = expression.left.object.name, annotationKey = expression.left.property.name, annotationValue = expression.right;
+            if (self._storyAnnotations[exportName] && (self._storyAnnotations[exportName][annotationKey] = annotationValue), annotationKey === "storyName" && t12.isStringLiteral(annotationValue)) {
+              let storyName = annotationValue.value, story = self._stories[exportName];
+              if (!story)
+                return;
+              story.name = storyName;
+            }
+          }
+          if (t12.isCallExpression(expression) && t12.isMemberExpression(expression.callee) && t12.isIdentifier(expression.callee.object) && t12.isIdentifier(expression.callee.property) && expression.callee.property.name === "test" && expression.arguments.length >= 2 && t12.isStringLiteral(expression.arguments[0])) {
+            let exportName = expression.callee.object.name, testName = expression.arguments[0].value, testFunction = expression.arguments.length === 2 ? expression.arguments[1] : expression.arguments[2], testArguments = expression.arguments.length === 2 ? null : expression.arguments[1], tags = parseTestTags(testArguments, self._ast.program);
+            self._tests.push({
+              function: testFunction,
+              name: testName,
+              node: expression,
+              // can't set id because meta title isn't available yet
+              // so it's set later on
+              id: "FIXME",
+              tags,
+              parent: { node: self._storyStatements[exportName] }
+            }), self._stories[exportName].__stats.tests = !0;
+          }
+        }
+      },
+      CallExpression: {
+        enter(path) {
+          let { node } = path, { callee } = node;
+          if (t12.isIdentifier(callee) && callee.name === "storiesOf")
+            throw new Error(dedent`
+              Unexpected \`storiesOf\` usage: ${formatLocation(node, self._options.fileName)}.
+
+              \`storiesOf\` was removed in Forkbook 8.0. Write stories in CSF instead.
+            `);
+          if (t12.isMemberExpression(callee) && t12.isIdentifier(callee.property) && callee.property.name === "meta" && !callee.computed) {
+            let rootObject = callee.object;
+            if (t12.isCallExpression(rootObject) && t12.isMemberExpression(rootObject.callee) && (rootObject = rootObject.callee.object), t12.isIdentifier(rootObject)) {
+              let configParent = path.scope.getBinding(rootObject.name)?.path?.parentPath?.node;
+              if (t12.isImportDeclaration(configParent)) {
+                if (isValidPreviewPath(configParent.source.value)) {
+                  self._metaIsFactory = !0, self._metaFactoryCall = node;
+                  let metaDeclarator = path.findParent((p) => p.isVariableDeclarator());
+                  self._metaVariableName = metaDeclarator?.isVariableDeclarator() && t12.isIdentifier(metaDeclarator.node.id) ? metaDeclarator.node.id.name : callee.property.name;
+                  let [argument] = node.arguments, argumentBinding = argument && t12.isIdentifier(argument) ? path.scope.getBinding(argument.name) : void 0, argumentNode = argumentBinding?.constant && argumentBinding.path.isVariableDeclarator() ? argumentBinding.path.node.init : argument, unwrappedArgument = argumentNode && unwrapExpression(argumentNode);
+                  t12.isObjectExpression(unwrappedArgument) ? self._parseMeta(unwrappedArgument, self._ast.program) : (self._metaNodeIsSynthetic = !0, self._parseMeta(t12.objectExpression([]), self._ast.program));
+                } else if (rootObject.name === "preview")
+                  throw new BadMetaError(
+                    "meta() factory must be imported from .forkbook/preview configuration",
+                    configParent,
+                    self._options.fileName
+                  );
+              }
+            }
+          }
+        }
+      },
+      ImportDeclaration: {
+        enter({ node }) {
+          let { source } = node;
+          if (t12.isStringLiteral(source))
+            self.imports.push(source.value);
+          else
+            throw new Error("CSF: unexpected import source");
+        }
+      }
+    }), !self._meta)
+      throw new NoMetaError("missing default export", self._ast, self._options.fileName);
+    let entries = Object.entries(self._stories);
+    if (self._meta.title = this._options.makeTitle(self._meta?.title), self._metaAnnotations.play && (self._meta.tags = [...self._meta.tags || [], Tag.PLAY_FN]), self._stories = entries.reduce(
+      (acc, [key, story]) => {
+        if (!isExportStory(key, self._meta))
+          return acc;
+        let id = story.parameters?.__id ?? toId(self._meta?.id || self._meta?.title, storyNameFromExport(key)), parameters = { ...story.parameters, __id: id }, { includeStories } = self._meta || {};
+        key === "__page" && (entries.length === 1 || Array.isArray(includeStories) && includeStories.length === 1) && (parameters.docsOnly = !0), acc[key] = { ...story, id, parameters };
+        let storyAnnotations = self._storyAnnotations[key], { tags, play } = storyAnnotations;
+        if (tags) {
+          let node = t12.isIdentifier(tags) ? findVarInitialization(tags.name, this._ast.program) : tags;
+          acc[key].tags = parseTags(node);
+        }
+        play && (acc[key].tags = [...acc[key].tags || [], Tag.PLAY_FN]);
+        let stats = acc[key].__stats;
+        ["play", "render", "loaders", "beforeEach", "globals", "tags"].forEach((annotation) => {
+          stats[annotation] = !!storyAnnotations[annotation] || !!self._metaAnnotations[annotation];
+        });
+        let storyExport = self.getStoryExport(key);
+        stats.storyFn = !!(t12.isArrowFunctionExpression(storyExport) || t12.isFunctionDeclaration(storyExport)), stats.mount = hasMount(storyAnnotations.play ?? self._metaAnnotations.play), stats.moduleMock = !!self.imports.find((fname) => isModuleMock(fname));
+        let storyNode = self._storyStatements[key], storyTests = self._tests.filter((t13) => t13.parent.node === storyNode);
+        return storyTests.length > 0 && (stats.tests = !0, storyTests.forEach((test) => {
+          test.id = toTestId(id, test.name);
+        })), acc;
+      },
+      {}
+    ), Object.keys(self._storyExports).forEach((key) => {
+      isExportStory(key, self._meta) || (delete self._storyExports[key], delete self._storyAnnotations[key], delete self._storyStatements[key]);
+    }), self._namedExportsOrder) {
+      let unsortedExports = Object.keys(self._storyExports);
+      self._storyExports = sortExports(self._storyExports, self._namedExportsOrder), self._stories = sortExports(self._stories, self._namedExportsOrder);
+      let sortedExports = Object.keys(self._storyExports);
+      if (unsortedExports.length !== sortedExports.length)
+        throw new Error(
+          `Missing exports after sort: ${unsortedExports.filter(
+            (key) => !sortedExports.includes(key)
+          )}`
+        );
+    }
+    return self;
+  }
+  get meta() {
+    return this._meta;
+  }
+  get stories() {
+    return Object.values(this._stories);
+  }
+  getStoryTests(story) {
+    let storyNode = typeof story == "string" ? this._storyStatements[story] : story;
+    return storyNode ? this._tests.filter((t13) => t13.parent.node === storyNode) : [];
+  }
+  get indexInputs() {
+    let { fileName } = this._options;
+    if (!fileName)
+      throw new Error(
+        dedent`Cannot automatically create index inputs with CsfFile.indexInputs because the CsfFile instance was created without a the fileName option.
+        Either add the fileName option when creating the CsfFile instance, or create the index inputs manually.`
+      );
+    let index = [];
+    return Object.entries(this._stories).map(([exportName, story]) => {
+      let tags = [...this._meta?.tags ?? [], ...story.tags ?? []], storyInput = {
+        rawComponentPath: this._rawComponentPath,
+        exportName,
+        title: this.meta?.title,
+        metaId: this.meta?.id,
+        tags,
+        __id: story.id,
+        __stats: story.__stats
+      }, tests = this.getStoryTests(exportName), hasTests = tests.length > 0;
+      index.push({
+        ...storyInput,
+        type: "story",
+        subtype: "story",
+        name: story.name
+      }), hasTests && tests.forEach((test) => {
+        index.push({
+          ...storyInput,
+          // TODO implementent proper title => path behavior in `transformStoryIndexToStoriesHash`
+          // title: `${storyInput.title}/${story.name}`,
+          type: "story",
+          subtype: "test",
+          name: test.name,
+          parent: story.id,
+          parentName: story.name,
+          tags: [
+            ...storyInput.tags,
+            // this tag comes before test tags so users can invert if they like
+            `!${Tag.AUTODOCS}`,
+            ...test.tags,
+            // this tag comes after test tags so users can't change it
+            Tag.TEST_FN
+          ],
+          __id: test.id
+        });
+      });
+    }), index;
+  }
+}, babelParseFile = ({
+  code,
+  filename = "",
+  ast
+}) => new BabelFileClass(
+  { filename, highlightCode: !1 },
+  { code, ast: ast ?? babelParse2(code) }
+), loadCsf = (code, options) => {
+  let ast = babelParse2(code), file = babelParseFile({ code, filename: options.fileName, ast });
+  return new CsfFile(ast, options, file);
+}, formatCsf = (csf, options = { sourceMaps: !1 }, code) => {
+  let result = generate3(csf._ast, options, code);
+  return options.sourceMaps ? result : result.code;
+}, printCsf = (csf, options = {}) => recast.print(csf._ast, {
+  // Recast defaults this to `os.EOL`, which would carriage-return printed files on Windows.
+  lineTerminator: `
+`,
+  ...options
+}), readCsf = async (fileName, options) => {
+  let code = (await readFile(fileName, "utf-8")).toString();
+  return loadCsf(code, { ...options, fileName });
+}, writeCsf = async (csf, fileName) => {
+  if (!(fileName || csf._options.fileName))
+    throw new Error("Please specify a fileName for writeCsf");
+  await writeFile(fileName, printCsf(csf).code);
+};
+
+// src/csf-tools/story-shape/reference-context.ts
+function createStoryReferenceResolver(options = {}) {
+  let resolver = createModuleResolver({
+    extensions: [...options.extensions ?? [], ...jsTsSourceExtensions],
+    mainFields: ["module", "main"],
+    tsconfig: "auto"
+  });
+  return function() {
+    let parsed = /* @__PURE__ */ new Map();
+    return {
+      externalize: options.externalize ?? selfContained,
+      resolveModule: (fromFile, specifier) => {
+        let filePath;
+        try {
+          filePath = resolver.resolveFileSync(fromFile, specifier);
+        } catch {
+          return;
+        }
+        return parsed.has(filePath) || parsed.set(filePath, parseReferenceModule(filePath)), parsed.get(filePath);
+      }
+    };
+  };
+}
+var parseReferenceModule = (filePath) => {
+  try {
+    let code = readFileSync(filePath, "utf8");
+    return { program: babelParseFile({ code, filename: filePath }).path, filePath };
+  } catch {
+    return;
+  }
+}, selfContained = (node) => isSelfContained(node) ? node : void 0;
+
+export {
+  defaultResolveConditionNames,
+  createModuleResolver,
+  isTypeSpecifier,
+  importedName,
+  collectImportBindings,
+  resolveComponentImport,
+  buildImportStatements,
+  unwrapExpression,
+  isCanonicalCsf2BindCall,
+  withoutTypeCalls,
+  isCsfFactoryCall,
+  csfFactoryReceiver,
+  templateParts,
+  keyOf,
+  propertyValue,
+  returnedExpression,
+  returnedExpressionPath,
+  resolveReturnedObjectExpression,
+  resolveIdentifierInit,
+  pathForNode,
+  metaObjectPath,
+  sourceOf,
+  resolveObjectMembers,
+  resolveArgsRecord,
+  resolveBindingMembers,
+  resolveReferencedValue,
+  resolveArgValue,
+  isSelfContained,
+  authoredSource,
+  enrichCsfStory,
+  enrichCsfMeta,
+  enrichCsf,
+  extractSource,
+  extractDescription,
+  extractJSDocInfo,
+  extractComponentDescription,
+  jsDocTagsForPath,
+  extractStoryJSDocInfo,
+  normalizeStoryDeclaration,
+  createStoryArgsResolver,
+  unresolvedWarning,
+  noSnippetWarning,
+  resolveRenderFunction,
+  resolveEffectiveRender,
+  createCsfObject,
+  isValidPreviewPath,
+  isModuleMock,
+  NoMetaError,
+  MultipleMetaError,
+  MixedFactoryError,
+  BadMetaError,
+  CsfFile,
+  babelParseFile,
+  loadCsf,
+  formatCsf,
+  printCsf,
+  readCsf,
+  writeCsf,
+  createStoryReferenceResolver,
+  parseReferenceModule
+};