storybook 10.1.0-alpha.12 → 10.1.0-alpha.13

package/dist/{_node-chunks/chunk-ZXSD6L3S.js → mocking-utils/index.js}

@@ -1,14 +1,23 @@
-import CJS_COMPAT_NODE_URL_57ru1wfqqjv from 'node:url';
-import CJS_COMPAT_NODE_PATH_57ru1wfqqjv from 'node:path';
-import CJS_COMPAT_NODE_MODULE_57ru1wfqqjv from "node:module";
+import CJS_COMPAT_NODE_URL_h0pwn2pcb57 from 'node:url';
+import CJS_COMPAT_NODE_PATH_h0pwn2pcb57 from 'node:path';
+import CJS_COMPAT_NODE_MODULE_h0pwn2pcb57 from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_57ru1wfqqjv.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_57ru1wfqqjv.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_57ru1wfqqjv.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_h0pwn2pcb57.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_h0pwn2pcb57.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_h0pwn2pcb57.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
+import {
+  basename,
+  dirname,
+  isAbsolute,
+  join,
+  normalize,
+  resolve
+} from "../_node-chunks/chunk-LPKSBF62.js";
+import "../_node-chunks/chunk-WC2YEQHJ.js";
 
 // ../node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
 var comma = 44, semicolon = 59, chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", intToChar = new Uint8Array(64), charToInt = new Uint8Array(128);
