@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/mocking-utils/index.js

@@ -0,0 +1,521 @@
+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 {
+  walk
+} from "../_node-chunks/chunk-7GUDZVRQ.js";
+import {
+  userModuleExtensions
+} from "../_node-chunks/chunk-TNJIXE37.js";
+import "../_node-chunks/chunk-CXRU72ET.js";
+
+// src/mocking-utils/automock.ts
+import MagicString from "magic-string";
+
+// 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/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 || 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(
+        "automocking files with `export *` is not supported in browser mode because it cannot be statically analysed"
+      );
+    if (_node.type === "ExportNamedDeclaration") {
+      let traversePattern2 = function(expression) {
+        if (expression.type === "Identifier")
+          allSpecifiers.push({ name: expression.name });
+        else if (expression.type === "ArrayPattern")
+          expression.elements.forEach((element) => {
+            element && traversePattern2(element);
+          });
+        else if (expression.type === "ObjectPattern")
+          expression.properties.forEach((property) => {
+            property.type === "RestElement" ? traversePattern2(property) : property.type === "Property" && traversePattern2(property.value);
+          });
+        else if (expression.type === "RestElement")
+          traversePattern2(expression.argument);
+        else {
+          if (expression.type === "AssignmentPattern")
+            throw new Error("AssignmentPattern is not supported. Please open a new bug report.");
+          if (expression.type === "MemberExpression")
+            throw new Error("MemberExpression is not supported. Please open a new bug report.");
+        }
+      };
+      var traversePattern = traversePattern2;
+      let node = _node, declaration = node.declaration;
+      declaration && (declaration.type === "FunctionDeclaration" ? allSpecifiers.push({ name: declaration.id.name }) : declaration.type === "VariableDeclaration" ? declaration.declarations.forEach((declaration2) => {
+        traversePattern2(declaration2.id);
+      }) : declaration.type === "ClassDeclaration" && allSpecifiers.push({ name: declaration.id.name }), m.remove(node.start, declaration.start));
+      let specifiers = node.specifiers || [], source = node.source;
+      if (!source && specifiers.length)
+        specifiers.forEach((specifier) => {
+          allSpecifiers.push({
+            alias: getArbitraryModuleIdentifier(specifier.exported),
+            name: getArbitraryModuleIdentifier(specifier.local)
+          });
+        }), m.remove(node.start, node.end);
+      else if (source && specifiers.length) {
+        let importNames = [];
+        specifiers.forEach((specifier) => {
+          let importedName = `__vitest_imported_${importIndex++}__`;
+          importNames.push([getArbitraryModuleIdentifier(specifier.local), importedName]), allSpecifiers.push({
+            name: importedName,
+            alias: getArbitraryModuleIdentifier(specifier.exported)
+          });
+        });
+        let importString = `import { ${importNames.map(([name, alias]) => `${name} as ${alias}`).join(", ")} } from '${source.value}'`;
+        m.overwrite(node.start, node.end, importString);
+      }
+    }
+    if (_node.type === "ExportDefaultDeclaration") {
+      let node = _node, declaration = node.declaration;
+      allSpecifiers.push({ name: "__vitest_default", alias: "default" }), m.overwrite(node.start, declaration.start, "const __vitest_default = ");
+    }
+  }
+  let moduleObject = `
+const __vitest_current_es_module__ = {
+  __esModule: true,
+  ${allSpecifiers.map(({ name }) => `["${name}"]: ${name},`).join(`
+  `)}
+}
+const __vitest_mocked_module__ = globalThis[${globalThisAccessor}].mockObject(__vitest_current_es_module__, "${mockType}")
+`, spyRegistration = `
+if (!globalThis.__STORYBOOK_MODULE_MOCK_SPIES__) { globalThis.__STORYBOOK_MODULE_MOCK_SPIES__ = new Set(); }
+for (const __vitest_key__ of Object.keys(__vitest_mocked_module__)) {
+  const __vitest_val__ = __vitest_mocked_module__[__vitest_key__];
+  if (__vitest_val__ && typeof __vitest_val__ === "function" && __vitest_val__._isMockFunction === true) {
+    globalThis.__STORYBOOK_MODULE_MOCK_SPIES__.add(__vitest_val__);
+  }
+}
+`, assigning = allSpecifiers.map(({ name }, index) => `const __vitest_mocked_${index}__ = __vitest_mocked_module__["${name}"]`).join(`
+`), specifiersExports = `
+export {
+${allSpecifiers.map(({ name, alias }, index) => `  __vitest_mocked_${index}__ as ${alias || name},`).join(`
+`)}
+}
+`;
+  return m.append(moduleObject + spyRegistration + assigning + specifiersExports), m;
+}
+
+// src/mocking-utils/extract.ts
+import { readFileSync } from "node:fs";
+import { generate, parser, types as t } from "@aussieljk/forkbook/internal/babel";
+import { logger } from "@aussieljk/forkbook/internal/node-logger";
+import { telemetry } from "@aussieljk/forkbook/internal/telemetry";
+import { transformSync } from "esbuild";
+import { basename, normalize } from "pathe";
+
+// src/mocking-utils/resolve.ts
+import { realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import { ResolverFactory } from "oxc-resolver";
+import { dirname, isAbsolute, resolve } from "pathe";
+var require2 = createRequire(import.meta.url), externalResolver = new ResolverFactory({
+  conditionNames: ["browser", "import", "module", "default"],
+  mainFields: ["browser", "module", "main"],
+  aliasFields: [["browser"]],
+  extensions: [...userModuleExtensions]
+});
+function resolveExternalModule(path, root) {
+  let result = externalResolver.sync(root, path);
+  return result.path ? result.path : 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, findMockRedirect2) {
+  let isExternal2 = getIsExternal(path, root), externalPath = isExternal2 ? path : null, absolutePath = isExternal2 ? resolveExternalModule(path, root) : require2.resolve(path, { paths: [dirname(importer)] }), normalizedAbsolutePath = resolve(absolutePath), redirectPath = findMockRedirect2(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) {
+  for (let extension of userModuleExtensions)
+    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] = t.stringLiteral(node.arguments[0].arguments[0].value));
+    }
+  }), generate(ast, {}, code);
+}
+function extractMockCalls(options, parse, root, findMockRedirect2) {
+  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 = readFileSync(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,
+          findMockRedirect2
+        ), pathWithoutExtension = path.replace(/\.[^/.]+$/, ""), basenameAbsolutePath = basename(absolutePath), basenamePath = basename(path), pathWithoutExtensionAndBasename = basenameAbsolutePath === basenamePath ? pathWithoutExtension : path;
+        mocks.push({
+          path: pathWithoutExtensionAndBasename,
+          absolutePath,
+          redirectPath,
+          spy
+        });
+      }
+    }), mocks.length > 0 && 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 { readFileSync as readFileSync2 } from "node:fs";
+import { fileURLToPath } from "node:url";
+function getMockerRuntime() {
+  return readFileSync2(
+    fileURLToPath(import.meta.resolve("@aussieljk/forkbook/internal/mocking-utils/mocker-runtime")),
+    "utf-8"
+  );
+}
+
+// ../../node_modules/@vitest/mocker/dist/redirect.js
+import fs from "node:fs";
+import { builtinModules } from "node:module";
+
+// ../../node_modules/@vitest/mocker/dist/chunk-pathe.M-eThtNZ.js
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+var _UNC_REGEX = /^[/\\]{2}/, _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/, _DRIVE_LETTER_RE = /^[A-Za-z]:$/, _EXTNAME_RE = /.(\.[^./]+|\.)$/, normalize2 = function(path) {
+  if (path.length === 0)
+    return ".";
+  path = normalizeWindowsPath(path);
+  let isUNCPath = path.match(_UNC_REGEX), isPathAbsolute = isAbsolute2(path), trailingSeparator = path[path.length - 1] === "/";
+  return path = normalizeString(path, !isPathAbsolute), path.length === 0 ? isPathAbsolute ? "/" : trailingSeparator ? "./" : "." : (trailingSeparator && (path += "/"), _DRIVE_LETTER_RE.test(path) && (path += "/"), isUNCPath ? isPathAbsolute ? `//${path}` : `//./${path}` : isPathAbsolute && !isAbsolute2(path) ? `/${path}` : path);
+}, join = function(...segments) {
+  let path = "";
+  for (let seg of segments)
+    if (seg)
+      if (path.length > 0) {
+        let pathTrailing = path[path.length - 1] === "/", segLeading = seg[0] === "/";
+        pathTrailing && segLeading ? path += seg.slice(1) : path += pathTrailing || segLeading ? seg : `/${seg}`;
+      } else
+        path += seg;
+  return normalize2(path);
+};
+function cwd() {
+  return typeof process < "u" && typeof process.cwd == "function" ? process.cwd().replace(/\\/g, "/") : "/";
+}
+var resolve2 = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "", resolvedAbsolute = !1;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    let path = index >= 0 ? arguments_[index] : cwd();
+    !path || path.length === 0 || (resolvedPath = `${path}/${resolvedPath}`, resolvedAbsolute = isAbsolute2(path));
+  }
+  return resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute), resolvedAbsolute && !isAbsolute2(resolvedPath) ? `/${resolvedPath}` : resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length)
+      char = path[index];
+    else {
+      if (char === "/")
+        break;
+      char = "/";
+    }
+    if (char === "/") {
+      if (!(lastSlash === index - 1 || dots === 1)) if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            let lastSlashIndex = res.lastIndexOf("/");
+            lastSlashIndex === -1 ? (res = "", lastSegmentLength = 0) : (res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/")), lastSlash = index, dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "", lastSegmentLength = 0, lastSlash = index, dots = 0;
+            continue;
+          }
+        }
+        allowAboveRoot && (res += res.length > 0 ? "/.." : "..", lastSegmentLength = 2);
+      } else
+        res.length > 0 ? res += `/${path.slice(lastSlash + 1, index)}` : res = path.slice(lastSlash + 1, index), lastSegmentLength = index - lastSlash - 1;
+      lastSlash = index, dots = 0;
+    } else char === "." && dots !== -1 ? ++dots : dots = -1;
+  }
+  return res;
+}
+var isAbsolute2 = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+}, extname = function(p) {
+  if (p === "..") return "";
+  let match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+  return match && match[1] || "";
+}, dirname2 = function(p) {
+  let segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  return segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0]) && (segments[0] += "/"), segments.join("/") || (isAbsolute2(p) ? "/" : ".");
+}, basename2 = function(p, extension) {
+  let segments = normalizeWindowsPath(p).split("/"), lastSegment = "";
+  for (let i = segments.length - 1; i >= 0; i--) {
+    let val = segments[i];
+    if (val) {
+      lastSegment = val;
+      break;
+    }
+  }
+  return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+
+// ../../node_modules/@vitest/mocker/dist/redirect.js
+var { existsSync, readdirSync, statSync } = fs;
+function findMockRedirect(root, mockPath, external) {
+  let path = external || mockPath;
+  if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
+    let findFile = function(mockFolder2, baseOriginal2) {
+      let files = readdirSync(mockFolder2);
+      for (let file of files)
+        if (basename2(file, extname(file)) === baseOriginal2) {
+          let path2 = resolve2(mockFolder2, file);
+          if (statSync(path2).isFile())
+            return path2;
+          {
+            let indexFile = findFile(path2, "index");
+            if (indexFile)
+              return indexFile;
+          }
+        }
+      return null;
+    }, mockDirname = dirname2(path), mockFolder = join(root, "__mocks__", mockDirname);
+    if (!existsSync(mockFolder))
+      return null;
+    let baseOriginal = basename2(path);
+    return findFile(mockFolder, baseOriginal);
+  }
+  let dir = dirname2(path), baseId = basename2(path), fullPath = resolve2(dir, "__mocks__", baseId);
+  return existsSync(fullPath) ? fullPath : null;
+}
+var builtins = /* @__PURE__ */ new Set([
+  ...builtinModules,
+  "assert/strict",
+  "diagnostics_channel",
+  "dns/promises",
+  "fs/promises",
+  "path/posix",
+  "path/win32",
+  "readline/promises",
+  "stream/consumers",
+  "stream/promises",
+  "stream/web",
+  "timers/promises",
+  "util/types",
+  "wasi"
+]), prefixedBuiltins = /* @__PURE__ */ new Set([
+  "node:sea",
+  "node:sqlite",
+  "node:test",
+  "node:test/reporters"
+]), NODE_BUILTIN_NAMESPACE = "node:";
+function isNodeBuiltin(id) {
+  return prefixedBuiltins.has(id) ? !0 : builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(NODE_BUILTIN_NAMESPACE.length) : id);
+}
+export {
+  __STORYBOOK_GLOBAL_THIS_ACCESSOR__,
+  automockModule,
+  babelParser,
+  esmWalker,
+  extractMockCalls,
+  findMockRedirect,
+  getArbitraryModuleIdentifier,
+  getAutomockCode,
+  getIsExternal,
+  getMockerRuntime,
+  getRealPath,
+  isExternal,
+  isFunctionNode,
+  isInDestructuringAssignment,
+  isModuleDirectory,
+  isNodeInPattern,
+  isStaticProperty,
+  isStaticPropertyKey,
+  resolveExternalModule,
+  resolveMock,
+  resolveWithExtensions,
+  rewriteSbMockImportCalls,
+  setIsNodeInPattern
+};