{"version":3,"sources":["../../../src/server/patch-error-inspect.ts"],"sourcesContent":["import * as path from 'path'\nimport * as url from 'url'\nimport type * as util from 'util'\nimport { SourceMapConsumer as SyncSourceMapConsumer } from 'next/dist/compiled/source-map'\nimport {\n  type ModernSourceMapPayload,\n  devirtualizeReactServerURL,\n  findApplicableSourceMapPayload,\n  findSourceMapPayload,\n  ignoreListAnonymousStackFramesIfSandwiched as ignoreListAnonymousStackFramesIfSandwichedGeneric,\n  sourceMapIgnoreListsEverything,\n} from './lib/source-maps'\nimport { parseStack, type StackFrame } from './lib/parse-stack'\nimport type { IgnorableStackFrame } from '../next-devtools/server/shared'\nimport { workUnitAsyncStorage } from './app-render/work-unit-async-storage.external'\nimport { dim, italic } from '../lib/picocolors'\n\ntype FindSourceMapPayload = (\n  sourceURL: string\n) => ModernSourceMapPayload | undefined\n// Find a source map using the bundler's API.\n// This is only a fallback for when Node.js fails to due to bugs e.g. https://github.com/nodejs/node/issues/52102\n// TODO: Remove once all supported Node.js versions are fixed.\n// TODO(veil): Set from Webpack as well\n//\n// Stored on `globalThis` for the same reason as the code frame renderer below:\n// this module is bundled into several runtimes that each get their own copy,\n// and the copy that installs the implementation is not necessarily the one that\n// symbolicates a frame. The dev validation worker depends on that, because it\n// installs its implementation from the worker bundle while the frames are\n// symbolicated by the app-page bundle's copy.\nconst BUNDLER_FIND_SOURCE_MAP = Symbol.for('next.dev.bundlerFindSourceMap')\ntype GlobalWithBundlerFindSourceMap = typeof globalThis & {\n  [BUNDLER_FIND_SOURCE_MAP]?: FindSourceMapPayload\n}\n\nexport function setBundlerFindSourceMapImplementation(\n  findSourceMapImplementation: FindSourceMapPayload\n): void {\n  ;(globalThis as GlobalWithBundlerFindSourceMap)[BUNDLER_FIND_SOURCE_MAP] =\n    findSourceMapImplementation\n}\n\nfunction bundlerFindSourceMapPayload(\n  sourceURL: string\n): ModernSourceMapPayload | undefined {\n  return (globalThis as GlobalWithBundlerFindSourceMap)[\n    BUNDLER_FIND_SOURCE_MAP\n  ]?.(sourceURL)\n}\n\n// Code frame renderer - injected by dev/build to avoid hard dependency on native bindings\ntype CodeFrameRenderer = (\n  frame: IgnorableStackFrame,\n  source: string | null,\n  colors: boolean\n) => string | null\n\n// The code-frame renderer is stored on `globalThis` rather than in a module\n// variable because this module is bundled into several runtimes (the dev\n// server, the app-page runtime bundle, and the dev worker bundles) that each\n// get their own copy. `Error.prepareStackTrace` is a single process-global, so\n// whichever copy patched it last is the one that renders errors, which may not\n// be the copy `setCodeFrameRenderer` was called on. Sharing the renderer\n// through a `globalThis` symbol lets any copy install it and any copy read it.\nconst CODE_FRAME_RENDERER = Symbol.for('next.dev.codeFrameRenderer')\ntype GlobalWithCodeFrameRenderer = typeof globalThis & {\n  [CODE_FRAME_RENDERER]?: CodeFrameRenderer\n}\n\nexport function setCodeFrameRenderer(renderer: CodeFrameRenderer): void {\n  ;(globalThis as GlobalWithCodeFrameRenderer)[CODE_FRAME_RENDERER] = renderer\n}\n\nfunction getOriginalCodeFrame(\n  frame: IgnorableStackFrame,\n  source: string | null,\n  colors: boolean = process.stdout.isTTY\n): string | null {\n  const codeFrameRenderer = (globalThis as GlobalWithCodeFrameRenderer)[\n    CODE_FRAME_RENDERER\n  ]\n  if (!codeFrameRenderer) {\n    // No renderer available - gracefully degrade\n    return null\n  }\n  return codeFrameRenderer(frame, source, colors)\n}\n\ntype SourceMapCache = Map<\n  string,\n  null | { map: SyncSourceMapConsumer; payload: ModernSourceMapPayload }\n>\n\n// Constructing a consumer indexes the whole payload — expensive for large\n// chunk maps and previously paid per frame — so consumers are shared across\n// all frames and errors whose lookups returned the same payload. The inner\n// key is the URL the consumer resolves relative `sources` against.\nconst sourceMapConsumers = new WeakMap<\n  ModernSourceMapPayload,\n  Map<string, SyncSourceMapConsumer>\n>()\n\nfunction getOrCreateSourceMapConsumer(\n  payload: ModernSourceMapPayload,\n  sourceMapURL: string\n): SyncSourceMapConsumer {\n  let consumersByURL = sourceMapConsumers.get(payload)\n  let consumer = consumersByURL?.get(sourceMapURL)\n  if (consumer === undefined) {\n    consumer = new SyncSourceMapConsumer(\n      payload,\n      // @ts-expect-error: our typings don't include this parameter but it is here.\n      sourceMapURL\n    )\n    if (consumersByURL === undefined) {\n      consumersByURL = new Map()\n      // Throws for payloads that aren't objects; those are invalid source\n      // maps anyway, and the caller reports them.\n      sourceMapConsumers.set(payload, consumersByURL)\n    }\n    consumersByURL.set(sourceMapURL, consumer)\n  }\n  return consumer\n}\n\nfunction frameToString(\n  methodName: string | null,\n  sourceURL: string | null,\n  line1: number | null,\n  column1: number | null\n): string {\n  let sourceLocation = line1 !== null ? `:${line1}` : ''\n  if (column1 !== null && sourceLocation !== '') {\n    sourceLocation += `:${column1}`\n  }\n\n  let fileLocation: string | null\n  if (\n    sourceURL !== null &&\n    sourceURL.startsWith('file://') &&\n    URL.canParse(sourceURL)\n  ) {\n    // If not relative to CWD, the path is ambiguous to IDEs and clicking will prompt to select the file first.\n    // In a multi-app repo, this leads to potentially larger file names but will make clicking snappy.\n    // There's no tradeoff for the cases where `dir` in `next dev [dir]` is omitted\n    // since relative to cwd is both the shortest and snappiest.\n    fileLocation = path.relative(process.cwd(), url.fileURLToPath(sourceURL))\n  } else if (sourceURL !== null && sourceURL.startsWith('/')) {\n    fileLocation = path.relative(process.cwd(), sourceURL)\n  } else {\n    fileLocation = sourceURL\n  }\n\n  return methodName\n    ? `    at ${methodName} (${fileLocation}${sourceLocation})`\n    : `    at ${fileLocation}${sourceLocation}`\n}\n\nfunction computeErrorName(error: Error): string {\n  // TODO: Node.js seems to use a different algorithm\n  // class ReadonlyRequestCookiesError extends Error {}` would read `ReadonlyRequestCookiesError: [...]`\n  // in the stack i.e. seems like under certain conditions it favors the constructor name.\n  return error.name || 'Error'\n}\n\nfunction prepareUnsourcemappedStackTrace(\n  error: Error,\n  structuredStackTrace: any[]\n): string {\n  const name = computeErrorName(error)\n  const message = error.message || ''\n  let stack = name + ': ' + message\n  for (let i = 0; i < structuredStackTrace.length; i++) {\n    stack += '\\n    at ' + structuredStackTrace[i].toString()\n  }\n  return stack\n}\n\nfunction shouldIgnoreListGeneratedFrame(file: string): boolean {\n  return file.startsWith('node:') || file.includes('node_modules')\n}\n\nfunction shouldIgnoreListOriginalFrame(file: string): boolean {\n  return file.includes('node_modules')\n}\n\ninterface SourcemappableStackFrame extends StackFrame {\n  file: NonNullable<StackFrame['file']>\n}\n\ninterface SourceMappedFrame {\n  stack: IgnorableStackFrame\n  // DEV only\n  code: string | null\n}\n\nfunction createUnsourcemappedFrame(\n  frame: SourcemappableStackFrame\n): SourceMappedFrame {\n  return {\n    stack: {\n      file: frame.file,\n      line1: frame.line1,\n      column1: frame.column1,\n      methodName: frame.methodName,\n      arguments: frame.arguments,\n      ignored: shouldIgnoreListGeneratedFrame(frame.file),\n    },\n    code: null,\n  }\n}\n\nfunction ignoreListAnonymousStackFramesIfSandwiched(\n  sourceMappedFrames: Array<{\n    stack: IgnorableStackFrame\n    code: string | null\n  }>\n) {\n  return ignoreListAnonymousStackFramesIfSandwichedGeneric(\n    sourceMappedFrames,\n    (frame) => frame.stack.file === '<anonymous>',\n    (frame) => frame.stack.ignored,\n    (frame) => frame.stack.methodName,\n    (frame) => {\n      frame.stack.ignored = true\n    }\n  )\n}\n\n/**\n * @param frame\n * @param sourceMapCache\n * @returns The original frame if not sourcemapped.\n */\nfunction getSourcemappedFrameIfPossible(\n  frame: SourcemappableStackFrame,\n  sourceMapCache: SourceMapCache,\n  inspectOptions: util.InspectOptions\n): {\n  stack: IgnorableStackFrame\n  code: string | null\n} {\n  const sourceMapCacheEntry = sourceMapCache.get(frame.file)\n  let sourceMapConsumer: SyncSourceMapConsumer\n  let sourceMapPayload: ModernSourceMapPayload\n  if (sourceMapCacheEntry === undefined) {\n    // Fake frame scripts (`about://React/Server/file:///path/to/chunk.js?42`)\n    // have their positions padded to match the underlying chunk, so they\n    // resolve via the chunk's source map.\n    let sourceURL = devirtualizeReactServerURL(frame.file)\n    // e.g. \"/Users/foo/APP/.next/server/chunks/ssr/[root-of-the-server]__2934a0._.js\"\n    // or \"C:\\Users\\foo\\APP\\.next\\server\\chunks\\ssr\\[root-of-the-server]__2934a0._.js\"\n    // will be keyed by Node.js as \"file:///APP/.next/server/chunks/ssr/[root-of-the-server]__2934a0._.js\".\n    // This is likely caused by `callsite.toString()` in `Error.prepareStackTrace converting file URLs to paths.\n    //\n    // But frame.file might also be \"webpack-internal:///(rsc)/./app/bad-sourcemap/page.js\" or\n    // \"<anonymous>\" or \"node:internal/process/task_queues\" here\n    if (path.isAbsolute(sourceURL)) {\n      sourceURL = url.pathToFileURL(sourceURL).toString()\n    }\n    let maybeSourceMapPayload: ModernSourceMapPayload | undefined\n    try {\n      maybeSourceMapPayload = findSourceMapPayload(sourceURL)\n\n      if (\n        maybeSourceMapPayload === undefined &&\n        sourceURL.startsWith('file://')\n      ) {\n        // Devirtualizing React's fake frame URL decodes the path, while Node.js\n        // keys its source map cache by the `pathToFileURL` encoding of the same\n        // path, so a path containing characters that encoding escapes (such as\n        // the brackets in Turbopack's `[root-of-the-server]` chunks) misses\n        // above. Node.js also accepts the plain path, which is unambiguous for\n        // both interpretations, so retry with that before giving up.\n        //\n        // TODO(veil): Making React's fake frame URLs reversible, as proposed in\n        // https://github.com/react/react/pull/37105, would let the first lookup\n        // succeed on its own and retire this retry.\n        maybeSourceMapPayload = findSourceMapPayload(\n          url.fileURLToPath(sourceURL)\n        )\n      }\n    } catch (cause) {\n      // We should not log an actual error instance here because that will re-enter\n      // this codepath during error inspection and could lead to infinite recursion.\n      console.error(\n        `${sourceURL}: Invalid source map. Only conformant source maps can be used to find the original code. Cause: ${cause}`\n      )\n      // If loading fails once, it'll fail every time.\n      // So set the cache to avoid duplicate errors.\n      sourceMapCache.set(frame.file, null)\n      // Don't even fall back to the bundler because it might be not as strict\n      // with regards to parsing and then we fail later once we consume the\n      // source map payload.\n      // This essentially avoids a redundant error where we fail here and then\n      // later on consumption because the bundler just handed back an invalid\n      // source map.\n      return createUnsourcemappedFrame(frame)\n    }\n    if (maybeSourceMapPayload === undefined) {\n      maybeSourceMapPayload = bundlerFindSourceMapPayload(sourceURL)\n    }\n\n    if (maybeSourceMapPayload === undefined) {\n      return createUnsourcemappedFrame(frame)\n    }\n    sourceMapPayload = maybeSourceMapPayload\n    try {\n      // Pass the source map URL as the second parameter so that the consumer\n      // can resolve relative paths in the source map's `sources` array. This is\n      // a guess! Turbopack places .map files as siblings to the chunks so this\n      // is sufficient to compute relative paths but is actually wrong (the\n      // chunk and sourcemap have different content hashes). We are using the\n      // node API to read the sourcemap and it doesn't give us access to the\n      // URI. `sourceURL` is already devirtualized so that relative `sources`\n      // resolve against the real chunk URL, not React's virtual one.\n      const sourceMapURL = sourceURL + '.map'\n      sourceMapConsumer = getOrCreateSourceMapConsumer(\n        sourceMapPayload,\n        sourceMapURL\n      )\n    } catch (cause) {\n      // We should not log an actual error instance here because that will re-enter\n      // this codepath during error inspection and could lead to infinite recursion.\n      console.error(\n        `${sourceURL}: Invalid source map. Only conformant source maps can be used to find the original code. Cause: ${cause}`\n      )\n      // If creating the consumer fails once, it'll fail every time.\n      // So set the cache to avoid duplicate errors.\n      sourceMapCache.set(frame.file, null)\n      return createUnsourcemappedFrame(frame)\n    }\n    sourceMapCache.set(frame.file, {\n      map: sourceMapConsumer,\n      payload: sourceMapPayload,\n    })\n  } else if (sourceMapCacheEntry === null) {\n    // We failed earlier getting the payload or consumer.\n    // Just return an unsourcemapped frame.\n    // Errors will already be logged.\n    return createUnsourcemappedFrame(frame)\n  } else {\n    sourceMapConsumer = sourceMapCacheEntry.map\n    sourceMapPayload = sourceMapCacheEntry.payload\n  }\n\n  const sourcePosition = sourceMapConsumer.originalPositionFor({\n    column: (frame.column1 ?? 1) - 1,\n    line: frame.line1 ?? 1,\n  })\n\n  const applicableSourceMap = findApplicableSourceMapPayload(\n    (frame.line1 ?? 1) - 1,\n    (frame.column1 ?? 1) - 1,\n    sourceMapPayload\n  )\n  let ignored =\n    applicableSourceMap !== undefined &&\n    sourceMapIgnoreListsEverything(applicableSourceMap)\n  if (sourcePosition.source === null) {\n    return {\n      stack: {\n        arguments: frame.arguments,\n        file: frame.file,\n        line1: frame.line1,\n        column1: frame.column1,\n        methodName: frame.methodName,\n        ignored: ignored || shouldIgnoreListGeneratedFrame(frame.file),\n      },\n      code: null,\n    }\n  }\n\n  // TODO(veil): Upstream a method to sourcemap consumer that immediately says if a frame is ignored or not.\n  if (applicableSourceMap === undefined) {\n    console.error('No applicable source map found in sections for frame', frame)\n  } else if (!ignored && shouldIgnoreListOriginalFrame(sourcePosition.source)) {\n    // Externals may be libraries that don't ship ignoreLists.\n    // This is really taking control away from libraries.\n    // They should still ship `ignoreList` so that attached debuggers ignore-list their frames.\n    // TODO: Maybe only ignore library sourcemaps if `ignoreList` is absent?\n    // Though keep in mind that Turbopack omits empty `ignoreList`.\n    // So if we establish this convention, we should communicate it to the ecosystem.\n    ignored = true\n  } else if (!ignored) {\n    // TODO: O(n^2). Consider moving `ignoreList` into a Set\n    const sourceIndex = applicableSourceMap.sources.indexOf(\n      sourcePosition.source\n    )\n    ignored = applicableSourceMap.ignoreList?.includes(sourceIndex) ?? false\n  }\n\n  const originalFrame: IgnorableStackFrame = {\n    // We ignore the sourcemapped name since it won't be the correct name.\n    // The callsite will point to the column of the variable name instead of the\n    // name of the enclosing function.\n    // TODO(NDX-531): Spy on prepareStackTrace to get the enclosing line number for method name mapping.\n    methodName: frame.methodName\n      ?.replace('__WEBPACK_DEFAULT_EXPORT__', 'default')\n      ?.replace('__webpack_exports__.', ''),\n    file: sourcePosition.source,\n    line1: sourcePosition.line,\n    column1: sourcePosition.column + 1,\n    // TODO: c&p from async createOriginalStackFrame but why not frame.arguments?\n    arguments: [],\n    ignored,\n  }\n\n  /** undefined = not yet computed */\n  let codeFrame: string | null | undefined\n\n  return {\n    stack: originalFrame,\n    get code() {\n      if (codeFrame === undefined) {\n        const sourceContent: string | null =\n          sourceMapConsumer.sourceContentFor(\n            sourcePosition.source,\n            /* returnNullOnMissing */ true\n          ) ?? null\n        codeFrame = getOriginalCodeFrame(\n          originalFrame,\n          sourceContent,\n          inspectOptions.colors\n        )\n      }\n      return codeFrame\n    },\n  }\n}\n\nfunction parseAndSourceMap(\n  error: Error,\n  inspectOptions: util.InspectOptions\n): string {\n  const showIgnoreListed = process.env.__NEXT_SHOW_IGNORE_LISTED === 'true'\n  // We overwrote Error.prepareStackTrace earlier so error.stack is not sourcemapped.\n  let unparsedStack = String(error.stack)\n  // We could just read it from `error.stack`.\n  // This works around cases where a 3rd party `Error.prepareStackTrace` implementation\n  // doesn't implement the name computation correctly.\n  const errorName = computeErrorName(error)\n\n  let idx = unparsedStack.indexOf('react_stack_bottom_frame')\n  if (idx !== -1) {\n    idx = unparsedStack.lastIndexOf('\\n', idx)\n  } else {\n    idx = unparsedStack.indexOf('react-stack-bottom-frame')\n    if (idx !== -1) {\n      idx = unparsedStack.lastIndexOf('\\n', idx)\n    }\n  }\n  if (idx !== -1 && !showIgnoreListed) {\n    // Cut off everything after the bottom frame since it'll be React internals.\n    unparsedStack = unparsedStack.slice(0, idx)\n  }\n\n  const unsourcemappedStack = parseStack(unparsedStack)\n  const sourceMapCache: SourceMapCache = new Map()\n\n  const sourceMappedFrames: Array<{\n    stack: IgnorableStackFrame\n    code: string | null\n  }> = []\n  let sourceFrame: null | string = null\n  for (const frame of unsourcemappedStack) {\n    if (frame.file === null) {\n      sourceMappedFrames.push({\n        code: null,\n        stack: {\n          file: frame.file,\n          line1: frame.line1,\n          column1: frame.column1,\n          methodName: frame.methodName,\n          arguments: frame.arguments,\n          ignored: false,\n        },\n      })\n    } else {\n      const sourcemappedFrame = getSourcemappedFrameIfPossible(\n        // We narrowed this earlier by bailing if `frame.file` is null.\n        frame as SourcemappableStackFrame,\n        sourceMapCache,\n        inspectOptions\n      )\n      sourceMappedFrames.push(sourcemappedFrame)\n\n      // We can determine the sourceframe here.\n      // anonymous frames won't have a sourceframe so we don't need to scan\n      // all stacks again to check if they are sandwiched between ignored frames.\n      if (\n        sourceFrame === null &&\n        // TODO: Is this the right choice?\n        !sourcemappedFrame.stack.ignored &&\n        sourcemappedFrame.code !== null\n      ) {\n        sourceFrame = sourcemappedFrame.code\n      }\n    }\n  }\n\n  ignoreListAnonymousStackFramesIfSandwiched(sourceMappedFrames)\n\n  let sourceMappedStack = ''\n  for (let i = 0; i < sourceMappedFrames.length; i++) {\n    const frame = sourceMappedFrames[i]\n\n    if (!frame.stack.ignored) {\n      sourceMappedStack +=\n        '\\n' +\n        frameToString(\n          frame.stack.methodName,\n          frame.stack.file,\n          frame.stack.line1,\n          frame.stack.column1\n        )\n    } else if (showIgnoreListed) {\n      sourceMappedStack +=\n        '\\n' +\n        dim(\n          frameToString(\n            frame.stack.methodName,\n            frame.stack.file,\n            frame.stack.line1,\n            frame.stack.column1\n          )\n        )\n    }\n  }\n\n  if (sourceMappedStack === '' && sourceMappedFrames.length > 0) {\n    // The `at` marker is important so that Node.js doesn't add square brackets\n    // around the stringified error i.e. this results in\n    // Error: message\n    //   at <ignore-listed frames>\n    // instead of\n    // [Error: message\n    //   at <ignore-listed frames>]\n    sourceMappedStack = '\\n    at ' + italic('ignore-listed frames')\n  }\n\n  return (\n    errorName +\n    ': ' +\n    error.message +\n    sourceMappedStack +\n    (sourceFrame !== null ? '\\n' + sourceFrame : '')\n  )\n}\n\nfunction sourceMapError(\n  this: void,\n  error: Error,\n  inspectOptions: util.InspectOptions\n): Error {\n  // Setting an undefined `cause` would print `[cause]: undefined`\n  const options = error.cause !== undefined ? { cause: error.cause } : undefined\n\n  // Create a new Error object with the source mapping applied and then use native\n  // Node.js formatting on the result.\n  const newError =\n    error instanceof AggregateError\n      ? // Preserve AggregateError's `errors` instance property\n        new AggregateError(error.errors, error.message, options)\n      : new Error(error.message, options)\n\n  // TODO: Ensure `class MyError extends Error {}` prints `MyError` as the name\n  newError.stack = parseAndSourceMap(error, inspectOptions)\n\n  for (const key in error) {\n    if (!Object.prototype.hasOwnProperty.call(newError, key)) {\n      // @ts-expect-error -- We're copying all enumerable properties.\n      // So they definitely exist on `this` and obviously have no type on `newError` (yet)\n      newError[key] = error[key]\n    }\n  }\n\n  return newError\n}\n\nexport function patchErrorInspectNodeJS(\n  errorConstructor: ErrorConstructor\n): void {\n  const inspectSymbol = Symbol.for('nodejs.util.inspect.custom')\n\n  errorConstructor.prepareStackTrace = prepareUnsourcemappedStackTrace\n\n  // @ts-expect-error -- TODO upstream types\n  errorConstructor.prototype[inspectSymbol] = function (\n    depth: number,\n    inspectOptions: util.InspectOptions,\n    inspect: typeof util.inspect\n  ): string {\n    // avoid false-positive dynamic i/o warnings e.g. due to usage of `Math.random` in `source-map`.\n    return workUnitAsyncStorage.exit(() => {\n      const newError = sourceMapError(this, inspectOptions)\n\n      const originalCustomInspect = (newError as any)[inspectSymbol]\n      // Prevent infinite recursion.\n      // { customInspect: false } would result in `error.cause` not using our inspect.\n      Object.defineProperty(newError, inspectSymbol, {\n        value: undefined,\n        enumerable: false,\n        writable: true,\n      })\n      try {\n        return inspect(newError, {\n          ...inspectOptions,\n          depth,\n        })\n      } finally {\n        ;(newError as any)[inspectSymbol] = originalCustomInspect\n      }\n    })\n  }\n}\n\nexport function patchErrorInspectEdgeLite(\n  errorConstructor: ErrorConstructor\n): void {\n  const inspectSymbol = Symbol.for('edge-runtime.inspect.custom')\n\n  errorConstructor.prepareStackTrace = prepareUnsourcemappedStackTrace\n\n  // @ts-expect-error -- TODO upstream types\n  errorConstructor.prototype[inspectSymbol] = function ({\n    format,\n  }: {\n    format: (...args: unknown[]) => string\n  }): string {\n    // avoid false-positive dynamic i/o warnings e.g. due to usage of `Math.random` in `source-map`.\n    return workUnitAsyncStorage.exit(() => {\n      const newError = sourceMapError(this, {})\n\n      const originalCustomInspect = (newError as any)[inspectSymbol]\n      // Prevent infinite recursion.\n      Object.defineProperty(newError, inspectSymbol, {\n        value: undefined,\n        enumerable: false,\n        writable: true,\n      })\n      try {\n        return format(newError)\n      } finally {\n        ;(newError as any)[inspectSymbol] = originalCustomInspect\n      }\n    })\n  }\n}\n"],"names":["path","url","SourceMapConsumer","SyncSourceMapConsumer","devirtualizeReactServerURL","findApplicableSourceMapPayload","findSourceMapPayload","ignoreListAnonymousStackFramesIfSandwiched","ignoreListAnonymousStackFramesIfSandwichedGeneric","sourceMapIgnoreListsEverything","parseStack","workUnitAsyncStorage","dim","italic","BUNDLER_FIND_SOURCE_MAP","Symbol","for","setBundlerFindSourceMapImplementation","findSourceMapImplementation","globalThis","bundlerFindSourceMapPayload","sourceURL","CODE_FRAME_RENDERER","setCodeFrameRenderer","renderer","getOriginalCodeFrame","frame","source","colors","process","stdout","isTTY","codeFrameRenderer","sourceMapConsumers","WeakMap","getOrCreateSourceMapConsumer","payload","sourceMapURL","consumersByURL","get","consumer","undefined","Map","set","frameToString","methodName","line1","column1","sourceLocation","fileLocation","startsWith","URL","canParse","relative","cwd","fileURLToPath","computeErrorName","error","name","prepareUnsourcemappedStackTrace","structuredStackTrace","message","stack","i","length","toString","shouldIgnoreListGeneratedFrame","file","includes","shouldIgnoreListOriginalFrame","createUnsourcemappedFrame","arguments","ignored","code","sourceMappedFrames","getSourcemappedFrameIfPossible","sourceMapCache","inspectOptions","sourceMapCacheEntry","sourceMapConsumer","sourceMapPayload","isAbsolute","pathToFileURL","maybeSourceMapPayload","cause","console","map","sourcePosition","originalPositionFor","column","line","applicableSourceMap","sourceIndex","sources","indexOf","ignoreList","originalFrame","replace","codeFrame","sourceContent","sourceContentFor","parseAndSourceMap","showIgnoreListed","env","__NEXT_SHOW_IGNORE_LISTED","unparsedStack","String","errorName","idx","lastIndexOf","slice","unsourcemappedStack","sourceFrame","push","sourcemappedFrame","sourceMappedStack","sourceMapError","options","newError","AggregateError","errors","Error","key","Object","prototype","hasOwnProperty","call","patchErrorInspectNodeJS","errorConstructor","inspectSymbol","prepareStackTrace","depth","inspect","exit","originalCustomInspect","defineProperty","value","enumerable","writable","patchErrorInspectEdgeLite","format"],"mappings":"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","ignoreList":[0]}