@chialab/pdfjs-lib 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/node/chunk-ZKUTXCS2.js

@@ -0,0 +1,801 @@
+import {
+  AbortException,
+  FeatureTest,
+  ImageKind,
+  InvalidPDFException,
+  PasswordException,
+  ResponseException,
+  UnknownErrorException,
+  assert,
+  unreachable
+} from "./chunk-XMKSLA4K.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "./chunk-7MW5RQZ5.js";
+
+// src/lib/polyfills.ts
+if (!Array.prototype.at) {
+  Object.defineProperty(Array.prototype, "at", {
+    value: function at(index) {
+      return this[index >= 0 ? index : this.length + index];
+    },
+    enumerable: false
+  });
+}
+if (!Promise.withResolvers) {
+  Promise.withResolvers = function withResolvers() {
+    let resolve;
+    let reject;
+    const promise = new this((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return {
+      resolve,
+      reject,
+      promise
+    };
+  };
+}
+if (!("try" in Promise)) {
+  Object.defineProperty(Promise, "try", {
+    value: function tryFn(fn, ...args) {
+      return new this(
+        (resolve, reject) => {
+          try {
+            resolve(fn(...args));
+          } catch (error) {
+            reject(error);
+          }
+        }
+      );
+    },
+    enumerable: false
+  });
+}
+
+// src/pdf.js/src/shared/message_handler.js
+var CallbackKind = {
+  DATA: 1,
+  ERROR: 2
+};
+var StreamKind = {
+  CANCEL: 1,
+  CANCEL_COMPLETE: 2,
+  CLOSE: 3,
+  ENQUEUE: 4,
+  ERROR: 5,
+  PULL: 6,
+  PULL_COMPLETE: 7,
+  START_COMPLETE: 8
+};
+function onFn() {
+}
+function wrapReason(ex) {
+  if (ex instanceof AbortException || ex instanceof InvalidPDFException || ex instanceof PasswordException || ex instanceof ResponseException || ex instanceof UnknownErrorException) {
+    return ex;
+  }
+  if (!(ex instanceof Error || typeof ex === "object" && ex !== null)) {
+    unreachable(
+      'wrapReason: Expected "reason" to be a (possibly cloned) Error.'
+    );
+  }
+  switch (ex.name) {
+    case "AbortException":
+      return new AbortException(ex.message);
+    case "InvalidPDFException":
+      return new InvalidPDFException(ex.message);
+    case "PasswordException":
+      return new PasswordException(ex.message, ex.code);
+    case "ResponseException":
+      return new ResponseException(ex.message, ex.status, ex.missing);
+    case "UnknownErrorException":
+      return new UnknownErrorException(ex.message, ex.details);
+  }
+  return new UnknownErrorException(ex.message, ex.toString());
+}
+var _messageAC, _MessageHandler_instances, onMessage_fn, createStreamSink_fn, processStreamMessage_fn, deleteStreamController_fn;
+var MessageHandler = class {
+  constructor(sourceName, targetName, comObj) {
+    __privateAdd(this, _MessageHandler_instances);
+    __privateAdd(this, _messageAC, new AbortController());
+    this.sourceName = sourceName;
+    this.targetName = targetName;
+    this.comObj = comObj;
+    this.callbackId = 1;
+    this.streamId = 1;
+    this.streamSinks = /* @__PURE__ */ Object.create(null);
+    this.streamControllers = /* @__PURE__ */ Object.create(null);
+    this.callbackCapabilities = /* @__PURE__ */ Object.create(null);
+    this.actionHandler = /* @__PURE__ */ Object.create(null);
+    comObj.addEventListener("message", __privateMethod(this, _MessageHandler_instances, onMessage_fn).bind(this), {
+      signal: __privateGet(this, _messageAC).signal
+    });
+  }
+  on(actionName, handler) {
+    if (false) {
+      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.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.
+   * @param {string} actionName - Action to call.
+   * @param {JSON} data - JSON data to send.
+   * @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 = Promise.withResolvers();
+    this.callbackCapabilities[callbackId] = capability;
+    try {
+      this.comObj.postMessage(
+        {
+          sourceName: this.sourceName,
+          targetName: this.targetName,
+          action: actionName,
+          callbackId,
+          data
+        },
+        transfers
+      );
+    } 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'.
+   * @param {string} actionName - Action to call.
+   * @param {JSON} data - JSON data to send.
+   * @param {Object} queueingStrategy - Strategy to signal backpressure based on
+   *                 internal queue.
+   * @param {Array} [transfers] - List of transfers/ArrayBuffers.
+   * @returns {ReadableStream} ReadableStream to read data in chunks.
+   */
+  sendWithStream(actionName, data, queueingStrategy, transfers) {
+    const streamId = this.streamId++, sourceName = this.sourceName, targetName = this.targetName, comObj = this.comObj;
+    return new ReadableStream(
+      {
+        start: (controller) => {
+          const startCapability = Promise.withResolvers();
+          this.streamControllers[streamId] = {
+            controller,
+            startCall: startCapability,
+            pullCall: null,
+            cancelCall: null,
+            isClosed: false
+          };
+          comObj.postMessage(
+            {
+              sourceName,
+              targetName,
+              action: actionName,
+              streamId,
+              data,
+              desiredSize: controller.desiredSize
+            },
+            transfers
+          );
+          return startCapability.promise;
+        },
+        pull: (controller) => {
+          const pullCapability = Promise.withResolvers();
+          this.streamControllers[streamId].pullCall = pullCapability;
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.PULL,
+            streamId,
+            desiredSize: controller.desiredSize
+          });
+          return pullCapability.promise;
+        },
+        cancel: (reason) => {
+          assert(reason instanceof Error, "cancel must have a valid reason");
+          const cancelCapability = Promise.withResolvers();
+          this.streamControllers[streamId].cancelCall = cancelCapability;
+          this.streamControllers[streamId].isClosed = true;
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.CANCEL,
+            streamId,
+            reason: wrapReason(reason)
+          });
+          return cancelCapability.promise;
+        }
+      },
+      queueingStrategy
+    );
+  }
+  destroy() {
+    __privateGet(this, _messageAC)?.abort();
+    __privateSet(this, _messageAC, null);
+  }
+};
+_messageAC = new WeakMap();
+_MessageHandler_instances = new WeakSet();
+onMessage_fn = function({ data }) {
+  if (data.targetName !== this.sourceName) {
+    return;
+  }
+  if (data.stream) {
+    __privateMethod(this, _MessageHandler_instances, processStreamMessage_fn).call(this, 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) {
+      capability.reject(wrapReason(data.reason));
+    } 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 sourceName = this.sourceName, targetName = data.sourceName, comObj = this.comObj;
+    Promise.try(action, data.data).then(
+      function(result) {
+        comObj.postMessage({
+          sourceName,
+          targetName,
+          callback: CallbackKind.DATA,
+          callbackId: data.callbackId,
+          data: result
+        });
+      },
+      function(reason) {
+        comObj.postMessage({
+          sourceName,
+          targetName,
+          callback: CallbackKind.ERROR,
+          callbackId: data.callbackId,
+          reason: wrapReason(reason)
+        });
+      }
+    );
+    return;
+  }
+  if (data.streamId) {
+    __privateMethod(this, _MessageHandler_instances, createStreamSink_fn).call(this, data);
+    return;
+  }
+  action(data.data);
+};
+createStreamSink_fn = function(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;
+      if (lastDesiredSize > 0 && this.desiredSize <= 0) {
+        this.sinkCapability = Promise.withResolvers();
+        this.ready = this.sinkCapability.promise;
+      }
+      comObj.postMessage(
+        {
+          sourceName,
+          targetName,
+          stream: StreamKind.ENQUEUE,
+          streamId,
+          chunk
+        },
+        transfers
+      );
+    },
+    close() {
+      if (this.isCancelled) {
+        return;
+      }
+      this.isCancelled = true;
+      comObj.postMessage({
+        sourceName,
+        targetName,
+        stream: StreamKind.CLOSE,
+        streamId
+      });
+      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,
+        targetName,
+        stream: StreamKind.ERROR,
+        streamId,
+        reason: wrapReason(reason)
+      });
+    },
+    sinkCapability: Promise.withResolvers(),
+    onPull: null,
+    onCancel: null,
+    isCancelled: false,
+    desiredSize: data.desiredSize,
+    ready: null
+  };
+  streamSink.sinkCapability.resolve();
+  streamSink.ready = streamSink.sinkCapability.promise;
+  this.streamSinks[streamId] = streamSink;
+  Promise.try(action, data.data, streamSink).then(
+    function() {
+      comObj.postMessage({
+        sourceName,
+        targetName,
+        stream: StreamKind.START_COMPLETE,
+        streamId,
+        success: true
+      });
+    },
+    function(reason) {
+      comObj.postMessage({
+        sourceName,
+        targetName,
+        stream: StreamKind.START_COMPLETE,
+        streamId,
+        reason: wrapReason(reason)
+      });
+    }
+  );
+};
+processStreamMessage_fn = function(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) {
+        streamController.startCall.resolve();
+      } else {
+        streamController.startCall.reject(wrapReason(data.reason));
+      }
+      break;
+    case StreamKind.PULL_COMPLETE:
+      if (data.success) {
+        streamController.pullCall.resolve();
+      } else {
+        streamController.pullCall.reject(wrapReason(data.reason));
+      }
+      break;
+    case StreamKind.PULL:
+      if (!streamSink) {
+        comObj.postMessage({
+          sourceName,
+          targetName,
+          stream: StreamKind.PULL_COMPLETE,
+          streamId,
+          success: true
+        });
+        break;
+      }
+      if (streamSink.desiredSize <= 0 && data.desiredSize > 0) {
+        streamSink.sinkCapability.resolve();
+      }
+      streamSink.desiredSize = data.desiredSize;
+      Promise.try(streamSink.onPull || onFn).then(
+        function() {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.PULL_COMPLETE,
+            streamId,
+            success: true
+          });
+        },
+        function(reason) {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.PULL_COMPLETE,
+            streamId,
+            reason: wrapReason(reason)
+          });
+        }
+      );
+      break;
+    case StreamKind.ENQUEUE:
+      assert(streamController, "enqueue should have stream controller");
+      if (streamController.isClosed) {
+        break;
+      }
+      streamController.controller.enqueue(data.chunk);
+      break;
+    case StreamKind.CLOSE:
+      assert(streamController, "close should have stream controller");
+      if (streamController.isClosed) {
+        break;
+      }
+      streamController.isClosed = true;
+      streamController.controller.close();
+      __privateMethod(this, _MessageHandler_instances, deleteStreamController_fn).call(this, streamController, streamId);
+      break;
+    case StreamKind.ERROR:
+      assert(streamController, "error should have stream controller");
+      streamController.controller.error(wrapReason(data.reason));
+      __privateMethod(this, _MessageHandler_instances, deleteStreamController_fn).call(this, streamController, streamId);
+      break;
+    case StreamKind.CANCEL_COMPLETE:
+      if (data.success) {
+        streamController.cancelCall.resolve();
+      } else {
+        streamController.cancelCall.reject(wrapReason(data.reason));
+      }
+      __privateMethod(this, _MessageHandler_instances, deleteStreamController_fn).call(this, streamController, streamId);
+      break;
+    case StreamKind.CANCEL:
+      if (!streamSink) {
+        break;
+      }
+      const dataReason = wrapReason(data.reason);
+      Promise.try(streamSink.onCancel || onFn, dataReason).then(
+        function() {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.CANCEL_COMPLETE,
+            streamId,
+            success: true
+          });
+        },
+        function(reason) {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.CANCEL_COMPLETE,
+            streamId,
+            reason: wrapReason(reason)
+          });
+        }
+      );
+      streamSink.sinkCapability.reject(dataReason);
+      streamSink.isCancelled = true;
+      delete this.streamSinks[streamId];
+      break;
+    default:
+      throw new Error("Unexpected stream case");
+  }
+};
+deleteStreamController_fn = async function(streamController, streamId) {
+  await Promise.allSettled([
+    streamController.startCall?.promise,
+    streamController.pullCall?.promise,
+    streamController.cancelCall?.promise
+  ]);
+  delete this.streamControllers[streamId];
+};
+
+// src/pdf.js/src/shared/scripting_utils.js
+function makeColorComp(n) {
+  return Math.floor(Math.max(0, Math.min(1, n)) * 255).toString(16).padStart(2, "0");
+}
+function scaleAndClamp(x) {
+  return Math.max(0, Math.min(255, 255 * x));
+}
+var ColorConverters = class {
+  static CMYK_G([c, y, m, k]) {
+    return ["G", 1 - Math.min(1, 0.3 * c + 0.59 * m + 0.11 * y + k)];
+  }
+  static G_CMYK([g]) {
+    return ["CMYK", 0, 0, 0, 1 - g];
+  }
+  static G_RGB([g]) {
+    return ["RGB", g, g, g];
+  }
+  static G_rgb([g]) {
+    g = scaleAndClamp(g);
+    return [g, g, g];
+  }
+  static G_HTML([g]) {
+    const G = makeColorComp(g);
+    return `#${G}${G}${G}`;
+  }
+  static RGB_G([r, g, b]) {
+    return ["G", 0.3 * r + 0.59 * g + 0.11 * b];
+  }
+  static RGB_rgb(color) {
+    return color.map(scaleAndClamp);
+  }
+  static RGB_HTML(color) {
+    return `#${color.map(makeColorComp).join("")}`;
+  }
+  static T_HTML() {
+    return "#00000000";
+  }
+  static T_rgb() {
+    return [null];
+  }
+  static CMYK_RGB([c, y, m, k]) {
+    return [
+      "RGB",
+      1 - Math.min(1, c + k),
+      1 - Math.min(1, m + k),
+      1 - Math.min(1, y + k)
+    ];
+  }
+  static CMYK_rgb([c, y, m, k]) {
+    return [
+      scaleAndClamp(1 - Math.min(1, c + k)),
+      scaleAndClamp(1 - Math.min(1, m + k)),
+      scaleAndClamp(1 - Math.min(1, y + k))
+    ];
+  }
+  static CMYK_HTML(components) {
+    const rgb = this.CMYK_RGB(components).slice(1);
+    return this.RGB_HTML(rgb);
+  }
+  static RGB_CMYK([r, g, b]) {
+    const c = 1 - r;
+    const m = 1 - g;
+    const y = 1 - b;
+    const k = Math.min(c, m, y);
+    return ["CMYK", c, m, y, k];
+  }
+};
+var DateFormats = [
+  "m/d",
+  "m/d/yy",
+  "mm/dd/yy",
+  "mm/yy",
+  "d-mmm",
+  "d-mmm-yy",
+  "dd-mmm-yy",
+  "yy-mm-dd",
+  "mmm-yy",
+  "mmmm-yy",
+  "mmm d, yyyy",
+  "mmmm d, yyyy",
+  "m/d/yy h:MM tt",
+  "m/d/yy HH:MM"
+];
+var TimeFormats = ["HH:MM", "h:MM tt", "HH:MM:ss", "h:MM:ss tt"];
+
+// src/pdf.js/src/shared/murmurhash3.js
+var SEED = 3285377520;
+var MASK_HIGH = 4294901760;
+var MASK_LOW = 65535;
+var MurmurHash3_64 = class {
+  constructor(seed) {
+    this.h1 = seed ? seed & 4294967295 : SEED;
+    this.h2 = seed ? seed & 4294967295 : 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 <= 255) {
+          data[length++] = code;
+        } else {
+          data[length++] = code >>> 8;
+          data[length++] = code & 255;
+        }
+      }
+    } 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;
+    const dataUint32 = new Uint32Array(data.buffer, 0, blockCounts);
+    let k1 = 0, k2 = 0;
+    let h1 = this.h1, h2 = this.h2;
+    const C1 = 3432918353, C2 = 461845907;
+    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 + 3864292196;
+      } 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 + 3864292196;
+      }
+    }
+    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];
+        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 * 3981806797 & MASK_HIGH | h1 * 36045 & MASK_LOW;
+    h2 = h2 * 4283543511 & MASK_HIGH | ((h2 << 16 | h1 >>> 16) * 2950163797 & MASK_HIGH) >>> 16;
+    h1 ^= h2 >>> 1;
+    h1 = h1 * 444984403 & MASK_HIGH | h1 * 60499 & MASK_LOW;
+    h2 = h2 * 3301882366 & MASK_HIGH | ((h2 << 16 | h1 >>> 16) * 3120437893 & MASK_HIGH) >>> 16;
+    h1 ^= h2 >>> 1;
+    return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
+  }
+};
+
+// src/pdf.js/src/shared/image_utils.js
+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 = 4294967295,
+  inverseDecode = false
+}) {
+  const black = FeatureTest.isLittleEndian ? 4278190080 : 255;
+  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 elem2 = srcPos < srcLength ? src[srcPos] : 255;
+      dest[destPos++] = elem2 & 128 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem2 & 64 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem2 & 32 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem2 & 16 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem2 & 8 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem2 & 4 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem2 & 2 ? oneMapping : zeroMapping;
+      dest[destPos++] = elem2 & 1 ? 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 len = width * height * 3;
+  const len32 = len >> 2;
+  const src32 = new Uint32Array(src.buffer, srcPos, len32);
+  if (FeatureTest.isLittleEndian) {
+    for (; i < len32 - 2; i += 3, destPos += 4) {
+      const s1 = src32[i];
+      const s2 = src32[i + 1];
+      const s3 = src32[i + 2];
+      dest[destPos] = s1 | 4278190080;
+      dest[destPos + 1] = s1 >>> 24 | s2 << 8 | 4278190080;
+      dest[destPos + 2] = s2 >>> 16 | s3 << 16 | 4278190080;
+      dest[destPos + 3] = s3 >>> 8 | 4278190080;
+    }
+    for (let j = i * 4, jj = srcPos + len; j < jj; j += 3) {
+      dest[destPos++] = src[j] | src[j + 1] << 8 | src[j + 2] << 16 | 4278190080;
+    }
+  } else {
+    for (; i < len32 - 2; i += 3, destPos += 4) {
+      const s1 = src32[i];
+      const s2 = src32[i + 1];
+      const s3 = src32[i + 2];
+      dest[destPos] = s1 | 255;
+      dest[destPos + 1] = s1 << 24 | s2 >>> 8 | 255;
+      dest[destPos + 2] = s2 << 16 | s3 >>> 16 | 255;
+      dest[destPos + 3] = s3 << 8 | 255;
+    }
+    for (let j = i * 4, jj = srcPos + len; j < jj; j += 3) {
+      dest[destPos++] = src[j] << 24 | src[j + 1] << 16 | src[j + 2] << 8 | 255;
+    }
+  }
+  return { srcPos: srcPos + len, destPos };
+}
+function grayToRGBA(src, dest) {
+  if (FeatureTest.isLittleEndian) {
+    for (let i = 0, ii = src.length; i < ii; i++) {
+      dest[i] = src[i] * 65793 | 4278190080;
+    }
+  } else {
+    for (let i = 0, ii = src.length; i < ii; i++) {
+      dest[i] = src[i] * 16843008 | 255;
+    }
+  }
+}
+
+export {
+  MurmurHash3_64,
+  wrapReason,
+  MessageHandler,
+  convertToRGBA,
+  convertBlackAndWhiteToRGBA,
+  grayToRGBA,
+  ColorConverters,
+  DateFormats,
+  TimeFormats
+};