@loaders.gl/core 3.1.8 → 3.2.0-alpha.3

package/dist/dist.min.js

@@ -65,7 +65,7 @@
   var DEFAULT_VERSION, VERSION;
   var init_version = __esm({
     "../worker-utils/src/lib/env-utils/version.ts"() {
-      DEFAULT_VERSION = "latest";
+      DEFAULT_VERSION = "beta";
       VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : DEFAULT_VERSION;
       if (typeof __VERSION__ === "undefined") {
         console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
@@ -112,13 +112,13 @@
       init_assert2();
       WorkerJob = class {
         constructor(jobName, workerThread) {
-          this.name = jobName;
-          this.workerThread = workerThread;
           this.isRunning = true;
           this._resolve = () => {
           };
           this._reject = () => {
           };
+          this.name = jobName;
+          this.workerThread = workerThread;
           this.result = new Promise((resolve, reject) => {
             this._resolve = resolve;
             this._reject = reject;
@@ -145,6 +145,21 @@
     }
   });
 
+  // ../worker-utils/src/lib/node/worker_threads-browser.js
+  var Worker2;
+  var init_worker_threads_browser = __esm({
+    "../worker-utils/src/lib/node/worker_threads-browser.js"() {
+      Worker2 = class {
+        on(message, cb) {
+        }
+        postMessage(...args) {
+        }
+        terminate() {
+        }
+      };
+    }
+  });
+
   // ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
   function getLoadableWorkerURL(props) {
     assert2(props.source && !props.url || !props.source && props.url);
@@ -232,6 +247,8 @@
   var NOOP, WorkerThread;
   var init_worker_thread = __esm({
     "../worker-utils/src/lib/worker-farm/worker-thread.ts"() {
+      init_worker_threads_browser();
+      init_globals2();
       init_assert2();
       init_get_loadable_worker_url();
       init_get_transfer_list();
@@ -248,10 +265,10 @@
           this.url = url;
           this.onMessage = NOOP;
           this.onError = (error) => console.log(error);
-          this.worker = this._createBrowserWorker();
+          this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker();
         }
         static isSupported() {
-          return typeof Worker !== "undefined";
+          return typeof Worker !== "undefined" && isBrowser2 || typeof Worker2 !== void 0;
         }
         destroy() {
           this.onMessage = NOOP;
@@ -294,6 +311,27 @@
           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 Worker2(url, { eval: false });
+          } else if (this.source) {
+            worker = new Worker2(this.source, { eval: true });
+          } else {
+            throw new Error("no worker");
+          }
+          worker.on("message", (data) => {
+            this.onMessage(data);
+          });
+          worker.on("error", (error) => {
+            this.onError(error);
+          });
+          worker.on("exit", (code) => {
+          });
+          return worker;
+        }
       };
     }
   });
@@ -322,6 +360,9 @@
           this.url = props.url;
           this.setProps(props);
         }
+        static isSupported() {
+          return WorkerThread.isSupported();
+        }
         destroy() {
           this.idleQueue.forEach((worker) => worker.destroy());
           this.isDestroyed = true;
@@ -344,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();
@@ -418,9 +459,9 @@
       DEFAULT_PROPS = {
         maxConcurrency: 3,
         maxMobileConcurrency: 1,
+        reuseWorkers: true,
         onDebug: () => {
-        },
-        reuseWorkers: true
+        }
       };
       WorkerFarm = class {
         constructor(props) {
@@ -441,6 +482,7 @@
           for (const workerPool of this.workerPools.values()) {
             workerPool.destroy();
           }
+          this.workerPools = new Map();
         }
         setProps(props) {
           this.props = { ...this.props, ...props };
@@ -474,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`;
@@ -496,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();
-      NPM_TAG = "latest";
+      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();
     }
   });
 
@@ -524,7 +648,9 @@
   var init_src = __esm({
     "../worker-utils/src/index.ts"() {
       init_assert2();
+      init_globals2();
       init_worker_farm();
+      init_process_on_worker();
       init_get_worker_url();
       init_validate_worker_version();
     }
@@ -535,6 +661,9 @@
     if (!WorkerFarm.isSupported()) {
       return false;
     }
+    if (!isBrowser2 && !options?._nodeWorkers) {
+      return false;
+    }
     return loader.worker && options?.worker;
   }
   async function parseWithWorker(loader, data, options, context, parseOnMainThread) {
@@ -543,15 +672,17 @@
     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));
+    context = JSON.parse(JSON.stringify(context || {}));
+    const job = await workerPool.startJob("process-on-worker", onMessage2.bind(null, parseOnMainThread));
     job.postMessage("process", {
       input: data,
-      options
+      options,
+      context
     });
     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);
@@ -576,6 +707,24 @@
   var init_parse_with_worker = __esm({
     "../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts"() {
       init_src();
+      init_src();
+    }
+  });
+
+  // ../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();
     }
   });
 
@@ -746,7 +895,7 @@
     }
   });
 
-  // ../loader-utils/node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js
+  // ../../node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js
   function getHiResTimestamp() {
     let timestamp;
     if (typeof window !== "undefined" && window.performance) {
@@ -760,14 +909,14 @@
     return timestamp;
   }
   var init_hi_res_timestamp = __esm({
-    "../loader-utils/node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js"() {
+    "../../node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js"() {
     }
   });
 
-  // ../loader-utils/node_modules/@probe.gl/stats/dist/esm/lib/stat.js
+  // ../../node_modules/@probe.gl/stats/dist/esm/lib/stat.js
   var Stat;
   var init_stat = __esm({
-    "../loader-utils/node_modules/@probe.gl/stats/dist/esm/lib/stat.js"() {
+    "../../node_modules/@probe.gl/stats/dist/esm/lib/stat.js"() {
       init_defineProperty();
       init_hi_res_timestamp();
       Stat = class {
@@ -883,10 +1032,10 @@
     }
   });
 
-  // ../loader-utils/node_modules/@probe.gl/stats/dist/esm/lib/stats.js
+  // ../../node_modules/@probe.gl/stats/dist/esm/lib/stats.js
   var Stats;
   var init_stats = __esm({
-    "../loader-utils/node_modules/@probe.gl/stats/dist/esm/lib/stats.js"() {
+    "../../node_modules/@probe.gl/stats/dist/esm/lib/stats.js"() {
       init_defineProperty();
       init_stat();
       Stats = class {
@@ -956,9 +1105,9 @@
     }
   });
 
-  // ../loader-utils/node_modules/@probe.gl/stats/dist/esm/index.js
+  // ../../node_modules/@probe.gl/stats/dist/esm/index.js
   var init_esm = __esm({
-    "../loader-utils/node_modules/@probe.gl/stats/dist/esm/index.js"() {
+    "../../node_modules/@probe.gl/stats/dist/esm/index.js"() {
       init_stats();
       init_stat();
       init_hi_res_timestamp();
@@ -1100,15 +1249,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",
@@ -1166,6 +1315,7 @@
       init_assert();
       init_globals();
       init_parse_with_worker();
+      init_encode_with_worker();
       init_array_buffer_utils();
       init_text_iterators();
       init_async_iteration();
@@ -1322,7 +1472,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;
@@ -1498,12 +1648,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();
     }
   });
@@ -1825,7 +1975,7 @@
           id: ""
         }) {
           this.id = id;
-          this.VERSION = VERSION3;
+          this.VERSION = VERSION4;
           this._startTs = getHiResTimestamp2();
           this._deltaTs = getHiResTimestamp2();
           this.LOG_THROTTLE_TIMEOUT = 0;
@@ -2021,33 +2171,33 @@
           return noop;
         }
       };
-      Log.VERSION = VERSION3;
+      Log.VERSION = VERSION4;
     }
   });
 
-  // ../../node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js
+  // ../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js
   var init_hi_res_timestamp3 = __esm({
-    "../../node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js"() {
+    "../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js"() {
     }
   });
 
-  // ../../node_modules/@probe.gl/stats/dist/esm/lib/stat.js
+  // ../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/lib/stat.js
   var init_stat2 = __esm({
-    "../../node_modules/@probe.gl/stats/dist/esm/lib/stat.js"() {
+    "../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/lib/stat.js"() {
       init_hi_res_timestamp3();
     }
   });
 
-  // ../../node_modules/@probe.gl/stats/dist/esm/lib/stats.js
+  // ../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/lib/stats.js
   var init_stats2 = __esm({
-    "../../node_modules/@probe.gl/stats/dist/esm/lib/stats.js"() {
+    "../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/lib/stats.js"() {
       init_stat2();
     }
   });
 
-  // ../../node_modules/@probe.gl/stats/dist/esm/index.js
+  // ../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/index.js
   var init_esm2 = __esm({
-    "../../node_modules/@probe.gl/stats/dist/esm/index.js"() {
+    "../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/index.js"() {
       init_stats2();
       init_stat2();
       init_hi_res_timestamp3();
@@ -2115,6 +2265,7 @@
   var DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS;
   var init_option_defaults = __esm({
     "src/lib/loader-utils/option-defaults.ts"() {
+      init_src2();
       init_loggers();
       DEFAULT_LOADER_OPTIONS = {
         fetch: null,
@@ -2125,7 +2276,8 @@
         worker: true,
         maxConcurrency: 3,
         maxMobileConcurrency: 1,
-        reuseWorkers: true,
+        reuseWorkers: isBrowser,
+        _nodeWorkers: false,
         _workerType: "",
         limit: 0,
         _limitMB: 0,
@@ -2275,12 +2427,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();
     }
   });
@@ -2403,11 +2553,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();
     }
   });
@@ -2754,7 +2904,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);
@@ -2960,7 +3110,7 @@
           return noop2;
         }
       };
-      _defineProperty(Log2, "VERSION", VERSION4);
+      _defineProperty(Log2, "VERSION", VERSION5);
     }
   });
 
@@ -3456,6 +3606,12 @@
   }
   async function parseWithLoader(loader, data, options, context) {
     validateWorkerVersion(loader);
+    if (isResponse(data)) {
+      const response = data;
+      const { ok, redirected, status, statusText, type, url } = response;
+      const headers = Object.fromEntries(response.headers.entries());
+      context.response = { headers, ok, redirected, status, statusText, type, url };
+    }
     data = await getArrayBufferOrStringFromData(data, loader, options);
     if (loader.parseTextSync && typeof data === "string") {
       options.dataType = "text";
@@ -3478,6 +3634,7 @@
       init_src();
       init_src2();
       init_normalize_loader();
+      init_is_type();
       init_option_utils();
       init_get_data();
       init_loader_context();
@@ -3668,6 +3825,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);
     }
@@ -3736,10 +3898,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();
     }
   });
 
@@ -3790,15 +3955,21 @@
   });
 
   // src/null-loader.ts
-  var VERSION5, NullWorkerLoader, NullLoader;
+  function parseSync2(arrayBuffer, options, context) {
+    if (!options.null.echoParameters)
+      return null;
+    context = context && JSON.parse(JSON.stringify(context));
+    return { arrayBuffer, options, context };
+  }
+  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"],
@@ -3811,19 +3982,21 @@
         name: "Null loader",
         id: "null",
         module: "core",
-        version: VERSION5,
+        version: VERSION6,
         mimeTypes: ["application/x.empty"],
         extensions: ["null"],
-        parse: async (arrayBuffer) => arrayBuffer,
-        parseSync: (arrayBuffer) => arrayBuffer,
-        parseInBatches: async function* generator(asyncIterator) {
+        parse: async (arrayBuffer, options, context) => parseSync2(arrayBuffer, options, context),
+        parseSync: parseSync2,
+        parseInBatches: async function* generator(asyncIterator, options, context) {
           for await (const batch of asyncIterator) {
-            yield batch;
+            yield parseSync2(batch, options, context);
           }
         },
         tests: [() => false],
         options: {
-          null: {}
+          null: {
+            echoParameters: false
+          }
         }
       };
     }
@@ -3982,6 +4155,7 @@
     encodeURLtoURL: () => encodeURLtoURL,
     fetchFile: () => fetchFile,
     forEach: () => forEach,
+    getLoaderOptions: () => getGlobalLoaderOptions,
     getPathPrefix: () => getPathPrefix,
     global: () => global_,
     isAsyncIterable: () => isAsyncIterable,
@@ -4014,7 +4188,7 @@
     selectLoader: () => selectLoader,
     selectLoaderSync: () => selectLoaderSync,
     self: () => self_,
-    setLoaderOptions: () => setLoaderOptions,
+    setLoaderOptions: () => setGlobalOptions,
     setPathPrefix: () => setPathPrefix,
     window: () => window_,
     writeFile: () => writeFile,
@@ -4026,7 +4200,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"}