@loaders.gl/core 3.2.0-alpha.1 → 3.2.0-alpha.2

package/dist/dist.min.js

@@ -268,7 +268,7 @@
           this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker();
         }
         static isSupported() {
-          return typeof Worker !== "undefined" && isBrowser2;
+          return typeof Worker !== "undefined" && isBrowser2 || typeof Worker2 !== void 0;
         }
         destroy() {
           this.onMessage = NOOP;
@@ -385,9 +385,9 @@
             this.onDebug = props.onDebug;
           }
         }
-        async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+        async startJob(name, onMessage3 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
           const startPromise = new Promise((onStart) => {
-            this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart });
+            this.jobQueue.push({ name, onMessage: onMessage3, onError, onStart });
             return this;
           });
           this._startQueuedJob();
@@ -516,7 +516,36 @@
     }
   });
 
+  // ../worker-utils/src/lib/worker-utils/remove-nontransferable-options.ts
+  function removeNontransferableOptions(object) {
+    return JSON.parse(stringifyJSON(object));
+  }
+  function stringifyJSON(v) {
+    const cache3 = new Set();
+    return JSON.stringify(v, (key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (cache3.has(value)) {
+          try {
+            return JSON.parse(JSON.stringify(value));
+          } catch (err) {
+            return void 0;
+          }
+        }
+        cache3.add(value);
+      }
+      return value;
+    });
+  }
+  var init_remove_nontransferable_options = __esm({
+    "../worker-utils/src/lib/worker-utils/remove-nontransferable-options.ts"() {
+    }
+  });
+
   // ../worker-utils/src/lib/worker-api/get-worker-url.ts
+  function getWorkerName(worker) {
+    const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
+    return `${worker.name}@${worker.version}${warning}`;
+  }
   function getWorkerURL(worker, options = {}) {
     const workerOptions = options[worker.id] || {};
     const workerFile = `${worker.id}-worker.js`;
@@ -538,11 +567,64 @@
     assert2(url);
     return url;
   }
-  var NPM_TAG;
+  var NPM_TAG, VERSION2;
   var init_get_worker_url = __esm({
     "../worker-utils/src/lib/worker-api/get-worker-url.ts"() {
       init_assert2();
+      init_version();
       NPM_TAG = "beta";
+      VERSION2 = typeof VERSION !== "undefined" ? VERSION : NPM_TAG;
+    }
+  });
+
+  // ../worker-utils/src/lib/worker-api/process-on-worker.ts
+  async function processOnWorker(worker, data, options = {}, context = {}) {
+    const name = getWorkerName(worker);
+    const workerFarm = WorkerFarm.getWorkerFarm(options);
+    const { source } = options;
+    const workerPoolProps = { name, source };
+    if (!source) {
+      workerPoolProps.url = getWorkerURL(worker, options);
+    }
+    const workerPool = workerFarm.getWorkerPool(workerPoolProps);
+    const jobName = options.jobName || worker.name;
+    const job = await workerPool.startJob(jobName, onMessage.bind(null, context));
+    const transferableOptions = removeNontransferableOptions(options);
+    job.postMessage("process", { input: data, options: transferableOptions });
+    const result = await job.result;
+    return result.result;
+  }
+  async function onMessage(context, job, type, payload) {
+    switch (type) {
+      case "done":
+        job.done(payload);
+        break;
+      case "error":
+        job.error(new Error(payload.error));
+        break;
+      case "process":
+        const { id, input, options } = payload;
+        try {
+          if (!context.process) {
+            job.postMessage("error", { id, error: "Worker not set up to process on main thread" });
+            return;
+          }
+          const result = await context.process(input, options);
+          job.postMessage("done", { id, result });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "unknown error";
+          job.postMessage("error", { id, error: message });
+        }
+        break;
+      default:
+        console.warn(`process-on-worker: unknown message ${type}`);
+    }
+  }
+  var init_process_on_worker = __esm({
+    "../worker-utils/src/lib/worker-api/process-on-worker.ts"() {
+      init_worker_farm();
+      init_remove_nontransferable_options();
+      init_get_worker_url();
     }
   });
 
@@ -568,6 +650,7 @@
       init_assert2();
       init_globals2();
       init_worker_farm();
