@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

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

@@ -0,0 +1,1133 @@
+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 {
+  createCsfObject,
+  pathForNode,
+  unwrapExpression
+} from "./chunk-YZFWBA5L.js";
+import {
+  invariant
+} from "./chunk-34EO2PUT.js";
+
+// src/csf-tools/ConfigFile.ts
+import { readFile, writeFile } from "node:fs/promises";
+import {
+  babelParse,
+  generate,
+  recast,
+  types as t2,
+  traverse as traverse2
+} from "@aussieljk/forkbook/internal/babel";
+import { logger } from "@aussieljk/forkbook/internal/node-logger";
+import { dedent } from "ts-dedent";
+
+// src/csf-tools/ConfigObject.ts
+import { traverse, types as t } from "@aussieljk/forkbook/internal/babel";
+var isConfigFactory = (callee) => {
+  if (!callee.isIdentifier())
+    return !1;
+  let binding = callee.scope.getBinding(callee.node.name), name = binding?.path.isImportSpecifier() ? binding.path.node.imported : binding ? void 0 : callee.node;
+  return t.isIdentifier(name) && ["defineMain", "definePreview", "defineConfig"].includes(name.name);
+}, isExportReference = (reference) => {
+  let parent = reference.parentPath;
+  return parent ? parent.isTSAsExpression() || parent.isTSSatisfiesExpression() || parent.isTSNonNullExpression() ? isExportReference(parent) : reference.isExportNamedDeclaration() || parent.isExportDefaultDeclaration() || parent.isExportSpecifier() || parent.isAssignmentExpression() && t.isMemberExpression(parent.node.left) && t.isIdentifier(parent.node.left.object, { name: "module" }) && t.isIdentifier(parent.node.left.property, { name: "exports" }) : !1;
+};
+function createConfigObject(config, mode, report, markChanged) {
+  let result = {
+    ok: !1,
+    diagnostic: {
+      code: "unsupported-initializer",
+      target: { kind: "config" },
+      path: [],
+      message: "Cannot find a mutable config root"
+    }
+  }, reject = (node, code, message) => {
+    result = {
+      ok: !1,
+      diagnostic: {
+        code,
+        target: { kind: "config" },
+        path: [],
+        message,
+        ...node.loc ? { loc: node.loc } : {}
+      }
+    };
+  };
+  return traverse(config._ast, {
+    Program(program) {
+      program.stop();
+      let assignments = [];
+      program.traverse({
+        AssignmentExpression(path) {
+          let { left } = path.node;
+          t.isMemberExpression(left) && (t.isIdentifier(left.object, { name: "module" }) && (t.isIdentifier(left.property, { name: "exports" }) || t.isStringLiteral(left.property, { value: "exports" })) || t.isIdentifier(left.object, { name: "exports" })) && assignments.push(path);
+        }
+      });
+      let root = pathForNode(program, config._exportsObject);
+      if (root) {
+        let declaration = root.findParent((parent) => parent.isVariableDeclarator());
+        if (mode === "mutate" && Object.values(config._exportDecls).some((exported) => exported !== declaration?.node)) {
+          reject(
+            root.node,
+            "ambiguous-binding",
+            "Cannot mutate mixed default and named config exports"
+          );
+          return;
+        }
+        for (let parent = root.parentPath; parent && !parent.isProgram(); parent = parent.parentPath) {
+          if (!parent.isCallExpression())
+            continue;
+          let callee = parent.get("callee");
+          if (!(callee.isMemberExpression() && !callee.node.computed && t.isIdentifier(callee.node.property, { name: "type" }) && parent.node.arguments.length === 0) && !(isConfigFactory(callee) && parent.node.arguments.length === 1)) {
+            reject(
+              parent.node,
+              "unsupported-initializer",
+              "Cannot mutate an arbitrary config factory call"
+            );
+            return;
+          }
+        }
+        let statement = root.getStatementParent();
+        if (statement?.isExpressionStatement() && (!t.isAssignmentExpression(statement.node.expression) || !t.isMemberExpression(statement.node.expression.left) || !t.isIdentifier(statement.node.expression.left.object, { name: "module" }) || !t.isIdentifier(statement.node.expression.left.property, { name: "exports" }))) {
+          reject(
+            root.node,
+            "ambiguous-binding",
+            "Cannot mutate a config that is not directly exported"
+          );
+          return;
+        }
+        if (!statement?.parentPath.isProgram() && !statement?.parentPath.isExportNamedDeclaration()) {
+          reject(
+            root.node,
+            "unsupported-initializer",
+            "Cannot mutate a config declared inside a function or conditional"
+          );
+          return;
+        }
+        if (declaration?.isVariableDeclarator() && t.isIdentifier(declaration.node.id)) {
+          let binding = declaration.scope.getBinding(declaration.node.id.name);
+          if (!binding?.constant || binding.referencePaths.length !== 1 || !binding.referencePaths.every(isExportReference)) {
+            reject(
+              declaration.node,
+              "ambiguous-binding",
+              "Cannot mutate a shared or reassigned config binding"
+            );
+            return;
+          }
+        }
+        if (assignments.length > 1 || assignments.some(
+          (assignment) => assignment.scope.hasBinding("module") || t.isMemberExpression(assignment.node.left) && assignment.node.left.computed || !assignment.parentPath.parentPath?.isProgram()
+        )) {
+          reject(
+            root.node,
+            "ambiguous-binding",
+            "Cannot mutate conditional, repeated, or shadowed module.exports"
+          );
+          return;
+        }
+        result = {
+          ok: !0,
+          object: createCsfObject({ kind: "config" }, root, [], report, markChanged)
+        };
+        return;
+      }
+      if (config.hasDefaultExport || assignments.length > 0) {
+        reject(
+          config._ast.program,
+          "unsupported-initializer",
+          "Cannot mutate a config without a static object initializer"
+        );
+        return;
+      }
+      let named = /* @__PURE__ */ new Map(), virtualRoot = t.objectExpression([]), seen = /* @__PURE__ */ new Set();
+      for (let statement of program.get("body"))
+        if (!(statement.isExportNamedDeclaration() && statement.node.exportKind === "type")) {
+          if (statement.isExportAllDeclaration() || statement.isExportNamedDeclaration() && statement.node.source) {
+            reject(
+              statement.node,
+              "unsupported-initializer",
+              "Cannot mutate re-exported config fields"
+            );
+            return;
+          }
+          if (statement.isExportNamedDeclaration())
+            for (let specifier of statement.get("specifiers")) {
+              if (!specifier.isExportSpecifier() || specifier.node.exportKind === "type")
+                continue;
+              let name = t.isIdentifier(specifier.node.exported) ? specifier.node.exported.name : specifier.node.exported.value;
+              if (!Object.hasOwn(config._exportDecls, name)) {
+                reject(
+                  specifier.node,
+                  "unsupported-initializer",
+                  `Cannot mutate the unresolved ${name} export`
+                );
+                return;
+              }
+            }
+        }
+      for (let [name, node] of Object.entries(config._exportDecls)) {
+        let declaration = pathForNode(program, node);
+        if (!(declaration?.isVariableDeclarator() || declaration?.isFunctionDeclaration()) || !t.isIdentifier(declaration.node.id)) {
+          reject(
+            node,
+            "unsupported-initializer",
+            `Cannot mutate the ${name} export without an expression initializer`
+          );
+          return;
+        }
+        let binding = declaration.scope.getBinding(declaration.node.id.name);
+        if (!binding?.constant || seen.has(node) || mode === "mutate" && !binding.referencePaths.every(isExportReference)) {
+          reject(
+            node,
+            "ambiguous-binding",
+            `Cannot mutate the shared or reassigned ${name} export`
+          );
+          return;
+        }
+        seen.add(node);
+        let specifier = binding.referencePaths.find(
+          (path) => path.parentPath?.isExportSpecifier()
+        )?.parentPath, value = declaration.isFunctionDeclaration() ? t.toExpression(t.cloneNode(declaration.node)) : declaration.node.init;
+        if (!t.isExpression(value)) {
+          reject(
+            node,
+            "unsupported-initializer",
+            `Cannot mutate the ${name} export without an expression initializer`
+          );
+          return;
+        }
+        let property = t.objectProperty(t.stringLiteral(name), value);
+        virtualRoot.properties.push(property), named.set(property, {
+          declaration,
+          ...specifier?.isExportSpecifier() ? { specifier } : {}
+        });
+      }
+      let syncExports = () => {
+        for (let [property, entry] of named)
+          virtualRoot.properties.includes(property) || (entry.specifier ? entry.specifier.remove() : entry.declaration.remove(), named.delete(property));
+        for (let property of virtualRoot.properties) {
+          if (!t.isObjectProperty(property) || !t.isExpression(property.value))
+            continue;
+          let name = t.isIdentifier(property.key) ? property.key.name : t.isStringLiteral(property.key) ? property.key.value : void 0;
+          if (name === void 0)
+            continue;
+          let entry = named.get(property);
+          if (entry) {
+            if (entry.declaration.isFunctionDeclaration())
+              if (t.isFunctionExpression(property.value) && (!property.value.id || property.value.id.name === entry.declaration.node.id?.name)) {
+                let { params, body, async, generator, returnType, typeParameters } = property.value;
+                Object.assign(entry.declaration.node, {
+                  params,
+                  body,
+                  async,
+                  generator,
+                  returnType,
+                  typeParameters
+                });
+              } else {
+                let id2 = entry.declaration.node.id;
+                if (!id2)
+                  continue;
+                let variable2 = t.variableDeclarator(id2, property.value);
+                entry.declaration.replaceWith(t.variableDeclaration("const", [variable2]));
+                let path = pathForNode(program, variable2);
+                path && (entry.declaration = path);
+              }
+            else entry.declaration.isVariableDeclarator() && (entry.declaration.node.init = property.value);
+            if (entry.specifier) {
+              entry.specifier.node.exported = t.isValidIdentifier(name) ? t.identifier(name) : t.stringLiteral(name);
+              continue;
+            }
+            if (t.isValidIdentifier(name) && (t.isIdentifier(entry.declaration.node.id, { name }) || !program.scope.hasBinding(name))) {
+              entry.declaration.node.id = t.identifier(name);
+              continue;
+            }
+            entry.declaration.remove();
+          }
+          let id = t.isValidIdentifier(name) && !program.scope.hasBinding(name) ? t.identifier(name) : program.scope.generateUidIdentifier(name), declaration = t.variableDeclarator(id, property.value), variable = t.variableDeclaration("const", [declaration]);
+          if (id.name === name)
+            program.pushContainer("body", t.exportNamedDeclaration(variable));
+          else {
+            let specifier = t.exportSpecifier(
+              id,
+              t.isValidIdentifier(name) ? t.identifier(name) : t.stringLiteral(name)
+            );
+            program.pushContainer("body", [variable, t.exportNamedDeclaration(null, [specifier])]);
+          }
+          let declarationPath = pathForNode(program, declaration);
+          if (declarationPath) {
+            let specifierPath = program.get("body").flatMap(
+              (statement) => statement.isExportNamedDeclaration() ? statement.get("specifiers") : []
+            ).find((specifier) => specifier.isExportSpecifier() && specifier.node.local === id);
+            named.set(property, {
+              declaration: declarationPath,
+              ...specifierPath?.isExportSpecifier() ? { specifier: specifierPath } : {}
+            });
+          }
+        }
+        program.scope.crawl(), markChanged();
+      };
+      result = {
+        ok: !0,
+        object: createCsfObject(
+          { kind: "config" },
+          {
+            node: virtualRoot,
+            detached: !0,
+            scope: program.scope,
+            buildCodeFrameError: program.buildCodeFrameError.bind(program)
+          },
+          [],
+          report,
+          syncExports
+        )
+      };
+    }
+  }), result;
+}
+
+// src/csf-tools/ConfigFile.ts
+var getCsfParsingErrorMessage = ({
+  fileName,
+  expectedType,
+  foundType,
+  node
+}) => dedent`
+      CSF Parsing error in ${fileName ?? "a config file"}: Expected '${expectedType}' but found '${foundType}' instead in '${node?.type}'.
+    `, propKey = (p) => t2.isIdentifier(p.key) ? p.key.name : t2.isStringLiteral(p.key) ? p.key.value : null, _getPath = (path, node) => {
+  if (path.length === 0)
+    return node;
+  if (t2.isObjectExpression(node)) {
+    let [first, ...rest] = path, field = node.properties.find((p) => propKey(p) === first);
+    if (field)
+      return _getPath(rest, field.value);
+  }
+}, _getPathProperties = (path, node) => {
+  if (path.length === 0) {
+    if (t2.isObjectExpression(node))
+      return node.properties;
+    throw new Error("Expected object expression");
+  }
+  if (t2.isObjectExpression(node)) {
+    let [first, ...rest] = path, field = node.properties.find((p) => propKey(p) === first);
+    if (field)
+      return rest.length === 0 ? node.properties : _getPathProperties(rest, field.value);
+  }
+}, _findVarDeclarator = (identifier, program) => {
+  let declarator = null, declarations = null;
+  return program.body.find((node) => (t2.isVariableDeclaration(node) ? declarations = node.declarations : t2.isExportNamedDeclaration(node) && t2.isVariableDeclaration(node.declaration) && (declarations = node.declaration.declarations), declarations && declarations.find((decl) => t2.isVariableDeclarator(decl) && t2.isIdentifier(decl.id) && decl.id.name === identifier ? (declarator = decl, !0) : !1))), declarator;
+}, _findVarInitialization = (identifier, program) => _findVarDeclarator(identifier, program)?.init, NEXT_LINE_DIRECTIVE = /^\s*(@ts-(expect-error|ignore)|[a-z]+-disable-next-line|prettier-ignore|biome-ignore)\b/, getHeaderComments = (statement) => {
+  let leading = (statement?.comments ?? []).filter((comment) => comment.leading), directive = leading.findIndex(({ value }) => NEXT_LINE_DIRECTIVE.test(value));
+  return directive === -1 ? leading : leading.slice(0, directive);
+}, prependStatement = (program, statement) => {
+  let first = program.body[0], header = getHeaderComments(first);
+  if (!first || !header.length) {
+    program.body.unshift(statement);
+    return;
+  }
+  let firstNonImport = program.body.findIndex((node) => !t2.isImportDeclaration(node)), index = firstNonImport === -1 ? program.body.length : firstNonImport;
+  if (index === 0) {
+    let notHeader = (comment) => !header.includes(comment);
+    first.comments = first.comments?.filter(notHeader), first.leadingComments = first.leadingComments?.filter(notHeader), Object.assign(statement, { comments: header, leadingComments: header });
+  }
+  program.body.splice(index, 0, statement);
+}, ConfigFile = class {
+  constructor(ast, code, fileName) {
+    /**
+     * Identify the config, meta, story, annotation, or call argument this editor represents.
+     *
+     * @example
+     * ```ts
+     * const object = loadConfig('export default {};').parse();
+     * object.target; // { kind: 'config' }
+     * ```
+     */
+    this.target = { kind: "config" };
+    // No member may be private: core resolves this class from both src and dist, and any private
+    // member makes the emitted class type nominal, so the two identities stop being assignable.
+    this._changed = !1;
+    this._mutationDiagnostics = [];
+    this._exports = {};
+    // FIXME: this is a hack. this is only used in the case where the user is
+    // modifying a named export that's a scalar. The _exports map is not suitable
+    // for that. But rather than refactor the whole thing, we just use this as a stopgap.
+    this._exportDecls = {};
+    this.hasDefaultExport = !1;
+    /** Unwraps TS assertions/satisfies from a node, to get the underlying node. */
+    this._unwrap = (node) => t2.isTSAsExpression(node) || t2.isTSSatisfiesExpression(node) ? this._unwrap(node.expression) : node;
+    /**
+     * Resolve a declaration node by unwrapping TS assertions/satisfies and following identifiers to
+     * resolve the correct node in case it's an identifier.
+     */
+    this._resolveDeclaration = (node, parent = this._ast.program) => {
+      let decl = this._unwrap(node);
+      if (t2.isIdentifier(decl) && t2.isProgram(parent)) {
+        let initialization = _findVarInitialization(decl.name, parent);
+        return initialization ? this._unwrap(initialization) : decl;
+      }
+      return decl;
+    };
+    this._ast = ast, this._code = code, this.fileName = fileName;
+  }
+  /**
+   * Report whether this editor has applied a mutation. Reads and no-op edits leave it unchanged.
+   *
+   * @example
+   * ```ts
+   * const object = loadConfig('export default {};').parse();
+   * object.changed; // false
+   * object.set(['tags'], ['autodocs']);
+   * object.changed; // true
+   * ```
+   */
+  get changed() {
+    return this._changed;
+  }
+  /**
+   * Read diagnostics from unsupported discovery, reads, or mutations. `writeConfig` refuses to
+   * write a config with diagnostics, even if another edit succeeded.
+   *
+   * @example
+   * ```ts
+   * const config = loadConfig('export default { old: 1, current: 2 };').parse();
+   * config.rename(['old'], 'current');
+   * config.mutationDiagnostics.map(({ code }) => code); // ['occupied-destination']
+   * config.changed; // false
+   * ```
+   */
+  get mutationDiagnostics() {
+    return [...this._mutationDiagnostics];
+  }
+  /**
+   * Read a copy of the Babel expression at a property path. Missing fields return `undefined`.
+   *
+   * @example
+   * ```ts
+   * const object = loadConfig("export default { tags: ['docs'] };").parse();
+   * object.get(['tags'])?.type; // 'ArrayExpression'
+   * object.get(['missing']); // undefined
+   * ```
+   */
+  get(path) {
+    let editor = this._editor("read");
+    return editor.ok ? editor.object.get(path) : void 0;
+  }
+  /**
+   * Read plain values without executing code. Missing fields return `undefined`; unresolved
+   * expressions also return `undefined` and add a mutation diagnostic.
+   *
+   * @example
+   * ```ts
+   * const object = loadConfig("export default { tags: ['docs'], enabled: true };").parse();
+   * object.getValue(['tags']); // ['docs']
+   * object.getValue(['enabled']); // true
+   * object.getValue(['missing']); // undefined
+   * ```
+   */
+  getValue(path) {
+    let editor = this._editor("read");
+    return editor.ok ? editor.object.getValue(path) : void 0;
+  }
+  /**
+   * Set a plain value or Babel expression, creating missing parents. Accepts nested arrays and
+   * objects; top-level expression-shaped objects are interpreted as AST nodes.
+   *
+   * @example
+   * ```ts
+   * const object = loadConfig('export default {};').parse();
+   * object.set(['parameters', 'a11y'], { test: 'todo', enabled: true });
+   * // { ok: true, changed: true }
+   * object.getValue(['parameters']); // { a11y: { test: 'todo', enabled: true } }
+   * ```
+   */
+  set(path, value) {
+    return this._mutate((object) => object.set(path, value));
+  }
+  /**
+   * Replace a value using its live Babel expression. Reused nodes preserve their source formatting.
+   * Return a new node, or `undefined` to leave the value unchanged. Do not mutate or retain the input
+   * node: such changes bypass change tracking and diagnostics.
+   *
+   * @example
+   * ```ts
+   * const object = loadConfig("export default { tags: ['docs'] };").parse();
+   * object.transform(['tags'], (value) =>
+   *   t.arrayExpression([t.spreadElement(value), t.stringLiteral('autodocs')])
+   * ); // { ok: true, changed: true }
+   * object.getValue(['tags']); // ['docs', 'autodocs']
+   * ```
+   */
+  transform(path, derive) {
+    return this._mutate((object) => object.transform(path, derive));
+  }
+  /**
+   * Remove a property and recursively clean up empty parents. Missing fields are a no-op.
+   *
+   * @example
+   * ```ts
+   * const object = loadConfig('export default { parameters: { a11y: { disable: true } } };').parse();
+   * object.remove(['parameters', 'a11y', 'disable']); // { ok: true, changed: true }
+   * object.getValue(['parameters']); // undefined
+   * object.remove(['parameters']); // { ok: true, changed: false }
+   * ```
+   */
+  remove(path) {
+    return this._mutate((object) => object.remove(path));
+  }
+  /**
+   * Rename a property within its parent. An occupied destination produces a diagnostic
+   * and leaves the source unchanged.
+   *
+   * @example
+   * ```ts
+   * const object = loadConfig("export default { a11y: { element: '#root' } };").parse();
+   * object.rename(['a11y', 'element'], 'context'); // { ok: true, changed: true }
+   * object.getValue(['a11y']); // { context: '#root' }
+   * ```
+   */
+  rename(path, name) {
+    return this._mutate((object) => object.rename(path, name));
+  }
+  /**
+   * Move a property to another path, creating missing destination parents and cleaning up
+   * empty source parents. Rejects occupied destinations. Use `group` when nesting siblings must
+   * preserve expression evaluation order.
+   *
+   * @example
+   * ```ts
+   * const object = loadConfig("export default { globals: { theme: 'dark' } };").parse();
+   * object.move(['globals'], ['initialGlobals']); // { ok: true, changed: true }
+   * object.getValue(['initialGlobals']); // { theme: 'dark' }
+   * object.getValue(['globals']); // undefined
+   * ```
+   */
+  move(from, to) {
+    return this._mutate((object) => object.move(from, to));
+  }
+  /**
+   * Nest named sibling properties under a destination, retaining their source order. Rejects
+   * conflicts and relocations that could change evaluation order. Missing source fields are ignored.
+   *
+   * @example
+   * ```ts
+   * const object = loadConfig('export default { showNav: false, showPanel: true };').parse();
+   * object.group(['layout'], ['showNav', 'showPanel']); // { ok: true, changed: true }
+   * object.getValue(['layout']); // { showNav: false, showPanel: true }
+   * object.getValue(['showNav']); // undefined
+   * ```
+   */
+  group(path, names) {
+    return this._mutate((object) => object.group(path, names));
+  }
+  _mutate(operation) {
+    let editor = this._editor("mutate");
+    return editor.ok === !0 ? operation(editor.object) : { ok: !1, changed: !1, diagnostic: editor.diagnostic };
+  }
+  _editor(mode) {
+    let editor = createConfigObject(
+      this,
+      mode,
+      (diagnostic) => this._mutationDiagnostics.push(diagnostic),
+      () => {
+        this._changed = !0, this._exports = {}, this._exportDecls = {}, this.parse();
+      }
+    );
+    return editor.ok === !1 && this._mutationDiagnostics.push(editor.diagnostic), editor;
+  }
+  _parseExportsObject(exportsObject) {
+    this._exportsObject = exportsObject, exportsObject.properties.forEach((p) => {
+      let exportName = propKey(p);
+      if (exportName) {
+        let exportVal = this._resolveDeclaration(p.value);
+        this._exports[exportName] = exportVal;
+      }
+    });
+  }
+  parse() {
+    this._inferQuotes();
+    let self = this;
+    return traverse2(this._ast, {
+      ExportDefaultDeclaration: {
+        enter({ node, parent }) {
+          self.hasDefaultExport = !0;
+          let decl = self._resolveDeclaration(node.declaration, parent);
+          for (; t2.isCallExpression(decl); )
+            if (t2.isObjectExpression(decl.arguments[0])) {
+              decl = decl.arguments[0];
+              break;
+            } else if (t2.isMemberExpression(decl.callee) && t2.isCallExpression(decl.callee.object))
+              decl = decl.callee.object;
+            else
+              break;
+          t2.isObjectExpression(decl) ? self._parseExportsObject(decl) : logger.debug(
+            getCsfParsingErrorMessage({
+              fileName: self.fileName,
+              expectedType: "ObjectExpression",
+              foundType: decl?.type,
+              node: decl || node.declaration
+            })
+          );
+        }
+      },
+      ExportNamedDeclaration: {
+        enter({ node, parent }) {
+          if (t2.isVariableDeclaration(node.declaration))
+            node.declaration.declarations.forEach((decl) => {
+              if (t2.isVariableDeclarator(decl) && t2.isIdentifier(decl.id)) {
+                let { name: exportName } = decl.id, exportVal = self._resolveDeclaration(decl.init, parent);
+                self._exports[exportName] = exportVal, self._exportDecls[exportName] = decl;
+              }
+            });
+          else if (t2.isFunctionDeclaration(node.declaration)) {
+            let decl = node.declaration;
+            if (t2.isIdentifier(decl.id)) {
+              let { name: exportName } = decl.id;
+              self._exportDecls[exportName] = decl, self._exports[exportName] = t2.toExpression(t2.cloneNode(decl));
+            }
+          } else node.specifiers ? node.specifiers.forEach((spec) => {
+            if (t2.isExportSpecifier(spec) && t2.isIdentifier(spec.local) && (t2.isIdentifier(spec.exported) || t2.isStringLiteral(spec.exported))) {
+              let { name: localName } = spec.local, exportName = t2.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value, decl = _findVarDeclarator(localName, self._ast.program) ?? self._ast.program.body.find(
+                (statement) => t2.isFunctionDeclaration(statement) && statement.id?.name === localName
+              );
+              if (decl) {
+                let value = t2.isFunctionDeclaration(decl) ? t2.toExpression(t2.cloneNode(decl)) : decl.init ? self._resolveDeclaration(decl.init, parent) : void 0;
+                if (exportName === "default" && t2.isObjectExpression(value)) {
+                  self.hasDefaultExport = !0, self._parseExportsObject(value);
+                  return;
+                }
+                self._exports[exportName] = value, self._exportDecls[exportName] = decl;
+              }
+            }
+          }) : logger.debug(
+            getCsfParsingErrorMessage({
+              fileName: self.fileName,
+              expectedType: "VariableDeclaration",
+              foundType: node.declaration?.type,
+              node: node.declaration
+            })
+          );
+        }
+      },
+      ExpressionStatement: {
+        enter({ node, parent }) {
+          if (t2.isAssignmentExpression(node.expression) && node.expression.operator === "=") {
+            let { left, right } = node.expression;
+            if (t2.isMemberExpression(left) && t2.isIdentifier(left.object) && left.object.name === "module" && t2.isIdentifier(left.property) && left.property.name === "exports") {
+              let exportObject = right;
+              exportObject = self._resolveDeclaration(exportObject, parent), t2.isObjectExpression(exportObject) ? (self._exportsObject = exportObject, exportObject.properties.forEach((p) => {
+                let exportName = propKey(p);
+                if (exportName) {
+                  let exportVal = self._resolveDeclaration(p.value, parent);
+                  self._exports[exportName] = exportVal;
+                }
+              })) : logger.debug(
+                getCsfParsingErrorMessage({
+                  fileName: self.fileName,
+                  expectedType: "ObjectExpression",
+                  foundType: exportObject?.type,
+                  node: exportObject
+                })
+              );
+            }
+          }
+        }
+      },
+      CallExpression: {
+        enter: ({ node }) => {
+          t2.isIdentifier(node.callee) && node.callee.name === "definePreview" && node.arguments.length === 1 && t2.isObjectExpression(node.arguments[0]) && self._parseExportsObject(node.arguments[0]);
+        }
+      }
+    }), self;
+  }
+  getFieldNode(path) {
+    let [root, ...rest] = path, exported = this._exports[root];
+    if (exported)
+      return _getPath(rest, exported);
+  }
+  getFieldProperties(path) {
+    let [root, ...rest] = path, exported = this._exports[root];
+    if (exported)
+      return _getPathProperties(rest, exported);
+  }
+  /**
+   * @example
+   *
+   * ```ts
+   * // 1. { framework: 'framework-name' }
+   * // 2. { framework: { name: 'framework-name', options: {} }
+   * getNameFromPath(['framework']); // => 'framework-name'
+   * ```
+   *
+   * @returns The name of a node in a given path, supporting the following formats:
+   */
+  getNameFromPath(path) {
+    let node = this.getFieldNode(path);
+    if (node)
+      return this._getPresetValue(node, "name");
+  }
+  /**
+   * Returns an array of names of a node in a given path, supporting the following formats:
+   *
+   * @example
+   *
+   * ```ts
+   * const config = {
+   *   addons: ['first-addon', { name: 'second-addon', options: {} }],
+   * };
+   * // => ['first-addon', 'second-addon']
+   * getNamesFromPath(['addons']);
+   * ```
+   */
+  getNamesFromPath(path) {
+    let node = this.getFieldNode(path);
+    if (!node)
+      return;
+    let pathNames = [];
+    return t2.isArrayExpression(node) && node.elements.forEach((element) => {
+      pathNames.push(this._getPresetValue(element, "name"));
+    }), pathNames;
+  }
+  _getWrappedValue(node) {
+    if (t2.isCallExpression(node)) {
+      let arg = node.arguments[0];
+      if (t2.isStringLiteral(arg))
+        return arg.value;
+    }
+  }
+  /**
+   * Given a node and a fallback property, returns a **non-evaluated** string value of the node.
+   *
+   * 1. `{ node: 'value' }`
+   * 2. `{ node: { fallbackProperty: 'value' } }`
+   */
+  _getPresetValue(node, fallbackProperty) {
+    let value;
+    if (t2.isStringLiteral(node) ? value = node.value : t2.isObjectExpression(node) ? node.properties.forEach((prop) => {
+      t2.isObjectProperty(prop) && t2.isIdentifier(prop.key) && prop.key.name === fallbackProperty && (t2.isStringLiteral(prop.value) ? value = prop.value.value : value = this._getWrappedValue(prop.value)), t2.isObjectProperty(prop) && t2.isStringLiteral(prop.key) && prop.key.value === "name" && t2.isStringLiteral(prop.value) && (value = prop.value.value);
+    }) : t2.isCallExpression(node) && (value = this._getWrappedValue(node)), !value)
+      throw new Error(
+        `The given node must be a string literal or an object expression with a "${fallbackProperty}" property that is a string literal.`
+      );
+    return value;
+  }
+  removeField(path) {
+    let removeProperty = (properties2, prop) => {
+      let index = properties2.findIndex(
+        (p) => t2.isIdentifier(p.key) && p.key.name === prop || t2.isStringLiteral(p.key) && p.key.value === prop
+      );
+      index >= 0 && properties2.splice(index, 1);
+    };
+    if (path.length === 1) {
+      let removedRootProperty = !1;
+      if (this._ast.program.body.forEach((node) => {
+        if (t2.isExportNamedDeclaration(node) && t2.isVariableDeclaration(node.declaration)) {
+          let decl = node.declaration.declarations[0];
+          t2.isIdentifier(decl.id) && decl.id.name === path[0] && (this._ast.program.body.splice(this._ast.program.body.indexOf(node), 1), removedRootProperty = !0);
+        }
+        if (t2.isExportDefaultDeclaration(node)) {
+          let resolved = this._resolveDeclaration(node.declaration);
+          if (t2.isObjectExpression(resolved)) {
+            let properties2 = resolved.properties;
+            removeProperty(properties2, path[0]), removedRootProperty = !0;
+          }
+        }
+        if (t2.isExpressionStatement(node) && t2.isAssignmentExpression(node.expression) && t2.isMemberExpression(node.expression.left) && t2.isIdentifier(node.expression.left.object) && node.expression.left.object.name === "module" && t2.isIdentifier(node.expression.left.property) && node.expression.left.property.name === "exports" && t2.isObjectExpression(node.expression.right)) {
+          let properties2 = node.expression.right.properties;
+          removeProperty(properties2, path[0]), removedRootProperty = !0;
+        }
+      }), removedRootProperty)
+        return;
+    }
+    let properties = this.getFieldProperties(path);
+    if (properties) {
+      let lastPath = path.at(-1);
+      removeProperty(properties, lastPath);
+    }
+  }
+  appendValueToArray(path, value) {
+    let node = this.valueToNode(value);
+    node && this.appendNodeToArray(path, node);
+  }
+  appendNodeToArray(path, node) {
+    let current = this.getFieldNode(path);
+    if (!current)
+      this.set(path, t2.arrayExpression([node]));
+    else if (t2.isArrayExpression(current))
+      current.elements.push(node);
+    else
+      throw new Error(`Expected array at '${path.join(".")}', got '${current.type}'`);
+  }
+  /**
+   * Specialized helper to remove addons or other array entries that can either be strings or
+   * objects with a name property.
+   */
+  removeEntryFromArray(path, value) {
+    let current = this.getFieldNode(path);
+    if (current)
+      if (t2.isArrayExpression(current)) {
+        let index = current.elements.findIndex((element) => t2.isStringLiteral(element) ? element.value === value : t2.isObjectExpression(element) ? this._getPresetValue(element, "name") === value : this._getWrappedValue(element) === value);
+        if (index >= 0)
+          current.elements.splice(index, 1);
+        else
+          throw new Error(`Could not find '${value}' in array at '${path.join(".")}'`);
+      } else
+        throw new Error(`Expected array at '${path.join(".")}', got '${current.type}'`);
+  }
+  _inferQuotes() {
+    if (!this._quotes) {
+      let occurrences = { "'": 0, '"': 0 }, countQuotes = ({ node }) => {
+        let raw = node.extra?.raw;
+        typeof raw == "string" && (raw[0] === "'" || raw[0] === '"') && (occurrences[raw[0]] += 1);
+      };
+      traverse2(this._ast, {
+        StringLiteral: { enter: countQuotes },
+        DirectiveLiteral: { enter: countQuotes }
+      }), this._quotes = occurrences["'"] > occurrences['"'] ? "single" : "double";
+    }
+    return this._quotes;
+  }
+  valueToNode(value) {
+    let quotes = this._inferQuotes(), valueNode;
+    if (quotes === "single") {
+      let { code } = generate(t2.valueToNode(value), { jsescOption: { quotes } }), program = babelParse(`const __x = ${code}`);
+      traverse2(program, {
+        VariableDeclaration: {
+          enter({ node }) {
+            node.declarations.length === 1 && t2.isVariableDeclarator(node.declarations[0]) && t2.isIdentifier(node.declarations[0].id) && node.declarations[0].id.name === "__x" && (valueNode = node.declarations[0].init);
+          }
+        }
+      });
+    } else
+      valueNode = t2.valueToNode(value);
+    return valueNode;
+  }
+  getBodyDeclarations() {
+    return this._ast.program.body;
+  }
+  /**
+   * Edit the first object argument of method calls on a named import, including CommonJS aliases.
+   * Unsupported arguments add mutation diagnostics; calls without arguments are ignored.
+   *
+   * @example
+   * ```ts
+   * const manager = loadConfig(`
+   *   import { addons } from '@aussieljk/forkbook/manager-api';
+   *   addons.setConfig({ showNav: false });
+   * `).parse();
+   * const [object] = manager.callArguments({
+   *   importedName: 'addons',
+   *   methodName: 'setConfig',
+   *   moduleNames: ['@aussieljk/forkbook/manager-api'],
+   * });
+   * object.group(['layout'], ['showNav']);
+   * object.getValue(['layout']); // { showNav: false }
+   * manager.changed; // true
+   * ```
+   */
+  callArguments({
+    importedName,
+    methodName,
+    moduleNames
+  }) {
+    let modules = new Set(moduleNames), imports = /* @__PURE__ */ new Map();
+    traverse2(this._ast, {
+      ImportDeclaration(path) {
+        if (!(!modules.has(path.node.source.value) || path.node.importKind === "type")) {
+          for (let specifier of path.node.specifiers)
+            if (t2.isImportSpecifier(specifier) && specifier.importKind !== "type" && t2.isIdentifier(specifier.imported, { name: importedName })) {
+              let bindingNodes = imports.get(specifier.local.name) ?? /* @__PURE__ */ new Set();
+              bindingNodes.add(specifier), imports.set(specifier.local.name, bindingNodes);
+            }
+        }
+      },
+      VariableDeclarator(path) {
+        let { id, init } = path.node;
+        if (!(!t2.isObjectPattern(id) || !t2.isCallExpression(init) || !t2.isIdentifier(init.callee, { name: "require" }) || path.scope.getBinding("require") !== void 0 || init.arguments.length !== 1 || !t2.isStringLiteral(init.arguments[0]) || !modules.has(init.arguments[0].value))) {
+          for (let property of id.properties)
+            if (t2.isObjectProperty(property) && !property.computed && (t2.isIdentifier(property.key) && property.key.name === importedName || t2.isStringLiteral(property.key) && property.key.value === importedName) && t2.isIdentifier(property.value)) {
+              let bindingNodes = imports.get(property.value.name) ?? /* @__PURE__ */ new Set();
+              bindingNodes.add(path.node), imports.set(property.value.name, bindingNodes);
+            }
+        }
+      }
+    });
+    let objects = [], report = (diagnostic) => this._mutationDiagnostics.push(diagnostic), markChanged = () => {
+      this._changed = !0;
+    };
+    return traverse2(this._ast, {
+      CallExpression(path) {
+        let { callee } = path.node;
+        if (!t2.isMemberExpression(callee) || !t2.isIdentifier(callee.object) || !(t2.isIdentifier(callee.property) && !callee.computed && callee.property.name === methodName || t2.isStringLiteral(callee.property) && callee.property.value === methodName))
+          return;
+        let bindingNode = path.scope.getBinding(callee.object.name)?.path.node;
+        if (bindingNode && imports.get(callee.object.name)?.has(bindingNode)) {
+          let argument = path.node.arguments[0];
+          if (!argument)
+            return;
+          let value = unwrapExpression(argument), target = { kind: "call-argument", importedName, methodName }, binding = path.scope.getBinding(callee.object.name);
+          if (!binding?.constant || !t2.isObjectExpression(value)) {
+            report({
+              code: binding?.constant ? "unsupported-initializer" : "ambiguous-binding",
+              target,
+              path: [],
+              message: binding?.constant ? "the call argument is not an object literal" : "the imported binding is reassigned",
+              ...argument.loc ? { loc: argument.loc } : {}
+            });
+            return;
+          }
+          objects.push(
+            createCsfObject(
+              target,
+              {
+                node: value,
+                scope: path.scope,
+                buildCodeFrameError: path.buildCodeFrameError.bind(path)
+              },
+              [],
+              report,
+              markChanged
+            )
+          );
+        }
+      }
+    }), objects;
+  }
+  setBodyDeclaration(declaration) {
+    this._ast.program.body.push(declaration);
+  }
+  /**
+   * Import specifiers for a specific require import
+   *
+   * @example
+   *
+   * ```ts
+   * // const { foo } = require('bar');
+   * setRequireImport(['foo'], 'bar');
+   *
+   * // const foo = require('bar');
+   * setRequireImport('foo', 'bar');
+   * ```
+   *
+   * @param importSpecifiers - The import specifiers to set. If a string is passed in, a default
+   *   import will be set. Otherwise, an array of named imports will be set
+   * @param fromImport - The module to import from
+   */
+  setRequireImport(importSpecifier, fromImport) {
+    let requireDeclaration = this._ast.program.body.find((node) => {
+      let hasDeclaration = t2.isVariableDeclaration(node) && node.declarations.length === 1 && t2.isVariableDeclarator(node.declarations[0]) && t2.isCallExpression(node.declarations[0].init) && t2.isIdentifier(node.declarations[0].init.callee) && node.declarations[0].init.callee.name === "require" && t2.isStringLiteral(node.declarations[0].init.arguments[0]) && (node.declarations[0].init.arguments[0].value === fromImport || node.declarations[0].init.arguments[0].value === fromImport.split("node:")[1]);
+      return hasDeclaration && (fromImport = node.declarations[0].init.arguments[0].value), hasDeclaration;
+    }), hasRequireSpecifier = (name) => t2.isObjectPattern(requireDeclaration?.declarations[0].id) && requireDeclaration?.declarations[0].id.properties.find(
+      (specifier) => t2.isObjectProperty(specifier) && t2.isIdentifier(specifier.key) && specifier.key.name === name
+    ), hasDefaultRequireSpecifier = (declaration, name) => declaration.declarations.length === 1 && t2.isVariableDeclarator(declaration.declarations[0]) && t2.isIdentifier(declaration.declarations[0].id) && declaration.declarations[0].id.name === name;
+    if (typeof importSpecifier == "string") {
+      let addDefaultRequireSpecifier = () => {
+        prependStatement(
+          this._ast.program,
+          t2.variableDeclaration("const", [
+            t2.variableDeclarator(
+              t2.identifier(importSpecifier),
+              t2.callExpression(t2.identifier("require"), [t2.stringLiteral(fromImport)])
+            )
+          ])
+        );
+      };
+      requireDeclaration && hasDefaultRequireSpecifier(requireDeclaration, importSpecifier) || addDefaultRequireSpecifier();
+    } else requireDeclaration ? importSpecifier.forEach((specifier) => {
+      hasRequireSpecifier(specifier) || requireDeclaration.declarations[0].id.properties.push(
+        t2.objectProperty(t2.identifier(specifier), t2.identifier(specifier), void 0, !0)
+      );
+    }) : prependStatement(
+      this._ast.program,
+      t2.variableDeclaration("const", [
+        t2.variableDeclarator(
+          t2.objectPattern(
+            importSpecifier.map(
+              (specifier) => t2.objectProperty(t2.identifier(specifier), t2.identifier(specifier), void 0, !0)
+            )
+          ),
+          t2.callExpression(t2.identifier("require"), [t2.stringLiteral(fromImport)])
+        )
+      ])
+    );
+  }
+  /**
+   * Set import specifiers for a given import statement.
+   *
+   * Does not support setting type imports (yet)
+   *
+   * @example
+   *
+   * ```ts
+   * // import { foo } from 'bar';
+   * setImport(['foo'], 'bar');
+   *
+   * // import foo from 'bar';
+   * setImport('foo', 'bar');
+   *
+   * // import * as foo from 'bar';
+   * setImport({ namespace: 'foo' }, 'bar');
+   *
+   * // import 'bar';
+   * setImport(null, 'bar');
+   * ```
+   *
+   * @param importSpecifiers - The import specifiers to set. If a string is passed in, a default
+   *   import will be set. Otherwise, an array of named imports will be set
+   * @param fromImport - The module to import from
+   */
+  setImport(importSpecifier, fromImport) {
+    let importDeclaration = this._ast.program.body.find((node) => {
+      let hasDeclaration = t2.isImportDeclaration(node) && (node.source.value === fromImport || node.source.value === fromImport.split("node:")[1]);
+      return hasDeclaration && (fromImport = node.source.value), hasDeclaration;
+    }), getNewImportSpecifier = (specifier) => t2.importSpecifier(t2.identifier(specifier), t2.identifier(specifier)), hasImportSpecifier = (declaration, name) => declaration.specifiers.find(
+      (specifier) => t2.isImportSpecifier(specifier) && t2.isIdentifier(specifier.imported) && specifier.imported.name === name
+    ), hasNamespaceImportSpecifier = (declaration, name) => declaration.specifiers.find(
+      (specifier) => t2.isImportNamespaceSpecifier(specifier) && t2.isIdentifier(specifier.local) && specifier.local.name === name
+    );
+    importSpecifier === null ? importDeclaration || prependStatement(this._ast.program, t2.importDeclaration([], t2.stringLiteral(fromImport))) : typeof importSpecifier == "string" ? importDeclaration ? ((declaration, name) => declaration.specifiers.find(
+      (specifier) => t2.isImportDefaultSpecifier(specifier) && t2.isIdentifier(specifier.local) && specifier.local.name === name
+    ))(importDeclaration, importSpecifier) || importDeclaration.specifiers.push(
+      t2.importDefaultSpecifier(t2.identifier(importSpecifier))
+    ) : prependStatement(
+      this._ast.program,
+      t2.importDeclaration(
+        [t2.importDefaultSpecifier(t2.identifier(importSpecifier))],
+        t2.stringLiteral(fromImport)
+      )
+    ) : Array.isArray(importSpecifier) ? importDeclaration ? importSpecifier.forEach((specifier) => {
+      hasImportSpecifier(importDeclaration, specifier) || importDeclaration.specifiers.push(getNewImportSpecifier(specifier));
+    }) : prependStatement(
+      this._ast.program,
+      t2.importDeclaration(
+        importSpecifier.map(getNewImportSpecifier),
+        t2.stringLiteral(fromImport)
+      )
+    ) : importSpecifier.namespace && (importDeclaration ? hasNamespaceImportSpecifier(importDeclaration, importSpecifier.namespace) || importDeclaration.specifiers.push(
+      t2.importNamespaceSpecifier(t2.identifier(importSpecifier.namespace))
+    ) : prependStatement(
+      this._ast.program,
+      t2.importDeclaration(
+        [t2.importNamespaceSpecifier(t2.identifier(importSpecifier.namespace))],
+        t2.stringLiteral(fromImport)
+      )
+    ));
+  }
+  _removeRequireImport(importSpecifier, fromImport) {
+    let requireDeclarationIndex = this._ast.program.body.findIndex((node) => t2.isVariableDeclaration(node) && node.declarations.length === 1 && t2.isVariableDeclarator(node.declarations[0]) && t2.isCallExpression(node.declarations[0].init) && t2.isIdentifier(node.declarations[0].init.callee) && node.declarations[0].init.callee.name === "require" && t2.isStringLiteral(node.declarations[0].init.arguments[0]) && (node.declarations[0].init.arguments[0].value === fromImport || node.declarations[0].init.arguments[0].value === fromImport.split("node:")[1]));
+    if (requireDeclarationIndex === -1)
+      return;
+    let declarator = this._ast.program.body[requireDeclarationIndex].declarations[0];
+    if (importSpecifier !== null) {
+      if (typeof importSpecifier == "string") {
+        t2.isIdentifier(declarator.id) && declarator.id.name === importSpecifier && this._ast.program.body.splice(requireDeclarationIndex, 1);
+        return;
+      }
+      if (!(typeof importSpecifier == "object" && "namespace" in importSpecifier) && Array.isArray(importSpecifier) && t2.isObjectPattern(declarator.id)) {
+        let objectPattern = declarator.id;
+        importSpecifier.forEach((specifier) => {
+          let index = objectPattern.properties.findIndex(
+            (prop) => t2.isObjectProperty(prop) && t2.isIdentifier(prop.key) && prop.key.name === specifier
+          );
+          index !== -1 && objectPattern.properties.splice(index, 1);
+        }), objectPattern.properties.length === 0 && this._ast.program.body.splice(requireDeclarationIndex, 1);
+      }
+    }
+  }
+  _removeImport(importSpecifier, fromImport) {
+    let importDeclarationIndex = this._ast.program.body.findIndex(
+      (node) => t2.isImportDeclaration(node) && (node.source.value === fromImport || node.source.value === fromImport.split("node:")[1])
+    );
+    if (importDeclarationIndex === -1)
+      return;
+    let importDeclaration = this._ast.program.body[importDeclarationIndex];
+    if (importSpecifier === null) {
+      importDeclaration.specifiers.length === 0 && this._ast.program.body.splice(importDeclarationIndex, 1);
+      return;
+    }
+    if (typeof importSpecifier == "object" && "namespace" in importSpecifier) {
+      let index = importDeclaration.specifiers.findIndex(
+        (specifier) => t2.isImportNamespaceSpecifier(specifier) && t2.isIdentifier(specifier.local) && specifier.local.name === importSpecifier.namespace
+      );
+      index !== -1 && importDeclaration.specifiers.splice(index, 1);
+    }
+    if (typeof importSpecifier == "string") {
+      let index = importDeclaration.specifiers.findIndex(
+        (specifier) => t2.isImportDefaultSpecifier(specifier) && t2.isIdentifier(specifier.local) && specifier.local.name === importSpecifier
+      );
+      index !== -1 && importDeclaration.specifiers.splice(index, 1);
+    }
+    Array.isArray(importSpecifier) && importSpecifier.forEach((specifier) => {
+      let index = importDeclaration.specifiers.findIndex(
+        (current) => t2.isImportSpecifier(current) && t2.isIdentifier(current.imported) && current.imported.name === specifier
+      );
+      index !== -1 && importDeclaration.specifiers.splice(index, 1);
+    }), importDeclaration.specifiers.length === 0 && this._ast.program.body.splice(importDeclarationIndex, 1);
+  }
+  /**
+   * Remove import specifiers for a given import statement.
+   *
+   * Does not support removing type imports (yet)
+   *
+   * @example
+   *
+   * ```ts
+   * // import { foo } from 'bar';
+   * setImport(['foo'], 'bar');
+   *
+   * // import foo from 'bar';
+   * setImport('foo', 'bar');
+   *
+   * // import * as foo from 'bar';
+   * setImport({ namespace: 'foo' }, 'bar');
+   *
+   * // import 'bar';
+   * setImport(null, 'bar');
+   * ```
+   *
+   * @param importSpecifiers - The import specifiers to remove. If a string is passed in, will only
+   *   remove the default import. Otherwise, named imports matching the array will be removed.
+   * @param fromImport - The module to import from
+   */
+  removeImport(importSpecifier, fromImport) {
+    this._removeRequireImport(importSpecifier, fromImport), this._removeImport(importSpecifier, fromImport);
+  }
+}, loadConfig = (code, fileName) => {
+  let ast = babelParse(code);
+  return new ConfigFile(ast, code, fileName);
+}, formatConfig = (config) => printConfig(config).code, printConfig = (config, options = {}) => recast.print(config._ast, {
+  quote: config._inferQuotes(),
+  // Recast defaults this to `os.EOL`, which would carriage-return printed files on Windows.
+  lineTerminator: `
+`,
+  ...options
+}), readConfig = async (fileName) => {
+  let code = (await readFile(fileName, "utf-8")).toString();
+  return loadConfig(code, fileName).parse();
+}, writeConfig = async (config, fileName) => {
+  let [diagnostic] = config.mutationDiagnostics;
+  invariant(!diagnostic, diagnostic?.message);
+  let fname = fileName || config.fileName;
+  if (!fname)
+    throw new Error("Please specify a fileName for writeConfig");
+  await writeFile(fname, formatConfig(config));
+}, isCsfFactoryPreview = (previewConfig) => !!previewConfig._ast.program.body.find((node) => t2.isImportDeclaration(node) && (node.source.value.includes("storybook") || node.source.value.includes("forkbook")) && node.specifiers.some((specifier) => t2.isImportSpecifier(specifier) && t2.isIdentifier(specifier.imported) && specifier.imported.name === "definePreview"));
+
+export {
+  getHeaderComments,
+  ConfigFile,
+  loadConfig,
+  formatConfig,
+  printConfig,
+  readConfig,
+  writeConfig,
+  isCsfFactoryPreview
+};