@illgrenoble/webx-client 1.11.0 → 1.12.1

package/dist/WebXClient.d.ts

@@ -2,7 +2,6 @@ import { WebXTunnel } from './tunnel';
 import { WebXDisplay } from './display';
 import { WebXKeyboard, WebXMouse, WebXMouseState } from './input';
 import { WebXDebugImageMessageHandler, WebXHandler } from './tracer';
-import { Blob } from "buffer";
 /**
  * Configuration options for the WebXClient.
  */
@@ -20,7 +19,7 @@ export interface WebXClientConfig {
  */
 export declare class WebXClient {
     private _tunnel;
-    private readonly _textureFactory;
+    private readonly _windowImageFactory;
     private readonly _cursorFactory;
     private _tracers;
     private _onCloseCallback;

package/dist/common/WebXImageBlenderFunc.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The Alpha and stencil buffer blending function. The alpha buffer contains alpha data in the
+ * green channel. The stencil buffer is a black and white image: only pixels with a stencil value > 127 are to be rendered
+ * @param colorData the color data array
+ * @param alphaData the alpha data array
+ * @param stencilData the stencil data array
+ */
+export declare const alphaAndStencilBlend: (colorData: Uint8ClampedArray, alphaData: Uint8ClampedArray, stencilData: Uint8ClampedArray) => void;
+/**
+ * The Alpha buffer blending function. The alpha buffer contains alpha data in the
+ * green channel.
+ * @param colorData the color data array
+ * @param alphaData the alpha data array
+ */
+export declare const alphaBufferBlend: (colorData: Uint8ClampedArray, alphaData: Uint8ClampedArray) => void;
+/**
+ * The Alpha image blending function. The alpha image contains alpha image data
+ * @param colorImage the color image array
+ * @param alphaImage the alpha image
+ */
+export declare const colorAndAlphaBlendImageToImageData: (colorImage: ImageBitmap | HTMLImageElement, alphaImage: ImageBitmap | HTMLImageElement) => ImageData;
+/**
+ * Draws an image to a canvas to obtain the raw image data
+ * @param image the image
+ */
+export declare const imageToImageData: (image: ImageBitmap | HTMLImageElement) => ImageData;

package/dist/{display → common}/WebXSubImage.d.ts

@@ -1,4 +1,4 @@
-import * as THREE from 'three';
+import { WebXTexture } from "../texture";
 /**
  * Represents a sub-image within a WebX window.
  *
@@ -28,11 +28,11 @@ export declare class WebXSubImage {
     /**
      * The color map texture of the sub-image.
      */
-    readonly colorMap: THREE.Texture;
+    readonly colorMap: WebXTexture;
     /**
      * The alpha map texture of the sub-image.
      */
-    readonly alphaMap: THREE.Texture;
+    readonly alphaMap: WebXTexture;
     /**
      * Creates a new instance of WebXSubImage.
      *
@@ -44,7 +44,7 @@ export declare class WebXSubImage {
         width: number;
         height: number;
         depth: number;
-        colorMap: THREE.Texture;
-        alphaMap: THREE.Texture;
+        colorMap: WebXTexture;
+        alphaMap: WebXTexture;
     });
 }

package/dist/common/index.d.ts

@@ -0,0 +1,3 @@
+export * from './WebXWindowProperties';
+export * from './WebXSubImage';
+export * from './WebXImageBlenderFunc';

package/dist/display/WebXCursor.d.ts

@@ -1,5 +1,3 @@
-import * as THREE from 'three';
-import { Texture } from 'three';
 import { WebXCursorFactory } from './WebXCursorFactory';
 /**
  * Represents the cursor in the WebX display.
@@ -9,11 +7,10 @@ import { WebXCursorFactory } from './WebXCursorFactory';
  */
 export declare class WebXCursor {
     private _cursorFactory;
-    private static _PLANE_GEOMETRY;
     private _cursorId;
     private _texture;
-    private readonly _material;
-    private readonly _mesh;
+    private readonly _canvas;
+    private readonly _context;
     private _x;
     private _y;
     private _xHot;
@@ -21,23 +18,17 @@ export declare class WebXCursor {
     private _width;
     private _height;
     /**
-     * Gets the THREE.js mesh representing the cursor.
+     * Gets the HTML Canvas containing the cursor image.
      *
-     * @returns The cursor mesh.
+     * @returns The cursor canvas.
      */
-    get mesh(): THREE.Mesh;
+    get canvas(): HTMLCanvasElement;
     /**
      * Gets the cursor ID.
      *
      * @returns The cursor ID.
      */
     get cursorId(): number;
-    /**
-     * Gets the texture of the cursor.
-     *
-     * @returns The cursor texture.
-     */
-    get texture(): Texture;
     /**
      * Sets the x-coordinate of the cursor.
      *
@@ -66,12 +57,9 @@ export declare class WebXCursor {
     /**
      * Updates the cursor's position and appearance based on the given cursor ID and coordinates.
      *
-     * @param x The x-coordinate of the cursor.
-     * @param y The y-coordinate of the cursor.
      * @param cursorId The ID of the cursor to display.
      */
     setCursorId(cursorId: number): void;
-    dispose(): void;
     /**
      * Updates the mouse cursor, appearance, and texture.
      *

package/dist/display/WebXCursorFactory.d.ts

@@ -1,5 +1,5 @@
 import { WebXTunnel } from '../tunnel';
-import { Texture } from 'three';
+import { WebXTexture } from "../texture";
 /**
  * Interface representing cursor data.
  */
@@ -7,7 +7,7 @@ export interface WebXCursorData {
     xHot: number;
     yHot: number;
     cursorId: number;
-    texture: Texture;
+    texture: WebXTexture;
 }
 /**
  * Factory class for creating and managing cursor textures.

package/dist/display/WebXDisplay.d.ts

@@ -1,12 +1,11 @@
 import * as THREE from 'three';
-import { OrthographicCamera, Texture } from 'three';
+import { OrthographicCamera } from 'three';
 import { WebXWindow } from './WebXWindow';
-import { WebXWindowProperties } from './WebXWindowProperties';
-import { WebXSubImage } from './WebXSubImage';
-import { WebXTextureFactory } from './WebXTextureFactory';
+import { WebXSubImage, WebXWindowProperties } from '../common';
 import { WebXCursorFactory } from './WebXCursorFactory';
 import { WebXCanvasRenderer } from '../renderer';
-import { Blob } from "buffer";
+import { WebXWindowImageFactory } from "./WebXWindowImageFactory";
+import { WebXTexture } from "../texture";
 /**
  * Manages the rendering of the WebX remote desktop using WebGL.
  *
@@ -21,15 +20,17 @@ export declare class WebXDisplay {
     private readonly _screen;
     private readonly _screenWidth;
     private readonly _screenHeight;
-    private readonly _textureFactory;
+    private readonly _windowImageFactory;
     private readonly _containerElement;
     private _windows;
     private _cursor;
     private _scale;
     private _displayElement;
     private _boundsElement;
+    private _displayOverlay;
     private _disposed;
     private _sceneDirty;
+    private _disableStencil;
     /**
      * Gets the WebGL renderer used for rendering the display.
      *
@@ -88,10 +89,10 @@ export declare class WebXDisplay {
      * @param containerElement The HTML element to render the display.
      * @param screenWidth The width of the screen.
      * @param screenHeight The height of the screen.
-     * @param textureFactory The texture factory used for creating textures.
+     * @param windowImageFactory The factory used for obtaining window images.
      * @param cursorFactory The cursor factory used for managing cursors.
      */
-    constructor(containerElement: HTMLElement, screenWidth: number, screenHeight: number, textureFactory: WebXTextureFactory, cursorFactory: WebXCursorFactory);
+    constructor(containerElement: HTMLElement, screenWidth: number, screenHeight: number, windowImageFactory: WebXWindowImageFactory, cursorFactory: WebXCursorFactory);
     /**
      * Displays the screen by adding it to the scene.
      */
@@ -156,7 +157,7 @@ export declare class WebXDisplay {
      * @param colorMap The color texture.
      * @param alphaMap The alpha texture.
      */
-    updateImage(windowId: number, depth: number, colorMap: Texture, alphaMap: Texture): void;
+    updateImage(windowId: number, depth: number, colorMap: WebXTexture, alphaMap: WebXTexture): void;
     /**
      * Updates sub-images of a window with new image data.
      *
@@ -170,7 +171,7 @@ export declare class WebXDisplay {
      * @param windowId The ID of the window to update.
      * @param stencilMap The stencil texture.
      */
-    updateShape(windowId: number, stencilMap: Texture): void;
+    updateShape(windowId: number, stencilMap: WebXTexture): void;
     /**
      * Updates the mouse cursor on the display.
      *

package/dist/display/WebXDisplayOverlay.d.ts

@@ -0,0 +1,10 @@
+import { WebXCursor } from "./WebXCursor";
+export declare class WebXDisplayOverlay {
+    private _cursor;
+    private readonly _overlayElement;
+    get overlayElement(): HTMLElement;
+    set visible(visible: boolean);
+    constructor(_cursor: WebXCursor);
+    update(): void;
+    private _createDisplayOverlayElement;
+}

package/dist/display/WebXWindow.d.ts

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
-import { WebXTextureFactory } from './WebXTextureFactory';
 import { Texture } from 'three';
+import { WebXWindowImageFactory } from "./WebXWindowImageFactory";
 /**
  * Represents a window in the WebX display.
  *
@@ -11,7 +11,7 @@ export declare class WebXWindow {
     static WINDOW_REFRESH_TIME_MS: number;
     private static _PLANE_GEOMETRY;
     private static _COLOR_INDEX;
-    private readonly _textureFactory;
+    private readonly _windowImageFactory;
     private readonly _colorIndex;
     private readonly _id;
     private readonly _material;
@@ -182,7 +182,7 @@ export declare class WebXWindow {
      * Creates a new instance of WebXWindow.
      *
      * @param configuration The properties of the window, such as position and size.
-     * @param textureFactory The factory used to create textures for the window.
+     * @param windowImageFactory The factory used to create textures for the window.
      */
     constructor(configuration: {
         id: number;
@@ -192,7 +192,7 @@ export declare class WebXWindow {
         width: number;
         height: number;
         shaped: boolean;
-    }, textureFactory: WebXTextureFactory);
+    }, windowImageFactory: WebXWindowImageFactory);
     /**
      * Loads the window image from the texture factory.
      */

package/dist/display/WebXWindowImageFactory.d.ts

@@ -0,0 +1,31 @@
+import { WebXTunnel } from '../tunnel';
+import { WebXTexture } from "../texture";
+/**
+ * Factory class for request textures for WebX windows.
+ *
+ * This class retrieves textures from the WebX Engine
+ */
+export declare class WebXWindowImageFactory {
+    private _tunnel;
+    constructor(_tunnel: WebXTunnel);
+    /**
+     * Retrieves the textures (colorMap and alphaMap) for a specific window ID from the WebX Engine.
+     *
+     * @param windowId The ID of the window to retrieve the texture for.
+     * @returns A promise that resolves to the textures and associated data.
+     */
+    getWindowTexture(windowId: number): Promise<{
+        depth: number;
+        colorMap: WebXTexture;
+        alphaMap: WebXTexture;
+    }>;
+    /**
+     * Retrieves the stencil textures for a specific window ID from the WebX Engine.
+     *
+     * @param windowId The ID of the window to retrieve the texture for.
+     * @returns A promise that resolves to the stencil texture
+     */
+    getWindowStencilTexture(windowId: number): Promise<{
+        stencilMap: WebXTexture;
+    }>;
+}

package/dist/display/index.d.ts

@@ -1,7 +1 @@
-export * from './WebXCursor';
 export * from './WebXDisplay';
-export * from './WebXWindow';
-export * from './WebXWindowProperties';
-export * from './WebXTextureFactory';
-export * from './WebXSubImage';
-export * from './WebXCursorFactory';

package/dist/index.d.ts

@@ -1,7 +1,9 @@
+export * from './common';
 export * from './display';
 export * from './input';
 export * from './instruction';
 export * from './message';
+export * from './texture';
 export * from './tracer';
 export * from './tunnel';
 export * from './WebXClient';

package/dist/message/WebXCursorImageMessage.d.ts

@@ -1,5 +1,5 @@
 import { WebXMessage } from './WebXMessage';
-import { Texture } from 'three';
+import { WebXTexture } from "../texture";
 /**
  * Represents a message containing cursor image data.
  *
@@ -22,7 +22,7 @@ export declare class WebXCursorImageMessage extends WebXMessage {
     /**
      * The texture of the cursor.
      */
-    readonly texture: Texture;
+    readonly texture: WebXTexture;
     /**
      * The x-coordinate of the cursor's position.
      */
@@ -42,5 +42,5 @@ export declare class WebXCursorImageMessage extends WebXMessage {
      * @param y The y-coordinate of the cursor's position.
      * @param commandId The ID of the command associated with this message.
      */
-    constructor(x: number, y: number, xHot: number, yHot: number, cursorId: number, texture: Texture, commandId: number);
+    constructor(x: number, y: number, xHot: number, yHot: number, cursorId: number, texture: WebXTexture, commandId: number);
 }

package/dist/message/WebXImageMessage.d.ts

@@ -1,5 +1,5 @@
 import { WebXMessage } from './WebXMessage';
-import { Texture } from 'three';
+import { WebXTexture } from "../texture";
 /**
  * Represents a message containing image data for a window.
  *
@@ -18,11 +18,11 @@ export declare class WebXImageMessage extends WebXMessage {
     /**
      * The color texture of the image.
      */
-    readonly colorMap: Texture;
+    readonly colorMap: WebXTexture;
     /**
      * The alpha texture of the image.
      */
-    readonly alphaMap: Texture;
+    readonly alphaMap: WebXTexture;
     /**
      * The size of the image.
      */
@@ -37,5 +37,5 @@ export declare class WebXImageMessage extends WebXMessage {
      * @param commandId The ID of the command associated with this message.
      * @param size The size of the image.
      */
-    constructor(windowId: number, depth: number, colorMap: Texture, alphaMap: Texture, commandId: number, size: number);
+    constructor(windowId: number, depth: number, colorMap: WebXTexture, alphaMap: WebXTexture, commandId: number, size: number);
 }

package/dist/message/WebXMessage.d.ts

@@ -14,11 +14,23 @@ export declare abstract class WebXMessage {
      * The ID of the command associated with this message.
      */
     readonly commandId: number;
+    /**
+     * Used to globally set function of web worker when decoding messages
+     */
+    private static _convertToImageDataInWorker;
     /**
      * Constructs a new WebXMessage.
      *
      * @param type The type of the message.
      * @param commandId The ID of the command associated with this message.
      */
-    constructor(type: WebXMessageType, commandId?: number);
+    protected constructor(type: WebXMessageType, commandId?: number);
+    /**
+     * Get the flag to determine if images should be converted to image data in a worker
+     */
+    static get convertToImageDataInWorker(): boolean;
+    /**
+     * Set the flag to specify whether images should be converted to image data in a worker
+     */
+    static set convertToImageDataInWorker(value: boolean);
 }

package/dist/message/WebXShapeMessage.d.ts

@@ -1,5 +1,5 @@
 import { WebXMessage } from './WebXMessage';
-import { Texture } from 'three';
+import { WebXTexture } from "../texture";
 /**
  * Represents a message containing image data for a window.
  *
@@ -14,7 +14,7 @@ export declare class WebXShapeMessage extends WebXMessage {
     /**
      * The stencil texture of the window.
      */
-    readonly stencilMap: Texture;
+    readonly stencilMap: WebXTexture;
     /**
      * The size of the image.
      */
@@ -27,5 +27,5 @@ export declare class WebXShapeMessage extends WebXMessage {
      * @param commandId The ID of the command associated with this message.
      * @param size The size of the image.
      */
-    constructor(windowId: number, stencilMap: Texture, commandId: number, size: number);
+    constructor(windowId: number, stencilMap: WebXTexture, commandId: number, size: number);
 }

package/dist/message/WebXSubImagesMessage.d.ts

@@ -1,5 +1,5 @@
 import { WebXMessage } from './WebXMessage';
-import { WebXSubImage } from '../display';
+import { WebXSubImage } from '../common';
 /**
  * Represents a message containing sub-image data for a window.
  *

package/dist/message/WebXWindowsMessage.d.ts

@@ -1,5 +1,5 @@
 import { WebXMessage } from './WebXMessage';
-import { WebXWindowProperties } from '../display';
+import { WebXWindowProperties } from '../common';
 /**
  * Represents a message containing information about visible windows.
  *

package/dist/renderer/WebXCanvasRenderer.d.ts

@@ -1,5 +1,4 @@
 import { Camera, ColorRepresentation, Object3D, Texture, Vector2 } from 'three';
-import { Blob } from "buffer";
 /**
  * The `WebXCanvasRenderer` class is responsible for rendering a desktop-like environment
  * using HTML elements. It integrates with the Three.js library using 3D objects (meshes, materials, textures)
@@ -11,7 +10,7 @@ export declare class WebXCanvasRenderer {
     private _desktopContainer;
     private _desktop;
     private _clearColor;
-    private readonly _alphaStencilBlender;
+    private readonly _imageBlender;
     private _windowCanvases;
     /**
      * Gets the root DOM element of the renderer.

package/dist/renderer/{WebXAlphaStencilBlender.d.ts → WebXImageBlender.d.ts}

@@ -2,7 +2,7 @@
  * The `WebXAlphaStencilBlender` class handles blending of alpha and stencil data
  * for rendering purposes. It uses a Web Worker for asynchronous processing.
  */
-export declare class WebXAlphaStencilBlender {
+export declare class WebXImageBlender {
     private readonly _worker;
     private _pending;
     private _nextId;

package/dist/renderer/WebXImageBlenderWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/renderer/WebXWindowCanvas.d.ts

@@ -1,5 +1,5 @@
 import { Mesh, Texture, Vector2 } from "three";
-import { WebXAlphaStencilBlender } from "./WebXAlphaStencilBlender";
+import { WebXImageBlender } from "./WebXImageBlender";
 /**
  * The `WebXWindowCanvas` class holds the graphical elements necessary for rendering
  * a specific window in the desktop environment. HTML Canvases are used for rendering image data. Window image data
@@ -7,11 +7,10 @@ import { WebXAlphaStencilBlender } from "./WebXAlphaStencilBlender";
  */
 export declare class WebXWindowCanvas {
     private readonly _mesh;
-    private readonly _alphaStencilBlender;
+    private readonly _imageBlender;
     private readonly _canvas;
     private _context;
-    private _stencilCanvas;
-    private _stencilContext;
+    private _stencilData;
     private _x;
     private _y;
     private _zIndex;
@@ -53,9 +52,9 @@ export declare class WebXWindowCanvas {
      * Initializes a new `WebXWindowCanvas` for the given window Mesh and Material. The Mesh and Material contains all graphical information
      * necessary to render a window (namely window position, size and z-order), the Mesh Material contains the graphical information (color, alpha and stencil data).
      * @param _mesh - The `Mesh` object representing the window.
-     * @param _alphaStencilBlender - The alpha stencil blender instance.
+     * @param _imageBlender - The image blender instance.
      */
-    constructor(_mesh: Mesh, _alphaStencilBlender: WebXAlphaStencilBlender);
+    constructor(_mesh: Mesh, _imageBlender: WebXImageBlender);
     /**
      * Updates the geometry of the window canvas based on the mesh's properties if any changes are needed.
      */
@@ -78,6 +77,7 @@ export declare class WebXWindowCanvas {
      * @param dstPosition - The destination position of the region.
      */
     addRegionUpdate(srcColorMap: Texture, dstColorMap: Texture, srcAlphaMap: Texture, dstAlphaMap: Texture, width: number, height: number, dstPosition: Vector2): void;
+    private resizeCanvas;
     /**
      * Handles all pending region updates for the canvas.  The different buffers (color, alpha and stencil) are blended (in a web
      * worker if available) and then re-rendered into the main canvas of the window. If the window has only a color buffer then this
@@ -98,8 +98,8 @@ export declare class WebXWindowCanvas {
     /**
      * Prepares temporary canvases to renderer the image data (jpeg format) into raw pixmaps. The pixmap data for the different
      * images is sent to the blender for processing.
-     * @param colorImage - The color image.
-     * @param alphaImage - The alpha image.
+     * @param colorMap - The color texture.
+     * @param alphaMap - The alpha texture.
      * @param dstX - The destination X position.
      * @param dstY - The destination Y position.
      * @returns A promise that resolves to the blended `ImageData`.
@@ -111,4 +111,23 @@ export declare class WebXWindowCanvas {
      * @returns The created `HTMLElement`.
      */
     private createElementNS;
+    /**
+     * Generates ImageData from an image (ImageBitmap | HTMLImageElement) by creating a temporary canvas
+     * and drawing the image onto it. The raw image data is then read from the canvas.
+     * @param image the image to convert to ImageData
+     */
+    private getImageData;
+    /**
+     * Converts raw image data from TextureImageData into an ImageData object. Ensures that the raw data is a Uin8ClampedArray
+     * @param textureData the raw image data from a TextureData
+     */
+    private dataTextureToImageData;
+    /**
+     * Returns a region of the stencil data as a new ImageData object
+     * @param x the x position of the region
+     * @param y the y position of the region
+     * @param width the width of the region
+     * @param height the height of the region
+     */
+    private getStencilDataRegion;
 }

package/dist/renderer/index.d.ts

@@ -1,3 +1,3 @@
 export * from './WebXCanvasRenderer';
 export * from './WebXWindowCanvas';
-export * from './WebXAlphaStencilBlender';
+export * from './WebXImageBlender';

package/dist/texture/WebXTexture.d.ts

@@ -0,0 +1,18 @@
+export declare const SRGBColorSpace = "srgb";
+export declare const LinearSRGBColorSpace = "srgb-linear";
+export declare class WebXTexture {
+    image: ImageBitmap | HTMLImageElement;
+    data: Uint8ClampedArray;
+    colorSpace: string;
+    flipY: boolean;
+    width: number;
+    height: number;
+    constructor(data: {
+        image?: ImageBitmap | HTMLImageElement;
+        data?: Uint8ClampedArray;
+        width?: number;
+        height?: number;
+    });
+    isTransferable(): boolean;
+    get transferable(): Transferable;
+}

package/dist/texture/WebXTextureFactory.d.ts

@@ -0,0 +1,23 @@
+import { WebXTexture } from "./WebXTexture";
+/**
+ * Factory class for creating textures for WebX windows from image data.
+ */
+export declare class WebXTextureFactory {
+    constructor();
+    /**
+     * Creates a texture from raw image data.
+     *
+     * @param imageData The raw image data as a Uint8Array.
+     * @param mimetype The MIME type of the image data (e.g., "image/png").
+     * @param colorSpace The color space of the image data (e.g., "srgb").
+     * @returns A promise that resolves to the created texture.
+     */
+    createTextureFromArray(imageData: Uint8Array, mimetype: string, colorSpace: string): Promise<WebXTexture>;
+    /**
+     * Creates a texture from a Blob object.
+     *
+     * @param blob The Blob object containing the image data.
+     * @returns A promise that resolves to the created texture.
+     */
+    createTextureFromBlob(blob: Blob): Promise<WebXTexture>;
+}

package/dist/texture/WebXTextureFunc.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from 'three';
+import { WebXTexture } from "./WebXTexture";
+export declare const toThreeTexture: (texture: WebXTexture) => THREE.Texture;

package/dist/texture/index.d.ts

@@ -0,0 +1,3 @@
+export * from './WebXTexture';
+export * from './WebXTextureFactory';
+export * from './WebXTextureFunc';

package/dist/transport/WebXBinarySerializer.d.ts

@@ -1,19 +1,23 @@
 import { WebXInstruction } from '../instruction';
 import { WebXMessage } from '../message';
-import { WebXMessageBuffer } from '.';
-import { WebXTextureFactory } from '../display';
+import { WebXMessageBuffer } from "./WebXMessageBuffer";
 /**
  * Serializes and deserializes WebX instructions and messages.
  */
 export declare class WebXBinarySerializer {
     private readonly _instructionEncoder;
     private readonly _messageDecoder;
+    private readonly _worker;
+    private _pending;
+    private _nextId;
     /**
      * Creates a new instance of WebXBinarySerializer.
-     *
-     * @param textureFactory The texture factory used for decoding image data.
      */
-    constructor(textureFactory: WebXTextureFactory);
+    constructor();
+    /**
+     * Terminates the Web Worker and clears pending tasks.
+     */
+    terminate(): void;
     /**
      * Serializes a WebXInstruction into a binary ArrayBuffer.
      *
@@ -22,10 +26,11 @@ export declare class WebXBinarySerializer {
      */
     serializeInstruction(instruction: WebXInstruction): ArrayBuffer;
     /**
-     * Deserializes a binary message buffer into a WebXMessage object.
+     * Deserializes a binary message buffer into a WebXMessage object. A web worker is used if available
+     * and the message should be decoded in a separate thread.
      *
-     * @param buffer The binary message buffer to deserialize.
+     * @param messageBuffer The binary message buffer to deserialize.
      * @returns A promise that resolves to the deserialized WebXMessage.
      */
-    deserializeMessage(buffer: WebXMessageBuffer): Promise<WebXMessage>;
+    deserializeMessage(messageBuffer: WebXMessageBuffer): Promise<WebXMessage>;
 }

package/dist/transport/WebXMessageBuffer.d.ts

@@ -30,6 +30,10 @@ export declare class WebXMessageBuffer {
      * Gets the current read offset
      */
     get readOffset(): number;
+    /**
+     * Returns the raw ArrayBuffer object
+     */
+    get buffer(): ArrayBuffer;
     private _readOffset;
     private _encoder;
     /**