+      init_process_on_worker();
       init_get_worker_url();
       init_validate_worker_version();
     }
@@ -589,7 +672,7 @@
     const workerFarm = WorkerFarm.getWorkerFarm(options);
     const workerPool = workerFarm.getWorkerPool({ name, url });
     options = JSON.parse(JSON.stringify(options));
-    const job = await workerPool.startJob("process-on-worker", onMessage.bind(null, parseOnMainThread));
+    const job = await workerPool.startJob("process-on-worker", onMessage2.bind(null, parseOnMainThread));
     job.postMessage("process", {
       input: data,
       options
@@ -597,7 +680,7 @@
     const result = await job.result;
     return await result.result;
   }
-  async function onMessage(parseOnMainThread, job, type, payload) {
+  async function onMessage2(parseOnMainThread, job, type, payload) {
     switch (type) {
       case "done":
         job.done(payload);
@@ -626,6 +709,23 @@
     }
   });
 
+  // ../loader-utils/src/lib/worker-loader-utils/encode-with-worker.ts
+  function canEncodeWithWorker(writer, options) {
+    if (!WorkerFarm.isSupported()) {
+      return false;
+    }
+    if (!isBrowser && !options?._nodeWorkers) {
+      return false;
+    }
+    return writer.worker && options?.worker;
+  }
+  var init_encode_with_worker = __esm({
+    "../loader-utils/src/lib/worker-loader-utils/encode-with-worker.ts"() {
+      init_src();
+      init_globals();
+    }
+  });
+
   // (disabled):../loader-utils/src/lib/node/buffer
   var init_buffer = __esm({
     "(disabled):../loader-utils/src/lib/node/buffer"() {
@@ -1147,15 +1247,15 @@
   function parseTextSync(text) {
     return JSON.parse(text);
   }
-  var VERSION2, JSONLoader;
+  var VERSION3, JSONLoader;
   var init_json_loader = __esm({
     "../loader-utils/src/json-loader.ts"() {
-      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       JSONLoader = {
         name: "JSON",
         id: "json",
         module: "json",
-        version: VERSION2,
+        version: VERSION3,
         extensions: ["json", "geojson"],
         mimeTypes: ["application/json"],
         category: "json",
@@ -1213,6 +1313,7 @@
       init_assert();
       init_globals();
       init_parse_with_worker();
+      init_encode_with_worker();
       init_array_buffer_utils();
       init_text_iterators();
       init_async_iteration();
@@ -1369,7 +1470,7 @@
         text += ` ${await response.text()}`;
       }
       message += text;
-      message = message.length > 60 ? `${message.slice(60)}...` : message;
+      message = message.length > 60 ? `${message.slice(0, 60)}...` : message;
     } catch (error) {
     }
     return message;
@@ -1545,12 +1646,12 @@
   });
 
   // ../../node_modules/probe.gl/dist/esm/utils/globals.js
-  var VERSION3, isBrowser4;
+  var VERSION4, isBrowser4;
   var init_globals4 = __esm({
     "../../node_modules/probe.gl/dist/esm/utils/globals.js"() {
       init_is_browser();
       init_globals3();
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
       isBrowser4 = isBrowser3();
     }
   });
@@ -1872,7 +1973,7 @@
           id: ""
         }) {
           this.id = id;
-          this.VERSION = VERSION3;
+          this.VERSION = VERSION4;
           this._startTs = getHiResTimestamp2();
           this._deltaTs = getHiResTimestamp2();
           this.LOG_THROTTLE_TIMEOUT = 0;
@@ -2068,7 +2169,7 @@
           return noop;
         }
       };
-      Log.VERSION = VERSION3;
+      Log.VERSION = VERSION4;
     }
   });
 
@@ -2324,12 +2425,10 @@
     }
   });
 
