@codingame/monaco-vscode-api 25.1.1 → 26.0.0

package/vscode/src/vs/workbench/services/extensions/common/lazyPromise.js

@@ -47,8 +47,7 @@ class LazyPromise {
         this._err = err;
         if (this._actual) {
             this._actualErr(err);
-        }
-        else {
+        } else {
             onUnexpectedError(err);
         }
     }

package/vscode/src/vs/workbench/services/extensions/common/proxyIdentifier.js

@@ -1,7 +1,9 @@
 
 
 class ProxyIdentifier {
-    static { this.count = 0; }
+    static {
+        this.count = 0;
+    }
     constructor(sid) {
         this._proxyIdentifierBrand = undefined;
         this.sid = sid;

package/vscode/src/vs/workbench/services/extensions/common/rpcProtocol.js

@@ -15,23 +15,25 @@ var _a;
 function safeStringify(obj, replacer) {
     try {
         return JSON.stringify(obj, replacer);
-    }
-    catch (err) {
-        return 'null';
+    } catch (err) {
+        return "null";
     }
 }
-const refSymbolName = '$$ref$$';
-const undefinedRef = { [refSymbolName]: -1 };
+const refSymbolName = "$$ref$$";
+const undefinedRef = {
+    [refSymbolName]: -1
+};
 function stringifyJsonWithBufferRefs(obj, replacer = null, useSafeStringify = false) {
     const foundBuffers = [];
     const serialized = (useSafeStringify ? safeStringify : JSON.stringify)(obj, (key, value) => {
-        if (typeof value === 'undefined') {
+        if (typeof value === "undefined") {
             return undefinedRef;
-        }
-        else if (typeof value === 'object') {
+        } else if (typeof value === "object") {
             if (value instanceof VSBuffer) {
                 const bufferIndex = foundBuffers.push(value) - 1;
-                return { [refSymbolName]: bufferIndex };
+                return {
+                    [refSymbolName]: bufferIndex
+                };
             }
             if (replacer) {
                 return replacer(key, value);
@@ -48,7 +50,7 @@ function parseJsonAndRestoreBufferRefs(jsonString, buffers, uriTransformer) {
     return JSON.parse(jsonString, (_key, value) => {
         if (value) {
             const ref = value[refSymbolName];
-            if (typeof ref === 'number') {
+            if (typeof ref === "number") {
                 return buffers[ref];
             }
             if (uriTransformer && value.$mid === MarshalledId.Uri) {
@@ -73,21 +75,25 @@ function createURIReplacer(transformer) {
     };
 }
 var RequestInitiator;
-(function (RequestInitiator) {
+(function(RequestInitiator) {
     RequestInitiator[RequestInitiator["LocalSide"] = 0] = "LocalSide";
     RequestInitiator[RequestInitiator["OtherSide"] = 1] = "OtherSide";
 })(RequestInitiator || (RequestInitiator = {}));
 var ResponsiveState;
-(function (ResponsiveState) {
+(function(ResponsiveState) {
     ResponsiveState[ResponsiveState["Responsive"] = 0] = "Responsive";
     ResponsiveState[ResponsiveState["Unresponsive"] = 1] = "Unresponsive";
 })(ResponsiveState || (ResponsiveState = {}));
-const noop = () => { };
-const _RPCProtocolSymbol = Symbol.for('rpcProtocol');
-const _RPCProxySymbol = Symbol.for('rpcProxy');
+const noop = () => {};
+const _RPCProtocolSymbol = Symbol.for("rpcProtocol");
+const _RPCProxySymbol = Symbol.for("rpcProxy");
 class RPCProtocol extends Disposable {
-    static { _a = _RPCProtocolSymbol; }
-    static { this.UNRESPONSIVE_TIME = 3 * 1000; }
+    static {
+        _a = _RPCProtocolSymbol;
+    }
+    static {
+        this.UNRESPONSIVE_TIME = 3 * 1000;
+    }
     constructor(protocol, logger = null, transformer = null) {
         super();
         this[_a] = true;
@@ -111,11 +117,11 @@ class RPCProtocol extends Disposable {
         this._unacknowledgedCount = 0;
         this._unresponsiveTime = 0;
         this._asyncCheckUresponsive = this._register(( new RunOnceScheduler(() => this._checkUnresponsive(), 1000)));
-        this._register(this._protocol.onMessage((msg) => this._receiveOneMessage(msg)));
+        this._register(this._protocol.onMessage(msg => this._receiveOneMessage(msg)));
     }
     dispose() {
         this._isDisposed = true;
-        ( Object.keys(this._pendingRPCReplies)).forEach((msgId) => {
+        ( Object.keys(this._pendingRPCReplies)).forEach(msgId => {
             const pending = this._pendingRPCReplies[msgId];
             delete this._pendingRPCReplies[msgId];
             pending.resolveErr(canceled());
@@ -123,7 +129,7 @@ class RPCProtocol extends Disposable {
         super.dispose();
     }
     drain() {
-        if (typeof this._protocol.drain === 'function') {
+        if (typeof this._protocol.drain === "function") {
             return this._protocol.drain();
         }
         return Promise.resolve();
@@ -151,8 +157,7 @@ class RPCProtocol extends Disposable {
         }
         if (Date.now() > this._unresponsiveTime) {
             this._setResponsiveState(ResponsiveState.Unresponsive);
-        }
-        else {
+        } else {
             this._asyncCheckUresponsive.schedule();
         }
     }
@@ -173,7 +178,10 @@ class RPCProtocol extends Disposable {
         return transformIncomingURIs(obj, this._uriTransformer);
     }
     getProxy(identifier) {
-        const { nid: rpcId, sid } = identifier;
+        const {
+            nid: rpcId,
+            sid
+        } = identifier;
         if (!this._proxies[rpcId]) {
             this._proxies[rpcId] = this._createProxy(rpcId, sid);
         }
@@ -182,7 +190,7 @@ class RPCProtocol extends Disposable {
     _createProxy(rpcId, debugName) {
         const handler = {
             get: (target, name) => {
-                if (typeof name === 'string' && !target[name] && name.charCodeAt(0) === CharCode.DollarSign) {
+                if (typeof name === "string" && !target[name] && name.charCodeAt(0) === CharCode.DollarSign) {
                     target[name] = (...myArgs) => {
                         return this._remoteCall(rpcId, name, myArgs);
                     };
@@ -216,38 +224,66 @@ class RPCProtocol extends Disposable {
         const messageType = buff.readUInt8();
         const req = buff.readUInt32();
         switch (messageType) {
-            case MessageType.RequestJSONArgs:
-            case MessageType.RequestJSONArgsWithCancellation: {
-                let { rpcId, method, args } = MessageIO.deserializeRequestJSONArgs(buff);
+        case MessageType.RequestJSONArgs:
+        case MessageType.RequestJSONArgsWithCancellation:
+            {
+                let {
+                    rpcId,
+                    method,
+                    args
+                } = MessageIO.deserializeRequestJSONArgs(buff);
                 if (this._uriTransformer) {
                     args = transformIncomingURIs(args, this._uriTransformer);
                 }
-                this._receiveRequest(msgLength, req, rpcId, method, args, (messageType === MessageType.RequestJSONArgsWithCancellation));
+                this._receiveRequest(
+                    msgLength,
+                    req,
+                    rpcId,
+                    method,
+                    args,
+                    (messageType === MessageType.RequestJSONArgsWithCancellation)
+                );
                 break;
             }
-            case MessageType.RequestMixedArgs:
-            case MessageType.RequestMixedArgsWithCancellation: {
-                let { rpcId, method, args } = MessageIO.deserializeRequestMixedArgs(buff);
+        case MessageType.RequestMixedArgs:
+        case MessageType.RequestMixedArgsWithCancellation:
+            {
+                let {
+                    rpcId,
+                    method,
+                    args
+                } = MessageIO.deserializeRequestMixedArgs(buff);
                 if (this._uriTransformer) {
                     args = transformIncomingURIs(args, this._uriTransformer);
                 }
-                this._receiveRequest(msgLength, req, rpcId, method, args, (messageType === MessageType.RequestMixedArgsWithCancellation));
+                this._receiveRequest(
+                    msgLength,
+                    req,
+                    rpcId,
+                    method,
+                    args,
+                    (messageType === MessageType.RequestMixedArgsWithCancellation)
+                );
                 break;
             }
-            case MessageType.Acknowledged: {
+        case MessageType.Acknowledged:
+            {
                 this._logger?.logIncoming(msgLength, req, RequestInitiator.LocalSide, `ack`);
                 this._onDidReceiveAcknowledge(req);
                 break;
             }
-            case MessageType.Cancel: {
+        case MessageType.Cancel:
+            {
                 this._receiveCancel(msgLength, req);
                 break;
             }
-            case MessageType.ReplyOKEmpty: {
+        case MessageType.ReplyOKEmpty:
+            {
                 this._receiveReply(msgLength, req, undefined);
                 break;
             }
-            case MessageType.ReplyOKJSON: {
+        case MessageType.ReplyOKJSON:
+            {
                 let value = MessageIO.deserializeReplyOKJSON(buff);
                 if (this._uriTransformer) {
                     value = transformIncomingURIs(value, this._uriTransformer);
@@ -255,17 +291,20 @@ class RPCProtocol extends Disposable {
                 this._receiveReply(msgLength, req, value);
                 break;
             }
-            case MessageType.ReplyOKJSONWithBuffers: {
+        case MessageType.ReplyOKJSONWithBuffers:
+            {
                 const value = MessageIO.deserializeReplyOKJSONWithBuffers(buff, this._uriTransformer);
                 this._receiveReply(msgLength, req, value);
                 break;
             }
-            case MessageType.ReplyOKVSBuffer: {
+        case MessageType.ReplyOKVSBuffer:
+            {
                 const value = MessageIO.deserializeReplyOKVSBuffer(buff);
                 this._receiveReply(msgLength, req, value);
                 break;
             }
-            case MessageType.ReplyErrError: {
+        case MessageType.ReplyErrError:
+            {
                 let err = MessageIO.deserializeReplyErrError(buff);
                 if (this._uriTransformer) {
                     err = transformIncomingURIs(err, this._uriTransformer);
@@ -273,17 +312,24 @@ class RPCProtocol extends Disposable {
                 this._receiveReplyErr(msgLength, req, err);
                 break;
             }
-            case MessageType.ReplyErrEmpty: {
+        case MessageType.ReplyErrEmpty:
+            {
                 this._receiveReplyErr(msgLength, req, undefined);
                 break;
             }
-            default:
-                console.error(`received unexpected message`);
-                console.error(rawmsg);
+        default:
+            console.error(`received unexpected message`);
+            console.error(rawmsg);
         }
     }
     _receiveRequest(msgLength, req, rpcId, method, args, usesCancellationToken) {
-        this._logger?.logIncoming(msgLength, req, RequestInitiator.OtherSide, `receiveRequest ${getStringIdentifierForProxy(rpcId)}.${method}(`, args);
+        this._logger?.logIncoming(
+            msgLength,
+            req,
+            RequestInitiator.OtherSide,
+            `receiveRequest ${getStringIdentifierForProxy(rpcId)}.${method}(`,
+            args
+        );
         const callId = String(req);
         let promise;
         let cancel;
@@ -292,8 +338,7 @@ class RPCProtocol extends Disposable {
             args.push(cancellationTokenSource.token);
             promise = this._invokeHandler(rpcId, method, args);
             cancel = () => cancellationTokenSource.cancel();
-        }
-        else {
+        } else {
             promise = this._invokeHandler(rpcId, method, args);
             cancel = noop;
         }
@@ -301,12 +346,12 @@ class RPCProtocol extends Disposable {
         const msg = MessageIO.serializeAcknowledged(req);
         this._logger?.logOutgoing(msg.byteLength, req, RequestInitiator.OtherSide, `ack`);
         this._protocol.send(msg);
-        promise.then((r) => {
+        promise.then(r => {
             delete this._cancelInvokedHandlers[callId];
             const msg = MessageIO.serializeReplyOK(req, r, this._uriReplacer);
             this._logger?.logOutgoing(msg.byteLength, req, RequestInitiator.OtherSide, `reply:`, r);
             this._protocol.send(msg);
-        }, (err) => {
+        }, err => {
             delete this._cancelInvokedHandlers[callId];
             const msg = MessageIO.serializeReplyErr(req, err);
             this._logger?.logOutgoing(msg.byteLength, req, RequestInitiator.OtherSide, `replyErr:`, err);
@@ -343,8 +388,7 @@ class RPCProtocol extends Disposable {
                 err.name = value.name;
                 err.message = value.message;
                 err.stack = value.stack;
-            }
-            else {
+            } else {
                 err = value;
             }
         }
@@ -353,20 +397,19 @@ class RPCProtocol extends Disposable {
     _invokeHandler(rpcId, methodName, args) {
         try {
             return Promise.resolve(this._doInvokeHandler(rpcId, methodName, args));
-        }
-        catch (err) {
+        } catch (err) {
             return Promise.reject(err);
         }
     }
     _doInvokeHandler(rpcId, methodName, args) {
         const actor = this._locals[rpcId];
         if (!actor) {
-            throw ( new Error('Unknown actor ' + getStringIdentifierForProxy(rpcId)));
+            throw ( new Error("Unknown actor " + getStringIdentifierForProxy(rpcId)));
         }
         const method = actor[methodName];
-        if (typeof method !== 'function') {
+        if (typeof method !== "function") {
             throw ( new Error(
-                'Unknown method ' + methodName + ' on actor ' + getStringIdentifierForProxy(rpcId)
+                "Unknown method " + methodName + " on actor " + getStringIdentifierForProxy(rpcId)
             ));
         }
         return method.apply(actor, args);
@@ -397,7 +440,13 @@ class RPCProtocol extends Disposable {
         this._pendingRPCReplies[callId] = ( new PendingRPCReply(result, disposable));
         this._onWillSendRequest(req);
         const msg = MessageIO.serializeRequest(req, rpcId, methodName, serializedRequestArguments, !!cancellationToken);
-        this._logger?.logOutgoing(msg.byteLength, req, RequestInitiator.LocalSide, `request: ${getStringIdentifierForProxy(rpcId)}.${methodName}(`, args);
+        this._logger?.logOutgoing(
+            msg.byteLength,
+            req,
+            RequestInitiator.LocalSide,
+            `request: ${getStringIdentifierForProxy(rpcId)}.${methodName}(`,
+            args
+        );
         this._protocol.send(msg);
         return result;
     }
@@ -436,7 +485,9 @@ class MessageBuffer {
     static sizeUInt8() {
         return 1;
     }
-    static { this.sizeUInt32 = 4; }
+    static {
+        this.sizeUInt32 = 4;
+    }
     writeUInt8(n) {
         this._buff.writeUInt8(n, this._offset);
         this._offset += 1;
@@ -518,19 +569,19 @@ class MessageBuffer {
             const el = arr[i];
             size += 1;
             switch (el.type) {
-                case ArgType.String:
-                    size += this.sizeLongString(el.value);
-                    break;
-                case ArgType.VSBuffer:
-                    size += this.sizeVSBuffer(el.value);
-                    break;
-                case ArgType.SerializedObjectWithBuffers:
-                    size += this.sizeUInt32;
-                    size += this.sizeLongString(el.value);
-                    for (let i = 0; i < el.buffers.length; ++i) {
-                        size += this.sizeVSBuffer(el.buffers[i]);
-                    }
-                    break;
+            case ArgType.String:
+                size += this.sizeLongString(el.value);
+                break;
+            case ArgType.VSBuffer:
+                size += this.sizeVSBuffer(el.value);
+                break;
+            case ArgType.SerializedObjectWithBuffers:
+                size += this.sizeUInt32;
+                size += this.sizeLongString(el.value);
+                for (let i = 0; i < el.buffers.length; ++i) {
+                    size += this.sizeVSBuffer(el.buffers[i]);
+                }
+                break;
             }
         }
         return size;
@@ -541,25 +592,25 @@ class MessageBuffer {
         for (let i = 0, len = arr.length; i < len; i++) {
             const el = arr[i];
             switch (el.type) {
-                case ArgType.String:
-                    this.writeUInt8(ArgType.String);
-                    this.writeLongString(el.value);
-                    break;
-                case ArgType.VSBuffer:
-                    this.writeUInt8(ArgType.VSBuffer);
-                    this.writeVSBuffer(el.value);
-                    break;
-                case ArgType.SerializedObjectWithBuffers:
-                    this.writeUInt8(ArgType.SerializedObjectWithBuffers);
-                    this.writeUInt32(el.buffers.length);
-                    this.writeLongString(el.value);
-                    for (let i = 0; i < el.buffers.length; ++i) {
-                        this.writeBuffer(el.buffers[i]);
-                    }
-                    break;
-                case ArgType.Undefined:
-                    this.writeUInt8(ArgType.Undefined);
-                    break;
+            case ArgType.String:
+                this.writeUInt8(ArgType.String);
+                this.writeLongString(el.value);
+                break;
+            case ArgType.VSBuffer:
+                this.writeUInt8(ArgType.VSBuffer);
+                this.writeVSBuffer(el.value);
+                break;
+            case ArgType.SerializedObjectWithBuffers:
+                this.writeUInt8(ArgType.SerializedObjectWithBuffers);
+                this.writeUInt32(el.buffers.length);
+                this.writeLongString(el.value);
+                for (let i = 0; i < el.buffers.length; ++i) {
+                    this.writeBuffer(el.buffers[i]);
+                }
+                break;
+            case ArgType.Undefined:
+                this.writeUInt8(ArgType.Undefined);
+                break;
             }
         }
     }
@@ -570,13 +621,14 @@ class MessageBuffer {
         for (let i = 0; i < arrLen; i++) {
             const argType = this.readUInt8();
             switch (argType) {
-                case ArgType.String:
-                    arr[i] = this.readLongString();
-                    break;
-                case ArgType.VSBuffer:
-                    arr[i] = this.readVSBuffer();
-                    break;
-                case ArgType.SerializedObjectWithBuffers: {
+            case ArgType.String:
+                arr[i] = this.readLongString();
+                break;
+            case ArgType.VSBuffer:
+                arr[i] = this.readVSBuffer();
+                break;
+            case ArgType.SerializedObjectWithBuffers:
+                {
                     const bufferCount = this.readUInt32();
                     const jsonString = this.readLongString();
                     const buffers = [];
@@ -586,16 +638,16 @@ class MessageBuffer {
                     arr[i] = ( new SerializableObjectWithBuffers(parseJsonAndRestoreBufferRefs(jsonString, buffers, null)));
                     break;
                 }
-                case ArgType.Undefined:
-                    arr[i] = undefined;
-                    break;
+            case ArgType.Undefined:
+                arr[i] = undefined;
+                break;
             }
         }
         return arr;
     }
 }
 var SerializedRequestArgumentType;
-(function (SerializedRequestArgumentType) {
+(function(SerializedRequestArgumentType) {
     SerializedRequestArgumentType[SerializedRequestArgumentType["Simple"] = 0] = "Simple";
     SerializedRequestArgumentType[SerializedRequestArgumentType["Mixed"] = 1] = "Mixed";
 })(SerializedRequestArgumentType || (SerializedRequestArgumentType = {}));
@@ -608,7 +660,7 @@ class MessageIO {
             if (arr[i] instanceof SerializableObjectWithBuffers) {
                 return true;
             }
-            if (typeof arr[i] === 'undefined') {
+            if (typeof arr[i] === "undefined") {
                 return true;
             }
         }
@@ -620,22 +672,34 @@ class MessageIO {
             for (let i = 0, len = args.length; i < len; i++) {
                 const arg = args[i];
                 if (arg instanceof VSBuffer) {
-                    massagedArgs[i] = { type: ArgType.VSBuffer, value: arg };
-                }
-                else if (typeof arg === 'undefined') {
-                    massagedArgs[i] = { type: ArgType.Undefined };
-                }
-                else if (arg instanceof SerializableObjectWithBuffers) {
-                    const { jsonString, referencedBuffers } = stringifyJsonWithBufferRefs(arg.value, replacer);
-                    massagedArgs[i] = { type: ArgType.SerializedObjectWithBuffers, value: VSBuffer.fromString(jsonString), buffers: referencedBuffers };
-                }
-                else {
-                    massagedArgs[i] = { type: ArgType.String, value: VSBuffer.fromString(stringify(arg, replacer)) };
+                    massagedArgs[i] = {
+                        type: ArgType.VSBuffer,
+                        value: arg
+                    };
+                } else if (typeof arg === "undefined") {
+                    massagedArgs[i] = {
+                        type: ArgType.Undefined
+                    };
+                } else if (arg instanceof SerializableObjectWithBuffers) {
+                    const {
+                        jsonString,
+                        referencedBuffers
+                    } = stringifyJsonWithBufferRefs(arg.value, replacer);
+                    massagedArgs[i] = {
+                        type: ArgType.SerializedObjectWithBuffers,
+                        value: VSBuffer.fromString(jsonString),
+                        buffers: referencedBuffers
+                    };
+                } else {
+                    massagedArgs[i] = {
+                        type: ArgType.String,
+                        value: VSBuffer.fromString(stringify(arg, replacer))
+                    };
                 }
             }
             return {
                 type: SerializedRequestArgumentType.Mixed,
-                args: massagedArgs,
+                args: massagedArgs
             };
         }
         return {
@@ -645,10 +709,10 @@ class MessageIO {
     }
     static serializeRequest(req, rpcId, method, serializedArgs, usesCancellationToken) {
         switch (serializedArgs.type) {
-            case SerializedRequestArgumentType.Simple:
-                return this._requestJSONArgs(req, rpcId, method, serializedArgs.args, usesCancellationToken);
-            case SerializedRequestArgumentType.Mixed:
-                return this._requestMixedArgs(req, rpcId, method, serializedArgs.args, usesCancellationToken);
+        case SerializedRequestArgumentType.Simple:
+            return this._requestJSONArgs(req, rpcId, method, serializedArgs.args, usesCancellationToken);
+        case SerializedRequestArgumentType.Mixed:
+            return this._requestMixedArgs(req, rpcId, method, serializedArgs.args, usesCancellationToken);
         }
     }
     static _requestJSONArgs(req, rpcId, method, args, usesCancellationToken) {
@@ -658,7 +722,11 @@ class MessageIO {
         len += MessageBuffer.sizeUInt8();
         len += MessageBuffer.sizeShortString(methodBuff);
         len += MessageBuffer.sizeLongString(argsBuff);
-        const result = MessageBuffer.alloc(usesCancellationToken ? MessageType.RequestJSONArgsWithCancellation : MessageType.RequestJSONArgs, req, len);
+        const result = MessageBuffer.alloc(
+            usesCancellationToken ? MessageType.RequestJSONArgsWithCancellation : MessageType.RequestJSONArgs,
+            req,
+            len
+        );
         result.writeUInt8(rpcId);
         result.writeShortString(methodBuff);
         result.writeLongString(argsBuff);
@@ -680,7 +748,11 @@ class MessageIO {
         len += MessageBuffer.sizeUInt8();
         len += MessageBuffer.sizeShortString(methodBuff);
         len += MessageBuffer.sizeMixedArray(args);
-        const result = MessageBuffer.alloc(usesCancellationToken ? MessageType.RequestMixedArgsWithCancellation : MessageType.RequestMixedArgs, req, len);
+        const result = MessageBuffer.alloc(
+            usesCancellationToken ? MessageType.RequestMixedArgsWithCancellation : MessageType.RequestMixedArgs,
+            req,
+            len
+        );
         result.writeUInt8(rpcId);
         result.writeShortString(methodBuff);
         result.writeMixedArray(args);
@@ -693,10 +765,9 @@ class MessageIO {
         const args = ( new Array(rawargs.length));
         for (let i = 0, len = rawargs.length; i < len; i++) {
             const rawarg = rawargs[i];
-            if (typeof rawarg === 'string') {
+            if (typeof rawarg === "string") {
                 args[i] = JSON.parse(rawarg);
-            }
-            else {
+            } else {
                 args[i] = rawarg;
             }
         }
@@ -713,17 +784,17 @@ class MessageIO {
         return MessageBuffer.alloc(MessageType.Cancel, req, 0).buffer;
     }
     static serializeReplyOK(req, res, replacer) {
-        if (typeof res === 'undefined') {
+        if (typeof res === "undefined") {
             return this._serializeReplyOKEmpty(req);
-        }
-        else if (res instanceof VSBuffer) {
+        } else if (res instanceof VSBuffer) {
             return this._serializeReplyOKVSBuffer(req, res);
-        }
-        else if (res instanceof SerializableObjectWithBuffers) {
-            const { jsonString, referencedBuffers } = stringifyJsonWithBufferRefs(res.value, replacer, true);
+        } else if (res instanceof SerializableObjectWithBuffers) {
+            const {
+                jsonString,
+                referencedBuffers
+            } = stringifyJsonWithBufferRefs(res.value, replacer, true);
             return this._serializeReplyOKJSONWithBuffers(req, jsonString, referencedBuffers);
-        }
-        else {
+        } else {
             return this._serializeReplyOKJSON(req, safeStringify(res, replacer));
         }
     }
@@ -779,7 +850,7 @@ class MessageIO {
     }
     static serializeReplyErr(req, err) {
         const errStr = (err ? safeStringify(transformErrorForSerialization(err), null) : undefined);
-        if (typeof errStr !== 'string') {
+        if (typeof errStr !== "string") {
             return this._serializeReplyErrEmpty(req);
         }
         const errBuff = VSBuffer.fromString(errStr);
@@ -798,7 +869,7 @@ class MessageIO {
     }
 }
 var MessageType;
-(function (MessageType) {
+(function(MessageType) {
     MessageType[MessageType["RequestJSONArgs"] = 1] = "RequestJSONArgs";
     MessageType[MessageType["RequestJSONArgsWithCancellation"] = 2] = "RequestJSONArgsWithCancellation";
     MessageType[MessageType["RequestMixedArgs"] = 3] = "RequestMixedArgs";
@@ -813,7 +884,7 @@ var MessageType;
     MessageType[MessageType["ReplyErrEmpty"] = 12] = "ReplyErrEmpty";
 })(MessageType || (MessageType = {}));
 var ArgType;
-(function (ArgType) {
+(function(ArgType) {
     ArgType[ArgType["String"] = 1] = "String";
     ArgType[ArgType["VSBuffer"] = 2] = "VSBuffer";
     ArgType[ArgType["SerializedObjectWithBuffers"] = 3] = "SerializedObjectWithBuffers";