vscode-debugadapter

  • Version 1.51.0
  • Published
  • 257 kB
  • 2 dependencies
  • MIT license

Install

npm i vscode-debugadapter
yarn add vscode-debugadapter
pnpm add vscode-debugadapter

Overview

Debug adapter implementation for node

Index

Variables

Classes

Enums

Namespaces

Variables

variable logger

const logger: Logger.Logger;

    Classes

    class Breakpoint

    class Breakpoint implements DebugProtocol.Breakpoint {}

      constructor

      constructor(verified: boolean, line?: number, column?: number, source?: Source);

        property verified

        verified: boolean;

          method setId

          setId: (id: number) => void;

            class BreakpointEvent

            class BreakpointEvent extends Event implements DebugProtocol.BreakpointEvent {}

              constructor

              constructor(reason: string, breakpoint: DebugProtocol.Breakpoint);

                property body

                body: { reason: string; breakpoint: DebugProtocol.Breakpoint };

                  class CapabilitiesEvent

                  class CapabilitiesEvent extends Event implements DebugProtocol.CapabilitiesEvent {}

                    constructor

                    constructor(capabilities: DebugProtocol.Capabilities);

                      property body

                      body: { capabilities: DebugProtocol.Capabilities };

                        class CompletionItem

                        class CompletionItem implements DebugProtocol.CompletionItem {}

                          constructor

                          constructor(label: string, start: number, length?: number);

                            property label

                            label: string;

                              property length

                              length: number;

                                property start

                                start: number;

                                  class ContinuedEvent

                                  class ContinuedEvent extends Event implements DebugProtocol.ContinuedEvent {}

                                    constructor

                                    constructor(threadId: number, allThreadsContinued?: boolean);

                                      property body

                                      body: { threadId: number };

                                        class DebugSession

                                        class DebugSession extends ProtocolServer {}

                                          constructor

                                          constructor(
                                          obsolete_debuggerLinesAndColumnsStartAt1?: boolean,
                                          obsolete_isServer?: boolean
                                          );

                                            method attachRequest

                                            protected attachRequest: (
                                            response: DebugProtocol.AttachResponse,
                                            args: DebugProtocol.AttachRequestArguments,
                                            request?: DebugProtocol.Request
                                            ) => void;

                                              method breakpointLocationsRequest

                                              protected breakpointLocationsRequest: (
                                              response: DebugProtocol.BreakpointLocationsResponse,
                                              args: DebugProtocol.BreakpointLocationsArguments,
                                              request?: DebugProtocol.Request
                                              ) => void;

                                                method cancelRequest

                                                protected cancelRequest: (
                                                response: DebugProtocol.CancelResponse,
                                                args: DebugProtocol.CancelArguments,
                                                request?: DebugProtocol.Request
                                                ) => void;

                                                  method completionsRequest

                                                  protected completionsRequest: (
                                                  response: DebugProtocol.CompletionsResponse,
                                                  args: DebugProtocol.CompletionsArguments,
                                                  request?: DebugProtocol.Request
                                                  ) => void;

                                                    method configurationDoneRequest

                                                    protected configurationDoneRequest: (
                                                    response: DebugProtocol.ConfigurationDoneResponse,
                                                    args: DebugProtocol.ConfigurationDoneArguments,
                                                    request?: DebugProtocol.Request
                                                    ) => void;

                                                      method continueRequest

                                                      protected continueRequest: (
                                                      response: DebugProtocol.ContinueResponse,
                                                      args: DebugProtocol.ContinueArguments,
                                                      request?: DebugProtocol.Request
                                                      ) => void;

                                                        method convertClientColumnToDebugger

                                                        protected convertClientColumnToDebugger: (column: number) => number;

                                                          method convertClientLineToDebugger

                                                          protected convertClientLineToDebugger: (line: number) => number;

                                                            method convertClientPathToDebugger

                                                            protected convertClientPathToDebugger: (clientPath: string) => string;

                                                              method convertDebuggerColumnToClient

                                                              protected convertDebuggerColumnToClient: (column: number) => number;

                                                                method convertDebuggerLineToClient

                                                                protected convertDebuggerLineToClient: (line: number) => number;

                                                                  method convertDebuggerPathToClient

                                                                  protected convertDebuggerPathToClient: (debuggerPath: string) => string;

                                                                    method customRequest

                                                                    protected customRequest: (
                                                                    command: string,
                                                                    response: DebugProtocol.Response,
                                                                    args: any,
                                                                    request?: DebugProtocol.Request
                                                                    ) => void;
                                                                    • Override this hook to implement custom requests.

                                                                    method dataBreakpointInfoRequest

                                                                    protected dataBreakpointInfoRequest: (
                                                                    response: DebugProtocol.DataBreakpointInfoResponse,
                                                                    args: DebugProtocol.DataBreakpointInfoArguments,
                                                                    request?: DebugProtocol.Request
                                                                    ) => void;

                                                                      method disassembleRequest

                                                                      protected disassembleRequest: (
                                                                      response: DebugProtocol.DisassembleResponse,
                                                                      args: DebugProtocol.DisassembleArguments,
                                                                      request?: DebugProtocol.Request
                                                                      ) => void;

                                                                        method disconnectRequest

                                                                        protected disconnectRequest: (
                                                                        response: DebugProtocol.DisconnectResponse,
                                                                        args: DebugProtocol.DisconnectArguments,
                                                                        request?: DebugProtocol.Request
                                                                        ) => void;

                                                                          method dispatchRequest

                                                                          protected dispatchRequest: (request: DebugProtocol.Request) => void;

                                                                            method evaluateRequest

                                                                            protected evaluateRequest: (
                                                                            response: DebugProtocol.EvaluateResponse,
                                                                            args: DebugProtocol.EvaluateArguments,
                                                                            request?: DebugProtocol.Request
                                                                            ) => void;

                                                                              method exceptionInfoRequest

                                                                              protected exceptionInfoRequest: (
                                                                              response: DebugProtocol.ExceptionInfoResponse,
                                                                              args: DebugProtocol.ExceptionInfoArguments,
                                                                              request?: DebugProtocol.Request
                                                                              ) => void;

                                                                                method gotoRequest

                                                                                protected gotoRequest: (
                                                                                response: DebugProtocol.GotoResponse,
                                                                                args: DebugProtocol.GotoArguments,
                                                                                request?: DebugProtocol.Request
                                                                                ) => void;

                                                                                  method gotoTargetsRequest

                                                                                  protected gotoTargetsRequest: (
                                                                                  response: DebugProtocol.GotoTargetsResponse,
                                                                                  args: DebugProtocol.GotoTargetsArguments,
                                                                                  request?: DebugProtocol.Request
                                                                                  ) => void;

                                                                                    method initializeRequest

                                                                                    protected initializeRequest: (
                                                                                    response: DebugProtocol.InitializeResponse,
                                                                                    args: DebugProtocol.InitializeRequestArguments
                                                                                    ) => void;

                                                                                      method launchRequest

                                                                                      protected launchRequest: (
                                                                                      response: DebugProtocol.LaunchResponse,
                                                                                      args: DebugProtocol.LaunchRequestArguments,
                                                                                      request?: DebugProtocol.Request
                                                                                      ) => void;

                                                                                        method loadedSourcesRequest

                                                                                        protected loadedSourcesRequest: (
                                                                                        response: DebugProtocol.LoadedSourcesResponse,
                                                                                        args: DebugProtocol.LoadedSourcesArguments,
                                                                                        request?: DebugProtocol.Request
                                                                                        ) => void;

                                                                                          method nextRequest

                                                                                          protected nextRequest: (
                                                                                          response: DebugProtocol.NextResponse,
                                                                                          args: DebugProtocol.NextArguments,
                                                                                          request?: DebugProtocol.Request
                                                                                          ) => void;

                                                                                            method pauseRequest

                                                                                            protected pauseRequest: (
                                                                                            response: DebugProtocol.PauseResponse,
                                                                                            args: DebugProtocol.PauseArguments,
                                                                                            request?: DebugProtocol.Request
                                                                                            ) => void;

                                                                                              method readMemoryRequest

                                                                                              protected readMemoryRequest: (
                                                                                              response: DebugProtocol.ReadMemoryResponse,
                                                                                              args: DebugProtocol.ReadMemoryArguments,
                                                                                              request?: DebugProtocol.Request
                                                                                              ) => void;

                                                                                                method restartFrameRequest

                                                                                                protected restartFrameRequest: (
                                                                                                response: DebugProtocol.RestartFrameResponse,
                                                                                                args: DebugProtocol.RestartFrameArguments,
                                                                                                request?: DebugProtocol.Request
                                                                                                ) => void;

                                                                                                  method restartRequest

                                                                                                  protected restartRequest: (
                                                                                                  response: DebugProtocol.RestartResponse,
                                                                                                  args: DebugProtocol.RestartArguments,
                                                                                                  request?: DebugProtocol.Request
                                                                                                  ) => void;

                                                                                                    method reverseContinueRequest

                                                                                                    protected reverseContinueRequest: (
                                                                                                    response: DebugProtocol.ReverseContinueResponse,
                                                                                                    args: DebugProtocol.ReverseContinueArguments,
                                                                                                    request?: DebugProtocol.Request
                                                                                                    ) => void;

                                                                                                      method run

                                                                                                      static run: (debugSession: typeof DebugSession) => void;
                                                                                                      • A virtual constructor...

                                                                                                      method runInTerminalRequest

                                                                                                      runInTerminalRequest: (
                                                                                                      args: DebugProtocol.RunInTerminalRequestArguments,
                                                                                                      timeout: number,
                                                                                                      cb: (response: DebugProtocol.RunInTerminalResponse) => void
                                                                                                      ) => void;

                                                                                                        method scopesRequest

                                                                                                        protected scopesRequest: (
                                                                                                        response: DebugProtocol.ScopesResponse,
                                                                                                        args: DebugProtocol.ScopesArguments,
                                                                                                        request?: DebugProtocol.Request
                                                                                                        ) => void;

                                                                                                          method sendErrorResponse

                                                                                                          protected sendErrorResponse: (
                                                                                                          response: DebugProtocol.Response,
                                                                                                          codeOrMessage: number | DebugProtocol.Message,
                                                                                                          format?: string,
                                                                                                          variables?: any,
                                                                                                          dest?: ErrorDestination
                                                                                                          ) => void;

                                                                                                            method setBreakPointsRequest

                                                                                                            protected setBreakPointsRequest: (
                                                                                                            response: DebugProtocol.SetBreakpointsResponse,
                                                                                                            args: DebugProtocol.SetBreakpointsArguments,
                                                                                                            request?: DebugProtocol.Request
                                                                                                            ) => void;

                                                                                                              method setDataBreakpointsRequest

                                                                                                              protected setDataBreakpointsRequest: (
                                                                                                              response: DebugProtocol.SetDataBreakpointsResponse,
                                                                                                              args: DebugProtocol.SetDataBreakpointsArguments,
                                                                                                              request?: DebugProtocol.Request
                                                                                                              ) => void;

                                                                                                                method setDebuggerColumnsStartAt1

                                                                                                                setDebuggerColumnsStartAt1: (enable: boolean) => void;

                                                                                                                  method setDebuggerLinesStartAt1

                                                                                                                  setDebuggerLinesStartAt1: (enable: boolean) => void;

                                                                                                                    method setDebuggerPathFormat

                                                                                                                    setDebuggerPathFormat: (format: string) => void;

                                                                                                                      method setExceptionBreakPointsRequest

                                                                                                                      protected setExceptionBreakPointsRequest: (
                                                                                                                      response: DebugProtocol.SetExceptionBreakpointsResponse,
                                                                                                                      args: DebugProtocol.SetExceptionBreakpointsArguments,
                                                                                                                      request?: DebugProtocol.Request
                                                                                                                      ) => void;

                                                                                                                        method setExpressionRequest

                                                                                                                        protected setExpressionRequest: (
                                                                                                                        response: DebugProtocol.SetExpressionResponse,
                                                                                                                        args: DebugProtocol.SetExpressionArguments,
                                                                                                                        request?: DebugProtocol.Request
                                                                                                                        ) => void;

                                                                                                                          method setFunctionBreakPointsRequest

                                                                                                                          protected setFunctionBreakPointsRequest: (
                                                                                                                          response: DebugProtocol.SetFunctionBreakpointsResponse,
                                                                                                                          args: DebugProtocol.SetFunctionBreakpointsArguments,
                                                                                                                          request?: DebugProtocol.Request
                                                                                                                          ) => void;

                                                                                                                            method setInstructionBreakpointsRequest

                                                                                                                            protected setInstructionBreakpointsRequest: (
                                                                                                                            response: DebugProtocol.SetInstructionBreakpointsResponse,
                                                                                                                            args: DebugProtocol.SetInstructionBreakpointsArguments,
                                                                                                                            request?: DebugProtocol.Request
                                                                                                                            ) => void;

                                                                                                                              method setRunAsServer

                                                                                                                              setRunAsServer: (enable: boolean) => void;

                                                                                                                                method setVariableRequest

                                                                                                                                protected setVariableRequest: (
                                                                                                                                response: DebugProtocol.SetVariableResponse,
                                                                                                                                args: DebugProtocol.SetVariableArguments,
                                                                                                                                request?: DebugProtocol.Request
                                                                                                                                ) => void;

                                                                                                                                  method shutdown

                                                                                                                                  shutdown: () => void;

                                                                                                                                    method sourceRequest

                                                                                                                                    protected sourceRequest: (
                                                                                                                                    response: DebugProtocol.SourceResponse,
                                                                                                                                    args: DebugProtocol.SourceArguments,
                                                                                                                                    request?: DebugProtocol.Request
                                                                                                                                    ) => void;

                                                                                                                                      method stackTraceRequest

                                                                                                                                      protected stackTraceRequest: (
                                                                                                                                      response: DebugProtocol.StackTraceResponse,
                                                                                                                                      args: DebugProtocol.StackTraceArguments,
                                                                                                                                      request?: DebugProtocol.Request
                                                                                                                                      ) => void;

                                                                                                                                        method stepBackRequest

                                                                                                                                        protected stepBackRequest: (
                                                                                                                                        response: DebugProtocol.StepBackResponse,
                                                                                                                                        args: DebugProtocol.StepBackArguments,
                                                                                                                                        request?: DebugProtocol.Request
                                                                                                                                        ) => void;

                                                                                                                                          method stepInRequest

                                                                                                                                          protected stepInRequest: (
                                                                                                                                          response: DebugProtocol.StepInResponse,
                                                                                                                                          args: DebugProtocol.StepInArguments,
                                                                                                                                          request?: DebugProtocol.Request
                                                                                                                                          ) => void;

                                                                                                                                            method stepInTargetsRequest

                                                                                                                                            protected stepInTargetsRequest: (
                                                                                                                                            response: DebugProtocol.StepInTargetsResponse,
                                                                                                                                            args: DebugProtocol.StepInTargetsArguments,
                                                                                                                                            request?: DebugProtocol.Request
                                                                                                                                            ) => void;

                                                                                                                                              method stepOutRequest

                                                                                                                                              protected stepOutRequest: (
                                                                                                                                              response: DebugProtocol.StepOutResponse,
                                                                                                                                              args: DebugProtocol.StepOutArguments,
                                                                                                                                              request?: DebugProtocol.Request
                                                                                                                                              ) => void;

                                                                                                                                                method terminateRequest

                                                                                                                                                protected terminateRequest: (
                                                                                                                                                response: DebugProtocol.TerminateResponse,
                                                                                                                                                args: DebugProtocol.TerminateArguments,
                                                                                                                                                request?: DebugProtocol.Request
                                                                                                                                                ) => void;

                                                                                                                                                  method terminateThreadsRequest

                                                                                                                                                  protected terminateThreadsRequest: (
                                                                                                                                                  response: DebugProtocol.TerminateThreadsResponse,
                                                                                                                                                  args: DebugProtocol.TerminateThreadsArguments,
                                                                                                                                                  request?: DebugProtocol.Request
                                                                                                                                                  ) => void;

                                                                                                                                                    method threadsRequest

                                                                                                                                                    protected threadsRequest: (
                                                                                                                                                    response: DebugProtocol.ThreadsResponse,
                                                                                                                                                    request?: DebugProtocol.Request
                                                                                                                                                    ) => void;

                                                                                                                                                      method variablesRequest

                                                                                                                                                      protected variablesRequest: (
                                                                                                                                                      response: DebugProtocol.VariablesResponse,
                                                                                                                                                      args: DebugProtocol.VariablesArguments,
                                                                                                                                                      request?: DebugProtocol.Request
                                                                                                                                                      ) => void;

                                                                                                                                                        method writeMemoryRequest

                                                                                                                                                        protected writeMemoryRequest: (
                                                                                                                                                        response: DebugProtocol.WriteMemoryResponse,
                                                                                                                                                        args: DebugProtocol.WriteMemoryArguments,
                                                                                                                                                        request?: DebugProtocol.Request
                                                                                                                                                        ) => void;

                                                                                                                                                          class Event

                                                                                                                                                          class Event extends Message implements DebugProtocol.Event {}

                                                                                                                                                            constructor

                                                                                                                                                            constructor(event: string, body?: any);

                                                                                                                                                              property event

                                                                                                                                                              event: string;

                                                                                                                                                                class ExitedEvent

                                                                                                                                                                class ExitedEvent extends Event implements DebugProtocol.ExitedEvent {}

                                                                                                                                                                  constructor

                                                                                                                                                                  constructor(exitCode: number);

                                                                                                                                                                    property body

                                                                                                                                                                    body: { exitCode: number };

                                                                                                                                                                      class Handles

                                                                                                                                                                      class Handles<T> {}

                                                                                                                                                                        constructor

                                                                                                                                                                        constructor(startHandle?: number);

                                                                                                                                                                          method create

                                                                                                                                                                          create: (value: T) => number;

                                                                                                                                                                            method get

                                                                                                                                                                            get: (handle: number, dflt?: T) => T;

                                                                                                                                                                              method reset

                                                                                                                                                                              reset: () => void;

                                                                                                                                                                                class InitializedEvent

                                                                                                                                                                                class InitializedEvent extends Event implements DebugProtocol.InitializedEvent {}

                                                                                                                                                                                  constructor

                                                                                                                                                                                  constructor();

                                                                                                                                                                                    class InvalidatedEvent

                                                                                                                                                                                    class InvalidatedEvent extends Event implements DebugProtocol.InvalidatedEvent {}

                                                                                                                                                                                      constructor

                                                                                                                                                                                      constructor(
                                                                                                                                                                                      areas?: DebugProtocol.InvalidatedAreas[],
                                                                                                                                                                                      threadId?: number,
                                                                                                                                                                                      stackFrameId?: number
                                                                                                                                                                                      );

                                                                                                                                                                                        property body

                                                                                                                                                                                        body: {
                                                                                                                                                                                        areas?: DebugProtocol.InvalidatedAreas[];
                                                                                                                                                                                        threadId?: number;
                                                                                                                                                                                        stackFrameId?: number;
                                                                                                                                                                                        };

                                                                                                                                                                                          class LoadedSourceEvent

                                                                                                                                                                                          class LoadedSourceEvent extends Event implements DebugProtocol.LoadedSourceEvent {}

                                                                                                                                                                                            constructor

                                                                                                                                                                                            constructor(reason: 'new' | 'changed' | 'removed', source: DebugProtocol.Source);

                                                                                                                                                                                              property body

                                                                                                                                                                                              body: { reason: 'new' | 'changed' | 'removed'; source: DebugProtocol.Source };

                                                                                                                                                                                                class LoggingDebugSession

                                                                                                                                                                                                class LoggingDebugSession extends DebugSession {}

                                                                                                                                                                                                  constructor

                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                  obsolete_logFilePath?: string,
                                                                                                                                                                                                  obsolete_debuggerLinesAndColumnsStartAt1?: boolean,
                                                                                                                                                                                                  obsolete_isServer?: boolean
                                                                                                                                                                                                  );

                                                                                                                                                                                                    method dispatchRequest

                                                                                                                                                                                                    protected dispatchRequest: (request: DebugProtocol.Request) => void;

                                                                                                                                                                                                      method sendEvent

                                                                                                                                                                                                      sendEvent: (event: DebugProtocol.Event) => void;
                                                                                                                                                                                                      • Overload sendEvent to log

                                                                                                                                                                                                      method sendRequest

                                                                                                                                                                                                      sendRequest: (
                                                                                                                                                                                                      command: string,
                                                                                                                                                                                                      args: any,
                                                                                                                                                                                                      timeout: number,
                                                                                                                                                                                                      cb: (response: DebugProtocol.Response) => void
                                                                                                                                                                                                      ) => void;
                                                                                                                                                                                                      • Overload sendRequest to log

                                                                                                                                                                                                      method sendResponse

                                                                                                                                                                                                      sendResponse: (response: DebugProtocol.Response) => void;
                                                                                                                                                                                                      • Overload sendResponse to log

                                                                                                                                                                                                      method start

                                                                                                                                                                                                      start: (
                                                                                                                                                                                                      inStream: NodeJS.ReadableStream,
                                                                                                                                                                                                      outStream: NodeJS.WritableStream
                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                        class Module

                                                                                                                                                                                                        class Module implements DebugProtocol.Module {}

                                                                                                                                                                                                          constructor

                                                                                                                                                                                                          constructor(id: string | number, name: string);

                                                                                                                                                                                                            property id

                                                                                                                                                                                                            id: string | number;

                                                                                                                                                                                                              property name

                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                class ModuleEvent

                                                                                                                                                                                                                class ModuleEvent extends Event implements DebugProtocol.ModuleEvent {}

                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                  constructor(reason: 'new' | 'changed' | 'removed', module: DebugProtocol.Module);

                                                                                                                                                                                                                    property body

                                                                                                                                                                                                                    body: { reason: 'new' | 'changed' | 'removed'; module: DebugProtocol.Module };

                                                                                                                                                                                                                      class OutputEvent

                                                                                                                                                                                                                      class OutputEvent extends Event implements DebugProtocol.OutputEvent {}

                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                        constructor(output: string, category?: string, data?: any);

                                                                                                                                                                                                                          property body

                                                                                                                                                                                                                          body: { category: string; output: string; data?: any };

                                                                                                                                                                                                                            class ProgressEndEvent

                                                                                                                                                                                                                            class ProgressEndEvent extends Event implements DebugProtocol.ProgressEndEvent {}

                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                              constructor(progressId: string, message?: string);

                                                                                                                                                                                                                                property body

                                                                                                                                                                                                                                body: { progressId: string };

                                                                                                                                                                                                                                  class ProgressStartEvent

                                                                                                                                                                                                                                  class ProgressStartEvent extends Event implements DebugProtocol.ProgressStartEvent {}

                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                    constructor(progressId: string, title: string, message?: string);

                                                                                                                                                                                                                                      property body

                                                                                                                                                                                                                                      body: { progressId: string; title: string };

                                                                                                                                                                                                                                        class ProgressUpdateEvent

                                                                                                                                                                                                                                        class ProgressUpdateEvent
                                                                                                                                                                                                                                        extends Event
                                                                                                                                                                                                                                        implements DebugProtocol.ProgressUpdateEvent {}

                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                          constructor(progressId: string, message?: string);

                                                                                                                                                                                                                                            property body

                                                                                                                                                                                                                                            body: { progressId: string };

                                                                                                                                                                                                                                              class Response

                                                                                                                                                                                                                                              class Response extends Message implements DebugProtocol.Response {}

                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                constructor(request: DebugProtocol.Request, message?: string);

                                                                                                                                                                                                                                                  property command

                                                                                                                                                                                                                                                  command: string;

                                                                                                                                                                                                                                                    property request_seq

                                                                                                                                                                                                                                                    request_seq: number;

                                                                                                                                                                                                                                                      property success

                                                                                                                                                                                                                                                      success: boolean;

                                                                                                                                                                                                                                                        class Scope

                                                                                                                                                                                                                                                        class Scope implements DebugProtocol.Scope {}

                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                          constructor(name: string, reference: number, expensive?: boolean);

                                                                                                                                                                                                                                                            property expensive

                                                                                                                                                                                                                                                            expensive: boolean;

                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                property variablesReference

                                                                                                                                                                                                                                                                variablesReference: number;

                                                                                                                                                                                                                                                                  class Source

                                                                                                                                                                                                                                                                  class Source implements DebugProtocol.Source {}

                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                    name: string,
                                                                                                                                                                                                                                                                    path?: string,
                                                                                                                                                                                                                                                                    id?: number,
                                                                                                                                                                                                                                                                    origin?: string,
                                                                                                                                                                                                                                                                    data?: any
                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                        property path

                                                                                                                                                                                                                                                                        path: string;

                                                                                                                                                                                                                                                                          property sourceReference

                                                                                                                                                                                                                                                                          sourceReference: number;

                                                                                                                                                                                                                                                                            class StackFrame

                                                                                                                                                                                                                                                                            class StackFrame implements DebugProtocol.StackFrame {}

                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                              constructor(i: number, nm: string, src?: Source, ln?: number, col?: number);

                                                                                                                                                                                                                                                                                property canRestart

                                                                                                                                                                                                                                                                                canRestart?: boolean;

                                                                                                                                                                                                                                                                                  property column

                                                                                                                                                                                                                                                                                  column: number;

                                                                                                                                                                                                                                                                                    property endColumn

                                                                                                                                                                                                                                                                                    endColumn?: number;

                                                                                                                                                                                                                                                                                      property endLine

                                                                                                                                                                                                                                                                                      endLine?: number;

                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                        id: number;

                                                                                                                                                                                                                                                                                          property instructionPointerReference

                                                                                                                                                                                                                                                                                          instructionPointerReference?: string;

                                                                                                                                                                                                                                                                                            property line

                                                                                                                                                                                                                                                                                            line: number;

                                                                                                                                                                                                                                                                                              property moduleId

                                                                                                                                                                                                                                                                                              moduleId?: string | number;

                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                                                                                  property presentationHint

                                                                                                                                                                                                                                                                                                  presentationHint?: 'normal' | 'label' | 'subtle';

                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                    source?: DebugProtocol.Source;

                                                                                                                                                                                                                                                                                                      class StoppedEvent

                                                                                                                                                                                                                                                                                                      class StoppedEvent extends Event implements DebugProtocol.StoppedEvent {}

                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                        constructor(reason: string, threadId?: number, exceptionText?: string);

                                                                                                                                                                                                                                                                                                          property body

                                                                                                                                                                                                                                                                                                          body: { reason: string };

                                                                                                                                                                                                                                                                                                            class TerminatedEvent

                                                                                                                                                                                                                                                                                                            class TerminatedEvent extends Event implements DebugProtocol.TerminatedEvent {}

                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                              constructor(restart?: any);

                                                                                                                                                                                                                                                                                                                class Thread

                                                                                                                                                                                                                                                                                                                class Thread implements DebugProtocol.Thread {}

                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                  constructor(id: number, name: string);

                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                    id: number;

                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                                                        class ThreadEvent

                                                                                                                                                                                                                                                                                                                        class ThreadEvent extends Event implements DebugProtocol.ThreadEvent {}

                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                          constructor(reason: string, threadId: number);

                                                                                                                                                                                                                                                                                                                            property body

                                                                                                                                                                                                                                                                                                                            body: { reason: string; threadId: number };

                                                                                                                                                                                                                                                                                                                              class Variable

                                                                                                                                                                                                                                                                                                                              class Variable implements DebugProtocol.Variable {}

                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                                                                                                                                name: string,
                                                                                                                                                                                                                                                                                                                                value: string,
                                                                                                                                                                                                                                                                                                                                ref?: number,
                                                                                                                                                                                                                                                                                                                                indexedVariables?: number,
                                                                                                                                                                                                                                                                                                                                namedVariables?: number
                                                                                                                                                                                                                                                                                                                                );

                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                    value: string;

                                                                                                                                                                                                                                                                                                                                      property variablesReference

                                                                                                                                                                                                                                                                                                                                      variablesReference: number;

                                                                                                                                                                                                                                                                                                                                        Enums

                                                                                                                                                                                                                                                                                                                                        enum ErrorDestination

                                                                                                                                                                                                                                                                                                                                        enum ErrorDestination {
                                                                                                                                                                                                                                                                                                                                        User = 1,
                                                                                                                                                                                                                                                                                                                                        Telemetry = 2,
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                          member Telemetry

                                                                                                                                                                                                                                                                                                                                          Telemetry = 2

                                                                                                                                                                                                                                                                                                                                            member User

                                                                                                                                                                                                                                                                                                                                            User = 1

                                                                                                                                                                                                                                                                                                                                              Namespaces

                                                                                                                                                                                                                                                                                                                                              namespace Logger

                                                                                                                                                                                                                                                                                                                                              module 'lib/logger.d.ts' {}
                                                                                                                                                                                                                                                                                                                                              • log adds a newline, write doesn't

                                                                                                                                                                                                                                                                                                                                              variable logger

                                                                                                                                                                                                                                                                                                                                              const logger: Logger;

                                                                                                                                                                                                                                                                                                                                                function trimLastNewline

                                                                                                                                                                                                                                                                                                                                                trimLastNewline: (str: string) => string;

                                                                                                                                                                                                                                                                                                                                                  class Logger

                                                                                                                                                                                                                                                                                                                                                  class Logger {}

                                                                                                                                                                                                                                                                                                                                                    method dispose

                                                                                                                                                                                                                                                                                                                                                    dispose: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                      method error

                                                                                                                                                                                                                                                                                                                                                      error: (msg: string) => void;

                                                                                                                                                                                                                                                                                                                                                        method init

                                                                                                                                                                                                                                                                                                                                                        init: (
                                                                                                                                                                                                                                                                                                                                                        logCallback: ILogCallback,
                                                                                                                                                                                                                                                                                                                                                        logFilePath?: string,
                                                                                                                                                                                                                                                                                                                                                        logToConsole?: boolean
                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                          method log

                                                                                                                                                                                                                                                                                                                                                          log: (msg: string, level?: LogLevel) => void;

                                                                                                                                                                                                                                                                                                                                                            method setup

                                                                                                                                                                                                                                                                                                                                                            setup: (
                                                                                                                                                                                                                                                                                                                                                            consoleMinLogLevel: LogLevel,
                                                                                                                                                                                                                                                                                                                                                            _logFilePath?: string | boolean,
                                                                                                                                                                                                                                                                                                                                                            prependTimestamp?: boolean
                                                                                                                                                                                                                                                                                                                                                            ) => void;
                                                                                                                                                                                                                                                                                                                                                            • Set the logger's minimum level to log in the console, and whether to log to the file. Log messages are queued before this is called the first time, because minLogLevel defaults to Warn.

                                                                                                                                                                                                                                                                                                                                                            method verbose

                                                                                                                                                                                                                                                                                                                                                            verbose: (msg: string) => void;

                                                                                                                                                                                                                                                                                                                                                              method warn

                                                                                                                                                                                                                                                                                                                                                              warn: (msg: string) => void;

                                                                                                                                                                                                                                                                                                                                                                class LogOutputEvent

                                                                                                                                                                                                                                                                                                                                                                class LogOutputEvent extends OutputEvent {}

                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                  constructor(msg: string, level: LogLevel);

                                                                                                                                                                                                                                                                                                                                                                    interface IInternalLogger

                                                                                                                                                                                                                                                                                                                                                                    interface IInternalLogger {}

                                                                                                                                                                                                                                                                                                                                                                      method dispose

                                                                                                                                                                                                                                                                                                                                                                      dispose: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                        method log

                                                                                                                                                                                                                                                                                                                                                                        log: (msg: string, level: LogLevel, prependTimestamp?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                          method setup

                                                                                                                                                                                                                                                                                                                                                                          setup: (options: IInternalLoggerOptions) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                            interface IInternalLoggerOptions

                                                                                                                                                                                                                                                                                                                                                                            interface IInternalLoggerOptions {}

                                                                                                                                                                                                                                                                                                                                                                              property consoleMinLogLevel

                                                                                                                                                                                                                                                                                                                                                                              consoleMinLogLevel: LogLevel;

                                                                                                                                                                                                                                                                                                                                                                                property logFilePath

                                                                                                                                                                                                                                                                                                                                                                                logFilePath?: string;

                                                                                                                                                                                                                                                                                                                                                                                  property prependTimestamp

                                                                                                                                                                                                                                                                                                                                                                                  prependTimestamp?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                    interface ILogger

                                                                                                                                                                                                                                                                                                                                                                                    interface ILogger {}

                                                                                                                                                                                                                                                                                                                                                                                      method error

                                                                                                                                                                                                                                                                                                                                                                                      error: (msg: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                        method log

                                                                                                                                                                                                                                                                                                                                                                                        log: (msg: string, level?: LogLevel) => void;

                                                                                                                                                                                                                                                                                                                                                                                          method verbose

                                                                                                                                                                                                                                                                                                                                                                                          verbose: (msg: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                            method warn

                                                                                                                                                                                                                                                                                                                                                                                            warn: (msg: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                              enum LogLevel

                                                                                                                                                                                                                                                                                                                                                                                              enum LogLevel {
                                                                                                                                                                                                                                                                                                                                                                                              Verbose = 0,
                                                                                                                                                                                                                                                                                                                                                                                              Log = 1,
                                                                                                                                                                                                                                                                                                                                                                                              Warn = 2,
                                                                                                                                                                                                                                                                                                                                                                                              Error = 3,
                                                                                                                                                                                                                                                                                                                                                                                              Stop = 4,
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                member Error

                                                                                                                                                                                                                                                                                                                                                                                                Error = 3

                                                                                                                                                                                                                                                                                                                                                                                                  member Log

                                                                                                                                                                                                                                                                                                                                                                                                  Log = 1

                                                                                                                                                                                                                                                                                                                                                                                                    member Stop

                                                                                                                                                                                                                                                                                                                                                                                                    Stop = 4

                                                                                                                                                                                                                                                                                                                                                                                                      member Verbose

                                                                                                                                                                                                                                                                                                                                                                                                      Verbose = 0

                                                                                                                                                                                                                                                                                                                                                                                                        member Warn

                                                                                                                                                                                                                                                                                                                                                                                                        Warn = 2

                                                                                                                                                                                                                                                                                                                                                                                                          type ILogCallback

                                                                                                                                                                                                                                                                                                                                                                                                          type ILogCallback = (outputEvent: OutputEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (6)

                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (5)

                                                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                            No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                            Badge

                                                                                                                                                                                                                                                                                                                                                                                                            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/vscode-debugadapter.

                                                                                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/vscode-debugadapter)
                                                                                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/vscode-debugadapter"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>