@isopodlabs/vscode_utils 0.2.6 → 0.3.0

package/dist/debug.d.ts

@@ -1,66 +1,66 @@
-import * as vscode from 'vscode';
 import * as fs from './fs';
 import { DebugProtocol } from '@vscode/debugprotocol';
+import { Disposable, Uri, ExtensionContext, DebugSession, DebugAdapterTracker, FileType, FilePermission, TextDocumentContentProvider } from 'vscode';
 type Response<T extends DebugProtocol.Response> = Promise<T['body']>;
-export declare function request(session: vscode.DebugSession, command: 'cancel', args: DebugProtocol.CancelArguments): Response<DebugProtocol.CancelResponse>;
-export declare function request(session: vscode.DebugSession, command: 'runInTerminal', args: DebugProtocol.RunInTerminalRequestArguments): Response<DebugProtocol.RunInTerminalResponse>;
-export declare function request(session: vscode.DebugSession, command: 'startDebugging', args: DebugProtocol.StartDebuggingRequestArguments): Response<DebugProtocol.StartDebuggingResponse>;
-export declare function request(session: vscode.DebugSession, command: 'initialize', args: DebugProtocol.InitializeRequestArguments): Response<DebugProtocol.InitializeResponse>;
-export declare function request(session: vscode.DebugSession, command: 'configurationDone', args: DebugProtocol.ConfigurationDoneArguments): Response<DebugProtocol.ConfigurationDoneResponse>;
-export declare function request(session: vscode.DebugSession, command: 'launch', args: DebugProtocol.LaunchRequestArguments): Response<DebugProtocol.LaunchResponse>;
-export declare function request(session: vscode.DebugSession, command: 'attach', args: DebugProtocol.AttachRequestArguments): Response<DebugProtocol.AttachResponse>;
-export declare function request(session: vscode.DebugSession, command: 'restart', args: DebugProtocol.RestartArguments): Response<DebugProtocol.RestartResponse>;
-export declare function request(session: vscode.DebugSession, command: 'disconnect', args: DebugProtocol.DisconnectArguments): Response<DebugProtocol.DisconnectResponse>;
-export declare function request(session: vscode.DebugSession, command: 'terminate', args: DebugProtocol.TerminateArguments): Response<DebugProtocol.TerminateResponse>;
-export declare function request(session: vscode.DebugSession, command: 'breakpointLocations', args: DebugProtocol.BreakpointLocationsArguments): Response<DebugProtocol.BreakpointLocationsResponse>;
-export declare function request(session: vscode.DebugSession, command: 'setBreakpoints', args: DebugProtocol.SetBreakpointsArguments): Response<DebugProtocol.SetBreakpointsResponse>;
-export declare function request(session: vscode.DebugSession, command: 'setFunctionBreakpoints', args: DebugProtocol.SetFunctionBreakpointsArguments): Response<DebugProtocol.SetFunctionBreakpointsResponse>;
-export declare function request(session: vscode.DebugSession, command: 'setExceptionBreakpoints', args: DebugProtocol.SetExceptionBreakpointsArguments): Response<DebugProtocol.SetExceptionBreakpointsResponse>;
-export declare function request(session: vscode.DebugSession, command: 'dataBreakpointInfo', args: DebugProtocol.DataBreakpointInfoArguments): Response<DebugProtocol.DataBreakpointInfoResponse>;
-export declare function request(session: vscode.DebugSession, command: 'setDataBreakpoints', args: DebugProtocol.SetDataBreakpointsArguments): Response<DebugProtocol.SetDataBreakpointsResponse>;
-export declare function request(session: vscode.DebugSession, command: 'setInstructionBreakpoints', args: DebugProtocol.SetInstructionBreakpointsArguments): Response<DebugProtocol.SetInstructionBreakpointsResponse>;
-export declare function request(session: vscode.DebugSession, command: 'continue', args: DebugProtocol.ContinueArguments): Response<DebugProtocol.ContinueResponse>;
-export declare function request(session: vscode.DebugSession, command: 'next', args: DebugProtocol.NextArguments): Response<DebugProtocol.NextResponse>;
-export declare function request(session: vscode.DebugSession, command: 'stepIn', args: DebugProtocol.StepInArguments): Response<DebugProtocol.StepInResponse>;
-export declare function request(session: vscode.DebugSession, command: 'stepOut', args: DebugProtocol.StepOutArguments): Response<DebugProtocol.StepOutResponse>;
-export declare function request(session: vscode.DebugSession, command: 'stepBack', args: DebugProtocol.StepBackArguments): Response<DebugProtocol.StepBackResponse>;
-export declare function request(session: vscode.DebugSession, command: 'reverseContinue', args: DebugProtocol.ReverseContinueArguments): Response<DebugProtocol.ReverseContinueResponse>;
-export declare function request(session: vscode.DebugSession, command: 'restartFrame', args: DebugProtocol.RestartFrameArguments): Response<DebugProtocol.RestartFrameResponse>;
-export declare function request(session: vscode.DebugSession, command: 'goto', args: DebugProtocol.GotoArguments): Response<DebugProtocol.GotoResponse>;
-export declare function request(session: vscode.DebugSession, command: 'pause', args: DebugProtocol.PauseArguments): Response<DebugProtocol.PauseResponse>;
-export declare function request(session: vscode.DebugSession, command: 'stackTrace', args: DebugProtocol.StackTraceArguments): Response<DebugProtocol.StackTraceResponse>;
-export declare function request(session: vscode.DebugSession, command: 'scopes', args: DebugProtocol.ScopesArguments): Response<DebugProtocol.ScopesResponse>;
-export declare function request(session: vscode.DebugSession, command: 'variables', args: DebugProtocol.VariablesArguments): Response<DebugProtocol.VariablesResponse>;
-export declare function request(session: vscode.DebugSession, command: 'setVariable', args: DebugProtocol.SetVariableArguments): Response<DebugProtocol.SetVariableResponse>;
-export declare function request(session: vscode.DebugSession, command: 'source', args: DebugProtocol.SourceArguments): Response<DebugProtocol.SourceResponse>;
-export declare function request(session: vscode.DebugSession, command: 'threads'): Response<DebugProtocol.ThreadsResponse>;
-export declare function request(session: vscode.DebugSession, command: 'terminateThreads', args: DebugProtocol.TerminateThreadsArguments): Response<DebugProtocol.TerminateThreadsResponse>;
-export declare function request(session: vscode.DebugSession, command: 'modules', args: DebugProtocol.ModulesArguments): Response<DebugProtocol.ModulesResponse>;
-export declare function request(session: vscode.DebugSession, command: 'loadedSources', args: DebugProtocol.LoadedSourcesArguments): Response<DebugProtocol.LoadedSourcesResponse>;
-export declare function request(session: vscode.DebugSession, command: 'evaluate', args: DebugProtocol.EvaluateArguments): Response<DebugProtocol.EvaluateResponse>;
-export declare function request(session: vscode.DebugSession, command: 'setExpression', args: DebugProtocol.SetExpressionArguments): Response<DebugProtocol.SetExpressionResponse>;
-export declare function request(session: vscode.DebugSession, command: 'stepInTargets', args: DebugProtocol.StepInTargetsArguments): Response<DebugProtocol.StepInTargetsResponse>;
-export declare function request(session: vscode.DebugSession, command: 'gotoTargets', args: DebugProtocol.GotoTargetsArguments): Response<DebugProtocol.GotoTargetsResponse>;
-export declare function request(session: vscode.DebugSession, command: 'completions', args: DebugProtocol.CompletionsArguments): Response<DebugProtocol.CompletionsResponse>;
-export declare function request(session: vscode.DebugSession, command: 'exceptionInfo', args: DebugProtocol.ExceptionInfoArguments): Response<DebugProtocol.ExceptionInfoResponse>;
-export declare function request(session: vscode.DebugSession, command: 'readMemory', args: DebugProtocol.ReadMemoryArguments): Response<DebugProtocol.ReadMemoryResponse>;
-export declare function request(session: vscode.DebugSession, command: 'writeMemory', args: DebugProtocol.WriteMemoryArguments): Response<DebugProtocol.WriteMemoryResponse>;
-export declare function request(session: vscode.DebugSession, command: 'disassemble', args: DebugProtocol.DisassembleArguments): Response<DebugProtocol.DisassembleResponse>;
-export declare function request(session: vscode.DebugSession, command: 'locations', args: DebugProtocol.LocationsArguments): Response<DebugProtocol.LocationsResponse>;
+export declare function request(session: DebugSession, command: 'cancel', args: DebugProtocol.CancelArguments): Response<DebugProtocol.CancelResponse>;
+export declare function request(session: DebugSession, command: 'runInTerminal', args: DebugProtocol.RunInTerminalRequestArguments): Response<DebugProtocol.RunInTerminalResponse>;
+export declare function request(session: DebugSession, command: 'startDebugging', args: DebugProtocol.StartDebuggingRequestArguments): Response<DebugProtocol.StartDebuggingResponse>;
+export declare function request(session: DebugSession, command: 'initialize', args: DebugProtocol.InitializeRequestArguments): Response<DebugProtocol.InitializeResponse>;
+export declare function request(session: DebugSession, command: 'configurationDone', args: DebugProtocol.ConfigurationDoneArguments): Response<DebugProtocol.ConfigurationDoneResponse>;
+export declare function request(session: DebugSession, command: 'launch', args: DebugProtocol.LaunchRequestArguments): Response<DebugProtocol.LaunchResponse>;
+export declare function request(session: DebugSession, command: 'attach', args: DebugProtocol.AttachRequestArguments): Response<DebugProtocol.AttachResponse>;
+export declare function request(session: DebugSession, command: 'restart', args: DebugProtocol.RestartArguments): Response<DebugProtocol.RestartResponse>;
+export declare function request(session: DebugSession, command: 'disconnect', args: DebugProtocol.DisconnectArguments): Response<DebugProtocol.DisconnectResponse>;
+export declare function request(session: DebugSession, command: 'terminate', args: DebugProtocol.TerminateArguments): Response<DebugProtocol.TerminateResponse>;
+export declare function request(session: DebugSession, command: 'breakpointLocations', args: DebugProtocol.BreakpointLocationsArguments): Response<DebugProtocol.BreakpointLocationsResponse>;
+export declare function request(session: DebugSession, command: 'setBreakpoints', args: DebugProtocol.SetBreakpointsArguments): Response<DebugProtocol.SetBreakpointsResponse>;
+export declare function request(session: DebugSession, command: 'setFunctionBreakpoints', args: DebugProtocol.SetFunctionBreakpointsArguments): Response<DebugProtocol.SetFunctionBreakpointsResponse>;
+export declare function request(session: DebugSession, command: 'setExceptionBreakpoints', args: DebugProtocol.SetExceptionBreakpointsArguments): Response<DebugProtocol.SetExceptionBreakpointsResponse>;
+export declare function request(session: DebugSession, command: 'dataBreakpointInfo', args: DebugProtocol.DataBreakpointInfoArguments): Response<DebugProtocol.DataBreakpointInfoResponse>;
+export declare function request(session: DebugSession, command: 'setDataBreakpoints', args: DebugProtocol.SetDataBreakpointsArguments): Response<DebugProtocol.SetDataBreakpointsResponse>;
+export declare function request(session: DebugSession, command: 'setInstructionBreakpoints', args: DebugProtocol.SetInstructionBreakpointsArguments): Response<DebugProtocol.SetInstructionBreakpointsResponse>;
+export declare function request(session: DebugSession, command: 'continue', args: DebugProtocol.ContinueArguments): Response<DebugProtocol.ContinueResponse>;
+export declare function request(session: DebugSession, command: 'next', args: DebugProtocol.NextArguments): Response<DebugProtocol.NextResponse>;
+export declare function request(session: DebugSession, command: 'stepIn', args: DebugProtocol.StepInArguments): Response<DebugProtocol.StepInResponse>;
+export declare function request(session: DebugSession, command: 'stepOut', args: DebugProtocol.StepOutArguments): Response<DebugProtocol.StepOutResponse>;
+export declare function request(session: DebugSession, command: 'stepBack', args: DebugProtocol.StepBackArguments): Response<DebugProtocol.StepBackResponse>;
+export declare function request(session: DebugSession, command: 'reverseContinue', args: DebugProtocol.ReverseContinueArguments): Response<DebugProtocol.ReverseContinueResponse>;
+export declare function request(session: DebugSession, command: 'restartFrame', args: DebugProtocol.RestartFrameArguments): Response<DebugProtocol.RestartFrameResponse>;
+export declare function request(session: DebugSession, command: 'goto', args: DebugProtocol.GotoArguments): Response<DebugProtocol.GotoResponse>;
+export declare function request(session: DebugSession, command: 'pause', args: DebugProtocol.PauseArguments): Response<DebugProtocol.PauseResponse>;
+export declare function request(session: DebugSession, command: 'stackTrace', args: DebugProtocol.StackTraceArguments): Response<DebugProtocol.StackTraceResponse>;
+export declare function request(session: DebugSession, command: 'scopes', args: DebugProtocol.ScopesArguments): Response<DebugProtocol.ScopesResponse>;
+export declare function request(session: DebugSession, command: 'variables', args: DebugProtocol.VariablesArguments): Response<DebugProtocol.VariablesResponse>;
+export declare function request(session: DebugSession, command: 'setVariable', args: DebugProtocol.SetVariableArguments): Response<DebugProtocol.SetVariableResponse>;
+export declare function request(session: DebugSession, command: 'source', args: DebugProtocol.SourceArguments): Response<DebugProtocol.SourceResponse>;
+export declare function request(session: DebugSession, command: 'threads'): Response<DebugProtocol.ThreadsResponse>;
+export declare function request(session: DebugSession, command: 'terminateThreads', args: DebugProtocol.TerminateThreadsArguments): Response<DebugProtocol.TerminateThreadsResponse>;
+export declare function request(session: DebugSession, command: 'modules', args: DebugProtocol.ModulesArguments): Response<DebugProtocol.ModulesResponse>;
+export declare function request(session: DebugSession, command: 'loadedSources', args: DebugProtocol.LoadedSourcesArguments): Response<DebugProtocol.LoadedSourcesResponse>;
+export declare function request(session: DebugSession, command: 'evaluate', args: DebugProtocol.EvaluateArguments): Response<DebugProtocol.EvaluateResponse>;
+export declare function request(session: DebugSession, command: 'setExpression', args: DebugProtocol.SetExpressionArguments): Response<DebugProtocol.SetExpressionResponse>;
+export declare function request(session: DebugSession, command: 'stepInTargets', args: DebugProtocol.StepInTargetsArguments): Response<DebugProtocol.StepInTargetsResponse>;
+export declare function request(session: DebugSession, command: 'gotoTargets', args: DebugProtocol.GotoTargetsArguments): Response<DebugProtocol.GotoTargetsResponse>;
+export declare function request(session: DebugSession, command: 'completions', args: DebugProtocol.CompletionsArguments): Response<DebugProtocol.CompletionsResponse>;
+export declare function request(session: DebugSession, command: 'exceptionInfo', args: DebugProtocol.ExceptionInfoArguments): Response<DebugProtocol.ExceptionInfoResponse>;
+export declare function request(session: DebugSession, command: 'readMemory', args: DebugProtocol.ReadMemoryArguments): Response<DebugProtocol.ReadMemoryResponse>;
+export declare function request(session: DebugSession, command: 'writeMemory', args: DebugProtocol.WriteMemoryArguments): Response<DebugProtocol.WriteMemoryResponse>;
+export declare function request(session: DebugSession, command: 'disassemble', args: DebugProtocol.DisassembleArguments): Response<DebugProtocol.DisassembleResponse>;
+export declare function request(session: DebugSession, command: 'locations', args: DebugProtocol.LocationsArguments): Response<DebugProtocol.LocationsResponse>;
 export declare const enum State {
     Inactive = 0,
     Initializing = 1,
     Stopped = 2,
     Running = 3
 }
