@codingame/monaco-vscode-api 11.1.1 → 12.0.0

package/vscode/src/vs/base/common/uri.d.ts

@@ -1,75 +1,12 @@
-/**
- * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
- * This class is a simple parser which creates the basic component parts
- * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
- * and encoding.
- *
- * ```txt
- *       foo://example.com:8042/over/there?name=ferret#nose
- *       \_/   \______________/\_________/ \_________/ \__/
- *        |           |            |            |        |
- *     scheme     authority       path        query   fragment
- *        |   _____________________|__
- *       / \ /                        \
- *       urn:example:animal:ferret:nose
- * ```
- */
-declare class URI implements UriComponents {
+export declare class URI implements UriComponents {
     static isUri(thing: any): thing is URI;
-    /**
-     * scheme is the 'http' part of 'http://www.example.com/some/path?query#fragment'.
-     * The part before the first colon.
-     */
     readonly scheme: string;
-    /**
-     * authority is the 'www.example.com' part of 'http://www.example.com/some/path?query#fragment'.
-     * The part between the first double slashes and the next slash.
-     */
     readonly authority: string;
-    /**
-     * path is the '/some/path' part of 'http://www.example.com/some/path?query#fragment'.
-     */
     readonly path: string;
-    /**
-     * query is the 'query' part of 'http://www.example.com/some/path?query#fragment'.
-     */
     readonly query: string;
-    /**
-     * fragment is the 'fragment' part of 'http://www.example.com/some/path?query#fragment'.
-     */
     readonly fragment: string;
-    /**
-     * @internal
-     */
     protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string, _strict?: boolean);
-    /**
-     * @internal
-     */
     protected constructor(components: UriComponents);
-    /**
-     * Returns a string representing the corresponding file system path of this URI.
-     * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the
-     * platform specific path separator.
-     *
-     * * Will *not* validate the path for invalid characters and semantics.
-     * * Will *not* look at the scheme of this URI.
-     * * The result shall *not* be used for display purposes but for accessing a file on disk.
-     *
-     *
-     * The *difference* to `URI#path` is the use of the platform specific separator and the handling
-     * of UNC paths. See the below sample of a file-uri with an authority (UNC path).
-     *
-     * ```ts
-        const u = URI.parse('file://server/c$/folder/file.txt')
-        u.authority === 'server'
-        u.path === '/shares/c$/file.txt'
-        u.fsPath === '\\server\c$\folder\file.txt'
-    ```
-     *
-     * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,
-     * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working
-     * with URIs that represent files on disk (`file` scheme).
-     */
     get fsPath(): string;
     with(change: {
         scheme?: string;
@@ -78,85 +15,26 @@ declare class URI implements UriComponents {
         query?: string | null;
         fragment?: string | null;
     }): URI;
-    /**
-     * Creates a new URI from a string, e.g. `http://www.example.com/some/path`,
-     * `file:///usr/home`, or `scheme:with/path`.
-     *
-     * @param value A string which represents an URI (see `URI#toString`).
-     */
     static parse(value: string, _strict?: boolean): URI;
-    /**
-     * Creates a new URI from a file system path, e.g. `c:\my\files`,
-     * `/usr/home`, or `\\server\share\some\path`.
-     *
-     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument
-     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**
-     * `URI.parse('file://' + path)` because the path might contain characters that are
-     * interpreted (# and ?). See the following sample:
-     * ```ts
-    const good = URI.file('/coding/c#/project1');
-    good.scheme === 'file';
-    good.path === '/coding/c#/project1';
-    good.fragment === '';
-    const bad = URI.parse('file://' + '/coding/c#/project1');
-    bad.scheme === 'file';
-    bad.path === '/coding/c'; // path is now broken
-    bad.fragment === '/project1';
-    ```
-     *
-     * @param path A file system path (see `URI#fsPath`)
-     */
     static file(path: string): URI;
-    /**
-     * Creates new URI from uri components.
-     *
-     * Unless `strict` is `true` the scheme is defaults to be `file`. This function performs
-     * validation and should be used for untrusted uri components retrieved from storage,
-     * user input, command arguments etc
-     */
     static from(components: UriComponents, strict?: boolean): URI;
-    /**
-     * Join a URI path with path fragments and normalizes the resulting path.
-     *
-     * @param uri The input URI.
-     * @param pathFragment The path fragment to add to the URI path.
-     * @returns The resulting URI.
-     */
     static joinPath(uri: URI, ...pathFragment: string[]): URI;
-    /**
-     * Creates a string representation for this URI. It's guaranteed that calling
-     * `URI.parse` with the result of this function creates an URI which is equal
-     * to this URI.
-     *
-     * * The result shall *not* be used for display purposes but for externalization or transport.
-     * * The result will be encoded using the percentage encoding and encoding happens mostly
-     * ignore the scheme-specific encoding rules.
-     *
-     * @param skipEncoding Do not encode the result, default is `false`
-     */
     toString(skipEncoding?: boolean): string;
     toJSON(): UriComponents;
-    /**
-     * A helper function to revive URIs.
-     *
-     * **Note** that this function should only be used when receiving URI#toJSON generated data
-     * and that it doesn't do any validation. Use {@link URI.from} when received "untrusted"
-     * uri components such as command arguments or data from storage.
-     *
-     * @param data The URI components or URI to revive.
-     * @returns The revived URI or undefined or null.
-     */
     static revive(data: UriComponents | URI): URI;
     static revive(data: UriComponents | URI | undefined): URI | undefined;
     static revive(data: UriComponents | URI | null): URI | null;
     static revive(data: UriComponents | URI | undefined | null): URI | undefined | null;
 }
-interface UriComponents {
+export interface UriComponents {
     scheme: string;
     authority?: string;
     path?: string;
     query?: string;
     fragment?: string;
 }
-
-export { URI, type UriComponents };
+export declare function isUriComponents(thing: any): thing is UriComponents;
+export declare function uriToFsPath(uri: URI, keepDriveLetterCasing: boolean): string;
+export type UriDto<T> = {
+    [K in keyof T]: T[K] extends URI ? UriComponents : UriDto<T[K]>;
+};

package/vscode/src/vs/base/common/uri.js

@@ -1,3 +1,6 @@
+
+import { CharCode } from './charCode.js';
+import { MarshalledId } from './marshallingIds.js';
 import { win32, posix } from './path.js';
 import { isWindows } from './platform.js';
 
@@ -251,7 +254,7 @@ class Uri extends URI {
     }
     toJSON() {
         const res = {
-            $mid: 1
+            $mid: MarshalledId.Uri
         };
         if (this._fsPath) {
             res.fsPath = this._fsPath;
@@ -279,42 +282,42 @@ class Uri extends URI {
     }
 }
 const encodeTable = {
-    [58 ]: '%3A',
-    [47 ]: '%2F',
-    [63 ]: '%3F',
-    [35 ]: '%23',
-    [91 ]: '%5B',
-    [93 ]: '%5D',
-    [64 ]: '%40',
-    [33 ]: '%21',
-    [36 ]: '%24',
-    [38 ]: '%26',
-    [39 ]: '%27',
-    [40 ]: '%28',
-    [41 ]: '%29',
-    [42 ]: '%2A',
-    [43 ]: '%2B',
-    [44 ]: '%2C',
-    [59 ]: '%3B',
-    [61 ]: '%3D',
-    [32 ]: '%20',
+    [CharCode.Colon]: '%3A',
+    [CharCode.Slash]: '%2F',
+    [CharCode.QuestionMark]: '%3F',
+    [CharCode.Hash]: '%23',
+    [CharCode.OpenSquareBracket]: '%5B',
+    [CharCode.CloseSquareBracket]: '%5D',
+    [CharCode.AtSign]: '%40',
+    [CharCode.ExclamationMark]: '%21',
+    [CharCode.DollarSign]: '%24',
+    [CharCode.Ampersand]: '%26',
+    [CharCode.SingleQuote]: '%27',
+    [CharCode.OpenParen]: '%28',
+    [CharCode.CloseParen]: '%29',
+    [CharCode.Asterisk]: '%2A',
+    [CharCode.Plus]: '%2B',
+    [CharCode.Comma]: '%2C',
+    [CharCode.Semicolon]: '%3B',
+    [CharCode.Equals]: '%3D',
+    [CharCode.Space]: '%20',
 };
 function encodeURIComponentFast(uriComponent, isPath, isAuthority) {
     let res = undefined;
     let nativeEncodePos = -1;
     for (let pos = 0; pos < uriComponent.length; pos++) {
         const code = uriComponent.charCodeAt(pos);
-        if (((code >= 97  && code <= 122) )
-            || ((code >= 65  && code <= 90) )
-            || ((code >= 48  && code <= 57) )
-            || code === 45
-            || code === 46
-            || code === 95
-            || code === 126
-            || ((isPath && code === 47) )
-            || ((isAuthority && code === 91) )
-            || ((isAuthority && code === 93) )
-            || ((isAuthority && code === 58) )) {
+        if ((code >= CharCode.a && code <= CharCode.z)
+            || (code >= CharCode.A && code <= CharCode.Z)
+            || (code >= CharCode.Digit0 && code <= CharCode.Digit9)
+            || code === CharCode.Dash
+            || code === CharCode.Period
+            || code === CharCode.Underline
+            || code === CharCode.Tilde
+            || (isPath && code === CharCode.Slash)
+            || (isAuthority && code === CharCode.OpenSquareBracket)
+            || (isAuthority && code === CharCode.CloseSquareBracket)
+            || (isAuthority && code === CharCode.Colon)) {
             if (nativeEncodePos !== -1) {
                 res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));
                 nativeEncodePos = -1;
@@ -349,7 +352,7 @@ function encodeURIComponentMinimal(path) {
     let res = undefined;
     for (let pos = 0; pos < path.length; pos++) {
         const code = path.charCodeAt(pos);
-        if (code === 35  || code === 63 ) {
+        if (code === CharCode.Hash || code === CharCode.QuestionMark) {
             if (res === undefined) {
                 res = path.substr(0, pos);
             }
@@ -368,9 +371,9 @@ function uriToFsPath(uri, keepDriveLetterCasing) {
     if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') {
         value = `//${uri.authority}${uri.path}`;
     }
-    else if (uri.path.charCodeAt(0) === 47
-        && ((uri.path.charCodeAt(1) >= 65  && uri.path.charCodeAt(1) <= 90  || uri.path.charCodeAt(1) >= 97  && uri.path.charCodeAt(1) <= 122) )
-        && uri.path.charCodeAt(2) === 58 ) {
+    else if (uri.path.charCodeAt(0) === CharCode.Slash
+        && (uri.path.charCodeAt(1) >= CharCode.A && uri.path.charCodeAt(1) <= CharCode.Z || uri.path.charCodeAt(1) >= CharCode.a && uri.path.charCodeAt(1) <= CharCode.z)
+        && uri.path.charCodeAt(2) === CharCode.Colon) {
         if (!keepDriveLetterCasing) {
             value = uri.path[1].toLowerCase() + uri.path.substr(2);
         }
@@ -427,15 +430,15 @@ function _asFormatted(uri, skipEncoding) {
         }
     }
     if (path) {
-        if (path.length >= 3 && path.charCodeAt(0) === 47  && path.charCodeAt(2) === 58 ) {
+        if (path.length >= 3 && path.charCodeAt(0) === CharCode.Slash && path.charCodeAt(2) === CharCode.Colon) {
             const code = path.charCodeAt(1);
-            if (code >= 65  && code <= 90 ) {
+            if (code >= CharCode.A && code <= CharCode.Z) {
                 path = `/${String.fromCharCode(code + 32)}:${path.substr(3)}`;
             }
         }
-        else if (path.length >= 2 && path.charCodeAt(1) === 58 ) {
+        else if (path.length >= 2 && path.charCodeAt(1) === CharCode.Colon) {
             const code = path.charCodeAt(0);
-            if (code >= 65  && code <= 90 ) {
+            if (code >= CharCode.A && code <= CharCode.Z) {
                 path = `${String.fromCharCode(code + 32)}:${path.substr(2)}`;
             }
         }

package/vscode/src/vs/base/common/uriIpc.d.ts

@@ -0,0 +1,31 @@
+import { URI, UriComponents } from "./uri.js";
+export interface IURITransformer {
+    transformIncoming(uri: UriComponents): UriComponents;
+    transformOutgoing(uri: UriComponents): UriComponents;
+    transformOutgoingURI(uri: URI): URI;
+    transformOutgoingScheme(scheme: string): string;
+}
+export interface UriParts {
+    scheme: string;
+    authority?: string;
+    path?: string;
+    query?: string;
+    fragment?: string;
+}
+export interface IRawURITransformer {
+    transformIncoming(uri: UriParts): UriParts;
+    transformOutgoing(uri: UriParts): UriParts;
+    transformOutgoingScheme(scheme: string): string;
+}
+export declare class URITransformer implements IURITransformer {
+    private readonly _uriTransformer;
+    constructor(uriTransformer: IRawURITransformer);
+    transformIncoming(uri: UriComponents): UriComponents;
+    transformOutgoing(uri: UriComponents): UriComponents;
+    transformOutgoingURI(uri: URI): URI;
+    transformOutgoingScheme(scheme: string): string;
+}
+export declare const DefaultURITransformer: IURITransformer;
+export declare function transformOutgoingURIs<T>(obj: T, transformer: IURITransformer): T;
+export declare function transformIncomingURIs<T>(obj: T, transformer: IURITransformer): T;
+export declare function transformAndReviveIncomingURIs<T>(obj: T, transformer: IURITransformer): T;

package/vscode/src/vs/base/common/uriIpc.js

@@ -1,4 +1,6 @@
+
 import { VSBuffer } from './buffer.js';
+import { MarshalledId } from './marshallingIds.js';
 import { URI } from './uri.js';
 
 const DefaultURITransformer = new class {
@@ -20,7 +22,7 @@ function _transformIncomingURIs(obj, transformer, revive, depth) {
         return null;
     }
     if (typeof obj === 'object') {
-        if (obj.$mid === 1 ) {
+        if (obj.$mid === MarshalledId.Uri) {
             return revive ? URI.revive(transformer.transformIncoming(obj)) : transformer.transformIncoming(obj);
         }
         if (obj instanceof VSBuffer) {

package/vscode/src/vs/base/common/uuid.d.ts

@@ -0,0 +1,2 @@
+export declare function isUUID(value: string): boolean;
+export declare const generateUuid: () => string;

package/vscode/src/vs/base/common/uuid.js

@@ -1,8 +1,10 @@
+
+
 const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function isUUID(value) {
     return _UUIDPattern.test(value);
 }
-const generateUuid = ( (function() {
+const generateUuid = (function () {
     if (typeof crypto === 'object' && typeof crypto.randomUUID === 'function') {
         return crypto.randomUUID.bind(crypto);
     }
@@ -51,6 +53,6 @@ const generateUuid = ( (function() {
         result += _hex[_data[i++]];
         return result;
     };
-})());
+})();
 
 export { generateUuid, isUUID };

package/vscode/src/vs/base/common/verifier.d.ts

@@ -0,0 +1,35 @@
+interface IVerifier<T> {
+    verify(value: unknown): T;
+}
+declare abstract class Verifier<T> implements IVerifier<T> {
+    protected readonly defaultValue: T;
+    constructor(defaultValue: T);
+    verify(value: unknown): T;
+    protected abstract isType(value: unknown): value is T;
+}
+export declare class BooleanVerifier extends Verifier<boolean> {
+    protected isType(value: unknown): value is boolean;
+}
+export declare class NumberVerifier extends Verifier<number> {
+    protected isType(value: unknown): value is number;
+}
+export declare class SetVerifier<T> extends Verifier<Set<T>> {
+    protected isType(value: unknown): value is Set<T>;
+}
+export declare class EnumVerifier<T> extends Verifier<T> {
+    private readonly allowedValues;
+    constructor(defaultValue: T, allowedValues: ReadonlyArray<T>);
+    protected isType(value: unknown): value is T;
+}
+export declare class ObjectVerifier<T extends Object> extends Verifier<T> {
+    private readonly verifier;
+    constructor(defaultValue: T, verifier: {
+        [K in keyof T]: IVerifier<T[K]>;
+    });
+    verify(value: unknown): T;
+    protected isType(value: unknown): value is T;
+}
+export declare function verifyObject<T extends Object>(verifiers: {
+    [K in keyof T]: IVerifier<T[K]>;
+}, value: Object): T;
+export {};

package/vscode/src/vs/base/common/verifier.js

@@ -1,3 +1,4 @@
+
 import { isObject } from './types.js';
 
 class Verifier {

package/vscode/src/vs/base/common/worker/simpleWorker.d.ts

@@ -0,0 +1,116 @@
+import { Disposable, IDisposable } from "../lifecycle.js";
+import { URI } from "../uri.js";
+export interface IWorker extends IDisposable {
+    getId(): number;
+    postMessage(message: Message, transfer: ArrayBuffer[]): void;
+}
+export interface IWorkerCallback {
+    (message: Message): void;
+}
+export interface IWorkerFactory {
+    create(modules: IWorkerDescriptor, callback: IWorkerCallback, onErrorCallback: (err: any) => void): IWorker;
+}
+export interface IWorkerDescriptor {
+    readonly moduleId: string;
+    readonly esmModuleLocation: URI | undefined;
+    readonly label: string | undefined;
+}
+export declare function logOnceWebWorkerWarning(err: any): void;
+declare enum MessageType {
+    Request = 0,
+    Reply = 1,
+    SubscribeEvent = 2,
+    Event = 3,
+    UnsubscribeEvent = 4
+}
+declare class RequestMessage {
+    readonly vsWorker: number;
+    readonly req: string;
+    readonly channel: string;
+    readonly method: string;
+    readonly args: any[];
+    readonly type = MessageType.Request;
+    constructor(vsWorker: number, req: string, channel: string, method: string, args: any[]);
+}
+declare class ReplyMessage {
+    readonly vsWorker: number;
+    readonly seq: string;
+    readonly res: any;
+    readonly err: any;
+    readonly type = MessageType.Reply;
+    constructor(vsWorker: number, seq: string, res: any, err: any);
+}
+declare class SubscribeEventMessage {
+    readonly vsWorker: number;
+    readonly req: string;
+    readonly channel: string;
+    readonly eventName: string;
+    readonly arg: any;
+    readonly type = MessageType.SubscribeEvent;
+    constructor(vsWorker: number, req: string, channel: string, eventName: string, arg: any);
+}
+declare class EventMessage {
+    readonly vsWorker: number;
+    readonly req: string;
+    readonly event: any;
+    readonly type = MessageType.Event;
+    constructor(vsWorker: number, req: string, event: any);
+}
+declare class UnsubscribeEventMessage {
+    readonly vsWorker: number;
+    readonly req: string;
+    readonly type = MessageType.UnsubscribeEvent;
+    constructor(vsWorker: number, req: string);
+}
+type Message = RequestMessage | ReplyMessage | SubscribeEventMessage | EventMessage | UnsubscribeEventMessage;
+type ProxiedMethodName = (`$${string}` | `on${string}`);
+export type Proxied<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (K extends ProxiedMethodName ? (...args: A) => Promise<Awaited<R>> : never) : never;
+};
+export interface IWorkerClient<W> {
+    proxy: Proxied<W>;
+    dispose(): void;
+    setChannel<T extends object>(channel: string, handler: T): void;
+    getChannel<T extends object>(channel: string): Proxied<T>;
+}
+export interface IWorkerServer {
+    setChannel<T extends object>(channel: string, handler: T): void;
+    getChannel<T extends object>(channel: string): Proxied<T>;
+}
+export declare class SimpleWorkerClient<W extends object> extends Disposable implements IWorkerClient<W> {
+    private readonly _worker;
+    private readonly _onModuleLoaded;
+    private readonly _protocol;
+    readonly proxy: Proxied<W>;
+    private readonly _localChannels;
+    private readonly _remoteChannels;
+    constructor(workerFactory: IWorkerFactory, workerDescriptor: IWorkerDescriptor);
+    private _handleMessage;
+    private _handleEvent;
+    setChannel<T extends object>(channel: string, handler: T): void;
+    getChannel<T extends object>(channel: string): Proxied<T>;
+    private _onError;
+}
+export interface IRequestHandler {
+    _requestHandlerBrand: any;
+    [prop: string]: any;
+}
+export interface IRequestHandlerFactory {
+    (workerServer: IWorkerServer): IRequestHandler;
+}
+export declare class SimpleWorkerServer implements IWorkerServer {
+    private _requestHandlerFactory;
+    private _requestHandler;
+    private _protocol;
+    private readonly _localChannels;
+    private readonly _remoteChannels;
+    constructor(postMessage: (msg: Message, transfer?: ArrayBuffer[]) => void, requestHandlerFactory: IRequestHandlerFactory | null);
+    onmessage(msg: any): void;
+    private _handleMessage;
+    private _handleEvent;
+    setChannel<T extends object>(channel: string, handler: T): void;
+    getChannel<T extends object>(channel: string): Proxied<T>;
+    private initialize;
+}
+export declare function create(postMessage: (msg: Message, transfer?: ArrayBuffer[]) => void): SimpleWorkerServer;
+export {};

package/vscode/src/vs/base/common/worker/simpleWorker.js

@@ -1,3 +1,5 @@
+
+import { CharCode } from '../charCode.js';
 import { transformErrorForSerialization, onUnexpectedError } from '../errors.js';
 import { Emitter } from '../event.js';
 import { Disposable } from '../lifecycle.js';
@@ -17,6 +19,14 @@ function logOnceWebWorkerWarning(err) {
     }
     console.warn(err.message);
 }
+var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["Request"] = 0] = "Request";
+    MessageType[MessageType["Reply"] = 1] = "Reply";
+    MessageType[MessageType["SubscribeEvent"] = 2] = "SubscribeEvent";
+    MessageType[MessageType["Event"] = 3] = "Event";
+    MessageType[MessageType["UnsubscribeEvent"] = 4] = "UnsubscribeEvent";
+})(MessageType || (MessageType = {}));
 class RequestMessage {
     constructor(vsWorker, req, channel, method, args) {
         this.vsWorker = vsWorker;
@@ -24,7 +34,7 @@ class RequestMessage {
         this.channel = channel;
         this.method = method;
         this.args = args;
-        this.type = 0 ;
+        this.type = MessageType.Request;
     }
 }
 class ReplyMessage {
@@ -33,7 +43,7 @@ class ReplyMessage {
         this.seq = seq;
         this.res = res;
         this.err = err;
-        this.type = 1 ;
+        this.type = MessageType.Reply;
     }
 }
 class SubscribeEventMessage {
@@ -43,7 +53,7 @@ class SubscribeEventMessage {
         this.channel = channel;
         this.eventName = eventName;
         this.arg = arg;
-        this.type = 2 ;
+        this.type = MessageType.SubscribeEvent;
     }
 }
 class EventMessage {
@@ -51,14 +61,14 @@ class EventMessage {
         this.vsWorker = vsWorker;
         this.req = req;
         this.event = event;
-        this.type = 3 ;
+        this.type = MessageType.Event;
     }
 }
 class UnsubscribeEventMessage {
     constructor(vsWorker, req) {
         this.vsWorker = vsWorker;
         this.req = req;
-        this.type = 4 ;
+        this.type = MessageType.UnsubscribeEvent;
     }
 }
 class SimpleWorkerProtocol {
@@ -120,7 +130,7 @@ class SimpleWorkerProtocol {
                     else if (propertyIsEvent(name)) {
                         target[name] = this.listen(channel, name, undefined);
                     }
-                    else if (name.charCodeAt(0) === 36 ) {
+                    else if (name.charCodeAt(0) === CharCode.DollarSign) {
                         target[name] = async (...myArgs) => {
                             await sendMessageBarrier?.();
                             return this.sendMessage(channel, name, myArgs);
@@ -134,15 +144,15 @@ class SimpleWorkerProtocol {
     }
     _handleMessage(msg) {
         switch (msg.type) {
-            case 1 :
+            case MessageType.Reply:
                 return this._handleReplyMessage(msg);
-            case 0 :
+            case MessageType.Request:
                 return this._handleRequestMessage(msg);
-            case 2 :
+            case MessageType.SubscribeEvent:
                 return this._handleSubscribeEventMessage(msg);
-            case 3 :
+            case MessageType.Event:
                 return this._handleEventMessage(msg);
-            case 4 :
+            case MessageType.UnsubscribeEvent:
                 return this._handleUnsubscribeEventMessage(msg);
         }
     }
@@ -202,14 +212,14 @@ class SimpleWorkerProtocol {
     }
     _send(msg) {
         const transfer = [];
-        if (msg.type === 0 ) {
+        if (msg.type === MessageType.Request) {
             for (let i = 0; i < msg.args.length; i++) {
                 if (msg.args[i] instanceof ArrayBuffer) {
                     transfer.push(msg.args[i]);
                 }
             }
         }
-        else if (msg.type === 1 ) {
+        else if (msg.type === MessageType.Reply) {
             if (msg.res instanceof ArrayBuffer) {
                 transfer.push(msg.res);
             }