@loaders.gl/core 4.0.0-alpha.8 → 4.0.0-beta.1

package/dist/dist.min.js

@@ -61,16 +61,45 @@
     }
   });
 
+  // ../loader-utils/src/lib/option-utils/merge-loader-options.ts
+  function mergeLoaderOptions(baseOptions, newOptions) {
+    return mergeOptionsRecursively(baseOptions || {}, newOptions);
+  }
+  function mergeOptionsRecursively(baseOptions, newOptions) {
+    const options = { ...baseOptions };
+    for (const [key, newValue] of Object.entries(newOptions)) {
+      if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
+        options[key] = mergeOptionsRecursively(options[key] || {}, newOptions[key]);
+      } else {
+        options[key] = newOptions[key];
+      }
+    }
+    return options;
+  }
+  var init_merge_loader_options = __esm({
+    "../loader-utils/src/lib/option-utils/merge-loader-options.ts"() {
+    }
+  });
+
   // ../worker-utils/src/lib/env-utils/version.ts
-  var DEFAULT_VERSION, VERSION;
-  var init_version = __esm({
-    "../worker-utils/src/lib/env-utils/version.ts"() {
-      DEFAULT_VERSION = "beta";
-      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : DEFAULT_VERSION;
+  function getVersion() {
+    if (!globalThis._loadersgl_?.version) {
+      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
       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.");
+        globalThis._loadersgl_.version = NPM_TAG;
+      } else {
+        globalThis._loadersgl_.version = __VERSION__;
       }
     }
+    return globalThis._loadersgl_.version;
+  }
+  var NPM_TAG, VERSION;
+  var init_version = __esm({
+    "../worker-utils/src/lib/env-utils/version.ts"() {
+      NPM_TAG = "beta";
+      VERSION = getVersion();
+    }
   });
 
   // ../worker-utils/src/lib/env-utils/assert.ts
@@ -530,7 +559,7 @@
 
   // ../worker-utils/src/lib/worker-api/get-worker-url.ts
   function getWorkerName(worker) {
-    const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
+    const warning = worker.version !== VERSION ? ` (worker-utils@${VERSION})` : "";
     return `${worker.name}@${worker.version}${warning}`;
   }
   function getWorkerURL(worker, options = {}) {
@@ -554,14 +583,11 @@
     assert2(url);
     return url;
   }
-  var NPM_TAG, VERSION2;
   var init_get_worker_url = __esm({
     "../worker-utils/src/lib/worker-api/get-worker-url.ts"() {
       init_assert2();
       init_globals2();
       init_version();
-      NPM_TAG = "beta";
-      VERSION2 = typeof VERSION !== "undefined" ? VERSION : NPM_TAG;
     }
   });
 
@@ -1043,41 +1069,41 @@
           return Object.keys(this.stats).length;
         }
         reset() {
-          for (const stat2 of Object.values(this.stats)) {
-            stat2.reset();
+          for (const stat of Object.values(this.stats)) {
+            stat.reset();
           }
           return this;
         }
         forEach(fn) {
-          for (const stat2 of Object.values(this.stats)) {
-            fn(stat2);
+          for (const stat of Object.values(this.stats)) {
+            fn(stat);
           }
         }
         getTable() {
           const table = {};
-          this.forEach((stat2) => {
-            table[stat2.name] = {
-              time: stat2.time || 0,
-              count: stat2.count || 0,
-              average: stat2.getAverageTime() || 0,
-              hz: stat2.getHz() || 0
+          this.forEach((stat) => {
+            table[stat.name] = {
+              time: stat.time || 0,
+              count: stat.count || 0,
+              average: stat.getAverageTime() || 0,
+              hz: stat.getHz() || 0
             };
           });
           return table;
         }
         _initializeStats() {
           let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
-          stats.forEach((stat2) => this._getOrCreate(stat2));
+          stats.forEach((stat) => this._getOrCreate(stat));
         }
-        _getOrCreate(stat2) {
+        _getOrCreate(stat) {
           const {
             name,
             type
-          } = stat2;
+          } = stat;
           let result = this.stats[name];
           if (!result) {
-            if (stat2 instanceof Stat) {
-              result = stat2;
+            if (stat instanceof Stat) {
+              result = stat;
             } else {
               result = new Stat(name, type);
             }
@@ -1233,15 +1259,15 @@
   function parseTextSync(text) {
     return JSON.parse(text);
   }
-  var VERSION3, JSONLoader;
+  var VERSION2, JSONLoader;
   var init_json_loader = __esm({
     "../loader-utils/src/json-loader.ts"() {
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       JSONLoader = {
         name: "JSON",
         id: "json",
         module: "json",
-        version: VERSION3,
+        version: VERSION2,
         extensions: ["json", "geojson"],
         mimeTypes: ["application/json"],
         category: "json",
@@ -1301,18 +1327,6 @@
     }
   });
 
-  // ../loader-utils/src/lib/node/promisify.ts
-  function promisify2(fn) {
-    return (arg1, arg2) => new Promise((resolve2, reject) => fn(arg1, arg2, (error, callbackArgs) => error ? reject(error) : resolve2(callbackArgs)));
-  }
-  function promisify3(fn) {
-    return (arg1, arg2, arg3) => new Promise((resolve2, reject) => fn(arg1, arg2, arg3, (error, callbackArgs) => error ? reject(error) : resolve2(callbackArgs)));
-  }
-  var init_promisify = __esm({
-    "../loader-utils/src/lib/node/promisify.ts"() {
-    }
-  });
-
   // ../loader-utils/src/lib/path-utils/get-cwd.ts
   function getCWD() {
     if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
@@ -1464,59 +1478,15 @@
     }
   });
 
-  // (disabled):fs
-  var require_fs = __commonJS({
-    "(disabled):fs"() {
-    }
-  });
-
-  // ../loader-utils/src/lib/node/fs.ts
-  var fs_exports = {};
-  __export(fs_exports, {
-    _readToArrayBuffer: () => _readToArrayBuffer,
-    close: () => close,
-    createWriteStream: () => createWriteStream,
-    fstat: () => fstat,
-    isSupported: () => isSupported,
-    open: () => open,
-    read: () => read,
-    readFile: () => readFile,
-    readFileSync: () => readFileSync,
-    readdir: () => readdir,
-    stat: () => stat,
-    writeFile: () => writeFile,
-    writeFileSync: () => writeFileSync
+  // ../loader-utils/src/lib/node/fs.browser.ts
+  var fs_browser_exports = {};
+  __export(fs_browser_exports, {
+    isSupported: () => isSupported
   });
-  async function _readToArrayBuffer(fd, start, length) {
-    const buffer = Buffer.alloc(length);
-    const { bytesRead } = await read(fd, buffer, 0, length, start);
-    if (bytesRead !== length) {
-      throw new Error("fs.read failed");
-    }
-    return toArrayBuffer(buffer);
-  }
-  var import_fs, readdir, stat, readFile, readFileSync, writeFile, writeFileSync, open, close, read, fstat, createWriteStream, isSupported;
-  var init_fs = __esm({
-    "../loader-utils/src/lib/node/fs.ts"() {
-      import_fs = __toModule(require_fs());
-      init_buffer_browser();
-      init_promisify();
-      isSupported = Boolean(import_fs.default);
-      try {
-        readdir = promisify2(import_fs.default.readdir);
-        stat = promisify2(import_fs.default.stat);
-        readFile = import_fs.default.readFile;
-        readFileSync = import_fs.default.readFileSync;
-        writeFile = promisify3(import_fs.default.writeFile);
-        writeFileSync = import_fs.default.writeFileSync;
-        open = import_fs.default.open;
-        close = (fd) => new Promise((resolve2, reject) => import_fs.default.close(fd, (err) => err ? reject(err) : resolve2()));
-        read = import_fs.default.read;
-        fstat = import_fs.default.fstat;
-        createWriteStream = import_fs.default.createWriteStream;
-        isSupported = Boolean(import_fs.default);
-      } catch {
-      }
+  var isSupported;
+  var init_fs_browser = __esm({
+    "../loader-utils/src/lib/node/fs.browser.ts"() {
+      isSupported = false;
     }
   });
 
@@ -1525,6 +1495,7 @@
     "../loader-utils/src/index.ts"() {
       init_assert();
       init_globals();
+      init_merge_loader_options();
       init_parse_with_worker();
       init_encode_with_worker();
       init_array_buffer_utils();
@@ -1535,7 +1506,7 @@
       init_json_loader();
       init_memory_conversion_utils();
       init_path();
-      init_fs();
+      init_fs_browser();
     }
   });
 
@@ -1548,7 +1519,7 @@
       isObject = (x) => x !== null && typeof x === "object";
       isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
       isPromise = (x) => isObject(x) && isFunction(x.then);
-      isIterable = (x) => x && typeof x[Symbol.iterator] === "function";
+      isIterable = (x) => Boolean(x) && typeof x[Symbol.iterator] === "function";
       isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === "function";
       isIterator = (x) => x && isFunction(x.next);
       isResponse = (x) => typeof Response !== "undefined" && x instanceof Response || x && x.arrayBuffer && x.text && x.json;
@@ -1741,29 +1712,45 @@
     }
   });
 
+  // (disabled):src/lib/fetch/fetch-file.node
+  var require_fetch_file = __commonJS({
+    "(disabled):src/lib/fetch/fetch-file.node"() {
+    }
+  });
+
   // src/lib/fetch/fetch-file.ts
-  async function fetchFile(url, options) {
-    if (typeof url === "string") {
-      url = resolvePath(url);
-      let fetchOptions = options;
-      if (options?.fetch && typeof options?.fetch !== "function") {
-        fetchOptions = options.fetch;
+  function isNodePath(url) {
+    return !isRequestURL(url) && !isDataURL(url);
+  }
+  function isRequestURL(url) {
+    return url.startsWith("http:") || url.startsWith("https:");
+  }
+  function isDataURL(url) {
+    return url.startsWith("data:");
+  }
+  async function fetchFile(urlOrData, fetchOptions) {
+    if (typeof urlOrData === "string") {
+      const url = resolvePath(urlOrData);
+      if (isNodePath(url) && node2?.fetchFileNode) {
+        return node2.fetchFileNode(url, fetchOptions);
       }
       return await fetch(url, fetchOptions);
     }
-    return await makeResponse(url);
+    return await makeResponse(urlOrData);
   }
+  var node2;
   var init_fetch_file = __esm({
     "src/lib/fetch/fetch-file.ts"() {
       init_src2();
       init_response_utils();
+      node2 = __toModule(require_fetch_file());
     }
   });
 
   // src/lib/fetch/read-array-buffer.ts
   async function readArrayBuffer(file, start, length) {
     if (typeof file === "number") {
-      return await fs_exports._readToArrayBuffer(file, start, length);
+      return await fs_browser_exports._readToArrayBuffer(file, start, length);
     }
     if (!(file instanceof Blob)) {
       file = new Blob([file]);
@@ -1786,10 +1773,10 @@
   });
 
   // src/lib/fetch/read-file.ts
-  function readFileSync2(url, options = {}) {
+  function readFileSync(url, options = {}) {
     url = resolvePath(url);
     if (!isBrowser) {
-      const buffer = fs_exports.readFileSync(url, options);
+      const buffer = fs_browser_exports.readFileSync(url, options);
       return typeof buffer !== "string" ? toArrayBuffer2(buffer) : buffer;
     }
     if (!options.nothrow) {
@@ -1805,17 +1792,17 @@
   });
 
   // src/lib/fetch/write-file.ts
-  async function writeFile2(filePath, arrayBufferOrString, options) {
+  async function writeFile(filePath, arrayBufferOrString, options) {
     filePath = resolvePath(filePath);
     if (!isBrowser) {
-      await fs_exports.writeFile(filePath, toBuffer2(arrayBufferOrString), { flag: "w" });
+      await fs_browser_exports.writeFile(filePath, toBuffer2(arrayBufferOrString), { flag: "w" });
     }
     assert(false);
   }
-  function writeFileSync2(filePath, arrayBufferOrString, options) {
+  function writeFileSync(filePath, arrayBufferOrString, options) {
     filePath = resolvePath(filePath);
     if (!isBrowser) {
-      fs_exports.writeFileSync(filePath, toBuffer2(arrayBufferOrString), { flag: "w" });
+      fs_browser_exports.writeFileSync(filePath, toBuffer2(arrayBufferOrString), { flag: "w" });
     }
     assert(false);
   }
@@ -1871,11 +1858,11 @@
   });
 
   // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
-  var VERSION4, isBrowser4;
+  var VERSION3, isBrowser4;
   var init_globals4 = __esm({
     "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js"() {
       init_is_browser();
-      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
       isBrowser4 = isBrowser3();
     }
   });
@@ -2212,7 +2199,7 @@
             id: ""
           };
           _defineProperty(this, "id", void 0);
-          _defineProperty(this, "VERSION", VERSION4);
+          _defineProperty(this, "VERSION", VERSION3);
           _defineProperty(this, "_startTs", getHiResTimestamp2());
           _defineProperty(this, "_deltaTs", getHiResTimestamp2());
           _defineProperty(this, "_storage", void 0);
@@ -2415,7 +2402,7 @@
           return noop;
         }
       };
-      _defineProperty(Log, "VERSION", VERSION4);
+      _defineProperty(Log, "VERSION", VERSION3);
     }
   });
 
@@ -2486,6 +2473,7 @@
         mimeType: void 0,
         nothrow: false,
         log: new ConsoleLog(),
+        useLocalLibraries: false,
         CDN: "https://unpkg.com/@loaders.gl",
         worker: true,
         maxConcurrency: 3,
@@ -2527,6 +2515,11 @@
     loaders._state = loaders._state || {};
     return loaders._state;
   }
+  function getGlobalLoaderOptions() {
+    const state = getGlobalLoaderState();
+    state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
+    return state.globalOptions;
+  }
   function setGlobalOptions(options) {
     const state = getGlobalLoaderState();
     const globalOptions = getGlobalLoaderOptions();
@@ -2612,17 +2605,11 @@
       options.baseUri = url;
     }
   }
-  var getGlobalLoaderOptions;
   var init_option_utils = __esm({
     "src/lib/loader-utils/option-utils.ts"() {
       init_is_type();
       init_loggers();
       init_option_defaults();
-      getGlobalLoaderOptions = () => {
-        const state = getGlobalLoaderState();
-        state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
-        return state.globalOptions;
-      };
     }
   });
 
@@ -2766,8 +2753,10 @@
     reason = reason || (loader ? `matched MIME type ${type}` : "");
     loader = loader || findLoaderByInitialBytes(loaders, data);
     reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : "");
-    loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
-    reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+    if (options?.fallbackMimeType) {
+      loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
+      reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+    }
     if (reason) {
       log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`);
     }
@@ -2863,7 +2852,7 @@
     }
     switch (typeof test) {
       case "function":
-        return test(data, loader);
+        return test(data);
       case "string":
         const magic = getMagicString(data, byteOffset, test.length);
         return test === magic;
@@ -3094,7 +3083,7 @@
       return makeIterator(data, options);
     }
     if (isAsyncIterable(data)) {
-      return data[Symbol.asyncIterator]();
+      return data;
     }
     return getIterableFromData(data);
   }
@@ -3131,12 +3120,12 @@
   // src/lib/loader-utils/get-fetch-function.ts
   function getFetchFunction(options, context) {
     const globalOptions = getGlobalLoaderOptions();
-    const fetchOptions = options || globalOptions;
-    if (typeof fetchOptions.fetch === "function") {
-      return fetchOptions.fetch;
+    const loaderOptions = options || globalOptions;
+    if (typeof loaderOptions.fetch === "function") {
+      return loaderOptions.fetch;
     }
-    if (isObject(fetchOptions.fetch)) {
-      return (url) => fetchFile(url, fetchOptions);
+    if (isObject(loaderOptions.fetch)) {
+      return (url) => fetchFile(url, loaderOptions.fetch);
     }
     if (context?.fetch) {
       return context?.fetch;
@@ -3173,7 +3162,7 @@
     return newContext;
   }
   function getLoadersFromContext(loaders, context) {
-    if (!context && loaders && !Array.isArray(loaders)) {
+    if (loaders && !Array.isArray(loaders)) {
       return loaders;
     }
     let candidateLoaders;
@@ -3184,7 +3173,7 @@
       const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
       candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
     }
-    return candidateLoaders && candidateLoaders.length ? candidateLoaders : null;
+    return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
   }
   var init_loader_context = __esm({
     "src/lib/loader-utils/loader-context.ts"() {
@@ -3196,7 +3185,6 @@
 
   // src/lib/api/parse.ts
   async function parse(data, loaders, options, context) {
-    assert2(!context || typeof context === "object");
     if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
       context = void 0;
       options = loaders;
@@ -3212,11 +3200,12 @@
       return null;
     }
     options = normalizeOptions(options, loader, candidateLoaders, url);
-    context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context || null);
+    context = getLoaderContext({ url, _parse: parse, loaders: candidateLoaders }, options, context || null);
     return await parseWithLoader(loader, data, options, context);
   }
   async function parseWithLoader(loader, data, options, context) {
     validateWorkerVersion(loader);
+    options = mergeLoaderOptions(loader.options, options);
     if (isResponse(data)) {
       const response = data;
       const { ok, redirected, status, statusText, type, url } = response;
@@ -3224,29 +3213,30 @@
       context.response = { headers, ok, redirected, status, statusText, type, url };
     }
     data = await getArrayBufferOrStringFromData(data, loader, options);
-    if (loader.parseTextSync && typeof data === "string") {
-      options.dataType = "text";
-      return loader.parseTextSync(data, options, context, loader);
+    const loaderWithParser = loader;
+    if (loaderWithParser.parseTextSync && typeof data === "string") {
+      return loaderWithParser.parseTextSync(data, options, context);
     }
     if (canParseWithWorker(loader, options)) {
       return await parseWithWorker(loader, data, options, context, parse);
     }
-    if (loader.parseText && typeof data === "string") {
-      return await loader.parseText(data, options, context, loader);
+    if (loaderWithParser.parseText && typeof data === "string") {
+      return await loaderWithParser.parseText(data, options, context);
     }
-    if (loader.parse) {
-      return await loader.parse(data, options, context, loader);
+    if (loaderWithParser.parse) {
+      return await loaderWithParser.parse(data, options, context);
     }
-    assert2(!loader.parseSync);
+    assert2(!loaderWithParser.parseSync);
     throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
   }
   var init_parse = __esm({
     "src/lib/api/parse.ts"() {
-      init_src();
       init_src2();
+      init_src();
       init_normalize_loader();
       init_is_type();
       init_option_utils();
+      init_src2();
       init_get_data();
       init_loader_context();
       init_resource_utils();
@@ -3256,7 +3246,6 @@
 
   // src/lib/api/parse-sync.ts
   function parseSync(data, loaders, options, context) {
-    assert(!context || typeof context === "object");
     if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
       context = void 0;
       options = loaders;
@@ -3274,7 +3263,7 @@
     const parse2 = () => {
       throw new Error("parseSync called parse (which is async");
     };
-    context = getLoaderContext({ url, parseSync, parse: parse2, loaders }, options, context || null);
+    context = getLoaderContext({ url, _parseSync: parse2, _parse: parse2, loaders }, options, context || null);
     return parseWithLoaderSync(loader, data, options, context);
   }
   function parseWithLoaderSync(loader, data, options, context) {
@@ -3289,7 +3278,6 @@
   }
   var init_parse_sync = __esm({
     "src/lib/api/parse-sync.ts"() {
-      init_src2();
       init_select_loader();
       init_normalize_loader();
       init_option_utils();
@@ -3301,7 +3289,6 @@
 
   // src/lib/api/parse-in-batches.ts
   async function parseInBatches(data, loaders, options, context) {
-    assert(!context || typeof context === "object");
     const loaderArray = Array.isArray(loaders) ? loaders : void 0;
     if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
       context = void 0;
@@ -3313,10 +3300,10 @@
     const url = getResourceUrl(data);
     const loader = await selectLoader(data, loaders, options);
     if (!loader) {
-      return null;
+      return [];
     }
     options = normalizeOptions(options, loader, loaderArray, url);
-    context = getLoaderContext({ url, parseInBatches, parse, loaders: loaderArray }, options, context || null);
+    context = getLoaderContext({ url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray }, options, context || null);
     return await parseWithLoaderInBatches(loader, data, options, context);
   }
   async function parseWithLoaderInBatches(loader, data, options, context) {
@@ -3412,25 +3399,28 @@
 
   // src/lib/api/load-in-batches.ts
   function loadInBatches(files, loaders, options, context) {
+    let loadersArray;
     if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
       context = void 0;
       options = loaders;
-      loaders = null;
+      loadersArray = void 0;
+    } else {
+      loadersArray = loaders;
     }
     const fetch2 = getFetchFunction(options || {});
     if (!Array.isArray(files)) {
-      return loadOneFileInBatches(files, loaders, options, fetch2);
+      return loadOneFileInBatches(files, loadersArray, options || {}, fetch2);
     }
-    const promises = files.map((file) => loadOneFileInBatches(file, loaders, options, fetch2));
+    const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}, fetch2));
     return promises;
   }
   async function loadOneFileInBatches(file, loaders, options, fetch2) {
     if (typeof file === "string") {
       const url = file;
       const response = await fetch2(url);
-      return await parseInBatches(response, loaders, options);
+      return Array.isArray(loaders) ? await parseInBatches(response, loaders, options) : await parseInBatches(response, loaders, options);
     }
-    return await parseInBatches(file, loaders, options);
+    return Array.isArray(loaders) ? await parseInBatches(file, loaders, options) : await parseInBatches(file, loaders, options);
   }
   var init_load_in_batches = __esm({
     "src/lib/api/load-in-batches.ts"() {
@@ -3467,7 +3457,7 @@
       const arrayBuffer = await encodeTable(data, writer, options);
       return new TextDecoder().decode(arrayBuffer);
     }
-    throw new Error("Writer could not encode data as text");
+    throw new Error(`Writer ${writer.name} could not encode data as text`);
   }
   function encodeTableInBatches(data, writer, options) {
     if (writer.encodeInBatches) {
@@ -3477,7 +3467,7 @@
     throw new Error("Writer could not encode data in batches");
   }
   function getIterator(data) {
-    const dataIterator = [{ table: data, start: 0, end: data.length }];
+    const dataIterator = [{ ...data, start: 0, end: data.length }];
     return dataIterator;
   }
   var init_encode_table = __esm({
@@ -3512,7 +3502,7 @@
     }
     if (!isBrowser && writer.encodeURLtoURL) {
       const tmpInputFilename = getTemporaryFilename("input");
-      await writeFile2(tmpInputFilename, data);
+      await writeFile(tmpInputFilename, data);
       const tmpOutputFilename = getTemporaryFilename("output");
       const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
       const response = await fetchFile(outputFilename);
@@ -3534,7 +3524,17 @@
       const arrayBuffer = await encode(data, writer, options);
       return new TextDecoder().decode(arrayBuffer);
     }
-    throw new Error("Writer could not encode data as text");
+    throw new Error(`Writer ${writer.name} could not encode data as text`);
+  }
+  function encodeTextSync(data, writer, options) {
+    if (writer.text && writer.encodeTextSync) {
+      return writer.encodeTextSync(data, options);
+    }
+    if (writer.text && writer.encodeSync) {
+      const arrayBuffer = encodeSync(data, writer, options);
+      return new TextDecoder().decode(arrayBuffer);
+    }
+    throw new Error(`Writer ${writer.name} could not encode data as text`);
   }
   function encodeInBatches(data, writer, options) {
     if (writer.encodeInBatches) {
@@ -3553,7 +3553,7 @@
     return outputFilename;
   }
   function getIterator2(data) {
-    const dataIterator = [{ table: data, start: 0, end: data.length }];
+    const dataIterator = [{ ...data, start: 0, end: data.length }];
     return dataIterator;
   }
   function getTemporaryFilename(filename2) {
@@ -3574,11 +3574,11 @@
   // src/lib/api/save.ts
   async function save(data, url, writer, options) {
     const encodedData = await encode(data, writer, options);
-    return await writeFile2(url, encodedData);
+    return await writeFile(url, encodedData);
   }
   function saveSync(data, url, writer, options) {
     const encodedData = encodeSync(data, writer, options);
-    return writeFileSync2(url, encodedData);
+    return writeFileSync(url, encodedData);
   }
   var init_save = __esm({
     "src/lib/api/save.ts"() {
@@ -3619,20 +3619,17 @@
 
   // src/null-loader.ts
   function parseSync2(arrayBuffer, options, context) {
-    if (!options.null.echoParameters)
-      return null;
-    context = context && JSON.parse(JSON.stringify(context));
-    return { arrayBuffer, options, context };
+    return null;
   }
-  var VERSION5, NullWorkerLoader, NullLoader;
+  var VERSION4, NullWorkerLoader, NullLoader;
   var init_null_loader = __esm({
     "src/null-loader.ts"() {
-      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       NullWorkerLoader = {
         name: "Null loader",
         id: "null",
         module: "core",
-        version: VERSION5,
+        version: VERSION4,
         worker: true,
         mimeTypes: ["application/x.empty"],
         extensions: ["null"],
@@ -3645,10 +3642,10 @@
         name: "Null loader",
         id: "null",
         module: "core",
-        version: VERSION5,
+        version: VERSION4,
         mimeTypes: ["application/x.empty"],
         extensions: ["null"],
-        parse: async (arrayBuffer, options, context) => parseSync2(arrayBuffer, options, context),
+        parse: async (arrayBuffer, options, context) => parseSync2(arrayBuffer, options || {}, context),
         parseSync: parseSync2,
         parseInBatches: async function* generator(asyncIterator, options, context) {
           for await (const batch of asyncIterator) {
@@ -3657,9 +3654,7 @@
         },
         tests: [() => false],
         options: {
-          null: {
-            echoParameters: false
-          }
+          null: {}
         }
       };
     }
@@ -3688,12 +3683,12 @@
     const progressStream = new ReadableStream({
       async start(controller) {
         const reader = body.getReader();
-        await read2(controller, reader, 0, totalBytes, onProgress, onDone, onError);
+        await read(controller, reader, 0, totalBytes, onProgress, onDone, onError);
       }
     });
     return new Response(progressStream);
   }
-  async function read2(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError) {
+  async function read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError) {
     try {
       const { done, value } = await reader.read();
       if (done) {
@@ -3705,7 +3700,7 @@
       const percent = Math.round(loadedBytes / totalBytes * 100);
       onProgress(percent, { loadedBytes, totalBytes });
       controller.enqueue(value);
-      await read2(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);
+      await read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);
     } catch (error) {
       controller.error(error);
       onError(error);
@@ -3818,6 +3813,7 @@
     encodeTableAsText: () => encodeTableAsText,
     encodeTableInBatches: () => encodeTableInBatches,
     encodeText: () => encodeText,
+    encodeTextSync: () => encodeTextSync,
     encodeURLtoURL: () => encodeURLtoURL,
     fetchFile: () => fetchFile,
     forEach: () => forEach,
@@ -3846,7 +3842,7 @@
     parseInBatches: () => parseInBatches,
     parseSync: () => parseSync,
     readArrayBuffer: () => readArrayBuffer,
-    readFileSync: () => readFileSync2,
+    readFileSync: () => readFileSync,
     registerLoaders: () => registerLoaders,
     resolvePath: () => resolvePath,
     save: () => save,
@@ -3857,8 +3853,8 @@
     setLoaderOptions: () => setGlobalOptions,
     setPathPrefix: () => setPathPrefix,
     window: () => window_,
-    writeFile: () => writeFile2,
-    writeFileSync: () => writeFileSync2
+    writeFile: () => writeFile,
+    writeFileSync: () => writeFileSync
   });
   var init_src3 = __esm({
     "src/index.ts"() {
@@ -3876,6 +3872,7 @@
       init_load_in_batches();
       init_encode_table();
       init_encode();
+      init_encode();
       init_save();
       init_src2();
       init_src2();