@adminide-stack/extension-api 5.0.1-alpha.9 → 6.0.2-alpha.0

package/lib/interfaces/text-document.js

@@ -1,8 +1,7 @@
-import minimatch from 'minimatch';
-/**
+import minimatch from'minimatch';/**
  * Returns whether any of the document selectors match (or "select") the document.
  */
-export function match(selectors, document) {
+function match(selectors, document) {
     for (const selector of isSingleDocumentSelector(selectors) ? [selectors] : selectors) {
         if (match1(selector, document)) {
             return true;
@@ -36,7 +35,7 @@ function match1(selector, document) {
  * Taken from
  * https://github.com/Microsoft/vscode/blob/3d35801127f0a62d58d752bc613506e836c5d120/src/vs/editor/common/modes/languageSelector.ts#L24.
  */
-export function score(selector, candidateUri, candidateLanguage) {
+function score(selector, candidateUri, candidateLanguage) {
     // array -> take max individual value
     let returnValue = 0;
     for (const filter of selector) {
@@ -110,5 +109,4 @@ function score1(selector, candidateUri, candidateLanguage) {
         }
     }
     return returnValue;
-}
-//# sourceMappingURL=text-document.js.map
+}export{match,score};

package/lib/interfaces/webview/webview.js

@@ -1,6 +1,5 @@
-export var WebviewContentPurpose;
+var WebviewContentPurpose;
 (function (WebviewContentPurpose) {
     WebviewContentPurpose["NotebookRenderer"] = "notebookRenderer";
     WebviewContentPurpose["CustomEditor"] = "customEditor";
-})(WebviewContentPurpose || (WebviewContentPurpose = {}));
-//# sourceMappingURL=webview.js.map
+})(WebviewContentPurpose || (WebviewContentPurpose = {}));export{WebviewContentPurpose};

package/lib/protocol/client.protocol.js

@@ -1,5 +1,3 @@
-import { createMainContextProxyIdentifier as createMainId } from './proxy-identifier';
-export const ClientContext = {
-    ClientThreadLanguageFeatures: createMainId('ClientThreadLanguageFeatures'),
-};
-//# sourceMappingURL=client.protocol.js.map
+import {createMainContextProxyIdentifier}from'./proxy-identifier.js';const ClientContext = {
+    ClientThreadLanguageFeatures: createMainContextProxyIdentifier('ClientThreadLanguageFeatures'),
+};export{ClientContext};

package/lib/protocol/common.protocol.js

@@ -1,5 +1,4 @@
-import { URI } from '@vscode-alt/monaco-editor/esm/vs/base/common/uri';
-export class IdObject {
+import {URI}from'@vscode-alt/monaco-editor/esm/vs/base/common/uri.js';class IdObject {
     static mixin(object) {
         object._id = IdObject._n++;
         return object;
@@ -7,7 +6,7 @@ export class IdObject {
 }
 IdObject._n = 0;
 // needed
-export var ISuggestDataDtoField;
+var ISuggestDataDtoField;
 (function (ISuggestDataDtoField) {
     ISuggestDataDtoField["label"] = "a";
     ISuggestDataDtoField["kind"] = "b";
@@ -26,14 +25,14 @@ export var ISuggestDataDtoField;
     // to merge into label
     ISuggestDataDtoField["label2"] = "o";
 })(ISuggestDataDtoField || (ISuggestDataDtoField = {}));
-export var ISuggestResultDtoField;
+var ISuggestResultDtoField;
 (function (ISuggestResultDtoField) {
     ISuggestResultDtoField["defaultRanges"] = "a";
     ISuggestResultDtoField["completions"] = "b";
     ISuggestResultDtoField["isIncomplete"] = "c";
     ISuggestResultDtoField["duration"] = "d";
 })(ISuggestResultDtoField || (ISuggestResultDtoField = {}));
-export function reviveWorkspaceEditDto(data) {
+function reviveWorkspaceEditDto(data) {
     if (data && data.edits) {
         for (const edit of data.edits) {
             if (typeof edit.resource === 'object') {
@@ -47,7 +46,7 @@ export function reviveWorkspaceEditDto(data) {
     }
     return data;
 }
-export var ObjectIdentifier;
+var ObjectIdentifier;
 (function (ObjectIdentifier) {
     ObjectIdentifier.name = '$ident';
     function mixin(obj, id) {
@@ -59,5 +58,4 @@ export var ObjectIdentifier;
         return obj[ObjectIdentifier.name];
     }
     ObjectIdentifier.of = of;
-})(ObjectIdentifier || (ObjectIdentifier = {}));
-//# sourceMappingURL=common.protocol.js.map
+})(ObjectIdentifier || (ObjectIdentifier = {}));export{ISuggestDataDtoField,ISuggestResultDtoField,IdObject,ObjectIdentifier,reviveWorkspaceEditDto};

package/lib/protocol/editor-missing-types.js

@@ -1,7 +1,6 @@
-export var EditorPosition;
+var EditorPosition;
 (function (EditorPosition) {
     EditorPosition[EditorPosition["ONE"] = 0] = "ONE";
     EditorPosition[EditorPosition["TWO"] = 1] = "TWO";
     EditorPosition[EditorPosition["THREE"] = 2] = "THREE";
-})(EditorPosition || (EditorPosition = {}));
-//# sourceMappingURL=editor-missing-types.js.map
+})(EditorPosition || (EditorPosition = {}));export{EditorPosition};

package/lib/protocol/index.d.ts

@@ -4,3 +4,6 @@ export * from './temporary-types';
 export * from './client.protocol';
 export * from './common.protocol';
 export * from './shared/editor';
+export * from './server.protocol';
+export * from './rpc-protocol';
+export * from './rpc-logger';

package/lib/protocol/proxy-identifier.js

@@ -1,5 +1,5 @@
 /* tslint:disable */
-export class ProxyIdentifier {
+class ProxyIdentifier {
     constructor(isMain, sid, hostId) {
         this.isMain = isMain;
         this.sid = sid;
@@ -9,27 +9,27 @@ export class ProxyIdentifier {
 }
 ProxyIdentifier.count = 0;
 const identifiers = [];
-export function createMainContextProxyIdentifier(identifier, hostIdentifier = 1 /* HostIdentifier.ServerMainThread */) {
+function createMainContextProxyIdentifier(identifier, hostIdentifier = 1 /* HostIdentifier.ServerMainThread */) {
     const result = new ProxyIdentifier(true, identifier, hostIdentifier);
     identifiers[result.nid] = result;
     return result;
 }
-export function createExtHostContextProxyIdentifier(identifier, hostIdentifier = 0 /* HostIdentifier.ServerExtHost */) {
+function createExtHostContextProxyIdentifier(identifier, hostIdentifier = 0 /* HostIdentifier.ServerExtHost */) {
     const result = new ProxyIdentifier(false, identifier, hostIdentifier);
     identifiers[result.nid] = result;
     return result;
 }
-export function getStringIdentifierForProxy(nid) {
+function getStringIdentifierForProxy(nid) {
     return identifiers[nid] ? identifiers[nid].sid : null;
 }
-export var HostIdentifier;
+var HostIdentifier;
 (function (HostIdentifier) {
     HostIdentifier[HostIdentifier["ServerExtHost"] = 0] = "ServerExtHost";
     HostIdentifier[HostIdentifier["ServerMainThread"] = 1] = "ServerMainThread";
     HostIdentifier[HostIdentifier["BrowserExtHost"] = 2] = "BrowserExtHost";
     HostIdentifier[HostIdentifier["BrowserClientThread"] = 3] = "BrowserClientThread";
 })(HostIdentifier || (HostIdentifier = {}));
-export var RequestType;
+var RequestType;
 (function (RequestType) {
     /**
      * Process the request on the reciever end
@@ -44,9 +44,8 @@ export var RequestType;
      */
     RequestType[RequestType["ProcessAndForward"] = 2] = "ProcessAndForward";
 })(RequestType || (RequestType = {}));
-export var TransportType;
+var TransportType;
 (function (TransportType) {
     TransportType[TransportType["Socket"] = 0] = "Socket";
     TransportType[TransportType["WebSocket"] = 1] = "WebSocket";
-})(TransportType || (TransportType = {}));
-//# sourceMappingURL=proxy-identifier.js.map
+})(TransportType || (TransportType = {}));export{HostIdentifier,ProxyIdentifier,RequestType,TransportType,createExtHostContextProxyIdentifier,createMainContextProxyIdentifier,getStringIdentifierForProxy};

package/lib/protocol/rpc-logger.js

@@ -1,6 +1,4 @@
 // Enable to see detailed message communication between window and extension host
-const LOG_EXTENSION_HOST_COMMUNICATION = false;
-const LOG_USE_COLORS = true;
 const colorTables = [
     ['#2977B1', '#FC802D', '#34A13A', '#D3282F', '#9366BA'],
     ['#8B564C', '#E177C0', '#7F7F7F', '#BBBE3D', '#2EBECD'],
@@ -23,7 +21,7 @@ function pretty(data) {
     }
     return prettyWithoutArrays(data);
 }
-export class RPCLogger {
+class RPCLogger {
     constructor() {
         this._totalIncoming = 0;
         this._totalOutgoing = 0;
@@ -31,7 +29,7 @@ export class RPCLogger {
     _log(direction, totalLength, msgLength, req, initiator, str, data) {
         data = pretty(data);
         const colorTable = colorTables[initiator];
-        const color = LOG_USE_COLORS ? colorTable[req % colorTable.length] : '#000000';
+        const color = colorTable[req % colorTable.length] ;
         /* tslint:disable-next-line:max-line-length */
         let args = [`%c[${direction}]%c[${String(totalLength).padStart(7)}]%c[len: ${String(msgLength).padStart(5)}]%c${String(req).padStart(5)} - ${str}`, 'color: darkgreen', 'color: grey', 'color: grey', `color: ${color}`];
         if (/\($/.test(str)) {
@@ -52,5 +50,4 @@ export class RPCLogger {
         this._totalOutgoing += msgLength;
         this._log('Win \u2192 Ext', this._totalOutgoing, msgLength, req, initiator, str, data);
     }
-}
-//# sourceMappingURL=rpc-logger.js.map
+}export{RPCLogger};

package/lib/protocol/rpc-protocol.js

@@ -1,14 +1,5 @@
-/* tslint:disable */
-import { RunOnceScheduler } from '@vscode-alt/monaco-editor/esm/vs/base/common/async';
-import { CancellationToken, CancellationTokenSource } from '@vscode-alt/monaco-editor/esm/vs/base/common/cancellation';
-import * as errors from '@vscode-alt/monaco-editor/esm/vs/base/common/errors';
-import { Emitter } from '@vscode-alt/monaco-editor/esm/vs/base/common/event';
-import { Disposable } from '@vscode-alt/monaco-editor/esm/vs/base/common/lifecycle';
-import { transformIncomingURIs } from '@vscode-alt/monaco-editor/esm/vs/base/common/uriIpc';
-import { LazyPromise } from './utils';
-import { ProxyIdentifier, getStringIdentifierForProxy } from './proxy-identifier';
-import { VSBuffer } from '@vscode-alt/monaco-editor/esm/vs/base/common/buffer';
-export function safeStringify(obj, replacer) {
+import {RunOnceScheduler}from'@vscode-alt/monaco-editor/esm/vs/base/common/async.js';import {CancellationTokenSource,CancellationToken}from'@vscode-alt/monaco-editor/esm/vs/base/common/cancellation.js';import*as errors from'@vscode-alt/monaco-editor/esm/vs/base/common/errors.js';import {Emitter}from'@vscode-alt/monaco-editor/esm/vs/base/common/event.js';import {Disposable}from'@vscode-alt/monaco-editor/esm/vs/base/common/lifecycle.js';import {transformIncomingURIs}from'@vscode-alt/monaco-editor/esm/vs/base/common/uriIpc.js';import {LazyPromise}from'./utils/lazy-promise.js';import {ProxyIdentifier,getStringIdentifierForProxy}from'./proxy-identifier.js';import {VSBuffer}from'@vscode-alt/monaco-editor/esm/vs/base/common/buffer.js';/* tslint:disable */
+function safeStringify(obj, replacer) {
     try {
         return JSON.stringify(obj, replacer);
     }
@@ -27,18 +18,18 @@ function createURIReplacer(transformer) {
         return value;
     };
 }
-export var RequestInitiator;
+var RequestInitiator;
 (function (RequestInitiator) {
     RequestInitiator[RequestInitiator["LocalSide"] = 0] = "LocalSide";
     RequestInitiator[RequestInitiator["OtherSide"] = 1] = "OtherSide";
 })(RequestInitiator || (RequestInitiator = {}));
-export var ResponsiveState;
+var ResponsiveState;
 (function (ResponsiveState) {
     ResponsiveState[ResponsiveState["Responsive"] = 0] = "Responsive";
     ResponsiveState[ResponsiveState["Unresponsive"] = 1] = "Unresponsive";
 })(ResponsiveState || (ResponsiveState = {}));
 const noop = () => { };
-export class RPCProtocol extends Disposable {
+class RPCProtocol extends Disposable {
     constructor(protocol, _localHostId = null, logger = null, transformer = null) {
         super();
         this._onDidChangeResponsiveState = this._register(new Emitter());
@@ -389,7 +380,7 @@ export class RPCProtocol extends Disposable {
     }
 }
 RPCProtocol.UNRESPONSIVE_TIME = 3 * 1000; // 3s
-export class MessageBuffer {
+class MessageBuffer {
     static alloc(type, req, messageSize) {
         let result = new MessageBuffer(VSBuffer.alloc(messageSize + 1 /* type */ + 4 /* req */), 0);
         result.writeUInt8(type);
@@ -553,7 +544,7 @@ export class MessageBuffer {
         return arr;
     }
 }
-export class MessageIO {
+class MessageIO {
     static _arrayContainsBuffer(arr) {
         for (let i = 0, len = arr.length; i < len; i++) {
             if (Buffer.isBuffer(arr[i])) {
@@ -719,7 +710,7 @@ export class MessageIO {
         return MessageBuffer.alloc(12 /* MessageType.ReplyErrEmpty */, req, 0).buffer;
     }
 }
-export var MessageType;
+var MessageType;
 (function (MessageType) {
     MessageType[MessageType["RequestJSONArgs"] = 1] = "RequestJSONArgs";
     MessageType[MessageType["RequestJSONArgsWithCancellation"] = 2] = "RequestJSONArgsWithCancellation";
@@ -734,10 +725,9 @@ export var MessageType;
     MessageType[MessageType["ReplyErrError"] = 11] = "ReplyErrError";
     MessageType[MessageType["ReplyErrEmpty"] = 12] = "ReplyErrEmpty";
 })(MessageType || (MessageType = {}));
-export var ArgType;
+var ArgType;
 (function (ArgType) {
     ArgType[ArgType["String"] = 1] = "String";
     ArgType[ArgType["Buffer"] = 2] = "Buffer";
     ArgType[ArgType["VSBuffer"] = 3] = "VSBuffer";
-})(ArgType || (ArgType = {}));
-//# sourceMappingURL=rpc-protocol.js.map
+})(ArgType || (ArgType = {}));export{ArgType,MessageBuffer,MessageIO,MessageType,RPCProtocol,RequestInitiator,ResponsiveState,safeStringify};

package/lib/protocol/server.protocol.js

@@ -1,28 +1,26 @@
-import { createExtHostContextProxyIdentifier as createExtId, createMainContextProxyIdentifier as createMainId } from './proxy-identifier';
-// -- proxy-identifiers are moved to `core` package
-export const MainContext = {
-    MainThreadCommands: createMainId('MainThreadCommands'),
-    MainThreadConfiguration: createMainId('MainThreadConfiguration'),
-    MainThreadUrls: createMainId('MainThreadUrls'),
-    MainThreadOrganization: createMainId('MainThreadOrganization'),
-    MainThreadExtensionService: createMainId('MainThreadExtensionService'),
+import {createMainContextProxyIdentifier,createExtHostContextProxyIdentifier}from'./proxy-identifier.js';// -- proxy-identifiers are moved to `core` package
+const MainContext = {
+    MainThreadCommands: createMainContextProxyIdentifier('MainThreadCommands'),
+    MainThreadConfiguration: createMainContextProxyIdentifier('MainThreadConfiguration'),
+    MainThreadUrls: createMainContextProxyIdentifier('MainThreadUrls'),
+    MainThreadOrganization: createMainContextProxyIdentifier('MainThreadOrganization'),
+    MainThreadExtensionService: createMainContextProxyIdentifier('MainThreadExtensionService'),
 };
-export const ExtHostContext = {
+const ExtHostContext = {
     // ExtHostTreeViews: createExtId<any>('ExtHostTreeViews'),
-    ExtHostCommands: createExtId('ExtHostCommands'),
-    ExtHostConfiguration: createExtId('ExtHostConfiguration'),
+    ExtHostCommands: createExtHostContextProxyIdentifier('ExtHostCommands'),
+    ExtHostConfiguration: createExtHostContextProxyIdentifier('ExtHostConfiguration'),
     // ExtHostDocuments: createExtId<ExtHostDocumentsShape>('ExtHostDocuments'),
-    ExtHostExtensionService: createExtId('ExtHostExtensionService'),
-    ExtHostLogService: createExtId('ExtHostLogService'),
+    ExtHostExtensionService: createExtHostContextProxyIdentifier('ExtHostExtensionService'),
+    ExtHostLogService: createExtHostContextProxyIdentifier('ExtHostLogService'),
     // ExtHostTerminalService: createExtId<ExtHostTerminalServiceShape>('ExtHostTerminalService'),
     // ExtHostSCM: createExtId<ExtHostSCMShape>('ExtHostSCM'),
     // ExtHostSearch: createExtId<ExtHostSearchShape>('ExtHostSearch'),
     // ExtHostTask: createExtId<ExtHostTaskShape>('ExtHostTask'),
-    ExtHostOrganization: createExtId('ExtHostOrganization'),
+    ExtHostOrganization: createExtHostContextProxyIdentifier('ExtHostOrganization'),
     // ExtHostWindow: createExtId<ExtHostWindowShape>('ExtHostWindow'),
     // ExtHostWebviews: createExtId<ExtHostWebviewsShape>('ExtHostWebviews'),
     // ExtHostProgress: createMainId<ExtHostProgressShape>('ExtHostProgress',  HostIdentifier.ServerExtHost),
     // ExtHostUrls: createExtId<ExtHostUrlsShape>('ExtHostUrls'),
     // ExtHostOutputService: createMainId<ExtHostOutputServiceShape>('ExtHostOutputService', HostIdentifier.ServerExtHost),
-};
-//# sourceMappingURL=server.protocol.js.map
+};export{ExtHostContext,MainContext};

package/lib/protocol/shared/editor.js

@@ -1,6 +1,5 @@
-/* tslint:disable */
-import { ACTIVE_GROUP, SIDE_GROUP } from '@workbench-stack/core';
-export function viewColumnToEditorGroup(editorGroupService, position) {
+import {ACTIVE_GROUP,SIDE_GROUP}from'@workbench-stack/core';/* tslint:disable */
+function viewColumnToEditorGroup(editorGroupService, position) {
     if (typeof position !== 'number' || position === ACTIVE_GROUP) {
         return ACTIVE_GROUP; // prefer active group when position is undefined or passed in as such
     }
@@ -16,8 +15,7 @@ export function viewColumnToEditorGroup(editorGroupService, position) {
     }
     return SIDE_GROUP; // open to the side if group not found or we are instructed to
 }
-export function editorGroupToViewColumn(editorGroupService, editorGroup) {
+function editorGroupToViewColumn(editorGroupService, editorGroup) {
     const group = (typeof editorGroup === 'number') ? editorGroupService.getGroup(editorGroup) : editorGroup;
     return editorGroupService.getGroups(2 /* GroupsOrder.GRID_APPEARANCE */).indexOf(group);
-}
-//# sourceMappingURL=editor.js.map
+}export{editorGroupToViewColumn,viewColumnToEditorGroup};

package/lib/protocol/temporary-types.js

@@ -1,18 +1,10 @@
-export var modes;
+var modes;
 (function (modes) {
-    /**
-     * @internal
-     */
-    let DraftMode;
     (function (DraftMode) {
         DraftMode[DraftMode["NotSupported"] = 0] = "NotSupported";
         DraftMode[DraftMode["InDraft"] = 1] = "InDraft";
         DraftMode[DraftMode["NotInDraft"] = 2] = "NotInDraft";
-    })(DraftMode = modes.DraftMode || (modes.DraftMode = {}));
-    /**
-     * @internal
-     */
-    let CommentThreadCollapsibleState;
+    })(modes.DraftMode || (modes.DraftMode = {}));
     (function (CommentThreadCollapsibleState) {
         /**
          * Determines an item is collapsed
@@ -22,6 +14,5 @@ export var modes;
          * Determines an item is expanded
          */
         CommentThreadCollapsibleState[CommentThreadCollapsibleState["Expanded"] = 1] = "Expanded";
-    })(CommentThreadCollapsibleState = modes.CommentThreadCollapsibleState || (modes.CommentThreadCollapsibleState = {}));
-})(modes || (modes = {}));
-//# sourceMappingURL=temporary-types.js.map
+    })(modes.CommentThreadCollapsibleState || (modes.CommentThreadCollapsibleState = {}));
+})(modes || (modes = {}));export{modes};

package/lib/protocol/utils/lazy-promise.js

@@ -1,7 +1,6 @@
-import { onUnexpectedError } from '@vscode-alt/monaco-editor/esm/vs/base/common/errors';
-// types taken from
+import {onUnexpectedError}from'@vscode-alt/monaco-editor/esm/vs/base/common/errors.js';// types taken from
 // https://github.com/andimarek/micro-manager/blob/ac5333a1e0400f6f985ceb0edcbcdfc5a7a79988/src/ipc/ipcRemoteCom.ts
-export class LazyPromise {
+class LazyPromise {
     constructor() {
         this._actual = null;
         this._actualOk = null;
@@ -60,6 +59,4 @@ export class LazyPromise {
     finally(callback) {
         return this._ensureActual().finally(callback);
     }
-}
-Symbol.toStringTag;
-//# sourceMappingURL=lazy-promise.js.map
+}export{LazyPromise};

package/lib/utils/abortable-rx.d.ts

@@ -0,0 +1,32 @@
+import { Observable, ObservableInput, OperatorFunction, Subscriber, TeardownLogic } from 'rxjs';
+/**
+ * Creates an Observable just like RxJS `create`, but exposes an AbortSignal in addition to the subscriber
+ */
+export declare const create: <T>(subscribe?: (subscriber: Subscriber<T>, signal: AbortSignal) => TeardownLogic) => Observable<T>;
+/**
+ * Easiest way to wrap an abortable async function into a Promise.
+ * The factory is called every time the Observable is subscribed to, and the AbortSignal is aborted on unsubscription.
+ */
+export declare const defer: <T>(factory: (signal: AbortSignal) => ObservableInput<T>) => Observable<T>;
+/**
+ * Returns a Promise that resolves with the last emission of the given Observable,
+ * rejects if the Observable errors or rejects with an `AbortError` when the AbortSignal is aborted.
+ */
+export declare const toPromise: <T>(observable: Observable<T>, signal?: AbortSignal) => Promise<T>;
+/**
+ * Calls `next` for every emission and returns a Promise that resolves when the Observable completed, rejects if the
+ * Observable errors or rejects with an `AbortError` when the AbortSignal is aborted.
+ */
+export declare const forEach: <T>(source: Observable<T>, next: (value: T) => void, signal?: AbortSignal) => Promise<void>;
+/**
+ * Like RxJS `switchMap`, but passes an AbortSignal that is aborted when the source emits another element.
+ */
+export declare const switchMap: <T, R>(project: (value: T, index: number, abortSignal: AbortSignal) => ObservableInput<R>) => OperatorFunction<T, R>;
+/**
+ * Like RxJS `concatMap`, but passes an AbortSignal that is aborted when the returned Observable is unsubscribed from.
+ */
+export declare const concatMap: <T, R>(project: (value: T, index: number, abortSignal: AbortSignal) => ObservableInput<R>) => OperatorFunction<T, R>;
+/**
+ * Like RxJS `mergeMap`, but passes an AbortSignal that is aborted when the returned Observable is unsubscribed from.
+ */
+export declare const mergeMap: <T, R>(project: (value: T, index: number, abortSignal: AbortSignal) => ObservableInput<R>) => OperatorFunction<T, R>;

package/lib/utils/abortable-rx.js

@@ -0,0 +1,112 @@
+import {Observable,Subscription,from}from'rxjs';import {switchMap as switchMap$1,concatMap as concatMap$1,mergeMap as mergeMap$1}from'rxjs/operators/index.js';/**
+ * Copied from https://github.com/felixfbecker/abortable-rx/blob/master/src/index.ts
+ * To support esm
+ * @returns
+ *
+ */
+const createAbortError = () => {
+    const error = new Error('Aborted');
+    error.name = 'AbortError';
+    return error;
+};
+/**
+ * Creates an Observable just like RxJS `create`, but exposes an AbortSignal in addition to the subscriber
+ */
+const create = (subscribe) => new Observable(subscriber => {
+    const abortController = new AbortController();
+    const subscription = new Subscription();
+    const teardown = subscribe && subscribe(subscriber, abortController.signal);
+    subscription.add(teardown);
+    subscription.add(() => abortController.abort());
+    return subscription;
+});
+/**
+ * Easiest way to wrap an abortable async function into a Promise.
+ * The factory is called every time the Observable is subscribed to, and the AbortSignal is aborted on unsubscription.
+ */
+const defer = (factory) => create((subscriber, signal) => from(factory(signal)).subscribe(subscriber));
+/**
+ * Returns a Promise that resolves with the last emission of the given Observable,
+ * rejects if the Observable errors or rejects with an `AbortError` when the AbortSignal is aborted.
+ */
+const toPromise = (observable, signal) => new Promise((resolve, reject) => {
+    if (signal && signal.aborted) {
+        reject(createAbortError());
+        return;
+    }
+    let subscription;
+    const listener = () => {
+        subscription.unsubscribe();
+        reject(createAbortError());
+    };
+    const cleanup = () => {
+        if (signal) {
+            signal.removeEventListener('abort', listener);
+        }
+    };
+    let value;
+    subscription = observable.subscribe(val => {
+        value = val;
+    }, err => {
+        cleanup();
+        reject(err);
+    }, () => {
+        cleanup();
+        resolve(value);
+    });
+    if (signal) {
+        signal.addEventListener('abort', listener, { once: true });
+    }
+});
+/**
+ * Calls `next` for every emission and returns a Promise that resolves when the Observable completed, rejects if the
+ * Observable errors or rejects with an `AbortError` when the AbortSignal is aborted.
+ */
+const forEach = (source, next, signal) => new Promise((resolve, reject) => {
+    if (signal && signal.aborted) {
+        reject(createAbortError());
+        return;
+    }
+    let subscription;
+    const listener = () => {
+        subscription.unsubscribe();
+        reject(createAbortError());
+    };
+    const cleanup = () => {
+        if (signal) {
+            signal.removeEventListener('abort', listener);
+        }
+    };
+    subscription = source.subscribe(value => {
+        try {
+            next(value);
+        }
+        catch (err) {
+            reject(err);
+            if (subscription) {
+                subscription.unsubscribe();
+            }
+        }
+    }, err => {
+        cleanup();
+        reject(err);
+    }, () => {
+        cleanup();
+        resolve();
+    });
+    if (signal) {
+        signal.addEventListener('abort', listener, { once: true });
+    }
+});
+/**
+ * Like RxJS `switchMap`, but passes an AbortSignal that is aborted when the source emits another element.
+ */
+const switchMap = (project) => source => source.pipe(switchMap$1((value, index) => defer(abortSignal => project(value, index, abortSignal))));
+/**
+ * Like RxJS `concatMap`, but passes an AbortSignal that is aborted when the returned Observable is unsubscribed from.
+ */
+const concatMap = (project) => source => source.pipe(concatMap$1((value, index) => defer(abortSignal => project(value, index, abortSignal))));
+/**
+ * Like RxJS `mergeMap`, but passes an AbortSignal that is aborted when the returned Observable is unsubscribed from.
+ */
+const mergeMap = (project) => source => source.pipe(mergeMap$1((value, index) => defer(abortSignal => project(value, index, abortSignal))));export{concatMap,create,defer,forEach,mergeMap,switchMap,toPromise};

package/lib/utils/errors.js

@@ -1,8 +1,8 @@
-export const isErrorLike = (val) => !!val && typeof val === 'object' && (!!val.stack || ('message' in val || 'code' in val)) && !('__typename' in val);
+const isErrorLike = (val) => !!val && typeof val === 'object' && (!!val.stack || ('message' in val || 'code' in val)) && !('__typename' in val);
 /**
  * Ensures a value is a proper Error, copying all properties if needed
  */
-export const asError = (err) => {
+const asError = (err) => {
     if (err instanceof Error) {
         return err;
     }
@@ -10,5 +10,4 @@ export const asError = (err) => {
         return Object.assign(new Error(err.message), err);
     }
     return new Error(err);
-};
-//# sourceMappingURL=errors.js.map
+};export{asError,isErrorLike};

package/lib/utils/extensions.js

@@ -1,12 +1,11 @@
-import { isErrorLike } from './errors';
-/**
+import {isErrorLike}from'./errors.js';/**
  * Returns the extension's script URL from its manifest.
  *
  * @param extension The extension whose script URL to get.
  * @throws If the script URL can't be dtermined.
  * @returns The extension's script URL.
  */
-export function getScriptURLFromExtensionManifest(extension) {
+function getScriptURLFromExtensionManifest(extension) {
     if (!extension.manifest) {
         throw new Error(`extension ${JSON.stringify(extension.id)}: no mainfest found`);
     }
@@ -17,5 +16,4 @@ export function getScriptURLFromExtensionManifest(extension) {
         throw new Error(`extension ${JSON.stringify(extension.id)}: no "url" property in manifest`);
     }
     return extension.manifest.bundleURL;
-}
-//# sourceMappingURL=extensions.js.map
+}export{getScriptURLFromExtensionManifest};

package/lib/utils/helper.test.js

@@ -3,9 +3,8 @@
  *
  * @internal
  */
-export function createBarrier() {
+function createBarrier() {
     let done;
     const wait = new Promise(resolve => (done = resolve));
     return { wait, done };
-}
-//# sourceMappingURL=helper.test.js.map
+}export{createBarrier};

package/lib/utils/paths-util.js

@@ -1,4 +1,4 @@
-/********************************************************************************
+import {sep}from'@vscode-alt/monaco-editor/esm/vs/base/common/path.js';/********************************************************************************
 
 Copyright (c) 2015 John Vilk and other contributors.
 
@@ -22,9 +22,8 @@ SOFTWARE.
 
 ====
 */
-import { sep } from '@vscode-alt/monaco-editor/esm/vs/base/common/path';
 const replaceRegex = new RegExp('//+', 'g');
-export function resolve(...paths) {
+function resolve(...paths) {
     let processed = [];
     for (const p of paths) {
         if (typeof p !== 'string') {
@@ -43,7 +42,7 @@ export function resolve(...paths) {
     }
     return resolved;
 }
-export function relative(from, to) {
+function relative(from, to) {
     let i;
     from = resolve(from);
     to = resolve(to);
@@ -78,7 +77,7 @@ export function relative(from, to) {
     }
     return rv;
 }
-export function normalize(p) {
+function normalize(p) {
     if (p === '') {
         p = '.';
     }
@@ -117,5 +116,4 @@ export function normalize(p) {
 function removeDuplicateSeparators(p) {
     p = p.replace(replaceRegex, sep);
     return p;
-}
-//# sourceMappingURL=paths-util.js.map
+}export{normalize,relative,resolve};