@vaadin-component-factory/vcf-pdf-viewer 4.0.2 → 4.1.0

package/pdfjs/dist/message_handler.js

@@ -1,4 +1,245 @@
-import { c as assert, l as createPromiseCapability, t as UnknownErrorException, v as UnexpectedResponseException, M as MissingPDFException, A as AbortException } from './util.js';
+import { F as FeatureTest, p as ImageKind, e as assert, u as unreachable, v as UnknownErrorException, x as UnexpectedResponseException, z as PasswordException, M as MissingPDFException, a as AbortException } from './util.js';
+
+/* Copyright 2014 Opera Software ASA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *
+ * Based on https://code.google.com/p/smhasher/wiki/MurmurHash3.
+ * Hashes roughly 100 KB per millisecond on i7 3.4 GHz.
+ */
+
+const SEED = 0xc3d2e1f0;
+// Workaround for missing math precision in JS.
+const MASK_HIGH = 0xffff0000;
+const MASK_LOW = 0xffff;
+class MurmurHash3_64 {
+  constructor(seed) {
+    this.h1 = seed ? seed & 0xffffffff : SEED;
+    this.h2 = seed ? seed & 0xffffffff : SEED;
+  }
+  update(input) {
+    let data, length;
+    if (typeof input === "string") {
+      data = new Uint8Array(input.length * 2);
+      length = 0;
+      for (let i = 0, ii = input.length; i < ii; i++) {
+        const code = input.charCodeAt(i);
+        if (code <= 0xff) {
+          data[length++] = code;
+        } else {
+          data[length++] = code >>> 8;
+          data[length++] = code & 0xff;
+        }
+      }
+    } else if (ArrayBuffer.isView(input)) {
+      data = input.slice();
+      length = data.byteLength;
+    } else {
+      throw new Error("Invalid data format, must be a string or TypedArray.");
+    }
+    const blockCounts = length >> 2;
+    const tailLength = length - blockCounts * 4;
+    // We don't care about endianness here.
+    const dataUint32 = new Uint32Array(data.buffer, 0, blockCounts);
+    let k1 = 0,
+      k2 = 0;
+    let h1 = this.h1,
+      h2 = this.h2;
+    const C1 = 0xcc9e2d51,
+      C2 = 0x1b873593;
+    const C1_LOW = C1 & MASK_LOW,
+      C2_LOW = C2 & MASK_LOW;
+    for (let i = 0; i < blockCounts; i++) {
+      if (i & 1) {
+        k1 = dataUint32[i];
+        k1 = k1 * C1 & MASK_HIGH | k1 * C1_LOW & MASK_LOW;
+        k1 = k1 << 15 | k1 >>> 17;
+        k1 = k1 * C2 & MASK_HIGH | k1 * C2_LOW & MASK_LOW;
+        h1 ^= k1;
+        h1 = h1 << 13 | h1 >>> 19;
+        h1 = h1 * 5 + 0xe6546b64;
+      } else {
+        k2 = dataUint32[i];
+        k2 = k2 * C1 & MASK_HIGH | k2 * C1_LOW & MASK_LOW;
+        k2 = k2 << 15 | k2 >>> 17;
+        k2 = k2 * C2 & MASK_HIGH | k2 * C2_LOW & MASK_LOW;
+        h2 ^= k2;
+        h2 = h2 << 13 | h2 >>> 19;
+        h2 = h2 * 5 + 0xe6546b64;
+      }
+    }
+    k1 = 0;
+    switch (tailLength) {
+      case 3:
+        k1 ^= data[blockCounts * 4 + 2] << 16;
+      /* falls through */
+      case 2:
+        k1 ^= data[blockCounts * 4 + 1] << 8;
+      /* falls through */
+      case 1:
+        k1 ^= data[blockCounts * 4];
+        /* falls through */
+
+        k1 = k1 * C1 & MASK_HIGH | k1 * C1_LOW & MASK_LOW;
+        k1 = k1 << 15 | k1 >>> 17;
+        k1 = k1 * C2 & MASK_HIGH | k1 * C2_LOW & MASK_LOW;
+        if (blockCounts & 1) {
+          h1 ^= k1;
+        } else {
+          h2 ^= k1;
+        }
+    }
+    this.h1 = h1;
+    this.h2 = h2;
+  }
+  hexdigest() {
+    let h1 = this.h1,
+      h2 = this.h2;
+    h1 ^= h2 >>> 1;
+    h1 = h1 * 0xed558ccd & MASK_HIGH | h1 * 0x8ccd & MASK_LOW;
+    h2 = h2 * 0xff51afd7 & MASK_HIGH | ((h2 << 16 | h1 >>> 16) * 0xafd7ed55 & MASK_HIGH) >>> 16;
+    h1 ^= h2 >>> 1;
+    h1 = h1 * 0x1a85ec53 & MASK_HIGH | h1 * 0xec53 & MASK_LOW;
+    h2 = h2 * 0xc4ceb9fe & MASK_HIGH | ((h2 << 16 | h1 >>> 16) * 0xb9fe1a85 & MASK_HIGH) >>> 16;
+    h1 ^= h2 >>> 1;
+    return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
+  }
+}
+
+/* Copyright 2022 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function convertToRGBA(params) {
+  switch (params.kind) {
+    case ImageKind.GRAYSCALE_1BPP:
+      return convertBlackAndWhiteToRGBA(params);
+    case ImageKind.RGB_24BPP:
+      return convertRGBToRGBA(params);
+  }
+  return null;
+}
+function convertBlackAndWhiteToRGBA({
+  src,
+  srcPos = 0,
+  dest,
+  width,
+  height,
+  nonBlackColor = 0xffffffff,
+  inverseDecode = false
+}) {
+  const black = FeatureTest.isLittleEndian ? 0xff000000 : 0x000000ff;
+  const [zeroMapping, oneMapping] = inverseDecode ? [nonBlackColor, black] : [black, nonBlackColor];
+  const widthInSource = width >> 3;
+  const widthRemainder = width & 7;
+  const srcLength = src.length;
+  dest = new Uint32Array(dest.buffer);
+  let destPos = 0;
+  for (let i = 0; i < height; i++) {
+    for (const max = srcPos + widthInSource; srcPos < max; srcPos++) {
+      const elem = srcPos < srcLength ? src[srcPos] : 255;
+      dest[destPos++] = elem & 0b10000000 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem & 0b1000000 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem & 0b100000 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem & 0b10000 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem & 0b1000 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem & 0b100 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem & 0b10 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem & 0b1 ? oneMapping : zeroMapping;
+    }
+    if (widthRemainder === 0) {
+      continue;
+    }
+    const elem = srcPos < srcLength ? src[srcPos++] : 255;
+    for (let j = 0; j < widthRemainder; j++) {
+      dest[destPos++] = elem & 1 << 7 - j ? oneMapping : zeroMapping;
+    }
+  }
+  return {
+    srcPos,
+    destPos
+  };
+}
+function convertRGBToRGBA({
+  src,
+  srcPos = 0,
+  dest,
+  destPos = 0,
+  width,
+  height
+}) {
+  let i = 0;
+  const len32 = src.length >> 2;
+  const src32 = new Uint32Array(src.buffer, srcPos, len32);
+  if (FeatureTest.isLittleEndian) {
+    // It's a way faster to do the shuffle manually instead of working
+    // component by component with some Uint8 arrays.
+    for (; i < len32 - 2; i += 3, destPos += 4) {
+      const s1 = src32[i]; // R2B1G1R1
+      const s2 = src32[i + 1]; // G3R3B2G2
+      const s3 = src32[i + 2]; // B4G4R4B3
+
+      dest[destPos] = s1 | 0xff000000;
+      dest[destPos + 1] = s1 >>> 24 | s2 << 8 | 0xff000000;
+      dest[destPos + 2] = s2 >>> 16 | s3 << 16 | 0xff000000;
+      dest[destPos + 3] = s3 >>> 8 | 0xff000000;
+    }
+    for (let j = i * 4, jj = src.length; j < jj; j += 3) {
+      dest[destPos++] = src[j] | src[j + 1] << 8 | src[j + 2] << 16 | 0xff000000;
+    }
+  } else {
+    for (; i < len32 - 2; i += 3, destPos += 4) {
+      const s1 = src32[i]; // R1G1B1R2
+      const s2 = src32[i + 1]; // G2B2R3G3
+      const s3 = src32[i + 2]; // B3R4G4B4
+
+      dest[destPos] = s1 | 0xff;
+      dest[destPos + 1] = s1 << 24 | s2 >>> 8 | 0xff;
+      dest[destPos + 2] = s2 << 16 | s3 >>> 16 | 0xff;
+      dest[destPos + 3] = s3 << 8 | 0xff;
+    }
+    for (let j = i * 4, jj = src.length; j < jj; j += 3) {
+      dest[destPos++] = src[j] << 24 | src[j + 1] << 16 | src[j + 2] << 8 | 0xff;
+    }
+  }
+  return {
+    srcPos,
+    destPos
+  };
+}
+function grayToRGBA(src, dest) {
+  if (FeatureTest.isLittleEndian) {
+    for (let i = 0, ii = src.length; i < ii; i++) {
+      dest[i] = src[i] * 0x10101 | 0xff000000;
+    }
+  } else {
+    for (let i = 0, ii = src.length; i < ii; i++) {
+      dest[i] = src[i] * 0x1010100 | 0x000000ff;
+    }
+  }
+}
 
 /* Copyright 2018 Mozilla Foundation
  *
@@ -14,13 +255,12 @@ import { c as assert, l as createPromiseCapability, t as UnknownErrorException,
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 const CallbackKind = {
-  UNKNOWN: 0,
   DATA: 1,
   ERROR: 2
 };
 const StreamKind = {
-  UNKNOWN: 0,
   CANCEL: 1,
   CANCEL_COMPLETE: 2,
   CLOSE: 3,
@@ -30,34 +270,25 @@ const StreamKind = {
   PULL_COMPLETE: 7,
   START_COMPLETE: 8
 };
-
 function wrapReason(reason) {
-  if (typeof PDFJSDev === "undefined" || PDFJSDev.test("!PRODUCTION || TESTING")) {
-    assert(reason instanceof Error || typeof reason === "object" && reason !== null, 'wrapReason: Expected "reason" to be a (possibly cloned) Error.');
-  } else {
-    if (typeof reason !== "object" || reason === null) {
-      return reason;
-    }
+  if (!(reason instanceof Error || typeof reason === "object" && reason !== null)) {
+    unreachable('wrapReason: Expected "reason" to be a (possibly cloned) Error.');
   }
-
   switch (reason.name) {
     case "AbortException":
       return new AbortException(reason.message);
-
     case "MissingPDFException":
       return new MissingPDFException(reason.message);
-
+    case "PasswordException":
+      return new PasswordException(reason.message, reason.code);
     case "UnexpectedResponseException":
       return new UnexpectedResponseException(reason.message, reason.status);
-
     case "UnknownErrorException":
       return new UnknownErrorException(reason.message, reason.details);
-
     default:
       return new UnknownErrorException(reason.message, reason.toString());
   }
 }
-
 class MessageHandler {
   constructor(sourceName, targetName, comObj) {
     this.sourceName = sourceName;
@@ -65,35 +296,26 @@ class MessageHandler {
     this.comObj = comObj;
     this.callbackId = 1;
     this.streamId = 1;
-    this.postMessageTransfers = true;
     this.streamSinks = Object.create(null);
     this.streamControllers = Object.create(null);
     this.callbackCapabilities = Object.create(null);
     this.actionHandler = Object.create(null);
-
     this._onComObjOnMessage = event => {
       const data = event.data;
-
       if (data.targetName !== this.sourceName) {
         return;
       }
-
       if (data.stream) {
-        this._processStreamMessage(data);
-
+        this.#processStreamMessage(data);
         return;
       }
-
       if (data.callback) {
         const callbackId = data.callbackId;
         const capability = this.callbackCapabilities[callbackId];
-
         if (!capability) {
           throw new Error(`Cannot resolve callback ${callbackId}`);
         }
-
         delete this.callbackCapabilities[callbackId];
-
         if (data.callback === CallbackKind.DATA) {
           capability.resolve(data.data);
         } else if (data.callback === CallbackKind.ERROR) {
@@ -101,16 +323,12 @@ class MessageHandler {
         } else {
           throw new Error("Unexpected callback case");
         }
-
         return;
       }
-
       const action = this.actionHandler[data.action];
-
       if (!action) {
         throw new Error(`Unknown action from worker: ${data.action}`);
       }
-
       if (data.callbackId) {
         const cbSourceName = this.sourceName;
         const cbTargetName = data.sourceName;
@@ -135,48 +353,40 @@ class MessageHandler {
         });
         return;
       }
-
       if (data.streamId) {
-        this._createStreamSink(data);
-
+        this.#createStreamSink(data);
         return;
       }
-
       action(data.data);
     };
-
     comObj.addEventListener("message", this._onComObjOnMessage);
   }
-
   on(actionName, handler) {
-    if (typeof PDFJSDev === "undefined" || PDFJSDev.test("!PRODUCTION || TESTING")) {
+    if (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) {
       assert(typeof handler === "function", 'MessageHandler.on: Expected "handler" to be a function.');
     }
-
     const ah = this.actionHandler;
-
     if (ah[actionName]) {
       throw new Error(`There is already an actionName called "${actionName}"`);
     }
-
     ah[actionName] = handler;
   }
+
   /**
    * Sends a message to the comObj to invoke the action with the supplied data.
    * @param {string} actionName - Action to call.
    * @param {JSON} data - JSON data to send.
    * @param {Array} [transfers] - List of transfers/ArrayBuffers.
    */
