@loaders.gl/worker-utils 4.0.0-alpha.4 → 4.0.0-alpha.5

package/dist/null-worker.js

@@ -1,576 +1,215 @@
-/******/ (function(modules) { // webpackBootstrap
-/******/ 	// The module cache
-/******/ 	var installedModules = {};
-/******/
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-/******/
-/******/ 		// Check if module is in cache
-/******/ 		if(installedModules[moduleId]) {
-/******/ 			return installedModules[moduleId].exports;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = installedModules[moduleId] = {
-/******/ 			i: moduleId,
-/******/ 			l: false,
-/******/ 			exports: {}
-/******/ 		};
-/******/
-/******/ 		// Execute the module function
-/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-/******/
-/******/ 		// Flag the module as loaded
-/******/ 		module.l = true;
-/******/
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-/******/
-/******/
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__webpack_require__.m = modules;
-/******/
-/******/ 	// expose the module cache
-/******/ 	__webpack_require__.c = installedModules;
-/******/
-/******/ 	// define getter function for harmony exports
-/******/ 	__webpack_require__.d = function(exports, name, getter) {
-/******/ 		if(!__webpack_require__.o(exports, name)) {
-/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
-/******/ 		}
-/******/ 	};
-/******/
-/******/ 	// define __esModule on exports
-/******/ 	__webpack_require__.r = function(exports) {
-/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 		}
-/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 	};
-/******/
-/******/ 	// create a fake namespace object
-/******/ 	// mode & 1: value is a module id, require it
-/******/ 	// mode & 2: merge all properties of value into the ns
-/******/ 	// mode & 4: return value when already ns object
-/******/ 	// mode & 8|1: behave like require
-/******/ 	__webpack_require__.t = function(value, mode) {
-/******/ 		if(mode & 1) value = __webpack_require__(value);
-/******/ 		if(mode & 8) return value;
-/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
-/******/ 		var ns = Object.create(null);
-/******/ 		__webpack_require__.r(ns);
-/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
-/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
-/******/ 		return ns;
-/******/ 	};
-/******/
-/******/ 	// getDefaultExport function for compatibility with non-harmony modules
-/******/ 	__webpack_require__.n = function(module) {
-/******/ 		var getter = module && module.__esModule ?
-/******/ 			function getDefault() { return module['default']; } :
-/******/ 			function getModuleExports() { return module; };
-/******/ 		__webpack_require__.d(getter, 'a', getter);
-/******/ 		return getter;
-/******/ 	};
-/******/
-/******/ 	// Object.prototype.hasOwnProperty.call
-/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
-/******/
-/******/ 	// __webpack_public_path__
-/******/ 	__webpack_require__.p = "";
-/******/
-/******/
-/******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = "./src/workers/null-worker.ts");
-/******/ })
-/************************************************************************/
-/******/ ({
-
-/***/ "../../node_modules/@babel/runtime/helpers/defineProperty.js":
-/*!**************************************************************************************************!*\
-  !*** /home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/defineProperty.js ***!
-  \**************************************************************************************************/
-/*! no static exports found */
-/***/ (function(module, exports) {
-
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
-module.exports = _defineProperty;
-module.exports["default"] = module.exports, module.exports.__esModule = true;
-
-/***/ }),
-
-/***/ "./src/lib/async-queue/async-queue.ts":
-/*!********************************************!*\
-  !*** ./src/lib/async-queue/async-queue.ts ***!
-  \********************************************/
-/*! exports provided: default */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return AsyncQueue; });
-/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
-/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__);
-
-
-let _Symbol$asyncIterator;
-
-_Symbol$asyncIterator = Symbol.asyncIterator;
-// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license
-// http://2ality.com/2016/10/asynchronous-iteration.html
-
-/**
- * Async Queue
- * - AsyncIterable: An async iterator can be
- * - Values can be pushed onto the queue
- * @example
- *   const asyncQueue = new AsyncQueue();
- *   setTimeout(() => asyncQueue.enqueue('tick'), 1000);
- *   setTimeout(() => asyncQueue.enqueue(new Error('done')), 10000);
- *   for await (const value of asyncQueue) {
- *     console.log(value); // tick
- *   }
- */
-class AsyncQueue {
-  constructor() {
-    _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(this, "_values", void 0);
-
-    _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(this, "_settlers", void 0);
-
-    _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(this, "_closed", void 0);
-
-    this._values = []; // enqueues > dequeues
-
-    this._settlers = []; // dequeues > enqueues
-
-    this._closed = false;
-  }
-  /** Return an async iterator for this queue */
-
-
-  [_Symbol$asyncIterator]() {
-    return this;
-  }
-  /** Push a new value - the async iterator will yield a promise resolved to this value */
-
-
-  push(value) {
-    return this.enqueue(value);
-  }
-  /**
-   * Push a new value - the async iterator will yield a promise resolved to this value
-   * Add an error - the async iterator will yield a promise rejected with this value
-   */
-
-
-  enqueue(value) {
-    if (this._closed) {
-      throw new Error('Closed');
+(() => {
+  // src/lib/async-queue/async-queue.ts
+  var AsyncQueue = class {
+    constructor() {
+      this._values = [];
+      this._settlers = [];
+      this._closed = false;
     }
-
-    if (this._settlers.length > 0) {
-      if (this._values.length > 0) {
-        throw new Error('Illegal internal state');
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+    push(value) {
+      return this.enqueue(value);
+    }
+    enqueue(value) {
+      if (this._closed) {
+        throw new Error("Closed");
       }
-
-      const settler = this._settlers.shift();
-
-      if (value instanceof Error) {
-        settler.reject(value);
+      if (this._settlers.length > 0) {
+        if (this._values.length > 0) {
+          throw new Error("Illegal internal state");
+        }
+        const settler = this._settlers.shift();
+        if (value instanceof Error) {
+          settler.reject(value);
+        } else {
+          settler.resolve({ value });
+        }
       } else {
-        settler.resolve({
-          value
-        });
+        this._values.push(value);
       }
-    } else {
-      this._values.push(value);
-    }
-  }
-  /** Indicate that we not waiting for more values - The async iterator will be done */
-
-
-  close() {
-    while (this._settlers.length > 0) {
-      const settler = this._settlers.shift();
-
-      settler.resolve({
-        done: true
-      });
     }
-
-    this._closed = true;
-  } // ITERATOR IMPLEMENTATION
-
-  /** @returns a Promise for an IteratorResult */
-
-
-  next() {
-    // If values in queue, yield the first value
-    if (this._values.length > 0) {
-      const value = this._values.shift();
-
-      if (value instanceof Error) {
-        return Promise.reject(value);
+    close() {
+      while (this._settlers.length > 0) {
+        const settler = this._settlers.shift();
+        settler.resolve({ done: true });
       }
-
-      return Promise.resolve({
-        done: false,
-        value
-      });
-    } // If queue is closed, the iterator is done
-
-
-    if (this._closed) {
-      if (this._settlers.length > 0) {
-        throw new Error('Illegal internal state');
+      this._closed = true;
+    }
+    next() {
+      if (this._values.length > 0) {
+        const value = this._values.shift();
+        if (value instanceof Error) {
+          return Promise.reject(value);
+        }
+        return Promise.resolve({ done: false, value });
       }
-
-      return Promise.resolve({
-        done: true,
-        value: undefined
-      });
-    } // Yield a promise that waits for new values to be enqueued
-
-
-    return new Promise((resolve, reject) => {
-      this._settlers.push({
-        resolve,
-        reject
-      });
-    });
-  }
-
-}
-
-/***/ }),
-
-/***/ "./src/lib/worker-api/create-worker.ts":
-/*!*********************************************!*\
-  !*** ./src/lib/worker-api/create-worker.ts ***!
-  \*********************************************/
-/*! exports provided: createWorker */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createWorker", function() { return createWorker; });
-/* harmony import */ var _async_queue_async_queue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../async-queue/async-queue */ "./src/lib/async-queue/async-queue.ts");
-/* harmony import */ var _worker_farm_worker_body__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../worker-farm/worker-body */ "./src/lib/worker-farm/worker-body.ts");
-
- // import {validateWorkerVersion} from './validate-worker-version';
-
-/** Counter for jobs */
-
-let requestId = 0;
-let inputBatches;
-let options;
-
-/**
- * Set up a WebWorkerGlobalScope to talk with the main thread
- */
-function createWorker(process, processInBatches) {
-  // Check that we are actually in a worker thread
-  if (typeof self === 'undefined') {
-    return;
-  }
-
-  const context = {
-    process: processOnMainThread
-  }; // eslint-disable-next-line complexity
-
-  _worker_farm_worker_body__WEBPACK_IMPORTED_MODULE_1__["default"].onmessage = async (type, payload) => {
-    try {
-      switch (type) {
-        case 'process':
-          if (!process) {
-            throw new Error('Worker does not support atomic processing');
-          }
-
-          const result = await process(payload.input, payload.options || {}, context);
-          _worker_farm_worker_body__WEBPACK_IMPORTED_MODULE_1__["default"].postMessage('done', {
-            result
-          });
-          break;
-
-        case 'process-in-batches':
-          if (!processInBatches) {
-            throw new Error('Worker does not support batched processing');
-          }
-
-          inputBatches = new _async_queue_async_queue__WEBPACK_IMPORTED_MODULE_0__["default"]();
-          options = payload.options || {};
-          const resultIterator = processInBatches(inputBatches, options, context);
-
-          for await (const batch of resultIterator) {
-            _worker_farm_worker_body__WEBPACK_IMPORTED_MODULE_1__["default"].postMessage('output-batch', {
-              result: batch
-            });
-          }
-
-          _worker_farm_worker_body__WEBPACK_IMPORTED_MODULE_1__["default"].postMessage('done', {});
-          break;
-
-        case 'input-batch':
-          inputBatches.push(payload.input);
-          break;
-
-        case 'input-done':
-          inputBatches.close();
-          break;
-
-        default:
+      if (this._closed) {
+        if (this._settlers.length > 0) {
+          throw new Error("Illegal internal state");
+        }
+        return Promise.resolve({ done: true, value: void 0 });
       }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : '';
-      _worker_farm_worker_body__WEBPACK_IMPORTED_MODULE_1__["default"].postMessage('error', {
-        error: message
+      return new Promise((resolve, reject) => {
+        this._settlers.push({ resolve, reject });
       });
     }
   };
-}
-
-function processOnMainThread(arrayBuffer, options = {}) {
-  return new Promise((resolve, reject) => {
-    const id = requestId++;
-    /**
-     */
-
-    const onMessage = (type, payload) => {
-      if (payload.id !== id) {
-        // not ours
-        return;
-      }
-
-      switch (type) {
-        case 'done':
-          _worker_farm_worker_body__WEBPACK_IMPORTED_MODULE_1__["default"].removeEventListener(onMessage);
-          resolve(payload.result);
-          break;
-
-        case 'error':
-          _worker_farm_worker_body__WEBPACK_IMPORTED_MODULE_1__["default"].removeEventListener(onMessage);
-          reject(payload.error);
-          break;
-
-        default: // ignore
 
+  // src/lib/worker-utils/get-transfer-list.ts
+  function getTransferList(object, recursive = true, transfers) {
+    const transfersSet = transfers || new Set();
+    if (!object) {
+    } else if (isTransferable(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList(object[key], recursive, transfersSet);
       }
-    };
-
-    _worker_farm_worker_body__WEBPACK_IMPORTED_MODULE_1__["default"].addEventListener(onMessage); // Ask the main thread to decode data
-
-    const payload = {
-      id,
-      input: arrayBuffer,
-      options
-    };
-    _worker_farm_worker_body__WEBPACK_IMPORTED_MODULE_1__["default"].postMessage('process', payload);
-  });
-}
-
-/***/ }),
-
-/***/ "./src/lib/worker-farm/worker-body.ts":
-/*!********************************************!*\
-  !*** ./src/lib/worker-farm/worker-body.ts ***!
-  \********************************************/
-/*! exports provided: default */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return WorkerBody; });
-/* harmony import */ var _worker_utils_get_transfer_list__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../worker-utils/get-transfer-list */ "./src/lib/worker-utils/get-transfer-list.ts");
-
-const onMessageWrapperMap = new Map();
-/**
- * Type safe wrapper for worker code
- */
-
-class WorkerBody {
-  /*
-   * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
-   */
-  static set onmessage(onMessage) {
-    // eslint-disable-next-line no-restricted-globals
-    self.onmessage = message => {
-      if (!isKnownMessage(message)) {
-        return;
-      } // Confusingly the message itself also has a 'type' field which is always set to 'message'
-
-
-      const {
-        type,
-        payload
-      } = message.data;
-      onMessage(type, payload);
-    };
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
+  }
+  function isTransferable(object) {
+    if (!object) {
+      return false;
+    }
+    if (object instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
+    }
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
+    }
+    return false;
   }
 
-  static addEventListener(onMessage) {
-    let onMessageWrapper = onMessageWrapperMap.get(onMessage);
-
-    if (!onMessageWrapper) {
-      onMessageWrapper = message => {
+  // src/lib/worker-farm/worker-body.ts
+  var onMessageWrapperMap = new Map();
+  var WorkerBody = class {
+    static set onmessage(onMessage) {
+      self.onmessage = (message) => {
         if (!isKnownMessage(message)) {
           return;
-        } // Confusingly the message itself also has a 'type' field which is always set to 'message'
-
-
-        const {
-          type,
-          payload
-        } = message.data;
+        }
+        const { type, payload } = message.data;
         onMessage(type, payload);
       };
-    } // eslint-disable-next-line no-restricted-globals
-
-
-    self.addEventListener('message', onMessageWrapper);
-  }
-
-  static removeEventListener(onMessage) {
-    const onMessageWrapper = onMessageWrapperMap.get(onMessage);
-    onMessageWrapperMap.delete(onMessage); // eslint-disable-next-line no-restricted-globals
-
-    self.removeEventListener('message', onMessageWrapper);
-  }
-  /**
-   * Send a message from a worker to creating thread (main thread)
-   * @param type
-   * @param payload
-   */
-
-
-  static postMessage(type, payload) {
-    if (self) {
-      const data = {
-        source: 'loaders.gl',
-        type,
-        payload
-      };
-      const transferList = Object(_worker_utils_get_transfer_list__WEBPACK_IMPORTED_MODULE_0__["getTransferList"])(payload); // eslint-disable-next-line no-restricted-globals
-      // @ts-ignore
-
-      self.postMessage(data, transferList);
     }
-  }
-
-} // Filter out noise messages sent to workers
-
-function isKnownMessage(message) {
-  const {
-    type,
-    data
-  } = message;
-  return type === 'message' && data && typeof data.source === 'string' && data.source.startsWith('loaders.gl');
-}
-
-/***/ }),
-
-/***/ "./src/lib/worker-utils/get-transfer-list.ts":
-/*!***************************************************!*\
-  !*** ./src/lib/worker-utils/get-transfer-list.ts ***!
-  \***************************************************/
-/*! exports provided: getTransferList */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getTransferList", function() { return getTransferList; });
-// NOTE - there is a copy of this function is both in core and loader-utils
-// core does not need all the utils in loader-utils, just this one.
-
-/**
- * Returns an array of Transferrable objects that can be used with postMessage
- * https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage
- * @param object data to be sent via postMessage
- * @param recursive - not for application use
- * @param transfers - not for application use
- * @returns a transfer list that can be passed to postMessage
- */
-function getTransferList(object, recursive = true, transfers) {
-  // Make sure that items in the transfer list is unique
-  const transfersSet = transfers || new Set();
-
-  if (!object) {// ignore
-  } else if (isTransferable(object)) {
-    transfersSet.add(object);
-  } else if (isTransferable(object.buffer)) {
-    // Typed array
-    transfersSet.add(object.buffer);
-  } else if (ArrayBuffer.isView(object)) {// object is a TypeArray viewing into a SharedArrayBuffer (not transferable)
-    // Do not iterate through the content in this case
-  } else if (recursive && typeof object === 'object') {
-    for (const key in object) {
-      // Avoid perf hit - only go one level deep
-      getTransferList(object[key], recursive, transfersSet);
+    static addEventListener(onMessage) {
+      let onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      if (!onMessageWrapper) {
+        onMessageWrapper = (message) => {
+          if (!isKnownMessage(message)) {
+            return;
+          }
+          const { type, payload } = message.data;
+          onMessage(type, payload);
+        };
+      }
+      self.addEventListener("message", onMessageWrapper);
     }
-  } // If transfers is defined, is internal recursive call
-  // Otherwise it's called by the user
-
-
-  return transfers === undefined ? Array.from(transfersSet) : [];
-} // https://developer.mozilla.org/en-US/docs/Web/API/Transferable
-
-function isTransferable(object) {
-  if (!object) {
-    return false;
-  }
-
-  if (object instanceof ArrayBuffer) {
-    return true;
+    static removeEventListener(onMessage) {
+      const onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      onMessageWrapperMap.delete(onMessage);
+      self.removeEventListener("message", onMessageWrapper);
+    }
+    static postMessage(type, payload) {
+      if (self) {
+        const data = { source: "loaders.gl", type, payload };
+        const transferList = getTransferList(payload);
+        self.postMessage(data, transferList);
+      }
+    }
+  };
+  function isKnownMessage(message) {
+    const { type, data } = message;
+    return type === "message" && data && typeof data.source === "string" && data.source.startsWith("loaders.gl");
   }
 
-  if (typeof MessagePort !== 'undefined' && object instanceof MessagePort) {
-    return true;
+  // src/lib/worker-api/create-worker.ts
+  var requestId = 0;
+  var inputBatches;
+  var options;
+  function createWorker(process, processInBatches) {
+    if (typeof self === "undefined") {
+      return;
+    }
+    const context = {
+      process: processOnMainThread
+    };
+    WorkerBody.onmessage = async (type, payload) => {
+      try {
+        switch (type) {
+          case "process":
+            if (!process) {
+              throw new Error("Worker does not support atomic processing");
+            }
+            const result = await process(payload.input, payload.options || {}, context);
+            WorkerBody.postMessage("done", { result });
+            break;
+          case "process-in-batches":
+            if (!processInBatches) {
+              throw new Error("Worker does not support batched processing");
+            }
+            inputBatches = new AsyncQueue();
+            options = payload.options || {};
+            const resultIterator = processInBatches(inputBatches, options, context);
+            for await (const batch of resultIterator) {
+              WorkerBody.postMessage("output-batch", { result: batch });
+            }
+            WorkerBody.postMessage("done", {});
+            break;
+          case "input-batch":
+            inputBatches.push(payload.input);
+            break;
+          case "input-done":
+            inputBatches.close();
+            break;
+          default:
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "";
+        WorkerBody.postMessage("error", { error: message });
+      }
+    };
   }
-
-  if (typeof ImageBitmap !== 'undefined' && object instanceof ImageBitmap) {
-    return true;
-  } // @ts-ignore
-
-
-  if (typeof OffscreenCanvas !== 'undefined' && object instanceof OffscreenCanvas) {
-    return true;
+  function processOnMainThread(arrayBuffer, options2 = {}) {
+    return new Promise((resolve, reject) => {
+      const id = requestId++;
+      const onMessage = (type, payload2) => {
+        if (payload2.id !== id) {
+          return;
+        }
+        switch (type) {
+          case "done":
+            WorkerBody.removeEventListener(onMessage);
+            resolve(payload2.result);
+            break;
+          case "error":
+            WorkerBody.removeEventListener(onMessage);
+            reject(payload2.error);
+            break;
+          default:
+        }
+      };
+      WorkerBody.addEventListener(onMessage);
+      const payload = { id, input: arrayBuffer, options: options2 };
+      WorkerBody.postMessage("process", payload);
+    });
   }
 
-  return false;
-}
-
-/***/ }),
-
-/***/ "./src/workers/null-worker.ts":
-/*!************************************!*\
-  !*** ./src/workers/null-worker.ts ***!
-  \************************************/
-/*! no exports provided */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony import */ var _lib_worker_api_create_worker__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../lib/worker-api/create-worker */ "./src/lib/worker-api/create-worker.ts");
-
-Object(_lib_worker_api_create_worker__WEBPACK_IMPORTED_MODULE_0__["createWorker"])(async data => {
-  // @ts-ignore
-  return data;
-});
-
-/***/ })
-
-/******/ });
-//# sourceMappingURL=null-worker.js.map
+  // src/workers/null-worker.ts
+  createWorker(async (data) => {
+    return data;
+  });
+})();
+//# sourceMappingURL=null-worker.js.map