-export declare class Session implements vscode.DebugAdapterTracker {
-    session: vscode.DebugSession;
+export declare class Session implements DebugAdapterTracker {
+    session: DebugSession;
     static sessions: Record<string, Session>;
     private static _onCreate;
     private static bpchange;
-    static get onCreate(): vscode.Event<Session>;
+    static get onCreate(): import("vscode").Event<Session>;
     static get_wrapper(id: string): Session;
-    static get(id: string): vscode.DebugSession;
+    static get(id: string): DebugSession;
     static get_caps(id: string): DebugProtocol.Capabilities | undefined;
     private _onMessage;
     private _onDidChangeState;
@@ -69,32 +69,32 @@ export declare class Session implements vscode.DebugAdapterTracker {
     threadId?: number;
     frameId?: Promise<number>;
     capabilities?: DebugProtocol.Capabilities;
-    static register(context: vscode.ExtensionContext): void;
-    constructor(session: vscode.DebugSession);
+    static register(context: ExtensionContext): void;
+    constructor(session: DebugSession);
     set state(value: number);
-    get onMessage(): vscode.Event<any>;
-    get onDidChangeState(): vscode.Event<number>;
-    get onDidInvalidateMemory(): vscode.Event<DebugProtocol.MemoryEvent>;
+    get onMessage(): import("vscode").Event<any>;
+    get onDidChangeState(): import("vscode").Event<number>;
+    get onDidInvalidateMemory(): import("vscode").Event<DebugProtocol.MemoryEvent>;
     onExit(_code: number | undefined, _signal: string | undefined): void;
     onWillStartSession(): void;
     onWillStopSession?(): void;
     onDidSendMessage(message: DebugProtocol.ProtocolMessage): void;
 }
-export declare function getTopStackFrameId(session: vscode.DebugSession): Promise<number> | undefined;
+export declare function getTopStackFrameId(session: DebugSession): Promise<number> | undefined;
 declare class MemoryFile implements fs.File {
-    session: vscode.DebugSession;
+    session: DebugSession;
     memoryReference: string;
-    constructor(session: vscode.DebugSession, memoryReference: string);
+    constructor(session: DebugSession, memoryReference: string);
     dispose(): void;
     read(pos: number, length: number): Promise<Uint8Array>;
     write(pos: number, data: Uint8Array): Promise<number>;
 }
 export declare class MemoryFileSystem extends fs.BaseFileSystem {
     static SCHEME: string;
-    static makeUri(session: vscode.DebugSession, memoryReference: string, range?: fs.FileRange, displayName?: string): vscode.Uri;
-    static getSessionWrapper(uri: vscode.Uri): Session;
-    static getSession(uri: vscode.Uri): vscode.DebugSession;
-    static parseUri(uri: vscode.Uri): {
+    static makeUri(session: DebugSession, memoryReference: string, range?: fs.FileRange, displayName?: string): Uri;
+    static getSessionWrapper(uri: Uri): Session;
+    static getSession(uri: Uri): DebugSession;
+    static parseUri(uri: Uri): {
         offset: {
             fromOffset: number;
             toOffset: number;
@@ -102,30 +102,30 @@ export declare class MemoryFileSystem extends fs.BaseFileSystem {
         readOnly: boolean | undefined;
         memoryReference: string;
     };
-    constructor(context: vscode.ExtensionContext);
-    openFile(uri: vscode.Uri): MemoryFile;
-    watch(uri: vscode.Uri, options: {
+    constructor(context: ExtensionContext);
+    openFile(uri: Uri): MemoryFile;
+    watch(uri: Uri, options: {
         readonly recursive: boolean;
         readonly excludes: readonly string[];
-    }): vscode.Disposable;
-    stat(uri: vscode.Uri): Promise<{
-        type: vscode.FileType;
+    }): Disposable;
+    stat(uri: Uri): Promise<{
+        type: FileType;
         mtime: number;
         ctime: number;
         size: number;
-        permissions: vscode.FilePermission | undefined;
+        permissions: FilePermission | undefined;
     }>;
-    readFile(uri: vscode.Uri): Promise<Uint8Array<ArrayBufferLike>>;
-    writeFile(uri: vscode.Uri, content: Uint8Array): Promise<void>;
+    readFile(uri: Uri): Promise<Uint8Array<ArrayBufferLike>>;
+    writeFile(uri: Uri, content: Uint8Array): Promise<void>;
 }
 export declare class MemorySchema {
     static SCHEME: string;
-    static makeUri(session: vscode.DebugSession, memoryReference: string, range?: fs.FileRange, displayName?: string): vscode.Uri;
+    static makeUri(session: DebugSession, memoryReference: string, range?: fs.FileRange, displayName?: string): Uri;
 }
-export declare class SourceProvider implements vscode.TextDocumentContentProvider {
+export declare class SourceProvider implements TextDocumentContentProvider {
     static SCHEME: string;
-    static makeUri(session: vscode.DebugSession, sourceReference: number, displayName?: string): vscode.Uri;
-    constructor(context: vscode.ExtensionContext);
-    provideTextDocumentContent(uri: vscode.Uri): Promise<string>;
+    static makeUri(session: DebugSession, sourceReference: number, displayName?: string): Uri;
+    constructor(context: ExtensionContext);
+    provideTextDocumentContent(uri: Uri): Promise<string>;
 }
 export {};

package/dist/debug.js

@@ -36,31 +36,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SourceProvider = exports.MemorySchema = exports.MemoryFileSystem = exports.Session = void 0;
 exports.request = request;
 exports.getTopStackFrameId = getTopStackFrameId;
-const vscode = __importStar(require("vscode"));
 const fs = __importStar(require("./fs"));
+const vscode_1 = require("vscode");
 async function request(session, command, args) {
     return session.customRequest(command, args);
 }
 class Session {
     session;
     static sessions = {};
-    static _onCreate = new vscode.EventEmitter();
-    static bpchange = vscode.debug.onDidChangeBreakpoints(event => {
+    static _onCreate = new vscode_1.EventEmitter();
+    static bpchange = vscode_1.debug.onDidChangeBreakpoints(event => {
         console.log(event);
     });
     static get onCreate() { return this._onCreate.event; }
     static get_wrapper(id) { return this.sessions[id]; }
     static get(id) { return this.sessions[id]?.session; }
     static get_caps(id) { return this.sessions[id]?.capabilities; }
-    _onMessage = new vscode.EventEmitter();
-    _onDidChangeState = new vscode.EventEmitter();
-    _onDidInvalidateMemory = new vscode.EventEmitter();
+    _onMessage = new vscode_1.EventEmitter();
+    _onDidChangeState = new vscode_1.EventEmitter();
+    _onDidInvalidateMemory = new vscode_1.EventEmitter();
     _state = 0 /* State.Inactive */;
     threadId;
     frameId;
     capabilities;
     static register(context) {
-        context.subscriptions.push(vscode.debug.registerDebugAdapterTrackerFactory('*', {
+        context.subscriptions.push(vscode_1.debug.registerDebugAdapterTrackerFactory('*', {
             createDebugAdapterTracker: (session) => new Session(session)
         }));
     }
@@ -163,7 +163,7 @@ class MemoryFile {
 class MemoryFileSystem extends fs.BaseFileSystem {
     static SCHEME = 'modules-debug-memory';
     static makeUri(session, memoryReference, range, displayName = 'memory') {
-        return vscode.Uri.from({
+        return vscode_1.Uri.from({
             scheme: this.SCHEME,
             authority: session.id,
             path: `/${encodeURIComponent(memoryReference)}/${encodeURIComponent(displayName)}`,
@@ -177,7 +177,7 @@ class MemoryFileSystem extends fs.BaseFileSystem {
         return session;
     }
     static getSession(uri) {
-        const session = Session.get_wrapper(uri.authority)?.session ?? vscode.debug.activeDebugSession;
+        const session = Session.get_wrapper(uri.authority)?.session ?? vscode_1.debug.activeDebugSession;
         if (!session)
             throw 'Debug session not found';
         return session;
@@ -202,25 +202,25 @@ class MemoryFileSystem extends fs.BaseFileSystem {
     }
     watch(uri, options) {
         if (options.recursive)
-            return new vscode.Disposable(() => { });
+            return new vscode_1.Disposable(() => { });
         const session = MemoryFileSystem.getSessionWrapper(uri);
         const { memoryReference, offset } = MemoryFileSystem.parseUri(uri);
-        return vscode.Disposable.from(session.onDidChangeState(state => {
+        return vscode_1.Disposable.from(session.onDidChangeState(state => {
             if (state === 3 /* State.Running */ || state === 0 /* State.Inactive */)
-                this._onDidChangeFile.fire([{ type: vscode.FileChangeType.Deleted, uri }]);
+                this._onDidChangeFile.fire([{ type: vscode_1.FileChangeType.Deleted, uri }]);
         }), session.onDidInvalidateMemory(e => {
             if (e.body.memoryReference === memoryReference && (!offset || (e.body.offset < offset.toOffset && e.body.offset + e.body.count >= offset.fromOffset)))
-                this._onDidChangeFile.fire([{ type: vscode.FileChangeType.Changed, uri }]);
+                this._onDidChangeFile.fire([{ type: vscode_1.FileChangeType.Changed, uri }]);
         }));
     }
     stat(uri) {
         const { readOnly, offset } = MemoryFileSystem.parseUri(uri);
         return Promise.resolve({
-            type: vscode.FileType.File,
+            type: vscode_1.FileType.File,
             mtime: 0,
             ctime: 0,
             size: offset ? offset.toOffset - offset.fromOffset : 0x10000,
-            permissions: readOnly ? vscode.FilePermission.Readonly : undefined,
+            permissions: readOnly ? vscode_1.FilePermission.Readonly : undefined,
         });
     }
     async readFile(uri) {
@@ -257,7 +257,7 @@ exports.MemoryFileSystem = MemoryFileSystem;
 class MemorySchema {
     static SCHEME = 'vscode-debug-memory';
     static makeUri(session, memoryReference, range, displayName = 'memory') {
-        return vscode.Uri.from({
+        return vscode_1.Uri.from({
             scheme: MemorySchema.SCHEME,
             authority: session.id,
             path: `/${encodeURIComponent(memoryReference)}/${encodeURIComponent(displayName)}`,
@@ -269,14 +269,14 @@ exports.MemorySchema = MemorySchema;
 class SourceProvider {
     static SCHEME = 'vscode-debug-source';
     static makeUri(session, sourceReference, displayName = 'memory') {
-        return vscode.Uri.from({
+        return vscode_1.Uri.from({
             scheme: this.SCHEME,
             authority: session.id,
             path: `/${sourceReference}/${encodeURIComponent(displayName)}`,
         });
     }
     constructor(context) {
-        context.subscriptions.push(vscode.workspace.registerTextDocumentContentProvider(SourceProvider.SCHEME, this));
+        context.subscriptions.push(vscode_1.workspace.registerTextDocumentContentProvider(SourceProvider.SCHEME, this));
     }
     async provideTextDocumentContent(uri) {
         const parts = uri.path.split('/');

package/dist/fs.d.ts

@@ -1,5 +1,5 @@
-import * as vscode from 'vscode';
-export type Filename = string | vscode.Uri;
+import { Uri, Disposable, ExtensionContext, EventEmitter, FileType, FilePermission, FileStat, FileChangeEvent, FileSystemProvider } from 'vscode';
+export type Filename = string | Uri;
 export interface FileRange {
     fromOffset: number;
     toOffset: number;
@@ -10,77 +10,77 @@ export interface File {
     write(pos: number, data: Uint8Array): Promise<number>;
 }
 export declare function isFile(obj: any): obj is File;
-interface FileSystem extends vscode.FileSystemProvider {
-    openFile(uri: vscode.Uri): File | Promise<File>;
+interface FileSystem extends FileSystemProvider {
+    openFile(uri: Uri): File | Promise<File>;
 }
 export declare abstract class BaseFileSystem implements FileSystem {
-    protected _onDidChangeFile: vscode.EventEmitter<vscode.FileChangeEvent[]>;
-    constructor(context: vscode.ExtensionContext, scheme: string);
-    get onDidChangeFile(): vscode.Event<vscode.FileChangeEvent[]>;
-    abstract openFile(uri: vscode.Uri): File | Promise<File>;
-    abstract readFile(uri: vscode.Uri): Uint8Array | Thenable<Uint8Array>;
-    watch(_uri: vscode.Uri, _options: {
+    protected _onDidChangeFile: EventEmitter<FileChangeEvent[]>;
+    constructor(context: ExtensionContext, scheme: string);
+    get onDidChangeFile(): import("vscode").Event<FileChangeEvent[]>;
+    abstract openFile(uri: Uri): File | Promise<File>;
+    abstract readFile(uri: Uri): Uint8Array | Thenable<Uint8Array>;
+    watch(_uri: Uri, _options: {
         readonly recursive: boolean;
         readonly excludes: readonly string[];
-    }): vscode.Disposable;
-    stat(_uri: vscode.Uri): vscode.FileStat | Thenable<vscode.FileStat>;
-    readDirectory(_uri: vscode.Uri): [string, vscode.FileType][];
-    createDirectory(_uri: vscode.Uri): void;
-    writeFile(_uri: vscode.Uri, _content: Uint8Array, _options: {
+    }): Disposable;
+    stat(_uri: Uri): FileStat | Thenable<FileStat>;
+    readDirectory(_uri: Uri): [string, FileType][];
+    createDirectory(_uri: Uri): void;
+    writeFile(_uri: Uri, _content: Uint8Array, _options: {
         readonly create: boolean;
         readonly overwrite: boolean;
     }): void;
-    delete(_uri: vscode.Uri, _options: {
+    delete(_uri: Uri, _options: {
         readonly recursive: boolean;
     }): void;
-    rename(_oldUri: vscode.Uri, _newUri: vscode.Uri, _options: {
+    rename(_oldUri: Uri, _newUri: Uri, _options: {
         readonly overwrite: boolean;
     }): void;
 }
 export declare function withOffset(file: File, offset: FileRange): File;
-export declare function withOffset(file: vscode.Uri, offset: FileRange): vscode.Uri;
-export declare function openFile(uri: vscode.Uri): File | Promise<File>;
+export declare function withOffset(file: Uri, offset: FileRange): Uri;
+export declare function openFile(uri: Uri): File | Promise<File>;
 export declare class NormalFile implements File {
     fd: number;
     constructor(fd: number);
-    static open(uri: vscode.Uri): Promise<NormalFile>;
+    static open(uri: Uri): Promise<NormalFile>;
     dispose(): void;
     read(pos: number, length: number): Promise<Uint8Array<ArrayBufferLike>>;
     write(pos: number, data: Uint8Array): Promise<number>;
 }
 export declare class ReadOnlyFilesystem extends BaseFileSystem {
     static SCHEME: string;
-    constructor(context: vscode.ExtensionContext);
-    stat(uri: vscode.Uri): Promise<{
-        permissions: vscode.FilePermission;
-        type: vscode.FileType;
+    constructor(context: ExtensionContext);
+    stat(uri: Uri): Promise<{
+        permissions: FilePermission;
+        type: FileType;
         ctime: number;
         mtime: number;
         size: number;
     }>;
-    openFile(uri: vscode.Uri): File | Promise<File>;
-    readFile(uri: vscode.Uri): Thenable<Uint8Array<ArrayBufferLike>>;
+    openFile(uri: Uri): File | Promise<File>;
+    readFile(uri: Uri): Thenable<Uint8Array<ArrayBufferLike>>;
 }
 export declare class SubfileFileSystem extends BaseFileSystem {
     static SCHEME: string;
-    static makeUri(uri: vscode.Uri, offset: FileRange): vscode.Uri;
-    static parseUri(uri: vscode.Uri): {
-        uri: vscode.Uri;
+    static makeUri(uri: Uri, offset: FileRange): Uri;
+    static parseUri(uri: Uri): {
+        uri: Uri;
         offset: {
             fromOffset: number;
             toOffset: number;
         };
     };
-    constructor(context: vscode.ExtensionContext);
-    stat(uri: vscode.Uri): Promise<{
+    constructor(context: ExtensionContext);
+    stat(uri: Uri): Promise<{
         size: number;
-        type: vscode.FileType;
+        type: FileType;
         ctime: number;
         mtime: number;
-        permissions?: vscode.FilePermission;
+        permissions?: FilePermission;
     }>;
-    readFile(uri: vscode.Uri): Promise<Uint8Array<ArrayBufferLike>>;
-    openFile(uri: vscode.Uri): Promise<File>;
+    readFile(uri: Uri): Promise<Uint8Array<ArrayBufferLike>>;
+    openFile(uri: Uri): Promise<File>;
 }
 export declare class Glob {
     private readonly regexp;
@@ -88,22 +88,22 @@ export declare class Glob {
     test(input: string): boolean;
 }
 export declare function toOSPath(input: string | undefined): string;
-export type Entry = [string, vscode.FileType];
+export type Entry = [string, FileType];
 export declare function readDirectory(dir: Filename): Thenable<Entry[]>;
 export declare function directories(entries: Entry[]): string[];
 export declare function files(entries: Entry[], glob?: string | Glob): string[];
-export declare function search(pattern: string, _exclude?: string | string[], want?: vscode.FileType): Promise<string[]>;
+export declare function search(pattern: string, _exclude?: string | string[], want?: FileType): Promise<string[]>;
 export declare function mapDirs<T>(root: string, glob: string | Glob, onFile: (filename: string) => T, combine: (...results: T[]) => T): Promise<T>;
-export declare function stat_reject(value: Filename): Thenable<vscode.FileStat>;
+export declare function stat_reject(value: Filename): Thenable<FileStat>;
 export declare function exists(value: Filename): Thenable<boolean>;
-export declare function getStat(value: Filename): Thenable<vscode.FileStat | undefined>;
+export declare function getStat(value: Filename): Thenable<FileStat | undefined>;
 export declare function isDirectory(value: Filename): Thenable<boolean>;
 export declare function loadFile(file: Filename): Promise<Uint8Array | void>;
 export declare function writeFile(file: Filename, bytes: Uint8Array): PromiseLike<boolean>;
 export declare function deleteFile(file: Filename): PromiseLike<boolean>;
 export declare function createDirectory(path: Filename): PromiseLike<boolean>;
 export declare function createNewName(filepath: string): Promise<string>;
-export declare function createNewName(filepath: vscode.Uri): Promise<vscode.Uri>;
+export declare function createNewName(filepath: Uri): Promise<Uri>;
 export declare function copyFile(sourcepath: string, destpath: string): Promise<void>;
 export declare function copyFileToDir(sourcepath: Filename, destdir: Filename): Promise<Filename>;
 export declare function copyDirectory(sourcepath: Filename, targetpath: Filename): Promise<Filename[]>;
@@ -114,6 +114,5 @@ export declare const Change: {
     readonly renamed: 3;
 };
 export declare function onChange(filename: Filename, func: (path: string, mode: number) => void): void;
-export declare function arrayRemove<T>(array: T[], item: T): boolean;
 export declare function removeOnChange(filename: Filename, func: (path: string) => void): void;
 export {};