-
-
   send(actionName, data, transfers) {
-    this._postMessage({
+    this.comObj.postMessage({
       sourceName: this.sourceName,
       targetName: this.targetName,
       action: actionName,
       data
     }, transfers);
   }
+
   /**
    * Sends a message to the comObj to invoke the action with the supplied data.
    * Expects that the other side will callback with the response.
@@ -185,15 +395,12 @@ class MessageHandler {
    * @param {Array} [transfers] - List of transfers/ArrayBuffers.
    * @returns {Promise} Promise to be resolved with response data.
    */
-
-
   sendWithPromise(actionName, data, transfers) {
     const callbackId = this.callbackId++;
-    const capability = createPromiseCapability();
+    const capability = Promise.withResolvers();
     this.callbackCapabilities[callbackId] = capability;
-
     try {
-      this._postMessage({
+      this.comObj.postMessage({
         sourceName: this.sourceName,
         targetName: this.targetName,
         action: actionName,
@@ -203,9 +410,9 @@ class MessageHandler {
     } catch (ex) {
       capability.reject(ex);
     }
-
     return capability.promise;
   }
+
   /**
    * Sends a message to the comObj to invoke the action with the supplied data.
    * Expect that the other side will callback to signal 'start_complete'.
@@ -216,16 +423,14 @@ class MessageHandler {
    * @param {Array} [transfers] - List of transfers/ArrayBuffers.
    * @returns {ReadableStream} ReadableStream to read data in chunks.
    */
-
-
   sendWithStream(actionName, data, queueingStrategy, transfers) {
-    const streamId = this.streamId++;
-    const sourceName = this.sourceName;
-    const targetName = this.targetName;
-    const comObj = this.comObj;
+    const streamId = this.streamId++,
+      sourceName = this.sourceName,
+      targetName = this.targetName,
+      comObj = this.comObj;
     return new ReadableStream({
       start: controller => {
-        const startCapability = createPromiseCapability();
+        const startCapability = Promise.withResolvers();
         this.streamControllers[streamId] = {
           controller,
           startCall: startCapability,
@@ -233,21 +438,19 @@ class MessageHandler {
           cancelCall: null,
           isClosed: false
         };
-
-        this._postMessage({
+        comObj.postMessage({
           sourceName,
           targetName,
           action: actionName,
           streamId,
           data,
           desiredSize: controller.desiredSize
-        }, transfers); // Return Promise for Async process, to signal success/failure.
-
-
+        }, transfers);
+        // Return Promise for Async process, to signal success/failure.
         return startCapability.promise;
       },
       pull: controller => {
-        const pullCapability = createPromiseCapability();
+        const pullCapability = Promise.withResolvers();
         this.streamControllers[streamId].pullCall = pullCapability;
         comObj.postMessage({
           sourceName,
@@ -255,14 +458,14 @@ class MessageHandler {
           stream: StreamKind.PULL,
           streamId,
           desiredSize: controller.desiredSize
-        }); // Returning Promise will not call "pull"
+        });
+        // Returning Promise will not call "pull"
         // again until current pull is resolved.
-
         return pullCapability.promise;
       },
       cancel: reason => {
         assert(reason instanceof Error, "cancel must have a valid reason");
-        const cancelCapability = createPromiseCapability();
+        const cancelCapability = Promise.withResolvers();
         this.streamControllers[streamId].cancelCall = cancelCapability;
         this.streamControllers[streamId].isClosed = true;
         comObj.postMessage({
@@ -271,41 +474,34 @@ class MessageHandler {
           stream: StreamKind.CANCEL,
           streamId,
           reason: wrapReason(reason)
-        }); // Return Promise to signal success or failure.
-
+        });
+        // Return Promise to signal success or failure.
         return cancelCapability.promise;
       }
     }, queueingStrategy);
   }
-  /**
-   * @private
-   */
-
-
-  _createStreamSink(data) {
-    const self = this;
-    const action = this.actionHandler[data.action];
-    const streamId = data.streamId;
-    const sourceName = this.sourceName;
-    const targetName = data.sourceName;
-    const comObj = this.comObj;
+  #createStreamSink(data) {
+    const streamId = data.streamId,
+      sourceName = this.sourceName,
+      targetName = data.sourceName,
+      comObj = this.comObj;
+    const self = this,
+      action = this.actionHandler[data.action];
     const streamSink = {
       enqueue(chunk, size = 1, transfers) {
         if (this.isCancelled) {
           return;
         }
-
         const lastDesiredSize = this.desiredSize;
-        this.desiredSize -= size; // Enqueue decreases the desiredSize property of sink,
+        this.desiredSize -= size;
+        // Enqueue decreases the desiredSize property of sink,
         // so when it changes from positive to negative,
         // set ready as unresolved promise.
-
         if (lastDesiredSize > 0 && this.desiredSize <= 0) {
-          this.sinkCapability = createPromiseCapability();
+          this.sinkCapability = Promise.withResolvers();
           this.ready = this.sinkCapability.promise;
         }
-
-        self._postMessage({
+        comObj.postMessage({
           sourceName,
           targetName,
           stream: StreamKind.ENQUEUE,
@@ -313,12 +509,10 @@ class MessageHandler {
           chunk
         }, transfers);
       },
-
       close() {
         if (this.isCancelled) {
           return;
         }
-
         this.isCancelled = true;
         comObj.postMessage({
           sourceName,
@@ -328,14 +522,11 @@ class MessageHandler {
         });
         delete self.streamSinks[streamId];
       },
-
       error(reason) {
         assert(reason instanceof Error, "error must have a valid reason");
-
         if (this.isCancelled) {
           return;
         }
-
         this.isCancelled = true;
         comObj.postMessage({
           sourceName,
@@ -345,8 +536,7 @@ class MessageHandler {
           reason: wrapReason(reason)
         });
       },
-
-      sinkCapability: createPromiseCapability(),
+      sinkCapability: Promise.withResolvers(),
       onPull: null,
       onCancel: null,
       isCancelled: false,
@@ -376,39 +566,31 @@ class MessageHandler {
       });
     });
   }
-  /**
-   * @private
-   */
-
-
-  _processStreamMessage(data) {
-    const streamId = data.streamId;
-    const sourceName = this.sourceName;
-    const targetName = data.sourceName;
-    const comObj = this.comObj;
-
+  #processStreamMessage(data) {
+    const streamId = data.streamId,
+      sourceName = this.sourceName,
+      targetName = data.sourceName,
+      comObj = this.comObj;
+    const streamController = this.streamControllers[streamId],
+      streamSink = this.streamSinks[streamId];
     switch (data.stream) {
       case StreamKind.START_COMPLETE:
         if (data.success) {
-          this.streamControllers[streamId].startCall.resolve();
+          streamController.startCall.resolve();
         } else {
-          this.streamControllers[streamId].startCall.reject(wrapReason(data.reason));
+          streamController.startCall.reject(wrapReason(data.reason));
         }
-
         break;
-
       case StreamKind.PULL_COMPLETE:
         if (data.success) {
-          this.streamControllers[streamId].pullCall.resolve();
+          streamController.pullCall.resolve();
         } else {
-          this.streamControllers[streamId].pullCall.reject(wrapReason(data.reason));
+          streamController.pullCall.reject(wrapReason(data.reason));
         }
-
         break;
-
       case StreamKind.PULL:
         // Ignore any pull after close is called.
-        if (!this.streamSinks[streamId]) {
+        if (!streamSink) {
           comObj.postMessage({
             sourceName,
             targetName,
@@ -417,22 +599,17 @@ class MessageHandler {
             success: true
           });
           break;
-        } // Pull increases the desiredSize property of sink,
-        // so when it changes from negative to positive,
-        // set ready property as resolved promise.
-
-
-        if (this.streamSinks[streamId].desiredSize <= 0 && data.desiredSize > 0) {
-          this.streamSinks[streamId].sinkCapability.resolve();
-        } // Reset desiredSize property of sink on every pull.
-
-
-        this.streamSinks[streamId].desiredSize = data.desiredSize;
-        const {
-          onPull
-        } = this.streamSinks[data.streamId];
+        }
+        // Pull increases the desiredSize property of sink, so when it changes
+        // from negative to positive, set ready property as resolved promise.
+        if (streamSink.desiredSize <= 0 && data.desiredSize > 0) {
+          streamSink.sinkCapability.resolve();
+        }
+        // Reset desiredSize property of sink on every pull.
+        streamSink.desiredSize = data.desiredSize;
         new Promise(function (resolve) {
-          resolve(onPull && onPull());
+          var _streamSink$onPull;
+          resolve((_streamSink$onPull = streamSink.onPull) === null || _streamSink$onPull === void 0 ? void 0 : _streamSink$onPull.call(streamSink));
         }).then(function () {
           comObj.postMessage({
             sourceName,
@@ -451,60 +628,42 @@ class MessageHandler {
           });
         });
         break;
-
       case StreamKind.ENQUEUE:
-        assert(this.streamControllers[streamId], "enqueue should have stream controller");
-
-        if (this.streamControllers[streamId].isClosed) {
+        assert(streamController, "enqueue should have stream controller");
+        if (streamController.isClosed) {
           break;
         }
-
-        this.streamControllers[streamId].controller.enqueue(data.chunk);
+        streamController.controller.enqueue(data.chunk);
         break;
-
       case StreamKind.CLOSE:
-        assert(this.streamControllers[streamId], "close should have stream controller");
-
-        if (this.streamControllers[streamId].isClosed) {
+        assert(streamController, "close should have stream controller");
+        if (streamController.isClosed) {
           break;
         }
-
-        this.streamControllers[streamId].isClosed = true;
-        this.streamControllers[streamId].controller.close();
-
-        this._deleteStreamController(streamId);
-
+        streamController.isClosed = true;
+        streamController.controller.close();
+        this.#deleteStreamController(streamController, streamId);
         break;
-
       case StreamKind.ERROR:
-        assert(this.streamControllers[streamId], "error should have stream controller");
-        this.streamControllers[streamId].controller.error(wrapReason(data.reason));
-
-        this._deleteStreamController(streamId);
-
+        assert(streamController, "error should have stream controller");
+        streamController.controller.error(wrapReason(data.reason));
+        this.#deleteStreamController(streamController, streamId);
         break;
-
       case StreamKind.CANCEL_COMPLETE:
         if (data.success) {
-          this.streamControllers[streamId].cancelCall.resolve();
+          streamController.cancelCall.resolve();
         } else {
-          this.streamControllers[streamId].cancelCall.reject(wrapReason(data.reason));
+          streamController.cancelCall.reject(wrapReason(data.reason));
         }
-
-        this._deleteStreamController(streamId);
-
+        this.#deleteStreamController(streamController, streamId);
         break;
-
       case StreamKind.CANCEL:
-        if (!this.streamSinks[streamId]) {
+        if (!streamSink) {
           break;
         }
-
-        const {
-          onCancel
-        } = this.streamSinks[data.streamId];
         new Promise(function (resolve) {
-          resolve(onCancel && onCancel(wrapReason(data.reason)));
+          var _streamSink$onCancel;
+          resolve((_streamSink$onCancel = streamSink.onCancel) === null || _streamSink$onCancel === void 0 ? void 0 : _streamSink$onCancel.call(streamSink, wrapReason(data.reason)));
         }).then(function () {
           comObj.postMessage({
             sourceName,
@@ -522,48 +681,24 @@ class MessageHandler {
             reason: wrapReason(reason)
           });
         });
-        this.streamSinks[streamId].sinkCapability.reject(wrapReason(data.reason));
-        this.streamSinks[streamId].isCancelled = true;
+        streamSink.sinkCapability.reject(wrapReason(data.reason));
+        streamSink.isCancelled = true;
         delete this.streamSinks[streamId];
         break;
-
       default:
         throw new Error("Unexpected stream case");
     }
   }
-  /**
-   * @private
-   */
-
-
-  async _deleteStreamController(streamId) {
+  async #deleteStreamController(streamController, streamId) {
+    var _streamController$sta, _streamController$pul, _streamController$can;
     // Delete the `streamController` only when the start, pull, and cancel
     // capabilities have settled, to prevent `TypeError`s.
-    await Promise.allSettled([this.streamControllers[streamId].startCall, this.streamControllers[streamId].pullCall, this.streamControllers[streamId].cancelCall].map(function (capability) {
-      return capability && capability.promise;
-    }));
+    await Promise.allSettled([(_streamController$sta = streamController.startCall) === null || _streamController$sta === void 0 ? void 0 : _streamController$sta.promise, (_streamController$pul = streamController.pullCall) === null || _streamController$pul === void 0 ? void 0 : _streamController$pul.promise, (_streamController$can = streamController.cancelCall) === null || _streamController$can === void 0 ? void 0 : _streamController$can.promise]);
     delete this.streamControllers[streamId];
   }
-  /**
-   * Sends raw message to the comObj.
-   * @param {Object} message - Raw message.
-   * @param transfers List of transfers/ArrayBuffers, or undefined.
-   * @private
-   */
-
-
-  _postMessage(message, transfers) {
-    if (transfers && this.postMessageTransfers) {
-      this.comObj.postMessage(message, transfers);
-    } else {
-      this.comObj.postMessage(message);
-    }
-  }
-
   destroy() {
     this.comObj.removeEventListener("message", this._onComObjOnMessage);
   }
-
 }
 
-export { MessageHandler as M };
+export { MurmurHash3_64 as M, MessageHandler as a, convertToRGBA as b, convertBlackAndWhiteToRGBA as c, grayToRGBA as g };