@loaders.gl/worker-utils 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/lib/worker-farm/worker-pool.js

@@ -1,125 +1,167 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { isMobile, isBrowser } from "../env-utils/globals.js";
 import WorkerThread from "./worker-thread.js";
 import WorkerJob from "./worker-job.js";
+/**
+ * Process multiple data messages with small pool of identical workers
+ */
 export default class WorkerPool {
-  static isSupported() {
-    return WorkerThread.isSupported();
-  }
-  constructor(props) {
-    this.name = 'unnamed';
-    this.source = void 0;
-    this.url = void 0;
-    this.maxConcurrency = 1;
-    this.maxMobileConcurrency = 1;
-    this.onDebug = () => {};
-    this.reuseWorkers = true;
-    this.props = {};
-    this.jobQueue = [];
-    this.idleQueue = [];
-    this.count = 0;
-    this.isDestroyed = false;
-    this.source = props.source;
-    this.url = props.url;
-    this.setProps(props);
-  }
-  destroy() {
-    this.idleQueue.forEach(worker => worker.destroy());
-    this.isDestroyed = true;
-  }
-  setProps(props) {
-    this.props = {
-      ...this.props,
-      ...props
-    };
-    if (props.name !== undefined) {
-      this.name = props.name;
+    name = 'unnamed';
+    source; // | Function;
+    url;
+    maxConcurrency = 1;
+    maxMobileConcurrency = 1;
+    onDebug = () => { };
+    reuseWorkers = true;
+    props = {};
+    jobQueue = [];
+    idleQueue = [];
+    count = 0;
+    isDestroyed = false;
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+        return WorkerThread.isSupported();
     }
-    if (props.maxConcurrency !== undefined) {
-      this.maxConcurrency = props.maxConcurrency;
+    /**
+     * @param processor - worker function
+     * @param maxConcurrency - max count of workers
+     */
+    constructor(props) {
+        this.source = props.source;
+        this.url = props.url;
+        this.setProps(props);
     }
-    if (props.maxMobileConcurrency !== undefined) {
-      this.maxMobileConcurrency = props.maxMobileConcurrency;
+    /**
+     * Terminates all workers in the pool
+     * @note Can free up significant memory
+     */
+    destroy() {
+        // Destroy idle workers, active Workers will be destroyed on completion
+        this.idleQueue.forEach((worker) => worker.destroy());
+        this.isDestroyed = true;
     }
-    if (props.reuseWorkers !== undefined) {
-      this.reuseWorkers = props.reuseWorkers;
+    setProps(props) {
+        this.props = { ...this.props, ...props };
+        if (props.name !== undefined) {
+            this.name = props.name;
+        }
+        if (props.maxConcurrency !== undefined) {
+            this.maxConcurrency = props.maxConcurrency;
+        }
+        if (props.maxMobileConcurrency !== undefined) {
+            this.maxMobileConcurrency = props.maxMobileConcurrency;
+        }
+        if (props.reuseWorkers !== undefined) {
+            this.reuseWorkers = props.reuseWorkers;
+        }
+        if (props.onDebug !== undefined) {
+            this.onDebug = props.onDebug;
+        }
     }
-    if (props.onDebug !== undefined) {
-      this.onDebug = props.onDebug;
+    async startJob(name, onMessage = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+        // Promise resolves when thread starts working on this job
+        const startPromise = new Promise((onStart) => {
+            // Promise resolves when thread completes or fails working on this job
+            this.jobQueue.push({ name, onMessage, onError, onStart });
+            return this;
+        });
+        this._startQueuedJob(); // eslint-disable-line @typescript-eslint/no-floating-promises
+        return await startPromise;
     }
-  }
-  async startJob(name) {
-    let onMessage = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (job, type, data) => job.done(data);
-    let onError = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : (job, error) => job.error(error);
-    const startPromise = new Promise(onStart => {
-      this.jobQueue.push({
-        name,
-        onMessage,
-        onError,
-        onStart
-      });
-      return this;
-    });
-    this._startQueuedJob();
-    return await startPromise;
-  }
-  async _startQueuedJob() {
-    if (!this.jobQueue.length) {
-      return;
+    // PRIVATE
+    /**
+     * Starts first queued job if worker is available or can be created
+     * Called when job is started and whenever a worker returns to the idleQueue
+     */
+    async _startQueuedJob() {
+        if (!this.jobQueue.length) {
+            return;
+        }
+        const workerThread = this._getAvailableWorker();
+        if (!workerThread) {
+            return;
+        }
+        // We have a worker, dequeue and start the job
+        const queuedJob = this.jobQueue.shift();
+        if (queuedJob) {
+            // Emit a debug event
+            // @ts-ignore
+            this.onDebug({
+                message: 'Starting job',
+                name: queuedJob.name,
+                workerThread,
+                backlog: this.jobQueue.length
+            });
+            // Create a worker job to let the app access thread and manage job completion
+            const job = new WorkerJob(queuedJob.name, workerThread);
+            // Set the worker thread's message handlers
+            workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
+            workerThread.onError = (error) => queuedJob.onError(job, error);
+            // Resolve the start promise so that the app can start sending messages to worker
+            queuedJob.onStart(job);
+            // Wait for the app to signal that the job is complete, then return worker to queue
+            try {
+                await job.result;
+            }
+            catch (error) {
+                // eslint-disable-next-line no-console
+                console.error(`Worker exception: ${error}`);
+            }
+            finally {
+                this.returnWorkerToQueue(workerThread);
+            }
+        }
     }
-    const workerThread = this._getAvailableWorker();
-    if (!workerThread) {
-      return;
+    /**
+     * Returns a worker to the idle queue
+     * Destroys the worker if
+     *  - pool is destroyed
+     *  - if this pool doesn't reuse workers
+     *  - if maxConcurrency has been lowered
+     * @param worker
+     */
+    returnWorkerToQueue(worker) {
+        const shouldDestroyWorker = 
+        // Workers on Node.js prevent the process from exiting.
+        // Until we figure out how to close them before exit, we always destroy them
+        !isBrowser ||
+            // If the pool is destroyed, there is no reason to keep the worker around
+            this.isDestroyed ||
+            // If the app has disabled worker reuse, any completed workers should be destroyed
+            !this.reuseWorkers ||
+            // If concurrency has been lowered, this worker might be surplus to requirements
+            this.count > this._getMaxConcurrency();
+        if (shouldDestroyWorker) {
+            worker.destroy();
+            this.count--;
+        }
+        else {
+            this.idleQueue.push(worker);
+        }
+        if (!this.isDestroyed) {
+            this._startQueuedJob(); // eslint-disable-line @typescript-eslint/no-floating-promises
+        }
     }
-    const queuedJob = this.jobQueue.shift();
-    if (queuedJob) {
-      this.onDebug({
-        message: 'Starting job',
-        name: queuedJob.name,
-        workerThread,
-        backlog: this.jobQueue.length
-      });
-      const job = new WorkerJob(queuedJob.name, workerThread);
-      workerThread.onMessage = data => queuedJob.onMessage(job, data.type, data.payload);
-      workerThread.onError = error => queuedJob.onError(job, error);
-      queuedJob.onStart(job);
-      try {
-        await job.result;
-      } catch (error) {
-        console.error(`Worker exception: ${error}`);
-      } finally {
-        this.returnWorkerToQueue(workerThread);
-      }
+    /**
+     * Returns idle worker or creates new worker if maxConcurrency has not been reached
+     */
+    _getAvailableWorker() {
+        // If a worker has completed and returned to the queue, it can be used
+        if (this.idleQueue.length > 0) {
+            return this.idleQueue.shift() || null;
+        }
+        // Create fresh worker if we haven't yet created the max amount of worker threads for this worker source
+        if (this.count < this._getMaxConcurrency()) {
+            this.count++;
+            const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
+            return new WorkerThread({ name, source: this.source, url: this.url });
+        }
+        // No worker available, have to wait
+        return null;
     }
-  }
-  returnWorkerToQueue(worker) {
-    const shouldDestroyWorker = !isBrowser || this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
-    if (shouldDestroyWorker) {
-      worker.destroy();
-      this.count--;
-    } else {
-      this.idleQueue.push(worker);
+    _getMaxConcurrency() {
+        return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
     }
-    if (!this.isDestroyed) {
-      this._startQueuedJob();
-    }
-  }
-  _getAvailableWorker() {
-    if (this.idleQueue.length > 0) {
-      return this.idleQueue.shift() || null;
-    }
-    if (this.count < this._getMaxConcurrency()) {
-      this.count++;
-      const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
-      return new WorkerThread({
-        name,
-        source: this.source,
-        url: this.url
-      });
-    }
-    return null;
-  }
-  _getMaxConcurrency() {
-    return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
-  }
 }
-//# sourceMappingURL=worker-pool.js.map

package/dist/lib/worker-farm/worker-thread.d.ts

@@ -1,4 +1,4 @@
-import { NodeWorkerType } from '../node/worker_threads';
+import { NodeWorkerType } from "../node/worker_threads.js";
 export type WorkerThreadProps = {
     name: string;
     source?: string;

package/dist/lib/worker-farm/worker-thread.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker-thread.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-farm/worker-thread.ts"],"names":[],"mappings":"AAIA,OAAO,EAAa,cAAc,EAAC,MAAM,wBAAwB,CAAC;AAQlE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,UAAU,EAAE,OAAO,CAAS;IAC5B,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC;IAChC,SAAS,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAC;IAClC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAEhC,OAAO,CAAC,YAAY,CAAc;IAElC,uDAAuD;IACvD,MAAM,CAAC,WAAW,IAAI,OAAO;gBAOjB,KAAK,EAAE,iBAAiB;IAYpC;;;OAGG;IACH,OAAO,IAAI,IAAI;IAOf,IAAI,SAAS,YAEZ;IAED;;;;OAIG;IACH,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI;IAQlD;;;OAGG;IACH,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK;IAiBjD;;OAEG;IACH,oBAAoB,IAAI,MAAM;IAsB9B;;;OAGG;IACH,iBAAiB,IAAI,cAAc;CA0BpC"}
+{"version":3,"file":"worker-thread.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-farm/worker-thread.ts"],"names":[],"mappings":"AAIA,OAAO,EAAa,cAAc,EAAC,kCAA+B;AAQlE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,UAAU,EAAE,OAAO,CAAS;IAC5B,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC;IAChC,SAAS,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAC;IAClC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAEhC,OAAO,CAAC,YAAY,CAAc;IAElC,uDAAuD;IACvD,MAAM,CAAC,WAAW,IAAI,OAAO;gBAOjB,KAAK,EAAE,iBAAiB;IAYpC;;;OAGG;IACH,OAAO,IAAI,IAAI;IAOf,IAAI,SAAS,YAEZ;IAED;;;;OAIG;IACH,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI;IAQlD;;;OAGG;IACH,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK;IAiBjD;;OAEG;IACH,oBAAoB,IAAI,MAAM;IAsB9B;;;OAGG;IACH,iBAAiB,IAAI,cAAc;CA0BpC"}

package/dist/lib/worker-farm/worker-thread.js

@@ -1,104 +1,136 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { NodeWorker } from "../node/worker_threads.js";
 import { isBrowser } from "../env-utils/globals.js";
 import { assert } from "../env-utils/assert.js";
 import { getLoadableWorkerURL } from "../worker-utils/get-loadable-worker-url.js";
 import { getTransferList } from "../worker-utils/get-transfer-list.js";
-const NOOP = () => {};
+const NOOP = () => { };
+/**
+ * Represents one worker thread
+ */
 export default class WorkerThread {
-  static isSupported() {
-    return typeof Worker !== 'undefined' && isBrowser || typeof NodeWorker !== 'undefined' && !isBrowser;
-  }
-  constructor(props) {
-    this.name = void 0;
-    this.source = void 0;
-    this.url = void 0;
-    this.terminated = false;
-    this.worker = void 0;
-    this.onMessage = void 0;
-    this.onError = void 0;
-    this._loadableURL = '';
-    const {
-      name,
-      source,
-      url
-    } = props;
-    assert(source || url);
-    this.name = name;
-    this.source = source;
-    this.url = url;
-    this.onMessage = NOOP;
-    this.onError = error => console.log(error);
-    this.worker = isBrowser ? this._createBrowserWorker() : this._createNodeWorker();
-  }
-  destroy() {
-    this.onMessage = NOOP;
-    this.onError = NOOP;
-    this.worker.terminate();
-    this.terminated = true;
-  }
-  get isRunning() {
-    return Boolean(this.onMessage);
-  }
-  postMessage(data, transferList) {
-    transferList = transferList || getTransferList(data);
-    this.worker.postMessage(data, transferList);
-  }
-  _getErrorFromErrorEvent(event) {
-    let message = 'Failed to load ';
-    message += `worker ${this.name} from ${this.url}. `;
-    if (event.message) {
-      message += `${event.message} in `;
+    name;
+    source;
+    url;
+    terminated = false;
+    worker;
+    onMessage;
+    onError;
+    _loadableURL = '';
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+        return ((typeof Worker !== 'undefined' && isBrowser) ||
+            (typeof NodeWorker !== 'undefined' && !isBrowser));
     }
-    if (event.lineno) {
-      message += `:${event.lineno}:${event.colno}`;
+    constructor(props) {
+        const { name, source, url } = props;
+        assert(source || url); // Either source or url must be defined
+        this.name = name;
+        this.source = source;
+        this.url = url;
+        this.onMessage = NOOP;
+        this.onError = (error) => console.log(error); // eslint-disable-line
+        this.worker = isBrowser ? this._createBrowserWorker() : this._createNodeWorker();
     }
-    return new Error(message);
-  }
-  _createBrowserWorker() {
-    this._loadableURL = getLoadableWorkerURL({
-      source: this.source,
-      url: this.url
-    });
-    const worker = new Worker(this._loadableURL, {
-      name: this.name
-    });
-    worker.onmessage = event => {
-      if (!event.data) {
-        this.onError(new Error('No data received'));
-      } else {
-        this.onMessage(event.data);
-      }
-    };
-    worker.onerror = error => {
-      this.onError(this._getErrorFromErrorEvent(error));
-      this.terminated = true;
-    };
-    worker.onmessageerror = event => console.error(event);
-    return worker;
-  }
-  _createNodeWorker() {
-    let worker;
-    if (this.url) {
-      const absolute = this.url.includes(':/') || this.url.startsWith('/');
-      const url = absolute ? this.url : `./${this.url}`;
-      worker = new NodeWorker(url, {
-        eval: false
-      });
-    } else if (this.source) {
-      worker = new NodeWorker(this.source, {
-        eval: true
-      });
-    } else {
-      throw new Error('no worker');
+    /**
+     * Terminate this worker thread
+     * @note Can free up significant memory
+     */
+    destroy() {
+        this.onMessage = NOOP;
+        this.onError = NOOP;
+        this.worker.terminate(); // eslint-disable-line @typescript-eslint/no-floating-promises
+        this.terminated = true;
+    }
+    get isRunning() {
+        return Boolean(this.onMessage);
+    }
+    /**
+     * Send a message to this worker thread
+     * @param data any data structure, ideally consisting mostly of transferrable objects
+     * @param transferList If not supplied, calculated automatically by traversing data
+     */
+    postMessage(data, transferList) {
+        transferList = transferList || getTransferList(data);
+        // @ts-ignore
+        this.worker.postMessage(data, transferList);
+    }
+    // PRIVATE
+    /**
+     * Generate a standard Error from an ErrorEvent
+     * @param event
+     */
+    _getErrorFromErrorEvent(event) {
+        // Note Error object does not have the expected fields if loading failed completely
+        // https://developer.mozilla.org/en-US/docs/Web/API/Worker#Event_handlers
+        // https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
+        let message = 'Failed to load ';
+        message += `worker ${this.name} from ${this.url}. `;
+        if (event.message) {
+            message += `${event.message} in `;
+        }
+        // const hasFilename = event.filename && !event.filename.startsWith('blob:');
+        // message += hasFilename ? event.filename : this.source.slice(0, 100);
+        if (event.lineno) {
+            message += `:${event.lineno}:${event.colno}`;
+        }
+        return new Error(message);
+    }
+    /**
+     * Creates a worker thread on the browser
+     */
+    _createBrowserWorker() {
+        this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url });
+        const worker = new Worker(this._loadableURL, { name: this.name });
+        worker.onmessage = (event) => {
+            if (!event.data) {
+                this.onError(new Error('No data received'));
+            }
+            else {
+                this.onMessage(event.data);
+            }
+        };
+        // This callback represents an uncaught exception in the worker thread
+        worker.onerror = (error) => {
+            this.onError(this._getErrorFromErrorEvent(error));
+            this.terminated = true;
+        };
+        // TODO - not clear when this would be called, for now just log in case it happens
+        worker.onmessageerror = (event) => console.error(event); // eslint-disable-line
+        return worker;
+    }
+    /**
+     * Creates a worker thread in node.js
+     * @todo https://nodejs.org/api/async_hooks.html#async-resource-worker-pool
+     */
+    _createNodeWorker() {
+        let worker;
+        if (this.url) {
+            // Make sure relative URLs start with './'
+            const absolute = this.url.includes(':/') || this.url.startsWith('/');
+            const url = absolute ? this.url : `./${this.url}`;
+            // console.log('Starting work from', url);
+            worker = new NodeWorker(url, { eval: false });
+        }
+        else if (this.source) {
+            worker = new NodeWorker(this.source, { eval: true });
+        }
+        else {
+            throw new Error('no worker');
+        }
+        worker.on('message', (data) => {
+            // console.error('message', data);
+            this.onMessage(data);
+        });
+        worker.on('error', (error) => {
+            // console.error('error', error);
+            this.onError(error);
+        });
+        worker.on('exit', (code) => {
+            // console.error('exit', code);
+        });
+        return worker;
     }
-    worker.on('message', data => {
-      this.onMessage(data);
-    });
-    worker.on('error', error => {
-      this.onError(error);
-    });
-    worker.on('exit', code => {});
-    return worker;
-  }
 }
-//# sourceMappingURL=worker-thread.js.map

package/dist/lib/worker-utils/get-loadable-worker-url.js

@@ -1,36 +1,67 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { assert } from "../env-utils/assert.js";
 const workerURLCache = new Map();
+/**
+ * Creates a loadable URL from worker source or URL
+ * that can be used to create `Worker` instances.
+ * Due to CORS issues it may be necessary to wrap a URL in a small importScripts
+ * @param props
+ * @param props.source Worker source
+ * @param props.url Worker URL
+ * @returns loadable url
+ */
 export function getLoadableWorkerURL(props) {
-  assert(props.source && !props.url || !props.source && props.url);
-  let workerURL = workerURLCache.get(props.source || props.url);
-  if (!workerURL) {
-    if (props.url) {
-      workerURL = getLoadableWorkerURLFromURL(props.url);
-      workerURLCache.set(props.url, workerURL);
+    assert((props.source && !props.url) || (!props.source && props.url)); // Either source or url must be defined
+    let workerURL = workerURLCache.get(props.source || props.url);
+    if (!workerURL) {
+        // Differentiate worker urls from worker source code
+        if (props.url) {
+            workerURL = getLoadableWorkerURLFromURL(props.url);
+            workerURLCache.set(props.url, workerURL);
+        }
+        if (props.source) {
+            workerURL = getLoadableWorkerURLFromSource(props.source);
+            workerURLCache.set(props.source, workerURL);
+        }
     }
-    if (props.source) {
-      workerURL = getLoadableWorkerURLFromSource(props.source);
-      workerURLCache.set(props.source, workerURL);
-    }
-  }
-  assert(workerURL);
-  return workerURL;
+    assert(workerURL);
+    return workerURL;
 }
+/**
+ * Build a loadable worker URL from worker URL
+ * @param url
+ * @returns loadable URL
+ */
 function getLoadableWorkerURLFromURL(url) {
-  if (!url.startsWith('http')) {
-    return url;
-  }
-  const workerSource = buildScriptSource(url);
-  return getLoadableWorkerURLFromSource(workerSource);
+    // A local script url, we can use it to initialize a Worker directly
+    if (!url.startsWith('http')) {
+        return url;
+    }
+    // A remote script, we need to use `importScripts` to load from different origin
+    const workerSource = buildScriptSource(url);
+    return getLoadableWorkerURLFromSource(workerSource);
 }
+/**
+ * Build a loadable worker URL from worker source
+ * @param workerSource
+ * @returns loadable url
+ */
 function getLoadableWorkerURLFromSource(workerSource) {
-  const blob = new Blob([workerSource], {
-    type: 'application/javascript'
-  });
-  return URL.createObjectURL(blob);
+    const blob = new Blob([workerSource], { type: 'application/javascript' });
+    return URL.createObjectURL(blob);
 }
+/**
+ * Per spec, worker cannot be initialized with a script from a different origin
+ * However a local worker script can still import scripts from other origins,
+ * so we simply build a wrapper script.
+ *
+ * @param workerUrl
+ * @returns source
+ */
 function buildScriptSource(workerUrl) {
-  return `\
+    return `\
 try {
   importScripts('${workerUrl}');
 } catch (error) {
@@ -38,4 +69,3 @@ try {
   throw error;
 }`;
 }
-//# sourceMappingURL=get-loadable-worker-url.js.map