-  // src/lib/api/set-loader-options.ts
-  function setLoaderOptions(options) {
-    setGlobalOptions(options);
-  }
-  var init_set_loader_options = __esm({
-    "src/lib/api/set-loader-options.ts"() {
+  // src/lib/api/loader-options.ts
+  var init_loader_options = __esm({
+    "src/lib/api/loader-options.ts"() {
+      init_option_utils();
       init_option_utils();
     }
   });
@@ -2452,11 +2551,11 @@
   });
 
   // ../../node_modules/@probe.gl/env/dist/esm/utils/globals.js
-  var VERSION4, isBrowser6;
+  var VERSION5, isBrowser6;
   var init_globals6 = __esm({
     "../../node_modules/@probe.gl/env/dist/esm/utils/globals.js"() {
       init_is_browser2();
-      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
       isBrowser6 = isBrowser5();
     }
   });
@@ -2803,7 +2902,7 @@
             id: ""
           };
           _defineProperty(this, "id", void 0);
-          _defineProperty(this, "VERSION", VERSION4);
+          _defineProperty(this, "VERSION", VERSION5);
           _defineProperty(this, "_startTs", getHiResTimestamp4());
           _defineProperty(this, "_deltaTs", getHiResTimestamp4());
           _defineProperty(this, "_storage", void 0);
@@ -3009,7 +3108,7 @@
           return noop2;
         }
       };
-      _defineProperty(Log2, "VERSION", VERSION4);
+      _defineProperty(Log2, "VERSION", VERSION5);
     }
   });
 
@@ -3717,6 +3816,11 @@
 
   // src/lib/api/encode.ts
   async function encode(data, writer, options) {
+    const globalOptions = getGlobalLoaderOptions();
+    options = { ...globalOptions, ...options };
+    if (canEncodeWithWorker(writer, options)) {
+      return await processOnWorker(writer, data, options);
+    }
     if (writer.encode) {
       return await writer.encode(data, options);
     }
@@ -3785,10 +3889,13 @@
   }
   var init_encode = __esm({
     "src/lib/api/encode.ts"() {
+      init_src2();
+      init_src();
       init_src2();
       init_src2();
       init_write_file();
       init_fetch_file();
+      init_loader_options();
     }
   });
 
@@ -3839,15 +3946,15 @@
   });
 
   // src/null-loader.ts
