h&?'      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Internal functions for consumption by other modules like Server.hs(C) 2023 David M. Johnson!BSD3-style (see the file LICENSE) experimental non-portable Safe-InferredKdap5Used for logging in the presence of multiple threads.dapUsed for performing actions (e.g. printing debug logs to stdout) Also used for writing to each connections Handle. Ensures operations occur one thread at a time.Used internally onlydapUsed for performing actions (e.g. printing debug logs to stdout) Ensures operations occur one thread at a time.Used internally only(C) 2023 David M. Johnson!BSD3-style (see the file LICENSE) experimental non-portable Safe-Inferred ";?dap-Encodes DAP protocol message appropriately >dap=Capitalization helper function >>> capitalize "fooBar" >>> FooBardap$Lower cases a word >>> toLowerCase FooBar >>> "fooBar"dapUsed as a fieldLabelModifier when generating aeson parsers >>> modifier (Proxy @Int) "intThing" >>> String "thing"dapUsed as a fieldLabelModifier when generating aeson parsers >>> getName (Proxy @Int) >>> IntdapUsed as a fieldLabelModifier when generating aeson parsers >>> getName (Proxy @Int) >>> IntdapUsed as a fieldLabelModifier when generating aeson parsers >>> getName (Proxy @Int) >>> IntdapLog formatting util(C) 2023 David M. Johnson!BSD3-style (see the file LICENSE) experimental non-portable Safe-Inferred "%&;=?¸dapAn ExceptionBreakpointsFilter is shown in the UI as an filter option for configuring how exceptions are dealt with.dapThe internal ID of the filter option. This value is passed to the setExceptionBreakpoints request.dap7The name of the filter option. This is shown in the UI.dapA help text providing additional information about the exception filter. This string is typically shown as a hover and can be translated.dapInitial value of the filter option. If not specified a value false is assumed.dapControls whether a condition can be specified for this filter option. If false or missing, a condition can not be set.dapA help text providing information about the condition. This string is shown as the placeholder text for a text box and can be translated.-dapAn ExceptionPathSegment represents a segment in a path that is used to match leafs or nodes in a tree of exceptions. If a segment consists of more than one name, it matches the names provided if negate is false or missing, or it matches anything except the names provided if negate is true.6dapA ColumnDescriptor specifies what module attribute to show in a column of the modules view, how to format it, and what the column@s label should be. It is only used if the underlying UI actually supports this level of customization.8dap.Name of the attribute rendered in this column.9dapHeader UI label of column.:dapFormat to use for the rendered values in this column. TBD how the format strings looks like.;dap/Datatype of values in this column. Defaults to string if not specified. Values: string, number, boolean, unixTimestampUTC<dap/Width of this column in characters (hint only).?dapMemory reference to the base location containing the instructions to disassemble.@dapOffset (in bytes) to be applied to the reference location before disassembling. Can be negative.AdapOffset (in instructions) to be applied after the byte offset (if any) before disassembling. Can be negative.BdapNumber of instructions to disassemble starting at the specified location and offset. An adapter must return exactly this number of instructions - any unavailable instructions should be replaced with an implementation-defined 'invalid instruction' value.CdapIf true, the adapter should attempt to resolve memory addresses and other values to symbolic names.FdapMemory reference to the base location to which data should be written.GdapOffset (in bytes) to be applied to the reference location before writing data. Can be negative.HdapProperty to control partial writes. If true, the debug adapter should attempt to write memory even if the entire memory region is not writable. In such a case the debug adapter should stop after hitting the first byte of memory that cannot be written and return the number of bytes written in the response via the offset and  bytesWritten properties. If false or missing, a debug adapter should attempt to verify the region is writable before writing, and fail the response if it is not.Idap%Bytes to write, encoded using base64.LdapMemory reference to the base location from which data should be read.MdapOffset (in bytes) to be applied to the reference location before reading data. Can be negative.Ndap=Number of bytes to read at the specified location and offset.Qdap;Thread for which exception information should be retrieved.TdapReturns completions in the scope of this stack frame. If not specified, the completions are returned for the global scope.UdapOne or more source lines. Typically this is the text users have typed into the debug console before they asked for completion.VdapThe position within text for which to determine the completion proposals. It is measured in UTF-16 code units and the client capability ( determines whether it is 0- or 1-based.WdapA line for which to determine the completion proposals. If missing the first line of the text is assumed.Zdap>The source location for which the goto targets are determined.[dapDetermines in what format paths are specified. The default is path(, which is the native format. Values: path, uri, etc.dapClient supports the `type` attribute for variables.dap(Client supports the paging of variables.dapClient supports the  runInTerminal request.dap"Client supports memory references.dap#Client supports progress reporting.dapClient supports the  invalidated event.dapClient supports the memory event.dapClient supports the argsCanBeInterpretedByShell attribute on the  runInTerminal request.dapClient supports the startDebugging request.dapArguments passed to the new debug session. The arguments must only contain properties understood by the launch or attach requests of the debug adapter and they must not contain any client-specific properties (e.g. `type`2) or client-specific features (e.g. substitutable ).dapIndicates whether the new debug session should be started with a launch or attach request. Values: launch, attachdap-What kind of terminal to launch. Defaults to  integrated if not specified. Values:  integrated, externaldapTitle of the terminal.dapWorking directory for the command. For non-empty, valid paths this typically results in execution of a change directory command.dap: Show the output as error program output from the debuggee.  telemetry: Send the output to telemetry instead of showing it to the user. etc.dapThe output to report.dapSupport for keeping an output log organized by grouping related messages. Values: start: Start a new group in expanded mode. Subsequent output events are members of the group and should be shown indented. The output? attribute becomes the name of the group and is not indented. startCollapsed: Start a new group in collapsed mode. Subsequent output events are members of the group and should be shown indented (as soon as the group is expanded). The output? attribute becomes the name of the group and is not indented. end: End the current group and decrease the indentation of subsequent output events. A non-empty output8 attribute is shown as the unindented end of the group.dapIf an attribute variablesReference exists and its value is > 0, the output contains objects which can be retrieved by passing variablesReference to the  request as long as execution remains suspended. See 'Lifetime of Object References' in the Overview section for details.dap2The source location where the output was produced.dap9The source location's line where the output was produced.dapThe position in line where the output was produced. It is measured in UTF-16 code units and the client capability ) determines whether it is 0- or 1-based.dap#Additional data to report. For the  telemetry category the data is sent to telemetry, for the other categories the data is shown in JSON format.dap#The reason for the event. Values: started, exited, etc.dapThe identifier of the thread.dapA debug adapter may set restart to true (or to an arbitrary object) to request that the client restarts the session. The value is not interpreted by the client and passed unmodified as an attribute  __restart to the launch and attach requests.dap)The exit code returned from the debuggee.dapThe thread which was continued.dapIf allThreadsContinued is true, a debug adapter can announce that all threads have continued.dapThe reason for the event. For backward compatibility this string is shown in the UI if the  description attribute is missing (but it must not be translated). Values: step,  breakpoint,  exception, pause, entry, goto, 'function breakpoint', 'data breakpoint', 'instruction breakpoint', etc.dapThe full reason for the event, e.g. 'Paused on exception'. This string is shown in the UI as is and can be translated.dapThe thread which was stopped.dapA value of true hints to the client that this event should not change the focus.dap*Additional information. E.g. if reason is  exception, text contains the exception name. This string is shown in the UI.dapIf allThreadsStopped is true, a debug adapter can announce that all threads have stopped. - The client should use this information to enable that all threads can be expanded to access their stacktraces. - If the attribute is missing or false, only the thread with the given  can be expanded.dapIds of the breakpoints that triggered the event. In most cases there is only a single breakpoint but here are some examples for multiple breakpoints: - Different types of breakpoints map to the same location. - Multiple source breakpoints get collapsed to the same instruction by the compiler/runtime. - Multiple function breakpoints with different function names map to the same location.dapThe address of the instruction. Treated as a hex value if prefixed with `0x`, or as a decimal value otherwise.dapRaw bytes representing the instruction and its operands, in an implementation-defined format.dapText representing the instruction and its operands, in an implementation-defined format.dapName of the symbol that corresponds with the location of this instruction, if any.dapSource location that corresponds to this instruction, if any. Should always be set (if available) on the first instruction returned, but can be omitted afterwards if this instruction maps to the same source file as the previous instruction.dapThe line within the source location that corresponds to this instruction, if any.dapThe column within the line that corresponds to this instruction, if any.dapThe end line of the range that corresponds to this instruction, if any.dapThe end column of the range that corresponds to this instruction, if any.dap&The list of disassembled instructions.dap&Property that should be returned when  allowPartial is true to indicate the offset of the first byte of data successfully written. Can be negative.dap&Property that should be returned when  allowPartial is true to indicate the number of bytes starting from address that were successfully written.dapThe address of the first byte of data returned. Treated as a hex value if prefixed with `0x`, or as a decimal value otherwise.dapThe number of unreadable bytes encountered after the last successfully read byte. This can be used to determine the number of bytes that should be skipped before a subsequent  readMemory request succeeds.dapThe bytes read from memory, encoded using base64. If the decoded length of `data` is less than the requested count in the original  readMemory request, and unreadableBytes is zero or omitted, then the client should assume it's reached the end of readable memory.dap#Message contained in the exception.dap(Short type name of the exception object.dap2Fully-qualified type name of the exception object.dapAn expression that can be evaluated in the current scope to obtain the exception object.dap1Stack trace at the time the exception was thrown.dap=Details of the exception contained by this exception, if any.dap$ID of the exception that was thrown.dap#Descriptive text for the exception.dap9Mode that caused the exception notification to be raised.dap)Detailed information about the exception.dapThe label of this completion item. By default this is also the text that is inserted when selecting this completion.dapIf text is returned and not an empty string, then it is inserted instead of the label.dapA string that should be used when comparing this item with other items. If not returned or an empty string, the label is used instead.dapA human-readable string with additional information about this item, like type or symbol information.dapThe item's type. Typically the client uses this information to render the item in the UI with an icon.dapStart position (within the text attribute of the  completions request) where the completion text is added. The position is measured in UTF-16 code units and the client capability  determines whether it is 0- or 1-based. If the start position is omitted the text is added at the location specified by the column attribute of the  completions request.dapLength determines how many characters are overwritten by the completion text and it is measured in UTF-16 code units. If missing the value 0 is assumed which results in the completion text being inserted.dapDetermines the start of the new selection after the text has been inserted (or replaced). selectionStart is measured in UTF-16 code units and must be in the range 0 and length of the completion text. If omitted the selection starts at the end of the completion text.dapDetermines the length of the new selection after the text has been inserted (or replaced) and it is measured in UTF-16 code units. The selection can not extend beyond the bounds of the completion text. If omitted the length is assumed to be 0.dapThe possible completions for .dap9Unique identifier for a goto target. This is used in the goto request.dap.The name of the goto target (shown in the UI).dap"The line of the gotoTarget target.dap$The column of the gotoTarget target.dap;The end line of the range covered by the gotoTarget target.dap=The end column of the range covered by the gotoTarget target.dapA memory reference for the instruction pointer value represented by this target.dap4The possible goto targets of the specified location.dap'Unique identifier for a step-in target.dap1The name of the step-in target (shown in the UI).dapThe line of the step-in target.dapStart position of the range covered by the step in target. It is measured in UTF-16 code units and the client capability ) determines whether it is 0- or 1-based.dap8The end line of the range covered by the step-in target.dapEnd position of the range covered by the step in target. It is measured in UTF-16 code units and the client capability ) determines whether it is 0- or 1-based.dap>The possible step-in targets of the specified source location.dap The new value of the expression.dapThe type of the value. This attribute should only be returned by a debug adapter if the corresponding capability  is true.dapProperties of a value that can be used to determine how to render the result in the UI.dapIf variablesReference is > 0, the evaluate result is structured and its children can be retrieved by passing variablesReference to the  request as long as execution remains suspended. See 'Lifetime of Object References' in the Overview section for details.dapThe number of named child variables. The client can use this information to present the variables in a paged UI and fetch them in chunks. The value should be less than or equal to 2147483647 (2^31-1).dapThe number of indexed child variables. The client can use this information to present the variables in a paged UI and fetch them in chunks. The value should be less than or equal to 2147483647 (2^31-1).dap#The result of the evaluate request.dapThe type of the evaluate result. This attribute should only be returned by a debug adapter if the corresponding capability  is true.dapProperties of an evaluate result that can be used to determine how to render the result in the UI.dapIf variablesReference is > 0, the evaluate result is structured and its children can be retrieved by passing variablesReference to the  request as long as execution remains suspended. See 'Lifetime of Object References' in the Overview section for details.dapThe number of named child variables. The client can use this information to present the variables in a paged UI and fetch them in chunks. The value should be less than or equal to 2147483647 (2^31-1).dapThe number of indexed child variables. The client can use this information to present the variables in a paged UI and fetch them in chunks. The value should be less than or equal to 2147483647 (2^31-1).dapA memory reference to a location appropriate for this result. For pointer type eval results, this is generally a reference to the memory address contained in the pointer. This attribute should be returned by a debug adapter if corresponding capability  is true.dapSet of loaded sources.dap All threads.dap Content of the source reference.dap'Content type (MIME type) of the source.dapThe new value of the variable.dapThe type of the new value. Typically shown in the UI when hovering over the value.dapIf variablesReference is > 0, the new value is structured and its children can be retrieved by passing variablesReference to the  request as long as execution remains suspended. See 'Lifetime of Object References' in the Overview section for details.dapThe number of named child variables. The client can use this information to present the variables in a paged UI and fetch them in chunks. The value should be less than or equal to 2147483647 (2^31-1).dapThe number of indexed child variables. The client can use this information to present the variables in a paged UI and fetch them in chunks. The value should be less than or equal to 2147483647 (2^31-1).dapThe kind of variable. Before introducing additional values, try to use the listed values. Values: property,: Indicates that the object is a property. method*: Indicates that the object is a method. 'class'): Indicates that the object is a class. 'data'&: Indicates that the object is data. event*: Indicates that the object is an event.  baseClass.: Indicates that the object is a base class.  innerClass0: Indicates that the object is an inner class.  interface.: Indicates that the object is an interface. mostDerivedClass8: Indicates that the object is the most derived class. virtual: Indicates that the object is virtual, that means it is a synthetic object introduced by the adapter for rendering purposes, e.g. an index range for large arrays. dataBreakpoint: Deprecated: Indicates that a data breakpoint is registered for the object. The hasDataBreakpoint3 attribute should generally be used instead. etc.dapSet of attributes represented as an array of strings. Before introducing additional values, try to use the listed values. Values: static(: Indicates that the object is static. constant,: Indicates that the object is a constant. readOnly+: Indicates that the object is read only. rawText.: Indicates that the object is a raw string.  hasObjectId: Indicates that the object can have an Object ID created for it. canHaveObjectId: Indicates that the object has an Object ID associated with it. hasSideEffects3: Indicates that the evaluation had side effects. hasDataBreakpoint: Indicates that the object has its value tracked by a data breakpoint. etc.dapVisibility of variable. Before introducing additional values, try to use the listed values. Values: public, private,  protected, internal, final, etc.dapIf true, clients can present the variable with a UI that supports a specific gesture to trigger its evaluation. This mechanism can be used for properties that require executing code when retrieving their value and where the code execution can be expensive and/or produce side-effects. A typical example are properties based on a getter function. Please note that in addition to the lazy flag, the variable's variablesReference is expected to refer to a variable that will provide the value through another variable request.dapThe variable's name.dapThe variable's value. This can be a multi-line text, e.g. for a function the body of a function. For structured variables (which do not have a simple value), it is recommended to provide a one-line representation of the structured object. This helps to identify the structured object in the collapsed state when its children are not yet visible. An empty string can be used if no value should be shown in the UI.dapThe type of the variable's value. Typically shown in the UI when hovering over the value. This attribute should only be returned by a debug adapter if the corresponding capability  is true.dapProperties of a variable that can be used to determine how to render the variable in the UI.dapThe evaluatable name of this variable which can be passed to the evaluate( request to fetch the variable's value.dapIf variablesReference is > 0, the variable is structured and its children can be retrieved by passing variablesReference to the  request as long as execution remains suspended. See 'Lifetime of Object References' in the Overview section for details.dapThe number of named child variables. The client can use this information to present the children in a paged UI and fetch them in chunks.dapThe number of indexed child variables. The client can use this information to present the children in a paged UI and fetch them in chunks.dapThe memory reference for the variable if the variable represents executable code, such as a function pointer. This attribute is only required if the corresponding capability  is true.dap?All (or a range) of variables for the given variable reference.dapName of the scope such as  Arguments, Locals, or  Registers>. This string is shown in the UI as is and can be translated.dapA hint for how to present this scope in the UI. If this attribute is missing, the scope is shown with a generic UI. Values:  arguments$: Scope contains method arguments. locals#: Scope contains local variables.  registers*: Scope contains registers. Only a single  registers" scope should be returned from a  request. etc.dapThe variables of this scope can be retrieved by passing the value of variablesReference to the  request as long as execution remains suspended. See 'Lifetime of Object References' in the Overview section for details.dapThe number of named variables in this scope. The client can use this information to present the variables in a paged UI and fetch them in chunks.dapThe number of indexed variables in this scope. The client can use this information to present the variables in a paged UI and fetch them in chunks.dapIf true, the number of variables in this scope is large or expensive to retrieve.dapThe source for this scope.dap2The start line of the range covered by this scope.dapStart position of the range covered by the scope. It is measured in UTF-16 code units and the client capability ) determines whether it is 0- or 1-based.dap0The end line of the range covered by this scope.dapEnd position of the range covered by the scope. It is measured in UTF-16 code units and the client capability ) determines whether it is 0- or 1-based.dapThe scopes of the stack frame. If the array has length zero, there are no scopes available.dapThe frames of the stack frame. If the array has length zero, there are no stack frames available. This means that there is no location information available.dapThe total number of frames available in the stack. If omitted or if  is larger than the available frames, a client is expected to request frames until a request returns less frames than requested (which indicates the end of the stack). Returning monotonically increasing  values for subsequent requests can be used to enforce paging in the client.dapThis enumeration defines all possible access types for data breakpoints. Values: @read@, @write@, @readWrite@dapAn identifier for the data on which a data breakpoint can be registered with the setDataBreakpoints5 request or null if no data breakpoint is available.dapUI string that describes on what data the breakpoint is set on or why a data breakpoint is not available.dapAttribute lists the available access types for a potential data breakpoint. A UI client could surface this information.dapAttribute indicates that a potential data breakpoint could be persisted across sessions.dap!Unique identifier for the module.dapA name of the module.dapLogical full path to the module. The exact definition is implementation defined, but usually this would be a full path to the on-disk file for the module.dap True if the module is optimized.dapTrue if the module is considered 'user code' by a debugger that supports 'Just My Code'.dapVersion of Module.dapUser-understandable description of if symbols were found for the module (ex: 'Symbols Loaded', 'Symbols not found', etc.)dapLogical full path to the symbol file. The exact definition is implementation defined.dapThe debug adapter , supports stepping granularities (argument  granularity) for the stepping requests.dapThe debug adapter , supports adding breakpoints based on instruction references.dapThe debug adapter , supports  filterOptions as an argument on the setExceptionBreakpoints request.dap!The debug adapter , supports the  singleThread& property on the execution requests (continue, next, stepIn, stepOut, reverseContinue, stepBack).dap!Unique identifier for the thread.dapThe name of the thread.dapAn identifier for the stack frame. It must be unique across all threads. This id can be used to retrieve the scopes of the frame with the 7 request or to restart the execution of a stack frame.dap5The name of the stack frame, typically a method name.dapThe source of the frame.dapThe line within the source of the frame. If the source attribute is missing or doesn't exist, line* is 0 and should be ignored by the client.dapStart position of the range covered by the stack frame. It is measured in UTF-16 code units and the client capability 7 determines whether it is 0- or 1-based. If attribute source is missing or doesn't exist, column* is 0 and should be ignored by the client.dap5The end line of the range covered by the stack frame.dapEnd position of the range covered by the stack frame. It is measured in UTF-16 code units and the client capability ) determines whether it is 0- or 1-based.dap7Indicates whether this frame can be restarted with the restart request. Clients should only use this if the debug adapter supports the restart+ request and the corresponding capability 8 is true. If a debug adapter has this capability, then  canRestart defaults to true if the property is absent.dapA memory reference for the current instruction pointer in this frame.dap.The module associated with this frame, if any.dap 0 the contents of the source must be retrieved through the source1 request (even if a path is specified). Since a sourceReference is only valid for a session, it can not be used to persist a source. The value should be less than or equal to 2147483647 (2^31-1).dapSession ID Local to the current connection's debugger sessiondap)Shared state for serializable concurrencydapA lock for writing to a Handle. One lock is created per connection and exists for the duration of that connectiondapCore type for Debug Adaptor to send and receive messages in a type safe way. the state is  which holds configuration information, along with the current event / response being constructed and the type of the message. Of note: A  is used because adaptorPayload* should not be shared with other threads.dap type DataBreakpointAccessType =  | write |  readWrite;dap?: public | private |  protected | internal | final | string;dapattributes?: (static | constant | readOnly | rawText |  hasObjectId canHaveObjectId | hasSideEffects | hasDataBreakpoint | string)[];  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(C) 2023 David M. Johnson!BSD3-style (see the file LICENSE) experimental non-portable Safe-Inferred"%&;=?dapMeant for internal consumption, used to signify a message has been SENT from the serverdapMeant for external consumptiondapMeant for external consumptiondapWhenever a debug Session ends (cleanly or otherwise) this function will remove the local debugger communication state from the global statedap (internal use only) Sends a raw JSON payload to the editor. No "seq", "type" or "command" fields are set. The message is still encoded with the ProtocolMessage Header, byte count, and CRLF.dapFunction for constructing a payload and writing bytes to a socket. This function takes care of incrementing sequence numbers and setting fields automatically that are required for response messages. i.e. "request_seq" and "command". We also have to be sure to reset the message payloaddapWrites payload to the given  using the local connection lockdapResets Adaptor's payloaddapSends successful eventdapRaises an error Meant abort the current reqeust / response cycle, prematurely sending an  https://microsoft.github.io/debug-adapter-protocol/specification#Base_Protocol_ErrorResponsedapSends unsuccessful response Only used internally within the Server moduledapSends successful eventdap+Attempt to parse arguments from the RequestdapEvaluates Adaptor action by using and updating the state in the MVardap0Utility for evaluating a monad transformer stackdapAction to run debugger (operates in a forked thread that gets killed when disconnect is set)dapLong running operation, meant to be used as a sink for the debugger to emit events and for the adaptor to forward to the editor This function should be in a forever5 loop waiting on the read end of a debugger channel.This event handler thread also takes an argument that allows any child thread to execute events on behalf of the DAP server (in 'Adaptor app ()'). This function should always be used when sending events to the editor from the debugger (or from any forked thread).  registerNewDebugSession sessionId appState loadDebugger $ \withAdaptor -> forever $ getDebuggerOutput >>= \output -> do withAdaptor $ sendOutputEvent defaultOutputEvent { outputEventOutput = output } (C) 2023 David M. Johnson!BSD3-style (see the file LICENSE) experimental non-portable Safe-Inferred "%&';=?dapInitializes the AdaptordapCommunication loop between editor and adaptor Evaluates the current  located in the , Fetches, updates and recurses on the next dapHandle exceptions from client threads, parse and log accordinglydap Internal function for parsing a ProtocolMessage* header This function also dispatches on talk$ Attempts to parse 'Content-Length:  byte-count' Helper function for parsing message headers e.g. ("Content-Length: 11rn")dap-Parses the HeaderPart of all ProtocolMessagesdapHelper function to parse a ProtocolMessage*, extracting it's body. used for testing.dapTop-level Server configuration, global across all debug sessionsdapA function to facilitate communication between DAP clients, debug adaptors and debuggers(C) 2023 David M. Johnson!BSD3-style (see the file LICENSE) experimental non-portable Safe-Inferred"%&;=?dap%AttachResponse has no body by defaultdap1BreakpointLocationResponse has no body by defaultdapSetDataBreakpointsResponsedap)BreakpointResponse has no body by defaultdap8SetInstructionsBreakpointResponse has no body by defaultdap4SetFunctionBreakpointResponse has no body by defaultdap6SetExceptionBreakpointsResponse has no body by defaultdapContinueResponsedapConfigurationDoneResponsedapLaunchResponsedapRestartResponsedapDisconnectResponsedapTerminateResponsedap NextResponsedapStepInResponsedapStepOutResponsedapStepBackResponsedapReverseContinueResponsedapRestartFrameResponsedapInitializeReponsedap GotoResponsedapGotoTargetsResponsedap PauseResponsedapTerminateThreadsResponse+(C) 2023 David M. Johnson!BSD3-style (see the file LICENSE) experimental non-portable Safe-Inferred"%&;=? Safe-Inferred3  )('&%$#"! *+,-0./154236<;:978=CBA@>?DIHGEFJNMKLOPQRWVUSTX\[YZ]^_`edcabfkjighlqpomnrstwuvxyz{~|}6789:;< !"#$%&'()-./0*+,12345lmnopqRSTUVW =>?@ABCfghijkOPQXYZ[\rstuvwJKLMN`abcde{|}~]^_xyz DEFGHI       !"#$%&'()*+,-./001223456789::;<=>?@@ABCDEFFGHIJKKLMNOOPQQRSTUVVWXYZZ[\\]^_`aabcdefghijkllmmnoppqrrstuuvwxyzz{||}~dap-0.1.0.0-inplaceDAP DAP.Internal DAP.Utils DAP.Types DAP.Adaptor DAP.Server DAP.Response DAP.EventwithLockwithGlobalLock DebugStatusSENTRECEIVEDLevelDEBUGINFOWARNERRORThreadsArgumentsConfigurationDoneArgumentsExceptionBreakpointsFilter exceptionBreakpointsFilterFilterexceptionBreakpointsFilterLabel%exceptionBreakpointsFilterDescription!exceptionBreakpointsFilterDefault+exceptionBreakpointsFilterSupportsCondition.exceptionBreakpointsFilterConditionDescriptionCompletionItemTypeCompletionItemTypeMethodCompletionItemTypeFunctionCompletionItemTypeConstructorCompletionItemTypeFieldCompletionItemTypeVariableCompletionItemTypeClassCompletionItemTypeInterfaceCompletionItemTypeModuleCompletionItemTypePropertyCompletionItemTypeUnitCompletionItemTypeValueCompletionItemTypeEnumCompletionItemTypeKeywordCompletionItemTypeSnippetCompletionItemTypeTextCompletionItemTypeColorCompletionItemTypeFileCompletionItemTypeReferenceCompletionItemTypeCustomcolorModulesViewDescriptormodulesViewDescriptorColumnsExceptionPathSegmentexceptionPathSegmentNegateexceptionPathSegmentNamesColumnDescriptorTypeColumnDescriptorTypeStringColumnDescriptorTypeIntColumnDescriptorTypeBoolColumnDescriptorTypeUTCTimeColumnDescriptorcolumnDescriptorAttributeNamecolumnDescriptorLabelcolumnDescriptorFormatcolumnDescriptorTypecolumnDescriptorWidthDisassembleArguments#disassembleArgumentsMemoryReferencedisassembleArgumentsOffset%disassembleArgumentsInstructionOffset$disassembleArgumentsInstructionCount"disassembleArgumentsResolveSymbolsWriteMemoryArgumentswriteMemoryMemoryReferencewriteMemoryArgumentsOffset writeMemoryArgumentsAllowPartialwriteMemoryArgumentsDataReadMemoryArguments"readMemoryArgumentsmemoryReferencereadMemoryArgumentsOffsetreadMemoryArgumentsCountExceptionInfoArgumentsexceptionInfoArgumentsThreadIdCompletionsArgumentscompletionsArgumentsFrameIdcompletionsArgumentsTextcompletionsArgumentsColumncompletionsArgumentsLineGotoTargetsArgumentsgotoTargetsArgumentsSourcegotoTargetsArgumentsLinegotoTargetsArgumentsColumnStepInTargetsArgumentsstepInTargetsArgumentsFrameIdSetExpressionArguments setExpressionArgumentsExpressionsetExpressionArgumentsValuesetExpressionArgumentsFrameIdsetExpressionArgumentsFormatEvaluateArgumentsevaluateArgumentsExpressionevaluateArgumentsFrameIdevaluateArgumentsContextevaluateArgumentsFormatEvaluateArgumentsContextEvaluateArgumentsContextWatchEvaluateArgumentsContextReplEvaluateArgumentsContextHover!EvaluateArgumentsContextClipboard EvaluateArgumentsContextVariableLoadedSourcesArgumentsModulesArgumentsmodulesArgumentsStartModulemodulesArgumentsModuleCountTerminateThreadsArguments"terminateThreadsArgumentsThreadIdsSourceArgumentssourceArgumentsSourcesourceArgumentsSourceReferenceSetVariableArguments&setVariableArgumentsVariablesReferencesetVariableArgumentsNamesetVariableArgumentsValuesetVariableArgumentsFormat ValueFormatvalueFormatHexVariablesArguments$variablesArgumentsVariablesReferencevariablesArgumentsFiltervariablesArgumentsStartvariablesArgumentsCountvariablesArgumentsFormatScopesArgumentsscopesArgumentsFrameIdStackFrameFormatstackFrameFormatParametersstackFrameFormatParameterTypesstackFrameFormatParameterNamesstackFrameFormatParameterValuesstackFrameFormatLinestackFrameFormatModulestackFrameFormatIncludeAllstackFrameFormatHexStackTraceArgumentsstackTraceArgumentsThreadIdstackTraceArgumentsStartFramestackTraceArgumentsLevelsstackTraceArgumentsFormatPauseArgumentspauseArgumentsThreadId GotoArgumentsgotoArgumentsThreadIdgotoArgumentsTargetIdRestartFrameArgumentsrestartFrameArgumentsFrameIdReverseContinueArguments reverseContinueArgumentsThreadId$reverseContinueArgumentsSingleThreadSteppingGranularitySteppingGranularityStatementSteppingGranularityLineSteppingGranularityInstructionStepBackArgumentsstepBackArgumentsThreadIdstepBackArgumentsSingleThreadstepBackArgumentsGranularityStepOutArgumentsstepOutArgumentsThreadIdstepOutArgumentsSingleThreadstepOutArgumentsGranularityStepInArgumentsstepInArgumentsThreadIdstepInArgumentsSingleThreadstepInArgumentsTargetIdstepInArgumentsGranularity NextArgumentsnextArgumentsThreadIdnextArgumentsSingleThreadnextArgumentsGranularityContinueArgumentscontinueArgumentsThreadIdcontinueArgumentsSingleThreadInstructionBreakpoint)instructionBreakpointInstructionReferenceinstructionBreakpointOffsetinstructionBreakpointCondition!instructionBreakpointHitCondition"SetInstructionBreakpointsArguments breakpointsDataBreakpointdataBreakpointDataIddataBreakpointAccessType condition hitConditionSetDataBreakpointsArguments&setDataBreakpointsArgumentsBreakpointsDataBreakpointInfoArguments-dataBreakpointInfoArgumentsVariablesReferencedataBreakpointInfoArgumentsName"dataBreakpointInfoArgumentsFrameIdExceptionOptionsexceptionOptionsPathexceptionOptionsBreakModeExceptionFilterOptionsexceptionFilterOptionsFilterIdexceptionFilterOptionsCondition SetExceptionBreakpointsArguments'setExceptionBreakpointsArgumentsFilters-setExceptionBreakpointsArgumentsFilterOptions0setExceptionBreakpointsArgumentsExceptionOptionsFunctionBreakpointfunctionBreakpointNamefunctionBreakpointConditionfunctionBreakpointHitConditionSetFunctionBreakpointsArguments*setFunctionBreakpointsArgumentsBreakpointsSourceBreakpointsourceBreakpointLinesourceBreakpointColumnsourceBreakpointConditionsourceBreakpointHitConditionsourceBreakpointLogMessageSetBreakpointsArgumentssetBreakpointsArgumentsSource"setBreakpointsArgumentsBreakpointssetBreakpointsArgumentsLines%setBreakpointsArgumentsSourceModifiedBreakpointLocationsArguments"breakpointLocationsArgumentsSource breakpointLocationsArgumentsLine"breakpointLocationsArgumentsColumn#breakpointLocationsArgumentsEndLine%breakpointLocationsArgumentsEndColumnTerminateArgumentsterminateArgumentsRestartDisconnectArgumentsdisconnectArgumentsRestart$disconnectArgumentsTerminateDebuggee"disconnectArgumentsSuspendDebuggeeRestartArgumentsrestartArgumentsArgumentsAttachRequestArgumentsattachRequestArgumentsRestartLaunchRequestArgumentslaunchRequestArgumentsNoDebuglaunchRequestArgumentsRestartInitializeRequestArgumentsclientID clientName adapterIDlocale linesStartAt1columnsStartAt1 pathFormatsupportsVariableTypesupportsVariablePagingsupportsRunInTerminalRequestsupportsMemoryReferencessupportsProgressReportingsupportsInvalidatedEventsupportsMemoryEvent#supportsArgsCanBeInterpretedByShellsupportsStartDebuggingRequest PathFormatPathURI MemoryEventmemoryEventMemoryReferencememoryEventOffsetmemoryEventCountInvalidatedAreasInvalidatedAreasAllInvalidatedAreasStacksInvalidatedAreasThreadsInvalidatedAreasVariablesInvalidatedEventinvalidatedEventAreasinvalidatedEventThreadIdinvalidatedEventStackFrameIdProgressEndEventprogressEndEventProgressIdprogressEndEventMessageProgressUpdateEventprogressUpdateEventProgressIdprogressUpdateEventMessageprogressUpdateEventPercentageProgressStartEventprogressStartEventProgressIdprogressStartEventTitleprogressStartEventRequestIdprogressStartEventCancellableprogressStartEventMessageprogressStartEventPercentageCapabilitiesEvent capabilities StartMethodStartMethodLaunchStartMethodAttach#StartMethodAttachForSuspendedLaunch ProcessEventprocessEventNameprocessEventSystemProcessIdprocessEventIsLocalProcessprocessEventStartMethodprocessEventPointerSizeLoadedSourceEventloadedSourceEventReasonloadedSourceSource ModuleEventmoduleEventReasonmoduleEventModule EventReasonEventReasonNewEventReasonChangedEventReasonRemovedBreakpointEventbreakpointEventReasonbreakpointEvevntBreakpoint OutputEventoutputEventCategoryoutputEventOutputoutputEventGroupoutputEventVariablesReferenceoutputEventSourceoutputEventLineoutputEventColumnoutputEventData EventGroupEventGroupStartEventGroupStartCollapsed EventGroupEndThreadEventReasonThreadEventReasonStartedThreadEventReasonExited ThreadEventthreadEventReasonthreadEventThreadIdTerminatedEventterminatedEventRestart ExitedEventexitedEventExitCodeContinuedEventcontinuedEventThreadId!continuedEventAllThreadsContinued StoppedEventstoppedEventReasonstoppedEventDescriptionstoppedEventThreadIdstoppedEventPreserveFocusHintstoppedEventTextstoppedEventAllThreadsStoppedstoppedEventHitBreakpointIdsStoppedEventReasonStoppedEventReasonStepStoppedEventReasonBreakpointStoppedEventReasonExceptionStoppedEventReasonPauseStoppedEventReasonEntryStoppedEventReasonGoto$StoppedEventReasonFunctionBreakpoint StoppedEventReasonDataBreakpoint'StoppedEventReasonInstructionBreakpointDisassembledInstructiondisassembledInstructionAddress'disassembledInstructionInstructionBytes"disassembledInstructionInstructiondisassembledInstructionSymboldisassembledInstructionLocationdisassembledInstructionLinedisassembledInstructionColumndisassembledInstructionEndLine disassembledInstructionEndColumnDisassembleResponsedisassembleResponseInstructionsWriteMemoryResponsewriteMemoryResponseOffsetwriteMemoryResponseBytesWrittenReadMemoryResponsereadMemoryResponseBodyreadMemoryResponseAddress!readMemoryResponseUnreadableBytesreadMemoryResponseDataExceptionDetailsexceptionDetailsMessageexceptionDetailstypeNameexceptionDetailsFullTypeNameexceptionDetailsEvaluateNameexceptionDetailsStackTraceexceptionDetailsInnerExceptionExceptionBreakModeNeverAlways Unhandled UserUnhandledExceptionInfoResponseexceptionInfoResponseIdexceptionInfoDescriptionIdexceptionInfoBreakModeexceptionInfoReponseDetailsCompletionItemcompletionItemLabelcompletionItemTextcompletionItemSortTextcompletionItemDetailcompletionItemTypecompletionItemTypeStartcompletionItemTypeLength completionItemTypeSelectionStart!completionItemTypeSelectionLengthCompletionsResponsecompletionResponseTargets GotoTarget gotoTargetIdgotoTargetLabelgotoTargetLinegotoTargetColumngotoTargetEndLinegotoTargetEndColumn%gotoTargetInstructionPointerReferenceGotoTargetsResponsegoToTargetsResponseTargets StepInTargetstepInTargetIdstepInTargetLabelstepInTargetLinestepInTargetColumnstepInTargetEndLinestepInTargetEndColumnStepInTargetsResponsestepInTargetsResponseTargetsSetExpressionResponsesetExpressionResponseValuesetExpressionResponseType%setExpressionResponsePresentationHint'setExpressionResponseVariablesReference#setExpressionResponseNamedVariables%setExpressionResponseIndexedVariablesEvaluateResponseevaluateResponseResultevaluateResponseType evaluateResponsePresentationHint"evaluateResponseVariablesReferenceevaluateResponseNamedVariables evaluateResponseIndexedVariablesevaluateResponseMemoryReferenceLoadedSourcesResponseloadedSourcesResponseSourcesThreadsResponsethreadsSourceResponsesourceResponseContentsourceResponseMimeTypeSetVariableResponsesetVariableResponseValuesetVariableResponseTypesetVariableResponseReference!setVariableResponseNamedVariables#setVariableResponseIndexedVariablesPresentationHintKindPresentationHintKindPropertyPresentationHintKindMethodPresentationHintKindClassPresentationHintKindDataPresentationHintKindEventPresentationHintKindBaseClassPresentationHintKindInnerClassPresentationHintKindInterface$PresentationHintKindMostDerivedClassPresentationHintKindVirtual"PresentationHintKindDataBreakpointPresentationHintAttributes PresentationHintAttributesStatic"PresentationHintAttributesConstant"PresentationHintAttributesReadOnly!PresentationHintAttributesRawText%PresentationHintAttributesHasObjectId)PresentationHintAttributesCanHaveObjectId(PresentationHintAttributesHasSideEffects+PresentationHintAttributesHasDataBreakpointPresentationHintVisibility PresentationHintVisibilityPublic!PresentationHintVisibilityPrivate#PresentationHintVisibilityProtected"PresentationHintVisibilityInternalPresentationHintVisibilityFinalVariablePresentationHintvariablePresentationHintKind"variablePresentationHintAttributes"variablePresentationHintVisibilityvariablePresentationHintLazyVariable variableName variableValue variableTypevariablePresentationHintvariableEvaluateNamevariableVariablesReferencevariableNamedVariablesvariableIndexedVariablesvariableMemoryReferenceVariablesResponse variablesScopePresentationHintScopePresentationHintArgumentsScopePresentationHintLocalsScopePresentationHintRegistersScope scopeNamescopePresentationHintscopeVariablesReferencescopeNamedVariablesscopeIndexedVariablesscopeExpensive scopeSource scopeLine scopeColumn scopeEndLinescopeEndColumnScopesResponsescopesStackTraceResponse stackFrames totalFramesDataBreakpointAccessTypeDataBreakpointAccessTypeReadDataBreakpointAccessTypeWrite!DataBreakpointAccessTypeReadWriteDataBreakpointInfoResponse dataBreakpointInfoResponseDataId%dataBreakpointInfoResponseDescription0dataBreakpointInfoResponseDescriptionAccessTypes/dataBreakpointInfoResponseDescriptionCanPersistModulemoduleId moduleName modulePathmoduleIsOptimizedmoduleIsUserCode moduleVersionmoduleSymbolStatusmoduleSymbolFilePathmoduleDateTimeStampmoduleAddressRangeModulesResponsemodulesResponseModulesmodulesResponseTotalModulesRunInTerminalResponserunInTerminalResponseProcessId#runInTerminalResponseShellProcessIdMessage messageId messageFormatmessageVariablesmessageSendTelemetrymessageShowUser messageUrlmessageUrlLabel ErrorResponseerrorResponseErrorContinueResponse#continueResponseAllThreadsContinuedBreakpointLocationbreakpointLocationLinebreakpointLocationColumnbreakpointLocationEndLinebreakpointLocationEndColumn ErrorMessageErrorMessageCancelledErrorMessageNotStoppedCommand CommandCancelCommandRunInTerminalCommandStartDebuggingCommandInitializeCommandConfigurationDone CommandLaunch CommandAttachCommandRestartCommandDisconnectCommandTerminateCommandBreakpointLocationsCommandSetBreakpointsCommandSetFunctionBreakpointsCommandSetExceptionBreakpointsCommandDataBreakpointInfoCommandSetDataBreakpoints CommandSetInstructionBreakpointsCommandContinue CommandNext CommandStepInCommandStepOutCommandStepBackCommandReverseContinueCommandRestartFrame CommandGoTo CommandPauseCommandStackTrace CommandScopesCommandVariablesCommandSetVariable CommandSourceCommandThreadsCommandTerminateThreadsCommandModulesCommandLoadedSourcesCommandEvaluateCommandSetExpressionCommandStepInTargetsCommandGoToTargetsCommandCompletionsCommandExceptionInfoCommandReadMemoryCommandWriteMemoryCommandDisassemble CustomCommand EventTypeEventTypeInitializedEventTypeStoppedEventTypeContinuedEventTypeExitedEventTypeTerminatedEventTypeThreadEventTypeOutputEventTypeBreakpointEventTypeModuleEventTypeLoadedSourceEventTypeProcessEventTypeCapabilitiesEventTypeProgressStartEventTypeProgressUpdateEventTypeProgressEndEventTypeInvalidatedEventTypeMemory Capabilities supportsConfigurationDoneRequestsupportsFunctionBreakpointssupportsConditionalBreakpoints!supportsHitConditionalBreakpointssupportsEvaluateForHoversexceptionBreakpointFilterssupportsStepBacksupportsSetVariablesupportsRestartFramesupportsGotoTargetsRequestsupportsStepInTargetsRequestsupportsCompletionsRequestcompletionTriggerCharacterssupportsModulesRequestadditionalModuleColumnssupportedChecksumAlgorithmssupportsRestartRequestsupportsExceptionOptionssupportsValueFormattingOptionssupportsExceptionInfoRequestsupportTerminateDebuggeesupportSuspendDebuggee supportsDelayedStackTraceLoadingsupportsLoadedSourcesRequestsupportsLogPointssupportsTerminateThreadsRequestsupportsSetExpressionsupportsTerminateRequestsupportsDataBreakpointssupportsReadMemoryRequestsupportsWriteMemoryRequestsupportsDisassembleRequestsupportsCancelRequest"supportsBreakpointLocationsRequestsupportsClipboardContextsupportsSteppingGranularitysupportsInstructionBreakpointssupportsExceptionFilterOptions%supportsSingleThreadExecutionRequestsThreadthreadId threadName StackFrame stackFrameIdstackFrameNamestackFrameSourcestackFrameLinestackFrameColumnstackFrameEndLinestackFrameEndColumnstackFrameCanRestart%stackFrameInstructionPointerReferencestackFrameModuleIdstackFramePresentationHintChecksumAlgorithmMD5SHA1SHA256 TimeStampChecksum algorithmchecksumPresentationHintPresentationHintNormalPresentationHintLabelPresentationHintSubtleSourcePresentationHintSourcePresentationHintNormalSourcePresentationHintEmphasize!SourcePresentationHintDeemphasizeSource sourceName sourcePathsourceSourceReferencesourcePresentationHint sourceOrigin sourceSourcessourceAdapterDatasourceChecksums Breakpoints Breakpoint breakpointIdbreakpointVerifiedbreakpointMessagebreakpointSourcebreakpointLinebreakpointColumnbreakpointEndLinebreakpointEndColumnbreakpointInstructionReferencebreakpointOffsetRequestargs requestSeqNumcommandSeq MessageTypeMessageTypeEventMessageTypeResponseMessageTypeRequest PayloadSizeAdaptorExceptionParseExceptionExpectedArgumentsDebugSessionIdExceptionDebuggerException ServerConfighostportserverCapabilities debugLoggingDebuggerThreadStatedebuggerThreaddebuggerOutputEventThreadAppStore SessionId AdaptorState messageTypepayloadappStore serverConfighandlerequestaddress sessionIdadaptorStateMVar handleLockAdaptordefaultBreakpoint defaultSourcedefaultStackFrame defaultThreaddefaultCapabilitiesdefaultBreakpointLocationdefaultMessage defaultModule defaultScopedefaultVariabledefaultVariablePresentationHintdefaultStepInTargetdefaultGotoTargetdefaultCompletionItemdefaultExceptionDetailsdefaultDisassembledInstructiondefaultSourceBreakpointdefaultFunctionBreakpointdefaultStackFrameFormatdefaultValueFormatdefaultColumnDescriptordefaultModulesViewDescriptor!defaultExceptionBreakpointsFilterlogWarnlogErrorlogInfo debugMessageloggergetServerCapabilitiesgetRequestSeqNumgetDebugSessionIdregisterNewDebugSessionupdateDebugSessiongetDebugSessiondestroyDebugSessionsendRawsendsendSuccesfulResponsesendSuccesfulEmptyResponsesendSuccesfulEvent sendErrorsendErrorResponsesetBodysetFieldwithConnectionLock getArgumentsrunAdaptorWith runDAPServer readPayloadsendAttachResponsesendBreakpointLocationsResponsesendSetDataBreakpointsResponsesendSetBreakpointsResponse%sendSetInstructionBreakpointsResponse"sendSetFunctionBreakpointsResponse#sendSetExceptionBreakpointsResponsesendContinueResponsesendConfigurationDoneResponsesendLaunchResponsesendRestartResponsesendDisconnectResponsesendTerminateResponsesendNextResponsesendStepInResponsesendStepOutResponsesendStepBackResponsesendReverseContinueResponsesendRestartFrameResponsesendInitializeResponsesendGotoResponsesendGotoTargetsResponsesendPauseResponsesendTerminateThreadsResponsesendModulesResponsesendStackTraceResponsesendSourceResponsesendThreadsResponsesendLoadedSourcesResponsesendWriteMemoryResponsesendReadMemoryResponsesendCompletionsResponsesendDataBreakpointInfoResponsesendDisassembleResponsesendEvaluateResponsesendExceptionInfoResponsesendScopesResponsesendSetExpressionResponsesendSetVariableResponsesendStepInTargetsResponsesendVariablesResponsesendRunInTerminalResponsesendStartDebuggingResponsesendBreakpointEventsendCapabilitiesEventsendContinuedEventdefaultContinuedEventsendExitedEventdefaultExitedEventsendInitializedEventsendInvalidatedEventdefaultInvalidatedEventsendLoadedSourceEventsendMemoryEventdefaultMemoryEventsendModuleEventsendOutputEventdefaultOutputEventsendProcessEventdefaultProcessEventsendProgressEndEventdefaultProgressEndEventsendProgressStartEventdefaultProgressStartEventsendProgressUpdateEventdefaultProgressUpdateEventsendStoppedEventdefaultStoppedEventsendTerminatedEventdefaultTerminatedEventsendThreadEventdefaultThreadEventlockencodeBaseProtocolMessage capitalize toLowerCasemodifiergetNamegenericToJSONWithModifiergenericParseJSONWithModifier withBracesbaseGHC.Listfilterbreak+startDebuggingRequestArgumentsConfiguration2startDebuggingRequestArgumentsConfigurationRequest!runInTerminalRequestArgumentsKind"runInTerminalRequestArgumentsTitle runInTerminalRequestArgumentsCwd!runInTerminalRequestArgumentsArgs runInTerminalRequestArgumentsEnv8runInTerminalRequestArgumentsArgsCanBeInterpretedByShellcancelArgumentsRequestIdghc-primGHC.PrimseqcancelArgumentsProgressId Data.FoldableallGHC.Baseid. GHC.Conc.SyncThreadIdtransformers-0.5.6.2Control.Monad.Trans.State.LazyStateT $fToJSONDataBreakpointAccessType Text.Readread"$fToJSONPresentationHintVisibility"$fToJSONPresentationHintAttributes logWithAddr writeToHandleGHC.IO.Handle.TypesHandleresetAdaptorStatePayload setSuccess runAdaptorinitAdaptorState serviceClientexceptionHandler getRequest parseHeader