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

package/dist/dist.min.js

@@ -672,10 +672,12 @@
     const workerFarm = WorkerFarm.getWorkerFarm(options);
     const workerPool = workerFarm.getWorkerPool({ name, url });
     options = JSON.parse(JSON.stringify(options));
+    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;
@@ -3604,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";
@@ -3626,6 +3634,7 @@
       init_src();
       init_src2();
       init_normalize_loader();
+      init_is_type();
       init_option_utils();
       init_get_data();
       init_loader_context();
@@ -3946,6 +3955,12 @@
   });
 
   // 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 };
+  }
   var VERSION6, NullWorkerLoader, NullLoader;
   var init_null_loader = __esm({
     "src/null-loader.ts"() {
@@ -3970,16 +3985,18 @@
         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
+          }
         }
       };
     }

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

@@ -19,6 +19,8 @@ var _loaderUtils = require("@loaders.gl/loader-utils");
 
 var _normalizeLoader = require("../loader-utils/normalize-loader");
 
+var _isType = require("../../javascript-utils/is-type");
+
 var _optionUtils = require("../loader-utils/option-utils");
 
 var _getData = require("../loader-utils/get-data");
@@ -100,66 +102,83 @@ function parseWithLoader(_x5, _x6, _x7, _x8) {
 
 function _parseWithLoader() {
   _parseWithLoader = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(loader, data, options, context) {
+    var response, ok, redirected, status, statusText, type, url, headers;
     return _regenerator.default.wrap(function _callee2$(_context2) {
       while (1) {
         switch (_context2.prev = _context2.next) {
           case 0:
             (0, _workerUtils.validateWorkerVersion)(loader);
-            _context2.next = 3;
+
+            if ((0, _isType.isResponse)(data)) {
+              response = data;
+              ok = response.ok, redirected = response.redirected, status = response.status, statusText = response.statusText, type = response.type, url = response.url;
+              headers = Object.fromEntries(response.headers.entries());
+              context.response = {
+                headers: headers,
+                ok: ok,
+                redirected: redirected,
+                status: status,
+                statusText: statusText,
+                type: type,
+                url: url
+              };
+            }
+
+            _context2.next = 4;
             return (0, _getData.getArrayBufferOrStringFromData)(data, loader, options);
 
-          case 3:
+          case 4:
             data = _context2.sent;
 
             if (!(loader.parseTextSync && typeof data === 'string')) {
-              _context2.next = 7;
+              _context2.next = 8;
               break;
             }
 
             options.dataType = 'text';
             return _context2.abrupt("return", loader.parseTextSync(data, options, context, loader));
 
-          case 7:
+          case 8:
             if (!(0, _loaderUtils.canParseWithWorker)(loader, options)) {
-              _context2.next = 11;
+              _context2.next = 12;
               break;
             }
 
-            _context2.next = 10;
+            _context2.next = 11;
             return (0, _loaderUtils.parseWithWorker)(loader, data, options, context, parse);
 
-          case 10:
+          case 11:
             return _context2.abrupt("return", _context2.sent);
 
-          case 11:
+          case 12:
             if (!(loader.parseText && typeof data === 'string')) {
-              _context2.next = 15;
+              _context2.next = 16;
               break;
             }
 
-            _context2.next = 14;
+            _context2.next = 15;
             return loader.parseText(data, options, context, loader);
 
-          case 14:
+          case 15:
             return _context2.abrupt("return", _context2.sent);
 
-          case 15:
+          case 16:
             if (!loader.parse) {
-              _context2.next = 19;
+              _context2.next = 20;
               break;
             }
 
-            _context2.next = 18;
+            _context2.next = 19;
             return loader.parse(data, options, context, loader);
 
-          case 18:
+          case 19:
             return _context2.abrupt("return", _context2.sent);
 
-          case 19:
+          case 20:
             (0, _workerUtils.assert)(!loader.parseSync);
             throw new Error("".concat(loader.id, " loader - no parser found and worker is disabled"));
 
-          case 21:
+          case 22:
           case "end":
             return _context2.stop();
         }

package/dist/es5/lib/api/parse.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/api/parse.ts"],"names":["parse","data","loaders","options","context","Array","isArray","undefined","url","typedLoaders","candidateLoaders","loader","parseWithLoader","parseTextSync","dataType","parseText","parseSync","Error","id"],"mappings":"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","sourcesContent":["import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';\nimport {parseWithWorker, canParseWithWorker} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getArrayBufferOrStringFromData} from '../loader-utils/get-data';\nimport {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport async function parse(\n  data: DataType | Promise<DataType>,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<any> {\n  assert(!context || typeof context === 'object'); // parse no longer accepts final url\n\n  // Signature: parse(data, options, context | url)\n  // Uses registered loaders\n  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders as LoaderOptions;\n    loaders = undefined;\n  }\n\n  data = await data; // Resolve any promise\n  options = options || {};\n\n  // Extract a url for auto detection\n  const {url} = getResourceUrlAndType(data);\n\n  // Chooses a loader (and normalizes it)\n  // Also use any loaders in the context, new loaders take priority\n  const typedLoaders = loaders as Loader | Loader[] | undefined;\n  const candidateLoaders = getLoadersFromContext(typedLoaders, context);\n  // todo hacky type cast\n  const loader = await selectLoader(data as ArrayBuffer, candidateLoaders, options);\n  // Note: if no loader was found, if so just return null\n  if (!loader) {\n    return null;\n  }\n\n  // Normalize options\n  options = normalizeOptions(options, loader, candidateLoaders, url);\n\n  // Get a context (if already present, will be unchanged)\n  context = getLoaderContext({url, parse, loaders: candidateLoaders}, options, context);\n\n  return await parseWithLoader(loader, data, options, context);\n}\n\n// TODO: support progress and abort\n// TODO - should accept loader.parseAsyncIterator and concatenate.\nasync function parseWithLoader(loader, data, options, context) {\n  validateWorkerVersion(loader);\n\n  data = await getArrayBufferOrStringFromData(data, loader, options);\n\n  // First check for synchronous text parser, wrap results in promises\n  if (loader.parseTextSync && typeof data === 'string') {\n    options.dataType = 'text';\n    return loader.parseTextSync(data, options, context, loader);\n  }\n\n  // If we have a workerUrl and the loader can parse the given options efficiently in a worker\n  if (canParseWithWorker(loader, options)) {\n    return await parseWithWorker(loader, data, options, context, parse);\n  }\n\n  // Check for asynchronous parser\n  if (loader.parseText && typeof data === 'string') {\n    return await loader.parseText(data, options, context, loader);\n  }\n\n  if (loader.parse) {\n    return await loader.parse(data, options, context, loader);\n  }\n\n  // This should not happen, all sync loaders should also offer `parse` function\n  assert(!loader.parseSync);\n\n  // TBD - If asynchronous parser not available, return null\n  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);\n}\n"],"file":"parse.js"}
+{"version":3,"sources":["../../../../src/lib/api/parse.ts"],"names":["parse","data","loaders","options","context","Array","isArray","undefined","url","typedLoaders","candidateLoaders","loader","parseWithLoader","response","ok","redirected","status","statusText","type","headers","Object","fromEntries","entries","parseTextSync","dataType","parseText","parseSync","Error","id"],"mappings":"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","sourcesContent":["import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';\nimport {parseWithWorker, canParseWithWorker} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {isResponse} from '../../javascript-utils/is-type';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getArrayBufferOrStringFromData} from '../loader-utils/get-data';\nimport {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport async function parse(\n  data: DataType | Promise<DataType>,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<any> {\n  assert(!context || typeof context === 'object'); // parse no longer accepts final url\n\n  // Signature: parse(data, options, context | url)\n  // Uses registered loaders\n  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders as LoaderOptions;\n    loaders = undefined;\n  }\n\n  data = await data; // Resolve any promise\n  options = options || {};\n\n  // Extract a url for auto detection\n  const {url} = getResourceUrlAndType(data);\n\n  // Chooses a loader (and normalizes it)\n  // Also use any loaders in the context, new loaders take priority\n  const typedLoaders = loaders as Loader | Loader[] | undefined;\n  const candidateLoaders = getLoadersFromContext(typedLoaders, context);\n  // todo hacky type cast\n  const loader = await selectLoader(data as ArrayBuffer, candidateLoaders, options);\n  // Note: if no loader was found, if so just return null\n  if (!loader) {\n    return null;\n  }\n\n  // Normalize options\n  options = normalizeOptions(options, loader, candidateLoaders, url);\n\n  // Get a context (if already present, will be unchanged)\n  context = getLoaderContext({url, parse, loaders: candidateLoaders}, options, context);\n\n  return await parseWithLoader(loader, data, options, context);\n}\n\n// TODO: support progress and abort\n// TODO - should accept loader.parseAsyncIterator and concatenate.\nasync function parseWithLoader(loader, data, options, context) {\n  validateWorkerVersion(loader);\n\n  if (isResponse(data)) {\n    // Serialize to support passing the response to web worker\n    const response = data as Response;\n    const {ok, redirected, status, statusText, type, url} = response;\n    const headers = Object.fromEntries(response.headers.entries());\n    context.response = {headers, ok, redirected, status, statusText, type, url};\n  }\n\n  data = await getArrayBufferOrStringFromData(data, loader, options);\n\n  // First check for synchronous text parser, wrap results in promises\n  if (loader.parseTextSync && typeof data === 'string') {\n    options.dataType = 'text';\n    return loader.parseTextSync(data, options, context, loader);\n  }\n\n  // If we have a workerUrl and the loader can parse the given options efficiently in a worker\n  if (canParseWithWorker(loader, options)) {\n    return await parseWithWorker(loader, data, options, context, parse);\n  }\n\n  // Check for asynchronous parser\n  if (loader.parseText && typeof data === 'string') {\n    return await loader.parseText(data, options, context, loader);\n  }\n\n  if (loader.parse) {\n    return await loader.parse(data, options, context, loader);\n  }\n\n  // This should not happen, all sync loaders should also offer `parse` function\n  assert(!loader.parseSync);\n\n  // TBD - If asynchronous parser not available, return null\n  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);\n}\n"],"file":"parse.js"}

package/dist/es5/lib/init.js

@@ -7,7 +7,7 @@ exports.default = void 0;
 
 var _log = require("./utils/log");
 
-var version = typeof "3.2.0-alpha.2" !== 'undefined' ? "3.2.0-alpha.2" : '';
+var version = typeof "3.2.0" !== 'undefined' ? "3.2.0" : '';
 
 if (!globalThis.loaders) {
   _log.log.log(1, "loaders.gl ".concat(version))();

package/dist/es5/lib/init.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/init.ts"],"names":["version","globalThis","loaders","log","Object","assign","VERSION"],"mappings":";;;;;;;AACA;;AAGA,IAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,EAAnE;;AAGA,IAAI,CAACC,UAAU,CAACC,OAAhB,EAAyB;AACvBC,WAAIA,GAAJ,CAAQ,CAAR,uBAAyBH,OAAzB;;AAEAC,EAAAA,UAAU,CAACC,OAAX,GAAqBE,MAAM,CAACC,MAAP,CAAcJ,UAAU,CAACC,OAAX,IAAsB,EAApC,EAAwC;AAC3DI,IAAAA,OAAO,EAAEN,OADkD;AAE3DG,IAAAA,GAAG,EAAHA;AAF2D,GAAxC,CAArB;AAID;;eAEcF,UAAU,CAACC,O","sourcesContent":["// loaders.gl, MIT license\nimport {log} from './utils/log';\n\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst version = typeof __VERSION__ !== 'undefined' ? __VERSION__ : '';\n\n// @ts-ignore\nif (!globalThis.loaders) {\n  log.log(1, `loaders.gl ${version}`)();\n\n  globalThis.loaders = Object.assign(globalThis.loaders || {}, {\n    VERSION: version,\n    log\n  });\n}\n// @ts-ignore\nexport default globalThis.loaders;\n"],"file":"init.js"}
+{"version":3,"sources":["../../../src/lib/init.ts"],"names":["version","globalThis","loaders","log","Object","assign","VERSION"],"mappings":";;;;;;;AACA;;AAGA,IAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,EAAnE;;AAGA,IAAI,CAACC,UAAU,CAACC,OAAhB,EAAyB;AACvBC,WAAIA,GAAJ,CAAQ,CAAR,uBAAyBH,OAAzB;;AAEAC,EAAAA,UAAU,CAACC,OAAX,GAAqBE,MAAM,CAACC,MAAP,CAAcJ,UAAU,CAACC,OAAX,IAAsB,EAApC,EAAwC;AAC3DI,IAAAA,OAAO,EAAEN,OADkD;AAE3DG,IAAAA,GAAG,EAAHA;AAF2D,GAAxC,CAArB;AAID;;eAEcF,UAAU,CAACC,O","sourcesContent":["// loaders.gl, MIT license\nimport {log} from './utils/log';\n\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst version = typeof __VERSION__ !== 'undefined' ? __VERSION__ : '';\n\n// @ts-ignore\nif (!globalThis.loaders) {\n  log.log(1, `loaders.gl ${version}`)();\n\n  globalThis.loaders = Object.assign(globalThis.loaders || {}, {\n    VERSION: version,\n    log\n  });\n}\n// @ts-ignore\nexport default globalThis.loaders;\n"],"file":"init.js"}

package/dist/es5/null-loader.js

@@ -17,7 +17,7 @@ var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helper
 
 var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
 
-var VERSION = typeof "3.2.0-alpha.2" !== 'undefined' ? "3.2.0-alpha.2" : 'latest';
+var VERSION = typeof "3.2.0" !== 'undefined' ? "3.2.0" : 'latest';
 var NullWorkerLoader = {
   name: 'Null loader',
   id: 'null',
@@ -34,6 +34,17 @@ var NullWorkerLoader = {
   }
 };
 exports.NullWorkerLoader = NullWorkerLoader;
+
+function parseSync(arrayBuffer, options, context) {
+  if (!options.null.echoParameters) return null;
+  context = context && JSON.parse(JSON.stringify(context));
+  return {
+    arrayBuffer: arrayBuffer,
+    options: options,
+    context: context
+  };
+}
+
 var NullLoader = {
   name: 'Null loader',
   id: 'null',
@@ -42,12 +53,12 @@ var NullLoader = {
   mimeTypes: ['application/x.empty'],
   extensions: ['null'],
   parse: function () {
-    var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer) {
+    var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer, options, context) {
       return _regenerator.default.wrap(function _callee$(_context) {
         while (1) {
           switch (_context.prev = _context.next) {
             case 0:
-              return _context.abrupt("return", arrayBuffer);
+              return _context.abrupt("return", parseSync(arrayBuffer, options, context));
 
             case 1:
             case "end":
@@ -57,17 +68,15 @@ var NullLoader = {
       }, _callee);
     }));
 
-    function parse(_x2) {
+    function parse(_x4, _x5, _x6) {
       return _parse.apply(this, arguments);
     }
 
     return parse;
   }(),
-  parseSync: function parseSync(arrayBuffer) {
-    return arrayBuffer;
-  },
+  parseSync: parseSync,
   parseInBatches: function () {
-    var _generator = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee2(asyncIterator) {
+    var _generator = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee2(asyncIterator, options, context) {
       var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, batch;
 
       return _regenerator.default.wrap(function _callee2$(_context2) {
@@ -99,7 +108,7 @@ var NullLoader = {
 
               batch = _value;
               _context2.next = 15;
-              return batch;
+              return parseSync(batch, options, context);
 
             case 15:
               _iteratorNormalCompletion = true;
@@ -152,7 +161,7 @@ var NullLoader = {
       }, _callee2, null, [[2, 20, 24, 34], [25,, 29, 33]]);
     }));
 
-    function generator(_x) {
+    function generator(_x, _x2, _x3) {
       return _generator.apply(this, arguments);
     }
 
@@ -162,7 +171,9 @@ var NullLoader = {
     return false;
   }],
   options: {
-    null: {}
+    null: {
+      echoParameters: false
+    }
   }
 };
 exports.NullLoader = NullLoader;

package/dist/es5/null-loader.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/null-loader.ts"],"names":["VERSION","NullWorkerLoader","name","id","module","version","worker","mimeTypes","extensions","tests","options","null","NullLoader","parse","arrayBuffer","parseSync","parseInBatches","asyncIterator","batch","generator"],"mappings":";;;;;;;;;;;;;;;;;;;AAEA,IAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAOO,IAAMC,gBAAwB,GAAG;AACtCC,EAAAA,IAAI,EAAE,aADgC;AAEtCC,EAAAA,EAAE,EAAE,MAFkC;AAGtCC,EAAAA,MAAM,EAAE,MAH8B;AAItCC,EAAAA,OAAO,EAAEL,OAJ6B;AAKtCM,EAAAA,MAAM,EAAE,IAL8B;AAMtCC,EAAAA,SAAS,EAAE,CAAC,qBAAD,CAN2B;AAOtCC,EAAAA,UAAU,EAAE,CAAC,MAAD,CAP0B;AAQtCC,EAAAA,KAAK,EAAE,CAAC;AAAA,WAAM,KAAN;AAAA,GAAD,CAR+B;AAStCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAT6B,CAAjC;;AAiBA,IAAMC,UAA4B,GAAG;AAC1CV,EAAAA,IAAI,EAAE,aADoC;AAE1CC,EAAAA,EAAE,EAAE,MAFsC;AAG1CC,EAAAA,MAAM,EAAE,MAHkC;AAI1CC,EAAAA,OAAO,EAAEL,OAJiC;AAK1CO,EAAAA,SAAS,EAAE,CAAC,qBAAD,CAL+B;AAM1CC,EAAAA,UAAU,EAAE,CAAC,MAAD,CAN8B;AAO1CK,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP;AAAA;AAAA;AAAA;AAAA;AAAA,+CAAuBA,WAAvB;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAPqC;AAQ1CC,EAAAA,SAAS,EAAE,mBAACD,WAAD;AAAA,WAAiBA,WAAjB;AAAA,GAR+B;AAS1CE,EAAAA,cAAc;AAAA,iFAAE,kBAA0BC,aAA1B;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uDACYA,aADZ;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AACGC,cAAAA,KADH;AAAA;AAEZ,qBAAMA,KAAN;;AAFY;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA,aAAkBC,SAAlB;AAAA;AAAA;;AAAA,WAAkBA,SAAlB;AAAA,KAT4B;AAc1CV,EAAAA,KAAK,EAAE,CAAC;AAAA,WAAM,KAAN;AAAA,GAAD,CAdmC;AAe1CC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAfiC,CAArC","sourcesContent":["// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nimport {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullWorkerLoader: Loader = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  worker: true,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  tests: [() => false],\n  options: {\n    null: {}\n  }\n};\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullLoader: LoaderWithParser = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  parse: async (arrayBuffer) => arrayBuffer,\n  parseSync: (arrayBuffer) => arrayBuffer,\n  parseInBatches: async function* generator(asyncIterator) {\n    for await (const batch of asyncIterator) {\n      yield batch;\n    }\n  },\n  tests: [() => false],\n  options: {\n    null: {}\n  }\n};\n"],"file":"null-loader.js"}
+{"version":3,"sources":["../../src/null-loader.ts"],"names":["VERSION","NullWorkerLoader","name","id","module","version","worker","mimeTypes","extensions","tests","options","null","parseSync","arrayBuffer","context","echoParameters","JSON","parse","stringify","NullLoader","parseInBatches","asyncIterator","batch","generator"],"mappings":";;;;;;;;;;;;;;;;;;;AAEA,IAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AAOO,IAAMC,gBAAwB,GAAG;AACtCC,EAAAA,IAAI,EAAE,aADgC;AAEtCC,EAAAA,EAAE,EAAE,MAFkC;AAGtCC,EAAAA,MAAM,EAAE,MAH8B;AAItCC,EAAAA,OAAO,EAAEL,OAJ6B;AAKtCM,EAAAA,MAAM,EAAE,IAL8B;AAMtCC,EAAAA,SAAS,EAAE,CAAC,qBAAD,CAN2B;AAOtCC,EAAAA,UAAU,EAAE,CAAC,MAAD,CAP0B;AAQtCC,EAAAA,KAAK,EAAE,CAAC;AAAA,WAAM,KAAN;AAAA,GAAD,CAR+B;AAStCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAT6B,CAAjC;;;AAkBP,SAASC,SAAT,CAAmBC,WAAnB,EAAgCH,OAAhC,EAAyCI,OAAzC,EAAkD;AAChD,MAAI,CAACJ,OAAO,CAACC,IAAR,CAAaI,cAAlB,EAAkC,OAAO,IAAP;AAClCD,EAAAA,OAAO,GAAGA,OAAO,IAAIE,IAAI,CAACC,KAAL,CAAWD,IAAI,CAACE,SAAL,CAAeJ,OAAf,CAAX,CAArB;AACA,SAAO;AAACD,IAAAA,WAAW,EAAXA,WAAD;AAAcH,IAAAA,OAAO,EAAPA,OAAd;AAAuBI,IAAAA,OAAO,EAAPA;AAAvB,GAAP;AACD;;AAKM,IAAMK,UAA4B,GAAG;AAC1CjB,EAAAA,IAAI,EAAE,aADoC;AAE1CC,EAAAA,EAAE,EAAE,MAFsC;AAG1CC,EAAAA,MAAM,EAAE,MAHkC;AAI1CC,EAAAA,OAAO,EAAEL,OAJiC;AAK1CO,EAAAA,SAAS,EAAE,CAAC,qBAAD,CAL+B;AAM1CC,EAAAA,UAAU,EAAE,CAAC,MAAD,CAN8B;AAO1CS,EAAAA,KAAK;AAAA,2EAAE,iBAAOJ,WAAP,EAAoBH,OAApB,EAA6BI,OAA7B;AAAA;AAAA;AAAA;AAAA;AAAA,+CAAyCF,SAAS,CAACC,WAAD,EAAcH,OAAd,EAAuBI,OAAvB,CAAlD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAPqC;AAQ1CF,EAAAA,SAAS,EAATA,SAR0C;AAS1CQ,EAAAA,cAAc;AAAA,iFAAE,kBAA0BC,aAA1B,EAAyCX,OAAzC,EAAkDI,OAAlD;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uDACYO,aADZ;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AACGC,cAAAA,KADH;AAAA;AAEZ,qBAAMV,SAAS,CAACU,KAAD,EAAQZ,OAAR,EAAiBI,OAAjB,CAAf;;AAFY;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA,aAAkBS,SAAlB;AAAA;AAAA;;AAAA,WAAkBA,SAAlB;AAAA,KAT4B;AAc1Cd,EAAAA,KAAK,EAAE,CAAC;AAAA,WAAM,KAAN;AAAA,GAAD,CAdmC;AAe1CC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AACJI,MAAAA,cAAc,EAAE;AADZ;AADC;AAfiC,CAArC","sourcesContent":["// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nimport {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullWorkerLoader: Loader = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  worker: true,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  tests: [() => false],\n  options: {\n    null: {}\n  }\n};\n\n/**\n * Returns arguments passed to the parse API in a format that can be transfered to a\n * web worker. The `context` parameter is stripped using JSON.stringify & parse.\n */\nfunction parseSync(arrayBuffer, options, context) {\n  if (!options.null.echoParameters) return null;\n  context = context && JSON.parse(JSON.stringify(context));\n  return {arrayBuffer, options, context};\n}\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullLoader: LoaderWithParser = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options, context),\n  parseSync,\n  parseInBatches: async function* generator(asyncIterator, options, context) {\n    for await (const batch of asyncIterator) {\n      yield parseSync(batch, options, context);\n    }\n  },\n  tests: [() => false],\n  options: {\n    null: {\n      echoParameters: false\n    }\n  }\n};\n"],"file":"null-loader.js"}

package/dist/esm/lib/api/parse.js

@@ -1,6 +1,7 @@
 import { assert, validateWorkerVersion } from '@loaders.gl/worker-utils';
 import { parseWithWorker, canParseWithWorker } from '@loaders.gl/loader-utils';
 import { isLoaderObject } from '../loader-utils/normalize-loader';
+import { isResponse } from '../../javascript-utils/is-type';
 import { normalizeOptions } from '../loader-utils/option-utils';
 import { getArrayBufferOrStringFromData } from '../loader-utils/get-data';
 import { getLoaderContext, getLoadersFromContext } from '../loader-utils/loader-context';
@@ -39,6 +40,29 @@ export async function parse(data, loaders, options, context) {
 
 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') {

package/dist/esm/lib/api/parse.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/api/parse.ts"],"names":["assert","validateWorkerVersion","parseWithWorker","canParseWithWorker","isLoaderObject","normalizeOptions","getArrayBufferOrStringFromData","getLoaderContext","getLoadersFromContext","getResourceUrlAndType","selectLoader","parse","data","loaders","options","context","Array","isArray","undefined","url","typedLoaders","candidateLoaders","loader","parseWithLoader","parseTextSync","dataType","parseText","parseSync","Error","id"],"mappings":"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","sourcesContent":["import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';\nimport {parseWithWorker, canParseWithWorker} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getArrayBufferOrStringFromData} from '../loader-utils/get-data';\nimport {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport async function parse(\n  data: DataType | Promise<DataType>,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<any> {\n  assert(!context || typeof context === 'object'); // parse no longer accepts final url\n\n  // Signature: parse(data, options, context | url)\n  // Uses registered loaders\n  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders as LoaderOptions;\n    loaders = undefined;\n  }\n\n  data = await data; // Resolve any promise\n  options = options || {};\n\n  // Extract a url for auto detection\n  const {url} = getResourceUrlAndType(data);\n\n  // Chooses a loader (and normalizes it)\n  // Also use any loaders in the context, new loaders take priority\n  const typedLoaders = loaders as Loader | Loader[] | undefined;\n  const candidateLoaders = getLoadersFromContext(typedLoaders, context);\n  // todo hacky type cast\n  const loader = await selectLoader(data as ArrayBuffer, candidateLoaders, options);\n  // Note: if no loader was found, if so just return null\n  if (!loader) {\n    return null;\n  }\n\n  // Normalize options\n  options = normalizeOptions(options, loader, candidateLoaders, url);\n\n  // Get a context (if already present, will be unchanged)\n  context = getLoaderContext({url, parse, loaders: candidateLoaders}, options, context);\n\n  return await parseWithLoader(loader, data, options, context);\n}\n\n// TODO: support progress and abort\n// TODO - should accept loader.parseAsyncIterator and concatenate.\nasync function parseWithLoader(loader, data, options, context) {\n  validateWorkerVersion(loader);\n\n  data = await getArrayBufferOrStringFromData(data, loader, options);\n\n  // First check for synchronous text parser, wrap results in promises\n  if (loader.parseTextSync && typeof data === 'string') {\n    options.dataType = 'text';\n    return loader.parseTextSync(data, options, context, loader);\n  }\n\n  // If we have a workerUrl and the loader can parse the given options efficiently in a worker\n  if (canParseWithWorker(loader, options)) {\n    return await parseWithWorker(loader, data, options, context, parse);\n  }\n\n  // Check for asynchronous parser\n  if (loader.parseText && typeof data === 'string') {\n    return await loader.parseText(data, options, context, loader);\n  }\n\n  if (loader.parse) {\n    return await loader.parse(data, options, context, loader);\n  }\n\n  // This should not happen, all sync loaders should also offer `parse` function\n  assert(!loader.parseSync);\n\n  // TBD - If asynchronous parser not available, return null\n  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);\n}\n"],"file":"parse.js"}
+{"version":3,"sources":["../../../../src/lib/api/parse.ts"],"names":["assert","validateWorkerVersion","parseWithWorker","canParseWithWorker","isLoaderObject","isResponse","normalizeOptions","getArrayBufferOrStringFromData","getLoaderContext","getLoadersFromContext","getResourceUrlAndType","selectLoader","parse","data","loaders","options","context","Array","isArray","undefined","url","typedLoaders","candidateLoaders","loader","parseWithLoader","response","ok","redirected","status","statusText","type","headers","Object","fromEntries","entries","parseTextSync","dataType","parseText","parseSync","Error","id"],"mappings":"AACA,SAAQA,MAAR,EAAgBC,qBAAhB,QAA4C,0BAA5C;AACA,SAAQC,eAAR,EAAyBC,kBAAzB,QAAkD,0BAAlD;AACA,SAAQC,cAAR,QAA6B,kCAA7B;AACA,SAAQC,UAAR,QAAyB,gCAAzB;AACA,SAAQC,gBAAR,QAA+B,8BAA/B;AACA,SAAQC,8BAAR,QAA6C,0BAA7C;AACA,SAAQC,gBAAR,EAA0BC,qBAA1B,QAAsD,gCAAtD;AACA,SAAQC,qBAAR,QAAoC,yBAApC;AACA,SAAQC,YAAR,QAA2B,iBAA3B;AASA,OAAO,eAAeC,KAAf,CACLC,IADK,EAELC,OAFK,EAGLC,OAHK,EAILC,OAJK,EAKS;AACdhB,EAAAA,MAAM,CAAC,CAACgB,OAAD,IAAY,OAAOA,OAAP,KAAmB,QAAhC,CAAN;;AAIA,MAAIF,OAAO,IAAI,CAACG,KAAK,CAACC,OAAN,CAAcJ,OAAd,CAAZ,IAAsC,CAACV,cAAc,CAACU,OAAD,CAAzD,EAAoE;AAClEE,IAAAA,OAAO,GAAGG,SAAV;AACAJ,IAAAA,OAAO,GAAGD,OAAV;AACAA,IAAAA,OAAO,GAAGK,SAAV;AACD;;AAEDN,EAAAA,IAAI,GAAG,MAAMA,IAAb;AACAE,EAAAA,OAAO,GAAGA,OAAO,IAAI,EAArB;AAGA,QAAM;AAACK,IAAAA;AAAD,MAAQV,qBAAqB,CAACG,IAAD,CAAnC;AAIA,QAAMQ,YAAY,GAAGP,OAArB;AACA,QAAMQ,gBAAgB,GAAGb,qBAAqB,CAACY,YAAD,EAAeL,OAAf,CAA9C;AAEA,QAAMO,MAAM,GAAG,MAAMZ,YAAY,CAACE,IAAD,EAAsBS,gBAAtB,EAAwCP,OAAxC,CAAjC;;AAEA,MAAI,CAACQ,MAAL,EAAa;AACX,WAAO,IAAP;AACD;;AAGDR,EAAAA,OAAO,GAAGT,gBAAgB,CAACS,OAAD,EAAUQ,MAAV,EAAkBD,gBAAlB,EAAoCF,GAApC,CAA1B;AAGAJ,EAAAA,OAAO,GAAGR,gBAAgB,CAAC;AAACY,IAAAA,GAAD;AAAMR,IAAAA,KAAN;AAAaE,IAAAA,OAAO,EAAEQ;AAAtB,GAAD,EAA0CP,OAA1C,EAAmDC,OAAnD,CAA1B;AAEA,SAAO,MAAMQ,eAAe,CAACD,MAAD,EAASV,IAAT,EAAeE,OAAf,EAAwBC,OAAxB,CAA5B;AACD;;AAID,eAAeQ,eAAf,CAA+BD,MAA/B,EAAuCV,IAAvC,EAA6CE,OAA7C,EAAsDC,OAAtD,EAA+D;AAC7Df,EAAAA,qBAAqB,CAACsB,MAAD,CAArB;;AAEA,MAAIlB,UAAU,CAACQ,IAAD,CAAd,EAAsB;AAEpB,UAAMY,QAAQ,GAAGZ,IAAjB;AACA,UAAM;AAACa,MAAAA,EAAD;AAAKC,MAAAA,UAAL;AAAiBC,MAAAA,MAAjB;AAAyBC,MAAAA,UAAzB;AAAqCC,MAAAA,IAArC;AAA2CV,MAAAA;AAA3C,QAAkDK,QAAxD;AACA,UAAMM,OAAO,GAAGC,MAAM,CAACC,WAAP,CAAmBR,QAAQ,CAACM,OAAT,CAAiBG,OAAjB,EAAnB,CAAhB;AACAlB,IAAAA,OAAO,CAACS,QAAR,GAAmB;AAACM,MAAAA,OAAD;AAAUL,MAAAA,EAAV;AAAcC,MAAAA,UAAd;AAA0BC,MAAAA,MAA1B;AAAkCC,MAAAA,UAAlC;AAA8CC,MAAAA,IAA9C;AAAoDV,MAAAA;AAApD,KAAnB;AACD;;AAEDP,EAAAA,IAAI,GAAG,MAAMN,8BAA8B,CAACM,IAAD,EAAOU,MAAP,EAAeR,OAAf,CAA3C;;AAGA,MAAIQ,MAAM,CAACY,aAAP,IAAwB,OAAOtB,IAAP,KAAgB,QAA5C,EAAsD;AACpDE,IAAAA,OAAO,CAACqB,QAAR,GAAmB,MAAnB;AACA,WAAOb,MAAM,CAACY,aAAP,CAAqBtB,IAArB,EAA2BE,OAA3B,EAAoCC,OAApC,EAA6CO,MAA7C,CAAP;AACD;;AAGD,MAAIpB,kBAAkB,CAACoB,MAAD,EAASR,OAAT,CAAtB,EAAyC;AACvC,WAAO,MAAMb,eAAe,CAACqB,MAAD,EAASV,IAAT,EAAeE,OAAf,EAAwBC,OAAxB,EAAiCJ,KAAjC,CAA5B;AACD;;AAGD,MAAIW,MAAM,CAACc,SAAP,IAAoB,OAAOxB,IAAP,KAAgB,QAAxC,EAAkD;AAChD,WAAO,MAAMU,MAAM,CAACc,SAAP,CAAiBxB,IAAjB,EAAuBE,OAAvB,EAAgCC,OAAhC,EAAyCO,MAAzC,CAAb;AACD;;AAED,MAAIA,MAAM,CAACX,KAAX,EAAkB;AAChB,WAAO,MAAMW,MAAM,CAACX,KAAP,CAAaC,IAAb,EAAmBE,OAAnB,EAA4BC,OAA5B,EAAqCO,MAArC,CAAb;AACD;;AAGDvB,EAAAA,MAAM,CAAC,CAACuB,MAAM,CAACe,SAAT,CAAN;AAGA,QAAM,IAAIC,KAAJ,WAAahB,MAAM,CAACiB,EAApB,sDAAN;AACD","sourcesContent":["import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';\nimport {parseWithWorker, canParseWithWorker} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {isResponse} from '../../javascript-utils/is-type';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getArrayBufferOrStringFromData} from '../loader-utils/get-data';\nimport {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport async function parse(\n  data: DataType | Promise<DataType>,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<any> {\n  assert(!context || typeof context === 'object'); // parse no longer accepts final url\n\n  // Signature: parse(data, options, context | url)\n  // Uses registered loaders\n  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders as LoaderOptions;\n    loaders = undefined;\n  }\n\n  data = await data; // Resolve any promise\n  options = options || {};\n\n  // Extract a url for auto detection\n  const {url} = getResourceUrlAndType(data);\n\n  // Chooses a loader (and normalizes it)\n  // Also use any loaders in the context, new loaders take priority\n  const typedLoaders = loaders as Loader | Loader[] | undefined;\n  const candidateLoaders = getLoadersFromContext(typedLoaders, context);\n  // todo hacky type cast\n  const loader = await selectLoader(data as ArrayBuffer, candidateLoaders, options);\n  // Note: if no loader was found, if so just return null\n  if (!loader) {\n    return null;\n  }\n\n  // Normalize options\n  options = normalizeOptions(options, loader, candidateLoaders, url);\n\n  // Get a context (if already present, will be unchanged)\n  context = getLoaderContext({url, parse, loaders: candidateLoaders}, options, context);\n\n  return await parseWithLoader(loader, data, options, context);\n}\n\n// TODO: support progress and abort\n// TODO - should accept loader.parseAsyncIterator and concatenate.\nasync function parseWithLoader(loader, data, options, context) {\n  validateWorkerVersion(loader);\n\n  if (isResponse(data)) {\n    // Serialize to support passing the response to web worker\n    const response = data as Response;\n    const {ok, redirected, status, statusText, type, url} = response;\n    const headers = Object.fromEntries(response.headers.entries());\n    context.response = {headers, ok, redirected, status, statusText, type, url};\n  }\n\n  data = await getArrayBufferOrStringFromData(data, loader, options);\n\n  // First check for synchronous text parser, wrap results in promises\n  if (loader.parseTextSync && typeof data === 'string') {\n    options.dataType = 'text';\n    return loader.parseTextSync(data, options, context, loader);\n  }\n\n  // If we have a workerUrl and the loader can parse the given options efficiently in a worker\n  if (canParseWithWorker(loader, options)) {\n    return await parseWithWorker(loader, data, options, context, parse);\n  }\n\n  // Check for asynchronous parser\n  if (loader.parseText && typeof data === 'string') {\n    return await loader.parseText(data, options, context, loader);\n  }\n\n  if (loader.parse) {\n    return await loader.parse(data, options, context, loader);\n  }\n\n  // This should not happen, all sync loaders should also offer `parse` function\n  assert(!loader.parseSync);\n\n  // TBD - If asynchronous parser not available, return null\n  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);\n}\n"],"file":"parse.js"}

package/dist/esm/lib/init.js

@@ -1,5 +1,5 @@
 import { log } from './utils/log';
-const version = typeof "3.2.0-alpha.2" !== 'undefined' ? "3.2.0-alpha.2" : '';
+const version = typeof "3.2.0" !== 'undefined' ? "3.2.0" : '';
 
 if (!globalThis.loaders) {
   log.log(1, "loaders.gl ".concat(version))();

package/dist/esm/lib/init.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/init.ts"],"names":["log","version","globalThis","loaders","Object","assign","VERSION"],"mappings":"AACA,SAAQA,GAAR,QAAkB,aAAlB;AAGA,MAAMC,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,EAAnE;;AAGA,IAAI,CAACC,UAAU,CAACC,OAAhB,EAAyB;AACvBH,EAAAA,GAAG,CAACA,GAAJ,CAAQ,CAAR,uBAAyBC,OAAzB;AAEAC,EAAAA,UAAU,CAACC,OAAX,GAAqBC,MAAM,CAACC,MAAP,CAAcH,UAAU,CAACC,OAAX,IAAsB,EAApC,EAAwC;AAC3DG,IAAAA,OAAO,EAAEL,OADkD;AAE3DD,IAAAA;AAF2D,GAAxC,CAArB;AAID;;AAED,eAAeE,UAAU,CAACC,OAA1B","sourcesContent":["// loaders.gl, MIT license\nimport {log} from './utils/log';\n\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst version = typeof __VERSION__ !== 'undefined' ? __VERSION__ : '';\n\n// @ts-ignore\nif (!globalThis.loaders) {\n  log.log(1, `loaders.gl ${version}`)();\n\n  globalThis.loaders = Object.assign(globalThis.loaders || {}, {\n    VERSION: version,\n    log\n  });\n}\n// @ts-ignore\nexport default globalThis.loaders;\n"],"file":"init.js"}
+{"version":3,"sources":["../../../src/lib/init.ts"],"names":["log","version","globalThis","loaders","Object","assign","VERSION"],"mappings":"AACA,SAAQA,GAAR,QAAkB,aAAlB;AAGA,MAAMC,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,EAAnE;;AAGA,IAAI,CAACC,UAAU,CAACC,OAAhB,EAAyB;AACvBH,EAAAA,GAAG,CAACA,GAAJ,CAAQ,CAAR,uBAAyBC,OAAzB;AAEAC,EAAAA,UAAU,CAACC,OAAX,GAAqBC,MAAM,CAACC,MAAP,CAAcH,UAAU,CAACC,OAAX,IAAsB,EAApC,EAAwC;AAC3DG,IAAAA,OAAO,EAAEL,OADkD;AAE3DD,IAAAA;AAF2D,GAAxC,CAArB;AAID;;AAED,eAAeE,UAAU,CAACC,OAA1B","sourcesContent":["// loaders.gl, MIT license\nimport {log} from './utils/log';\n\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst version = typeof __VERSION__ !== 'undefined' ? __VERSION__ : '';\n\n// @ts-ignore\nif (!globalThis.loaders) {\n  log.log(1, `loaders.gl ${version}`)();\n\n  globalThis.loaders = Object.assign(globalThis.loaders || {}, {\n    VERSION: version,\n    log\n  });\n}\n// @ts-ignore\nexport default globalThis.loaders;\n"],"file":"init.js"}

package/dist/esm/null-loader.js

@@ -1,4 +1,4 @@
-const VERSION = typeof "3.2.0-alpha.2" !== 'undefined' ? "3.2.0-alpha.2" : 'latest';
+const VERSION = typeof "3.2.0" !== 'undefined' ? "3.2.0" : 'latest';
 export const NullWorkerLoader = {
   name: 'Null loader',
   id: 'null',
@@ -12,6 +12,17 @@ export const NullWorkerLoader = {
     null: {}
   }
 };
+
+function parseSync(arrayBuffer, options, context) {
+  if (!options.null.echoParameters) return null;
+  context = context && JSON.parse(JSON.stringify(context));
+  return {
+    arrayBuffer,
+    options,
+    context
+  };
+}
+
 export const NullLoader = {
   name: 'Null loader',
   id: 'null',
@@ -19,16 +30,18 @@ export const NullLoader = {
   version: VERSION,
   mimeTypes: ['application/x.empty'],
   extensions: ['null'],
-  parse: async arrayBuffer => arrayBuffer,
-  parseSync: arrayBuffer => arrayBuffer,
-  parseInBatches: async function* generator(asyncIterator) {
+  parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options, context),
+  parseSync,
+  parseInBatches: async function* generator(asyncIterator, options, context) {
     for await (const batch of asyncIterator) {
-      yield batch;
+      yield parseSync(batch, options, context);
     }
   },
   tests: [() => false],
   options: {
-    null: {}
+    null: {
+      echoParameters: false
+    }
   }
 };
 //# sourceMappingURL=null-loader.js.map

package/dist/esm/null-loader.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/null-loader.ts"],"names":["VERSION","NullWorkerLoader","name","id","module","version","worker","mimeTypes","extensions","tests","options","null","NullLoader","parse","arrayBuffer","parseSync","parseInBatches","generator","asyncIterator","batch"],"mappings":"AAEA,MAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAOA,OAAO,MAAMC,gBAAwB,GAAG;AACtCC,EAAAA,IAAI,EAAE,aADgC;AAEtCC,EAAAA,EAAE,EAAE,MAFkC;AAGtCC,EAAAA,MAAM,EAAE,MAH8B;AAItCC,EAAAA,OAAO,EAAEL,OAJ6B;AAKtCM,EAAAA,MAAM,EAAE,IAL8B;AAMtCC,EAAAA,SAAS,EAAE,CAAC,qBAAD,CAN2B;AAOtCC,EAAAA,UAAU,EAAE,CAAC,MAAD,CAP0B;AAQtCC,EAAAA,KAAK,EAAE,CAAC,MAAM,KAAP,CAR+B;AAStCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAT6B,CAAjC;AAiBP,OAAO,MAAMC,UAA4B,GAAG;AAC1CV,EAAAA,IAAI,EAAE,aADoC;AAE1CC,EAAAA,EAAE,EAAE,MAFsC;AAG1CC,EAAAA,MAAM,EAAE,MAHkC;AAI1CC,EAAAA,OAAO,EAAEL,OAJiC;AAK1CO,EAAAA,SAAS,EAAE,CAAC,qBAAD,CAL+B;AAM1CC,EAAAA,UAAU,EAAE,CAAC,MAAD,CAN8B;AAO1CK,EAAAA,KAAK,EAAE,MAAOC,WAAP,IAAuBA,WAPY;AAQ1CC,EAAAA,SAAS,EAAGD,WAAD,IAAiBA,WARc;AAS1CE,EAAAA,cAAc,EAAE,gBAAgBC,SAAhB,CAA0BC,aAA1B,EAAyC;AACvD,eAAW,MAAMC,KAAjB,IAA0BD,aAA1B,EAAyC;AACvC,YAAMC,KAAN;AACD;AACF,GAbyC;AAc1CV,EAAAA,KAAK,EAAE,CAAC,MAAM,KAAP,CAdmC;AAe1CC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAfiC,CAArC","sourcesContent":["// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nimport {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullWorkerLoader: Loader = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  worker: true,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  tests: [() => false],\n  options: {\n    null: {}\n  }\n};\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullLoader: LoaderWithParser = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  parse: async (arrayBuffer) => arrayBuffer,\n  parseSync: (arrayBuffer) => arrayBuffer,\n  parseInBatches: async function* generator(asyncIterator) {\n    for await (const batch of asyncIterator) {\n      yield batch;\n    }\n  },\n  tests: [() => false],\n  options: {\n    null: {}\n  }\n};\n"],"file":"null-loader.js"}
+{"version":3,"sources":["../../src/null-loader.ts"],"names":["VERSION","NullWorkerLoader","name","id","module","version","worker","mimeTypes","extensions","tests","options","null","parseSync","arrayBuffer","context","echoParameters","JSON","parse","stringify","NullLoader","parseInBatches","generator","asyncIterator","batch"],"mappings":"AAEA,MAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AAOA,OAAO,MAAMC,gBAAwB,GAAG;AACtCC,EAAAA,IAAI,EAAE,aADgC;AAEtCC,EAAAA,EAAE,EAAE,MAFkC;AAGtCC,EAAAA,MAAM,EAAE,MAH8B;AAItCC,EAAAA,OAAO,EAAEL,OAJ6B;AAKtCM,EAAAA,MAAM,EAAE,IAL8B;AAMtCC,EAAAA,SAAS,EAAE,CAAC,qBAAD,CAN2B;AAOtCC,EAAAA,UAAU,EAAE,CAAC,MAAD,CAP0B;AAQtCC,EAAAA,KAAK,EAAE,CAAC,MAAM,KAAP,CAR+B;AAStCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAT6B,CAAjC;;AAkBP,SAASC,SAAT,CAAmBC,WAAnB,EAAgCH,OAAhC,EAAyCI,OAAzC,EAAkD;AAChD,MAAI,CAACJ,OAAO,CAACC,IAAR,CAAaI,cAAlB,EAAkC,OAAO,IAAP;AAClCD,EAAAA,OAAO,GAAGA,OAAO,IAAIE,IAAI,CAACC,KAAL,CAAWD,IAAI,CAACE,SAAL,CAAeJ,OAAf,CAAX,CAArB;AACA,SAAO;AAACD,IAAAA,WAAD;AAAcH,IAAAA,OAAd;AAAuBI,IAAAA;AAAvB,GAAP;AACD;;AAKD,OAAO,MAAMK,UAA4B,GAAG;AAC1CjB,EAAAA,IAAI,EAAE,aADoC;AAE1CC,EAAAA,EAAE,EAAE,MAFsC;AAG1CC,EAAAA,MAAM,EAAE,MAHkC;AAI1CC,EAAAA,OAAO,EAAEL,OAJiC;AAK1CO,EAAAA,SAAS,EAAE,CAAC,qBAAD,CAL+B;AAM1CC,EAAAA,UAAU,EAAE,CAAC,MAAD,CAN8B;AAO1CS,EAAAA,KAAK,EAAE,OAAOJ,WAAP,EAAoBH,OAApB,EAA6BI,OAA7B,KAAyCF,SAAS,CAACC,WAAD,EAAcH,OAAd,EAAuBI,OAAvB,CAPf;AAQ1CF,EAAAA,SAR0C;AAS1CQ,EAAAA,cAAc,EAAE,gBAAgBC,SAAhB,CAA0BC,aAA1B,EAAyCZ,OAAzC,EAAkDI,OAAlD,EAA2D;AACzE,eAAW,MAAMS,KAAjB,IAA0BD,aAA1B,EAAyC;AACvC,YAAMV,SAAS,CAACW,KAAD,EAAQb,OAAR,EAAiBI,OAAjB,CAAf;AACD;AACF,GAbyC;AAc1CL,EAAAA,KAAK,EAAE,CAAC,MAAM,KAAP,CAdmC;AAe1CC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AACJI,MAAAA,cAAc,EAAE;AADZ;AADC;AAfiC,CAArC","sourcesContent":["// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nimport {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullWorkerLoader: Loader = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  worker: true,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  tests: [() => false],\n  options: {\n    null: {}\n  }\n};\n\n/**\n * Returns arguments passed to the parse API in a format that can be transfered to a\n * web worker. The `context` parameter is stripped using JSON.stringify & parse.\n */\nfunction parseSync(arrayBuffer, options, context) {\n  if (!options.null.echoParameters) return null;\n  context = context && JSON.parse(JSON.stringify(context));\n  return {arrayBuffer, options, context};\n}\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullLoader: LoaderWithParser = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options, context),\n  parseSync,\n  parseInBatches: async function* generator(asyncIterator, options, context) {\n    for await (const batch of asyncIterator) {\n      yield parseSync(batch, options, context);\n    }\n  },\n  tests: [() => false],\n  options: {\n    null: {\n      echoParameters: false\n    }\n  }\n};\n"],"file":"null-loader.js"}

package/dist/lib/api/parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/lib/api/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAU7F;;;;;;GAMG;AACH,wBAAsB,KAAK,CACzB,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAClC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa,EAC3C,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,GAAG,CAAC,CAmCd"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/lib/api/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAW7F;;;;;;GAMG;AACH,wBAAsB,KAAK,CACzB,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAClC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa,EAC3C,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,GAAG,CAAC,CAmCd"}

package/dist/lib/api/parse.js

@@ -4,6 +4,7 @@ exports.parse = void 0;
 const worker_utils_1 = require("@loaders.gl/worker-utils");
 const loader_utils_1 = require("@loaders.gl/loader-utils");
 const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const is_type_1 = require("../../javascript-utils/is-type");
 const option_utils_1 = require("../loader-utils/option-utils");
 const get_data_1 = require("../loader-utils/get-data");
 const loader_context_1 = require("../loader-utils/loader-context");
@@ -50,6 +51,13 @@ exports.parse = parse;
 // TODO - should accept loader.parseAsyncIterator and concatenate.
 async function parseWithLoader(loader, data, options, context) {
     (0, worker_utils_1.validateWorkerVersion)(loader);
+    if ((0, is_type_1.isResponse)(data)) {
+        // Serialize to support passing the response to web worker
+        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 (0, get_data_1.getArrayBufferOrStringFromData)(data, loader, options);
     // First check for synchronous text parser, wrap results in promises
     if (loader.parseTextSync && typeof data === 'string') {

package/dist/null-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"null-loader.d.ts","sourceRoot":"","sources":["../src/null-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAY9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,gBAkBxB,CAAC"}
+{"version":3,"file":"null-loader.d.ts","sourceRoot":"","sources":["../src/null-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAY9B,CAAC;AAYF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,gBAoBxB,CAAC"}

package/dist/null-loader.js

@@ -20,6 +20,16 @@ exports.NullWorkerLoader = {
         null: {}
     }
 };
+/**
+ * Returns arguments passed to the parse API in a format that can be transfered to a
+ * web worker. The `context` parameter is stripped using JSON.stringify & parse.
+ */
+function parseSync(arrayBuffer, options, context) {
+    if (!options.null.echoParameters)
+        return null;
+    context = context && JSON.parse(JSON.stringify(context));
+    return { arrayBuffer, options, context };
+}
 /**
  * Loads any data and returns null (or optionally passes through data unparsed)
  */
@@ -30,15 +40,17 @@ exports.NullLoader = {
     version: VERSION,
     mimeTypes: ['application/x.empty'],
     extensions: ['null'],
-    parse: async (arrayBuffer) => arrayBuffer,
-    parseSync: (arrayBuffer) => arrayBuffer,
-    parseInBatches: async function* generator(asyncIterator) {
+    parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options, context),
+    parseSync,
+    parseInBatches: async function* generator(asyncIterator, options, context) {
         for await (const batch of asyncIterator) {
-            yield batch;
+            yield parseSync(batch, options, context);
         }
     },
     tests: [() => false],
     options: {
-        null: {}
+        null: {
+            echoParameters: false
+        }
     }
 };

package/dist/null-worker.js

@@ -118,12 +118,13 @@
       switch (type) {
         case "process":
           try {
-            const { input, options = {} } = payload;
+            const { input, options = {}, context = {} } = payload;
             const result = await parseData({
               loader,
               arrayBuffer: input,
               options,
               context: {
+                ...context,
                 parse: parseOnMainThread
               }
             });
@@ -183,7 +184,13 @@
   }
 
   // src/null-loader.ts
-  var VERSION = true ? "3.2.0-alpha.2" : "latest";
+  var VERSION = true ? "3.2.0" : "latest";
+  function parseSync(arrayBuffer, options, context) {
+    if (!options.null.echoParameters)
+      return null;
+    context = context && JSON.parse(JSON.stringify(context));
+    return { arrayBuffer, options, context };
+  }
   var NullLoader = {
     name: "Null loader",
     id: "null",
@@ -191,16 +198,18 @@
     version: VERSION,
     mimeTypes: ["application/x.empty"],
     extensions: ["null"],
-    parse: async (arrayBuffer) => arrayBuffer,
-    parseSync: (arrayBuffer) => arrayBuffer,
-    parseInBatches: async function* generator(asyncIterator) {
+    parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options, context),
+    parseSync,
+    parseInBatches: async function* generator(asyncIterator, options, context) {
       for await (const batch of asyncIterator) {
-        yield batch;
+        yield parseSync(batch, options, context);
       }
     },
     tests: [() => false],
     options: {
-      null: {}
+      null: {
+        echoParameters: false
+      }
     }
   };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/core",
-  "version": "3.2.0-alpha.2",
+  "version": "3.2.0",
   "description": "Framework-independent loaders for 3D graphics formats",
   "license": "MIT",
   "publishConfig": {
@@ -42,10 +42,10 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "3.2.0-alpha.2",
-    "@loaders.gl/worker-utils": "3.2.0-alpha.2",
+    "@loaders.gl/loader-utils": "3.2.0",
+    "@loaders.gl/worker-utils": "3.2.0",
     "@probe.gl/log": "^3.5.0",
     "probe.gl": "^3.4.0"
   },
-  "gitHead": "52a602739cbfce60fc314f474efc984d199dff78"
+  "gitHead": "6660dc9291526752c40063b73a3f9dd97cc0ccc5"
 }

package/src/lib/api/parse.ts

@@ -2,6 +2,7 @@ import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/l
 import {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';
 import {parseWithWorker, canParseWithWorker} from '@loaders.gl/loader-utils';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
+import {isResponse} from '../../javascript-utils/is-type';
 import {normalizeOptions} from '../loader-utils/option-utils';
 import {getArrayBufferOrStringFromData} from '../loader-utils/get-data';
 import {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';
@@ -62,6 +63,14 @@ export async function parse(
 async function parseWithLoader(loader, data, options, context) {
   validateWorkerVersion(loader);
 
+  if (isResponse(data)) {
+    // Serialize to support passing the response to web worker
+    const response = data as Response;
+    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);
 
   // First check for synchronous text parser, wrap results in promises

package/src/null-loader.ts

@@ -21,6 +21,16 @@ export const NullWorkerLoader: Loader = {
   }
 };
 
+/**
+ * Returns arguments passed to the parse API in a format that can be transfered to a
+ * web worker. The `context` parameter is stripped using JSON.stringify & parse.
+ */
+function parseSync(arrayBuffer, options, context) {
+  if (!options.null.echoParameters) return null;
+  context = context && JSON.parse(JSON.stringify(context));
+  return {arrayBuffer, options, context};
+}
+
 /**
  * Loads any data and returns null (or optionally passes through data unparsed)
  */
@@ -31,15 +41,17 @@ export const NullLoader: LoaderWithParser = {
   version: VERSION,
   mimeTypes: ['application/x.empty'],
   extensions: ['null'],
-  parse: async (arrayBuffer) => arrayBuffer,
-  parseSync: (arrayBuffer) => arrayBuffer,
-  parseInBatches: async function* generator(asyncIterator) {
+  parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options, context),
+  parseSync,
+  parseInBatches: async function* generator(asyncIterator, options, context) {
     for await (const batch of asyncIterator) {
-      yield batch;
+      yield parseSync(batch, options, context);
     }
   },
   tests: [() => false],
   options: {
-    null: {}
+    null: {
+      echoParameters: false
+    }
   }
 };