-  var VERSION5, NullWorkerLoader, NullLoader;
+  var VERSION6, NullWorkerLoader, NullLoader;
   var init_null_loader = __esm({
     "src/null-loader.ts"() {
-      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       NullWorkerLoader = {
         name: "Null loader",
         id: "null",
         module: "core",
-        version: VERSION5,
+        version: VERSION6,
         worker: true,
         mimeTypes: ["application/x.empty"],
         extensions: ["null"],
@@ -3860,7 +3967,7 @@
         name: "Null loader",
         id: "null",
         module: "core",
-        version: VERSION5,
+        version: VERSION6,
         mimeTypes: ["application/x.empty"],
         extensions: ["null"],
         parse: async (arrayBuffer) => arrayBuffer,
@@ -4031,6 +4138,7 @@
     encodeURLtoURL: () => encodeURLtoURL,
     fetchFile: () => fetchFile,
     forEach: () => forEach,
+    getLoaderOptions: () => getGlobalLoaderOptions,
     getPathPrefix: () => getPathPrefix,
     global: () => global_,
     isAsyncIterable: () => isAsyncIterable,
@@ -4063,7 +4171,7 @@
     selectLoader: () => selectLoader,
     selectLoaderSync: () => selectLoaderSync,
     self: () => self_,
-    setLoaderOptions: () => setLoaderOptions,
+    setLoaderOptions: () => setGlobalOptions,
     setPathPrefix: () => setPathPrefix,
     window: () => window_,
     writeFile: () => writeFile,
@@ -4075,7 +4183,7 @@
       init_read_array_buffer();
       init_read_file();
       init_write_file();
-      init_set_loader_options();
+      init_loader_options();
       init_register_loaders();
       init_select_loader();
       init_parse();

package/dist/es5/index.js

@@ -38,7 +38,13 @@ Object.defineProperty(exports, "writeFileSync", {
 Object.defineProperty(exports, "setLoaderOptions", {
   enumerable: true,
   get: function get() {
-    return _setLoaderOptions.setLoaderOptions;
+    return _loaderOptions.setLoaderOptions;
+  }
+});
+Object.defineProperty(exports, "getLoaderOptions", {
+  enumerable: true,
+  get: function get() {
+    return _loaderOptions.getLoaderOptions;
   }
 });
 Object.defineProperty(exports, "registerLoaders", {
@@ -338,7 +344,7 @@ var _readFile = require("./lib/fetch/read-file");
 
 var _writeFile = require("./lib/fetch/write-file");
 
-var _setLoaderOptions = require("./lib/api/set-loader-options");
+var _loaderOptions = require("./lib/api/loader-options");
 
 var _registerLoaders = require("./lib/api/register-loaders");
 

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;;AAEA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AAEA;;AACA;;AAGA;;AACA;;AAGA;;AAIA;;AACA;;AAGA;;AAIA;;AACA;;AAqBA","sourcesContent":["// FILE READING AND WRITING\nexport {fetchFile} from './lib/fetch/fetch-file';\n\nexport {readArrayBuffer} from './lib/fetch/read-array-buffer';\nexport {readFileSync} from './lib/fetch/read-file';\nexport {writeFile, writeFileSync} from './lib/fetch/write-file';\n\n// CONFIGURATION\nexport {setLoaderOptions} from './lib/api/set-loader-options';\nexport {registerLoaders} from './lib/api/register-loaders';\nexport {selectLoader, selectLoaderSync} from './lib/api/select-loader';\n\n// LOADING (READING + PARSING)\nexport {parse} from './lib/api/parse';\nexport {parseSync} from './lib/api/parse-sync';\nexport {parseInBatches} from './lib/api/parse-in-batches';\n\nexport {load} from './lib/api/load';\nexport {loadInBatches} from './lib/api/load-in-batches';\n\n// ENCODING (ENCODING AND WRITING)\nexport {encode, encodeSync, encodeInBatches, encodeText, encodeURLtoURL} from './lib/api/encode';\nexport {save, saveSync} from './lib/api/save';\n\n// CORE UTILS SHARED WITH LOADERS (RE-EXPORTED FROM LOADER-UTILS)\nexport {setPathPrefix, getPathPrefix, resolvePath} from '@loaders.gl/loader-utils';\nexport {RequestScheduler} from '@loaders.gl/loader-utils';\n\n// ITERATOR UTILS\nexport {makeIterator} from './iterators/make-iterator/make-iterator';\nexport {makeStream} from './iterators/make-stream/make-node-stream';\n\n// CORE LOADERS\nexport {NullWorkerLoader, NullLoader} from './null-loader';\nexport {JSONLoader} from '@loaders.gl/loader-utils';\n\n// EXPERIMENTAL\nexport {default as _fetchProgress} from './lib/progress/fetch-progress';\nexport {default as _BrowserFileSystem} from './lib/filesystems/browser-filesystem';\n\n// FOR TESTING\nexport {_unregisterLoaders} from './lib/api/register-loaders';\n\n//\n// TODO - MOVE TO LOADER-UTILS AND DEPRECATE IN CORE?\n//\n\nexport {isBrowser, isWorker, self, window, global, document} from '@loaders.gl/loader-utils';\nexport {assert} from '@loaders.gl/loader-utils';\nexport {forEach, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\n\nexport {\n  makeTextDecoderIterator,\n  makeTextEncoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from '@loaders.gl/loader-utils';\n\n// \"JAVASCRIPT\" UTILS - move to loader-utils?\nexport {\n  isPureObject,\n  isPromise,\n  isIterable,\n  isAsyncIterable,\n  isIterator,\n  isResponse,\n  isReadableStream,\n  isWritableStream\n} from './javascript-utils/is-type';\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;;AAEA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AAEA;;AACA;;AAGA;;AACA;;AAGA;;AAIA;;AACA;;AAGA;;AAIA;;AACA;;AAqBA","sourcesContent":["// FILE READING AND WRITING\nexport {fetchFile} from './lib/fetch/fetch-file';\n\nexport {readArrayBuffer} from './lib/fetch/read-array-buffer';\nexport {readFileSync} from './lib/fetch/read-file';\nexport {writeFile, writeFileSync} from './lib/fetch/write-file';\n\n// CONFIGURATION\nexport {setLoaderOptions, getLoaderOptions} from './lib/api/loader-options';\nexport {registerLoaders} from './lib/api/register-loaders';\nexport {selectLoader, selectLoaderSync} from './lib/api/select-loader';\n\n// LOADING (READING + PARSING)\nexport {parse} from './lib/api/parse';\nexport {parseSync} from './lib/api/parse-sync';\nexport {parseInBatches} from './lib/api/parse-in-batches';\n\nexport {load} from './lib/api/load';\nexport {loadInBatches} from './lib/api/load-in-batches';\n\n// ENCODING (ENCODING AND WRITING)\nexport {encode, encodeSync, encodeInBatches, encodeText, encodeURLtoURL} from './lib/api/encode';\nexport {save, saveSync} from './lib/api/save';\n\n// CORE UTILS SHARED WITH LOADERS (RE-EXPORTED FROM LOADER-UTILS)\nexport {setPathPrefix, getPathPrefix, resolvePath} from '@loaders.gl/loader-utils';\nexport {RequestScheduler} from '@loaders.gl/loader-utils';\n\n// ITERATOR UTILS\nexport {makeIterator} from './iterators/make-iterator/make-iterator';\nexport {makeStream} from './iterators/make-stream/make-node-stream';\n\n// CORE LOADERS\nexport {NullWorkerLoader, NullLoader} from './null-loader';\nexport {JSONLoader} from '@loaders.gl/loader-utils';\n\n// EXPERIMENTAL\nexport {default as _fetchProgress} from './lib/progress/fetch-progress';\nexport {default as _BrowserFileSystem} from './lib/filesystems/browser-filesystem';\n\n// FOR TESTING\nexport {_unregisterLoaders} from './lib/api/register-loaders';\n\n//\n// TODO - MOVE TO LOADER-UTILS AND DEPRECATE IN CORE?\n//\n\nexport {isBrowser, isWorker, self, window, global, document} from '@loaders.gl/loader-utils';\nexport {assert} from '@loaders.gl/loader-utils';\nexport {forEach, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\n\nexport {\n  makeTextDecoderIterator,\n  makeTextEncoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from '@loaders.gl/loader-utils';\n\n// \"JAVASCRIPT\" UTILS - move to loader-utils?\nexport {\n  isPureObject,\n  isPromise,\n  isIterable,\n  isAsyncIterable,\n  isIterator,\n  isResponse,\n  isReadableStream,\n  isWritableStream\n} from './javascript-utils/is-type';\n"],"file":"index.js"}

package/dist/es5/lib/api/encode.js

@@ -13,64 +13,89 @@ exports.encodeURLtoURL = encodeURLtoURL;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 
 var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
 
 var _loaderUtils = require("@loaders.gl/loader-utils");
 
+var _workerUtils = require("@loaders.gl/worker-utils");
+
 var _writeFile = require("../fetch/write-file");
 
 var _fetchFile = require("../fetch/fetch-file");
 
+var _loaderOptions = require("./loader-options");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
 function encode(_x, _x2, _x3) {
   return _encode.apply(this, arguments);
 }
 
 function _encode() {
   _encode = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(data, writer, options) {
-    var batches, chunks, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, batch, tmpInputFilename, tmpOutputFilename, outputFilename, response;
+    var globalOptions, batches, chunks, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, batch, tmpInputFilename, tmpOutputFilename, outputFilename, response;
 
     return _regenerator.default.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
+            globalOptions = (0, _loaderOptions.getLoaderOptions)();
+            options = _objectSpread(_objectSpread({}, globalOptions), options);
+
+            if (!(0, _loaderUtils.canEncodeWithWorker)(writer, options)) {
+              _context.next = 6;
+              break;
+            }
+
+            _context.next = 5;
+            return (0, _workerUtils.processOnWorker)(writer, data, options);
+
+          case 5:
+            return _context.abrupt("return", _context.sent);
+
+          case 6:
             if (!writer.encode) {
-              _context.next = 4;
+              _context.next = 10;
               break;
             }
 
-            _context.next = 3;
+            _context.next = 9;
             return writer.encode(data, options);
 
-          case 3:
+          case 9:
             return _context.abrupt("return", _context.sent);
 
-          case 4:
+          case 10:
             if (!writer.encodeSync) {
-              _context.next = 6;
+              _context.next = 12;
               break;
             }
 
             return _context.abrupt("return", writer.encodeSync(data, options));
 
-          case 6:
+          case 12:
             if (!writer.encodeText) {
-              _context.next = 12;
+              _context.next = 18;
               break;
             }
 
             _context.t0 = new TextEncoder();
-            _context.next = 10;
+            _context.next = 16;
             return writer.encodeText(data, options);
 
-          case 10:
+          case 16:
             _context.t1 = _context.sent;
             return _context.abrupt("return", _context.t0.encode.call(_context.t0, _context.t1));
 
-          case 12:
+          case 18:
             if (!writer.encodeInBatches) {
-              _context.next = 49;
+              _context.next = 55;
               break;
             }
 
@@ -78,109 +103,109 @@ function _encode() {
             chunks = [];
             _iteratorNormalCompletion = true;
             _didIteratorError = false;
-            _context.prev = 17;
+            _context.prev = 23;
             _iterator = (0, _asyncIterator2.default)(batches);
 
-          case 19:
-            _context.next = 21;
+          case 25:
+            _context.next = 27;
             return _iterator.next();
 
-          case 21:
+          case 27:
             _step = _context.sent;
             _iteratorNormalCompletion = _step.done;
-            _context.next = 25;
+            _context.next = 31;
             return _step.value;
 
-          case 25:
+          case 31:
             _value = _context.sent;
 
             if (_iteratorNormalCompletion) {
-              _context.next = 32;
+              _context.next = 38;
               break;
             }
 
             batch = _value;
             chunks.push(batch);
 
-          case 29:
+          case 35:
             _iteratorNormalCompletion = true;
-            _context.next = 19;
+            _context.next = 25;
             break;
 
-          case 32:
-            _context.next = 38;
+          case 38:
+            _context.next = 44;
             break;
 
-          case 34:
-            _context.prev = 34;
-            _context.t2 = _context["catch"](17);
+          case 40:
+            _context.prev = 40;
+            _context.t2 = _context["catch"](23);
             _didIteratorError = true;
             _iteratorError = _context.t2;
 
-          case 38:
-            _context.prev = 38;
-            _context.prev = 39;
+          case 44:
+            _context.prev = 44;
+            _context.prev = 45;
 
             if (!(!_iteratorNormalCompletion && _iterator.return != null)) {
-              _context.next = 43;
+              _context.next = 49;
               break;
             }
 
-            _context.next = 43;
+            _context.next = 49;
             return _iterator.return();
 
-          case 43:
-            _context.prev = 43;
+          case 49:
+            _context.prev = 49;
 
             if (!_didIteratorError) {
-              _context.next = 46;
+              _context.next = 52;
               break;
             }
 
             throw _iteratorError;
 
-          case 46:
-            return _context.finish(43);
+          case 52:
+            return _context.finish(49);
 
-          case 47:
-            return _context.finish(38);
+          case 53:
+            return _context.finish(44);
 
-          case 48:
+          case 54:
             return _context.abrupt("return", _loaderUtils.concatenateArrayBuffers.apply(void 0, chunks));
 
-          case 49:
+          case 55:
             if (!(!_loaderUtils.isBrowser && writer.encodeURLtoURL)) {
-              _context.next = 61;
+              _context.next = 67;
               break;
             }
 
             tmpInputFilename = getTemporaryFilename('input');
-            _context.next = 53;
+            _context.next = 59;
             return (0, _writeFile.writeFile)(tmpInputFilename, data);
 
-          case 53:
+          case 59:
             tmpOutputFilename = getTemporaryFilename('output');
-            _context.next = 56;
+            _context.next = 62;
             return encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
 
-          case 56:
+          case 62:
             outputFilename = _context.sent;
-            _context.next = 59;
+            _context.next = 65;
             return (0, _fetchFile.fetchFile)(outputFilename);
 
-          case 59:
+          case 65:
             response = _context.sent;
             return _context.abrupt("return", response.arrayBuffer());
 
-          case 61:
+          case 67:
             throw new Error('Writer could not encode data');
 
-          case 62:
+          case 68:
           case "end":
             return _context.stop();
         }
       }
-    }, _callee, null, [[17, 34, 38, 48], [39,, 43, 47]]);
+    }, _callee, null, [[23, 40, 44, 54], [45,, 49, 53]]);
   }));
   return _encode.apply(this, arguments);
 }