• Version 2.0.0
  • Published
  • 4.38 kB
  • No dependencies
  • MIT license


npm i @types/stack-utils
yarn add @types/stack-utils
pnpm add @types/stack-utils


TypeScript definitions for stack-utils



class StackUtils

class StackUtils {}


    constructor(options?: StackUtils.Options);

      method at

      at: (startStackFunction?: Function) => StackUtils.CallSiteLike;

        method capture

        capture: {
        (limit?: number, startStackFunction?: Function): StackUtils.CallSite[];
        (startStackFunction: Function): StackUtils.CallSite[];

          method captureString

          captureString: {
          (limit?: number, startStackFunction?: Function): string;
          (startStackFunction: Function): string;

            method clean

            clean: (stack: string | string[]) => string;

              method nodeInternals

              static nodeInternals: () => RegExp[];

                method parseLine

                parseLine: (line: string) => StackUtils.StackLineData | null;


                  interface CallSite

                  interface CallSite {}

                    method getColumnNumber

                    getColumnNumber: () => number;

                      method getEvalOrigin

                      getEvalOrigin: () => CallSite | string;

                        method getFileName

                        getFileName: () => string | undefined;

                          method getFunction

                          getFunction: () => Function | undefined;

                            method getFunctionName

                            getFunctionName: () => string;

                              method getLineNumber

                              getLineNumber: () => number;

                                method getMethodName

                                getMethodName: () => string | null;

                                  method getThis

                                  getThis: () => object | undefined;

                                    method getTypeName

                                    getTypeName: () => string;

                                      method isConstructor

                                      isConstructor: () => boolean;

                                        method isEval

                                        isEval: () => boolean;

                                          method isNative

                                          isNative: () => boolean;

                                            method isToplevel

                                            isToplevel: () => boolean;

                                              interface CallSiteLike

                                              interface CallSiteLike extends StackData {}

                                                property type

                                                type?: string;

                                                  interface Options

                                                  interface Options {}

                                                    property cwd

                                                    cwd?: string;

                                                      property ignoredPackages

                                                      ignoredPackages?: string[];

                                                        property internals

                                                        internals?: RegExp[];

                                                          method wrapCallSite

                                                          wrapCallSite: (callSite: CallSite) => CallSite;

                                                            interface StackData

                                                            interface StackData {}

                                                              property column

                                                              column?: number;

                                                                property constructor

                                                                constructor?: boolean;

                                                                  property evalOrigin

                                                                  evalOrigin?: string;

                                                                    property file

                                                                    file?: string;

                                                                      property function

                                                                      function?: string;

                                                                        property line

                                                                        line?: number;

                                                                          property method

                                                                          method?: string;

                                                                            property native

                                                                            native?: boolean;

                                                                              interface StackLineData

                                                                              interface StackLineData extends StackData {}

                                                                                property evalColumn

                                                                                evalColumn?: number;

                                                                                  property evalFile

                                                                                  evalFile?: string;

                                                                                    property evalLine

                                                                                    evalLine?: number;

                                                                                      Package Files (1)

                                                                                      Dependencies (0)

                                                                                      No dependencies.

                                                                                      Dev Dependencies (0)

                                                                                      No dev dependencies.

                                                                                      Peer Dependencies (0)

                                                                                      No peer dependencies.


                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/stack-utils.

                                                                                      • Markdown
                                                                                      • HTML
                                                                                        <a href="https://www.jsdocs.io/package/@types/stack-utils"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>