@@ -68,11 +77,11 @@ var BitSet = class _BitSet {
   constructor(arg) {
     this.bits = arg instanceof _BitSet ? arg.bits.slice() : [];
   }
-  add(n2) {
-    this.bits[n2 >> 5] |= 1 << (n2 & 31);
+  add(n3) {
+    this.bits[n3 >> 5] |= 1 << (n3 & 31);
   }
-  has(n2) {
-    return !!(this.bits[n2 >> 5] & 1 << (n2 & 31));
+  has(n3) {
+    return !!(this.bits[n3 >> 5] & 1 << (n3 & 31));
   }
 }, Chunk = class _Chunk {
   constructor(start, end, content) {
@@ -661,22 +670,209 @@ var wordRegex = /\w/, Mappings = class {
   }
 };
 
-// src/core-server/presets/vitePlugins/vite-inject-mocker/constants.ts
-var __STORYBOOK_GLOBAL_THIS_ACCESSOR__ = "__vitest_mocker__";
+// ../node_modules/estree-walker/src/walker.js
+var WalkerBase = class {
+  constructor() {
+    this.should_skip = !1, this.should_remove = !1, this.replacement = null, this.context = {
+      skip: () => this.should_skip = !0,
+      remove: () => this.should_remove = !0,
+      replace: (node) => this.replacement = node
+    };
+  }
+  /**
+   * @template {Node} Parent
+   * @param {Parent | null | undefined} parent
+   * @param {keyof Parent | null | undefined} prop
+   * @param {number | null | undefined} index
+   * @param {Node} node
+   */
+  replace(parent, prop, index, node) {
+    parent && prop && (index != null ? parent[prop][index] = node : parent[prop] = node);
+  }
+  /**
+   * @template {Node} Parent
+   * @param {Parent | null | undefined} parent
+   * @param {keyof Parent | null | undefined} prop
+   * @param {number | null | undefined} index
+   */
+  remove(parent, prop, index) {
+    parent && prop && (index != null ? parent[prop].splice(index, 1) : delete parent[prop]);
+  }
+};
 
-// src/core-server/mocking-utils/esmWalker.ts
+// ../node_modules/estree-walker/src/sync.js
+var SyncWalker = class extends WalkerBase {
+  /**
+   *
+   * @param {SyncHandler} [enter]
+   * @param {SyncHandler} [leave]
+   */
+  constructor(enter, leave) {
+    super(), this.should_skip = !1, this.should_remove = !1, this.replacement = null, this.context = {
+      skip: () => this.should_skip = !0,
+      remove: () => this.should_remove = !0,
+      replace: (node) => this.replacement = node
+    }, this.enter = enter, this.leave = leave;
+  }
+  /**
+   * @template {Node} Parent
+   * @param {Node} node
+   * @param {Parent | null} parent
+   * @param {keyof Parent} [prop]
+   * @param {number | null} [index]
+   * @returns {Node | null}
+   */
+  visit(node, parent, prop, index) {
+    if (node) {
+      if (this.enter) {
+        let _should_skip = this.should_skip, _should_remove = this.should_remove, _replacement = this.replacement;
+        this.should_skip = !1, this.should_remove = !1, this.replacement = null, this.enter.call(this.context, node, parent, prop, index), this.replacement && (node = this.replacement, this.replace(parent, prop, index, node)), this.should_remove && this.remove(parent, prop, index);
+        let skipped = this.should_skip, removed = this.should_remove;
+        if (this.should_skip = _should_skip, this.should_remove = _should_remove, this.replacement = _replacement, skipped) return node;
+        if (removed) return null;
+      }
+      let key;
+      for (key in node) {
+        let value = node[key];
+        if (value && typeof value == "object")
+          if (Array.isArray(value)) {
+            let nodes = (
+              /** @type {Array<unknown>} */
+              value
+            );
+            for (let i = 0; i < nodes.length; i += 1) {
+              let item = nodes[i];
+              isNode(item) && (this.visit(item, node, key, i) || i--);
+            }
+          } else isNode(value) && this.visit(value, node, key, null);
+      }
+      if (this.leave) {
+        let _replacement = this.replacement, _should_remove = this.should_remove;
+        this.replacement = null, this.should_remove = !1, this.leave.call(this.context, node, parent, prop, index), this.replacement && (node = this.replacement, this.replace(parent, prop, index, node)), this.should_remove && this.remove(parent, prop, index);
+        let removed = this.should_remove;
+        if (this.replacement = _replacement, this.should_remove = _should_remove, removed) return null;
+      }
+    }
+    return node;
+  }
+};
+function isNode(value) {
+  return value !== null && typeof value == "object" && "type" in value && typeof value.type == "string";
+}
+
+// ../node_modules/estree-walker/src/index.js
+function walk(ast, { enter, leave }) {
+  return new SyncWalker(enter, leave).visit(ast, null);
+}
+
+// src/mocking-utils/esmWalker.ts
+var isNodeInPatternWeakSet = /* @__PURE__ */ new WeakSet();
+function setIsNodeInPattern(node) {
+  return isNodeInPatternWeakSet.add(node);
+}
+function isNodeInPattern(node) {
+  return isNodeInPatternWeakSet.has(node);
+}
+function esmWalker(root, { onIdentifier, onImportMeta, onDynamicImport, onCallExpression }) {
+  let parentStack = [], varKindStack = [], scopeMap = /* @__PURE__ */ new WeakMap(), identifiers = [], setScope = (node, name) => {
+    let scopeIds = scopeMap.get(node);
+    scopeIds && scopeIds.has(name) || (scopeIds || (scopeIds = /* @__PURE__ */ new Set(), scopeMap.set(node, scopeIds)), scopeIds.add(name));
+  };
+  function isInScope(name, parents) {
+    return parents.some((node) => node && scopeMap.get(node)?.has(name));
+  }
+  function handlePattern(p, parentScope) {
+    p.type === "Identifier" ? setScope(parentScope, p.name) : p.type === "RestElement" ? handlePattern(p.argument, parentScope) : p.type === "ObjectPattern" ? p.properties.forEach((property) => {
+      property.type === "RestElement" ? setScope(parentScope, property.argument.name) : handlePattern(property.value, parentScope);
+    }) : p.type === "ArrayPattern" ? p.elements.forEach((element) => {
+      element && handlePattern(element, parentScope);
+    }) : p.type === "AssignmentPattern" ? handlePattern(p.left, parentScope) : setScope(parentScope, p.name);
+  }
+  walk(root, {
+    enter(node, parent) {
+      if (node.type === "ImportDeclaration")
+        return this.skip();
+      if (parent && !(parent.type === "IfStatement" && node === parent.alternate) && parentStack.unshift(parent), node.type === "VariableDeclaration" && varKindStack.unshift(node.kind), node.type === "CallExpression" && onCallExpression?.(node), node.type === "MetaProperty" && node.meta.name === "import" ? onImportMeta?.(node) : node.type === "ImportExpression" && onDynamicImport?.(node), node.type === "Identifier")
+        !isInScope(node.name, parentStack) && isRefIdentifier(node, parent, parentStack) && identifiers.push([node, parentStack.slice(0)]);
+      else if (isFunctionNode(node)) {
+        if (node.type === "FunctionDeclaration") {
+          let parentScope = findParentScope(parentStack);
+          parentScope && setScope(parentScope, node.id.name);
+        }
+        node.params.forEach((p) => {
+          if (p.type === "ObjectPattern" || p.type === "ArrayPattern") {
+            handlePattern(p, node);
+            return;
+          }
+          walk(p.type === "AssignmentPattern" ? p.left : p, {
+            enter(child, parent2) {
+              if (parent2?.type === "AssignmentPattern" && parent2?.right === child)
+                return this.skip();
+              child.type === "Identifier" && (isStaticPropertyKey(child, parent2) || parent2?.type === "TemplateLiteral" && parent2?.expressions.includes(child) || parent2?.type === "CallExpression" && parent2?.callee === child || setScope(node, child.name));
+            }
+          });
+        });
+      } else if (node.type === "Property" && parent.type === "ObjectPattern")
+        setIsNodeInPattern(node);
+      else if (node.type === "VariableDeclarator") {
+        let parentFunction = findParentScope(parentStack, varKindStack[0] === "var");
+        parentFunction && handlePattern(node.id, parentFunction);
+      } else node.type === "CatchClause" && node.param && handlePattern(node.param, node);
+    },
+    leave(node, parent) {
+      parent && !(parent.type === "IfStatement" && node === parent.alternate) && parentStack.shift(), node.type === "VariableDeclaration" && varKindStack.shift();
+    }
+  }), identifiers.forEach(([node, stack]) => {
+    if (!isInScope(node.name, stack)) {
+      let parent = stack[0], grandparent = stack[1], hasBindingShortcut = isStaticProperty(parent) && parent.shorthand && (!isNodeInPattern(parent) || isInDestructuringAssignment(parent, parentStack)), classDeclaration = parent.type === "PropertyDefinition" && grandparent?.type === "ClassBody" || parent.type === "ClassDeclaration" && node === parent.superClass, classExpression = parent.type === "ClassExpression" && node === parent.id;
+      onIdentifier?.(
+        node,
+        {
+          hasBindingShortcut,
+          classDeclaration,
+          classExpression
+        },
+        stack
+      );
+    }
+  });
+}
+function isRefIdentifier(id, parent, parentStack) {
+  return !(parent.type === "CatchClause" || (parent.type === "VariableDeclarator" || parent.type === "ClassDeclaration") && parent.id === id || isFunctionNode(parent) && (parent.id === id || parent.params.includes(id)) || parent.type === "MethodDefinition" && !parent.computed || isStaticPropertyKey(id, parent) || isNodeInPattern(parent) && parent.value === id || parent.type === "ArrayPattern" && !isInDestructuringAssignment(parent, parentStack) || parent.type === "MemberExpression" && parent.property === id && !parent.computed || parent.type === "ExportSpecifier" || id.name === "arguments");
+}
+function isStaticProperty(node) {
+  return node && node.type === "Property" && !node.computed;
+}
+function isStaticPropertyKey(node, parent) {
+  return isStaticProperty(parent) && parent.key === node;
+}
+var functionNodeTypeRE = /Function(?:Expression|Declaration)$|Method$/;
+function isFunctionNode(node) {
+  return functionNodeTypeRE.test(node.type);
+}
+var blockNodeTypeRE = /^BlockStatement$|^For(?:In|Of)?Statement$/;
+function isBlock(node) {
+  return blockNodeTypeRE.test(node.type);
+}
+function findParentScope(parentStack, isVar = !1) {
+  return parentStack.find(isVar ? isFunctionNode : isBlock);
+}
+function isInDestructuringAssignment(parent, parentStack) {
+  return parent && (parent.type === "Property" || parent.type === "ArrayPattern") ? parentStack.some((i) => i.type === "AssignmentExpression") : !1;
+}
 function getArbitraryModuleIdentifier(node) {
   return node.type === "Identifier" ? node.name : node.raw;
 }
 
-// src/core-server/mocking-utils/automock.ts
+// src/mocking-utils/automock.ts
+var __STORYBOOK_GLOBAL_THIS_ACCESSOR__ = "__vitest_mocker__";
 function getAutomockCode(originalCode, isSpy, parse) {
   return automockModule(originalCode, isSpy ? "autospy" : "automock", parse, {
     globalThisAccessor: JSON.stringify(__STORYBOOK_GLOBAL_THIS_ACCESSOR__)
   });
 }
 function automockModule(code, mockType, parse, options = {}) {
-  let globalThisAccessor = options.globalThisAccessor || '"__vitest_mocker__"', ast = parse(code), m = new MagicString(code), allSpecifiers = [], importIndex = 0;
+  let globalThisAccessor = options.globalThisAccessor || JSON.stringify(__STORYBOOK_GLOBAL_THIS_ACCESSOR__), ast = parse(code), m = new MagicString(code), allSpecifiers = [], importIndex = 0;
   for (let _node of ast.body) {
     if (_node.type === "ExportAllDeclaration")
       throw new Error(
@@ -751,6 +947,235 @@ ${allSpecifiers.map(({ name, alias }, index) => `  __vitest_mocked_${index}__ as
   return m.append(moduleObject + assigning + specifiersExports), m;
 }
 
+// src/mocking-utils/extract.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { generate, parser, types as t2 } from "storybook/internal/babel";
+import { logger } from "storybook/internal/node-logger";
+import { telemetry } from "storybook/internal/telemetry";
+import { transformSync } from "esbuild";
+
+// src/mocking-utils/resolve.ts
+import { readFileSync, realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+
+// ../node_modules/resolve.exports/dist/index.mjs
+function e(e2, n3, r2) {
+  throw new Error(r2 ? `No known conditions for "${n3}" specifier in "${e2}" package` : `Missing "${n3}" specifier in "${e2}" package`);
+}
+function n2(n3, i, o2, f) {
+  let s, u, l = r(n3, o2), c = (function(e2) {
+    let n4 = /* @__PURE__ */ new Set(["default", ...e2.conditions || []]);
+    return e2.unsafe || n4.add(e2.require ? "require" : "import"), e2.unsafe || n4.add(e2.browser ? "browser" : "node"), n4;
+  })(f || {}), a = i[l];
+  if (a === void 0) {
+    let e2, n4, r2, t3;
+    for (t3 in i) n4 && t3.length < n4.length || (t3[t3.length - 1] === "/" && l.startsWith(t3) ? (u = l.substring(t3.length), n4 = t3) : t3.length > 1 && (r2 = t3.indexOf("*", 1), ~r2 && (e2 = RegExp("^" + t3.substring(0, r2) + "(.*)" + t3.substring(1 + r2) + "$").exec(l), e2 && e2[1] && (u = e2[1], n4 = t3))));
+    a = i[n4];
+  }
+  return a || e(n3, l), s = t(a, c), s || e(n3, l, 1), u && (function(e2, n4) {
+    let r2, t3 = 0, i2 = e2.length, o3 = /[*]/g, f2 = /[/]$/;
+    for (; t3 < i2; t3++) e2[t3] = o3.test(r2 = e2[t3]) ? r2.replace(o3, n4) : f2.test(r2) ? r2 + n4 : r2;
+  })(s, u), s;
+}
+function r(e2, n3, r2) {
+  if (e2 === n3 || n3 === ".") return ".";
+  let t3 = e2 + "/", i = t3.length, o2 = n3.slice(0, i) === t3, f = o2 ? n3.slice(i) : n3;
+  return f[0] === "#" ? f : o2 || !r2 ? f.slice(0, 2) === "./" ? f : "./" + f : f;
+}
+function t(e2, n3, r2) {
+  if (e2) {
+    if (typeof e2 == "string") return r2 && r2.add(e2), [e2];
+    let i, o2;
+    if (Array.isArray(e2)) {
+      for (o2 = r2 || /* @__PURE__ */ new Set(), i = 0; i < e2.length; i++) t(e2[i], n3, o2);
+      if (!r2 && o2.size) return [...o2];
+    } else for (i in e2) if (n3.has(i)) return t(e2[i], n3, r2);
+  }
+}
+function o(e2, r2, t3) {
+  let i, o2 = e2.exports;
+  if (o2) {
+    if (typeof o2 == "string") o2 = { ".": o2 };
+    else for (i in o2) {
+      i[0] !== "." && (o2 = { ".": o2 });
+      break;
+    }
+    return n2(e2.name, o2, r2 || ".", t3);
+  }
+}
+
+// src/mocking-utils/resolve.ts
+var require2 = createRequire(import.meta.url);
+function findPackageJson(specifier, basedir) {
+  let packageJsonPath = require2.resolve(`${specifier}/package.json`, { paths: [basedir] });
+  return {
+    path: packageJsonPath,
+    data: JSON.parse(readFileSync(packageJsonPath, "utf-8"))
+  };
+}
+function resolveExternalModule(path, root) {
+  let parts = path.split("/"), packageName = path.startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0], entry = `.${path.slice(packageName.length)}`, { path: packageJsonPath, data: pkg } = findPackageJson(packageName, root), packageDir = dirname(packageJsonPath);
+  if (pkg.exports) {
+    let result = o(pkg, entry, {
+      browser: !0
+    });
+    if (result)
+      return join(packageDir, result[0]);
+  }
+  return require2.resolve(path, { paths: [root] });
+}
+function getIsExternal(path, importer) {
+  try {
+    return !isAbsolute(path) && isModuleDirectory(require2.resolve(path, { paths: [importer] }));
+  } catch {
+    return !1;
+  }
+}
+function resolveMock(path, root, importer, findMockRedirect) {
+  let isExternal2 = getIsExternal(path, root), externalPath = isExternal2 ? path : null, absolutePath = isExternal2 ? resolveExternalModule(path, root) : require2.resolve(path, { paths: [dirname(importer)] }), normalizedAbsolutePath = resolve(absolutePath), redirectPath = findMockRedirect(root, normalizedAbsolutePath, externalPath);
+  return {
+    absolutePath: normalizedAbsolutePath,
+    redirectPath
+    // will be null if no __mocks__ file is found
+  };
+}
+function isExternal(path, from) {
+  try {
+    return !isAbsolute(path) && isModuleDirectory(require2.resolve(path, { paths: [from] }));
+  } catch {
+    return !1;
+  }
+}
+function getRealPath(path, preserveSymlinks) {
+  try {
+    return preserveSymlinks ? realpathSync(path) : path;
+  } catch {
+    return path;
+  }
+}
+function resolveWithExtensions(path, from) {
+  let extensions = [".js", ".ts", ".tsx", ".mjs", ".cjs", ".svelte", ".vue"];
+  for (let extension of extensions)
+    try {
+      return require2.resolve(path + extension, { paths: [from] });
+    } catch {
+      continue;
+    }
+  return require2.resolve(path, { paths: [from] });
+}
+
+// src/mocking-utils/extract.ts
+var DEFAULT_MODULE_DIRECTORIES = ["/node_modules/"];
+function isModuleDirectory(path) {
+  let normalizedPath = normalize(path);
+  return DEFAULT_MODULE_DIRECTORIES.some((dir) => normalizedPath.includes(dir));
+}
+var babelParser = (code) => parser.parse(code, {
+  sourceType: "module",
+  // Enable plugins to handle modern JavaScript features, including TSX.
+  plugins: ["typescript", "jsx", "classProperties", "objectRestSpread"],
+  errorRecovery: !0
+}).program;
+function rewriteSbMockImportCalls(code) {
+  let ast = babelParser(code);
+  return walk(ast, {
+    enter(node) {
+      node.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "sb" && node.callee.property.type === "Identifier" && node.callee.property.name === "mock" && node.arguments.length > 0 && node.arguments[0].type === "CallExpression" && node.arguments[0].callee.type === "Import" && node.arguments[0].arguments.length === 1 && node.arguments[0].arguments[0].type === "StringLiteral" && (node.arguments[0] = t2.stringLiteral(node.arguments[0].arguments[0].value));
+    }
+  }), generate(ast, {}, code);
+}
+function extractMockCalls(options, parse, root, findMockRedirect) {
+  try {
+    let hasSpyTrue2 = function(objectExpression) {
+      if (!objectExpression || !objectExpression.properties)
+        return !1;
+      for (let prop of objectExpression.properties)
+        if (prop.type === "ObjectProperty" && (prop.key.type === "Identifier" && prop.key.name === "spy" || prop.key.type === "StringLiteral" && prop.key.value === "spy") && prop.value.type === "BooleanLiteral" && prop.value.value === !0)
+          return !0;
+      return !1;
+    };
+    var hasSpyTrue = hasSpyTrue2;
+    let previewConfigCode = readFileSync2(options.previewConfigPath, "utf-8"), { code: jsCode } = transformSync(previewConfigCode, { loader: "tsx", format: "esm" }), ast = parse(jsCode), mocks = [];
+    return walk(ast, {
+      // @ts-expect-error - Node comes from babel
+      async enter(node) {
+        if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression" || node.callee.object.type !== "Identifier" || node.callee.object.name !== "sb" || node.callee.property.type !== "Identifier" || node.callee.property.name !== "mock" || node.arguments.length === 0)
+          return;
+        let path;
+        if (node.arguments[0].type === "StringLiteral")
+          path = node.arguments[0].value;
+        else if (node.arguments[0].type === "CallExpression" && node.arguments[0].callee.type === "Import" && node.arguments[0].arguments[0].type === "StringLiteral")
+          path = node.arguments[0].arguments[0].value;
+        else
+          return;
+        let spy = node.arguments.length > 1 && node.arguments[1].type === "ObjectExpression" && hasSpyTrue2(node.arguments[1]), { absolutePath, redirectPath } = resolveMock(
+          path,
+          root,
+          options.previewConfigPath,
+          findMockRedirect
+        ), pathWithoutExtension = path.replace(/\.[^/.]+$/, ""), basenameAbsolutePath = basename(absolutePath), basenamePath = basename(path), pathWithoutExtensionAndBasename = basenameAbsolutePath === basenamePath ? pathWithoutExtension : path;
+        mocks.push({
+          path: pathWithoutExtensionAndBasename,
+          absolutePath,
+          redirectPath,
+          spy
+        });
+      }
+    }), options.coreOptions?.disableTelemetry || telemetry(
+      "mocking",
+      {
+        modulesMocked: mocks.length,
+        modulesSpied: mocks.map((mock) => mock.spy).filter(Boolean).length,
+        modulesManuallyMocked: mocks.map((mock) => !!mock.redirectPath).filter(Boolean).length
+      },
+      { configDir: options.configDir }
+    ), mocks;
+  } catch (error) {
+    return logger.debug("Error extracting mock calls: " + String(error)), [];
+  }
+}
+
+// src/mocking-utils/runtime.ts
+import { resolvePackageDir } from "storybook/internal/common";
+import { buildSync } from "esbuild";
+var runtimeTemplatePath = join(
+  resolvePackageDir("storybook"),
+  "assets",
+  "server",
+  "mocker-runtime.template.js"
+);
+function getMockerRuntime() {
+  return buildSync({
+    entryPoints: [runtimeTemplatePath],
+    bundle: !0,
+    write: !1,
+    // Return the result in memory instead of writing to disk
+    format: "esm",
+    target: "es2020",
+    external: ["msw/browser", "msw/core/http"]
+  }).outputFiles[0].text;
+}
 export {
-  getAutomockCode
+  __STORYBOOK_GLOBAL_THIS_ACCESSOR__,
+  automockModule,
+  babelParser,
+  esmWalker,
+  extractMockCalls,
+  getArbitraryModuleIdentifier,
+  getAutomockCode,
+  getIsExternal,
+  getMockerRuntime,
+  getRealPath,
+  isExternal,
+  isFunctionNode,
+  isInDestructuringAssignment,
+  isModuleDirectory,
+  isNodeInPattern,
+  isStaticProperty,
+  isStaticPropertyKey,
+  resolveExternalModule,
+  resolveMock,
+  resolveWithExtensions,
+  rewriteSbMockImportCalls,
+  setIsNodeInPattern
 };