@loaders.gl/core 3.1.0-alpha.3 → 4.0.0-alpha.4

package/dist/null-worker.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/regenerator/index.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/AwaitValue.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/defineProperty.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/classCallCheck.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/createClass.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/typeof.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/asyncIterator.js","webpack:////home/user/apps/loaders.gl/node_modules/regenerator-runtime/runtime.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/AsyncGenerator.js","webpack:///../worker-utils/src/lib/worker-utils/get-transfer-list.ts","webpack:///../worker-utils/src/lib/worker-farm/worker-body.ts","webpack:///../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts","webpack:///./src/null-loader.ts","webpack:///./src/workers/null-worker.ts"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","asyncGeneratorStep","gen","resolve","reject","_next","_throw","arg","info","error","done","Promise","then","fn","self","this","args","arguments","apply","err","undefined","AwaitValue","wrapped","obj","configurable","writable","instance","Constructor","TypeError","_defineProperties","target","props","length","descriptor","protoProps","staticProps","_typeof","iterator","constructor","AsyncGenerator","iterable","method","asyncIterator","runtime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","toStringTagSymbol","define","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","context","Context","_invoke","state","Error","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","type","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","forEach","AsyncIterator","PromiseImpl","previousPromise","callInvokeWithMethodAndArg","invoke","result","__await","unwrapped","resultName","next","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","push","resetTryEntry","completion","reset","iteratorMethod","isNaN","displayName","isGeneratorFunction","genFun","ctor","mark","setPrototypeOf","__proto__","awrap","async","iter","toString","keys","reverse","pop","skipTempReset","prev","charAt","slice","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","Function","front","back","resume","wrappedAwait","settle","request","isTransferable","ArrayBuffer","MessagePort","ImageBitmap","OffscreenCanvas","onMessageWrapperMap","Map","WorkerBody","onMessage","onmessage","message","isKnownMessage","data","payload","onMessageWrapper","addEventListener","removeEventListener","source","transferList","getTransferList","recursive","transfers","transfersSet","Set","add","buffer","isView","Array","from","postMessage","startsWith","requestId","parseOnMainThread","arrayBuffer","options","id","input","parseData","a","loader","parseSync","parse","parser","parseTextSync","textDecoder","TextDecoder","decode","worker","NullLoader","version","mimeTypes","extensions","parseInBatches","batch","tests","null"],"mappings":"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","file":"null-worker.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 12);\n","module.exports = require(\"regenerator-runtime\");\n","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var AwaitValue = require(\"./AwaitValue.js\");\n\nfunction _awaitAsyncGenerator(value) {\n  return new AwaitValue(value);\n}\n\nmodule.exports = _awaitAsyncGenerator;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _AwaitValue(value) {\n  this.wrapped = value;\n}\n\nmodule.exports = _AwaitValue;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nmodule.exports = _defineProperty;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nmodule.exports = _classCallCheck;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nmodule.exports = _createClass;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    module.exports = _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  } else {\n    module.exports = _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  }\n\n  return _typeof(obj);\n}\n\nmodule.exports = _typeof;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var AsyncGenerator = require(\"./AsyncGenerator.js\");\n\nfunction _wrapAsyncGenerator(fn) {\n  return function () {\n    return new AsyncGenerator(fn.apply(this, arguments));\n  };\n}\n\nmodule.exports = _wrapAsyncGenerator;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _asyncIterator(iterable) {\n  var method;\n\n  if (typeof Symbol !== \"undefined\") {\n    if (Symbol.asyncIterator) method = iterable[Symbol.asyncIterator];\n    if (method == null && Symbol.iterator) method = iterable[Symbol.iterator];\n  }\n\n  if (method == null) method = iterable[\"@@asyncIterator\"];\n  if (method == null) method = iterable[\"@@iterator\"];\n  if (method == null) throw new TypeError(\"Object is not async iterable\");\n  return method.call(iterable);\n}\n\nmodule.exports = _asyncIterator;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","var AwaitValue = require(\"./AwaitValue.js\");\n\nfunction AsyncGenerator(gen) {\n  var front, back;\n\n  function send(key, arg) {\n    return new Promise(function (resolve, reject) {\n      var request = {\n        key: key,\n        arg: arg,\n        resolve: resolve,\n        reject: reject,\n        next: null\n      };\n\n      if (back) {\n        back = back.next = request;\n      } else {\n        front = back = request;\n        resume(key, arg);\n      }\n    });\n  }\n\n  function resume(key, arg) {\n    try {\n      var result = gen[key](arg);\n      var value = result.value;\n      var wrappedAwait = value instanceof AwaitValue;\n      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {\n        if (wrappedAwait) {\n          resume(key === \"return\" ? \"return\" : \"next\", arg);\n          return;\n        }\n\n        settle(result.done ? \"return\" : \"normal\", arg);\n      }, function (err) {\n        resume(\"throw\", err);\n      });\n    } catch (err) {\n      settle(\"throw\", err);\n    }\n  }\n\n  function settle(type, value) {\n    switch (type) {\n      case \"return\":\n        front.resolve({\n          value: value,\n          done: true\n        });\n        break;\n\n      case \"throw\":\n        front.reject(value);\n        break;\n\n      default:\n        front.resolve({\n          value: value,\n          done: false\n        });\n        break;\n    }\n\n    front = front.next;\n\n    if (front) {\n      resume(front.key, front.arg);\n    } else {\n      back = null;\n    }\n  }\n\n  this._invoke = send;\n\n  if (typeof gen[\"return\"] !== \"function\") {\n    this[\"return\"] = undefined;\n  }\n}\n\nAsyncGenerator.prototype[typeof Symbol === \"function\" && Symbol.asyncIterator || \"@@asyncIterator\"] = function () {\n  return this;\n};\n\nAsyncGenerator.prototype.next = function (arg) {\n  return this._invoke(\"next\", arg);\n};\n\nAsyncGenerator.prototype[\"throw\"] = function (arg) {\n  return this._invoke(\"throw\", arg);\n};\n\nAsyncGenerator.prototype[\"return\"] = function (arg) {\n  return this._invoke(\"return\", arg);\n};\n\nmodule.exports = AsyncGenerator;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","// NOTE - there is a copy of this function is both in core and loader-utils\n// core does not need all the utils in loader-utils, just this one.\n\n/**\n * Returns an array of Transferrable objects that can be used with postMessage\n * https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage\n * @param object data to be sent via postMessage\n * @param recursive - not for application use\n * @param transfers - not for application use\n * @returns a transfer list that can be passed to postMessage\n */\nexport function getTransferList(\n  object: any,\n  recursive: boolean = true,\n  transfers?: Set<any>\n): Transferable[] {\n  // Make sure that items in the transfer list is unique\n  const transfersSet = transfers || new Set();\n\n  if (!object) {\n    // ignore\n  } else if (isTransferable(object)) {\n    transfersSet.add(object);\n  } else if (isTransferable(object.buffer)) {\n    // Typed array\n    transfersSet.add(object.buffer);\n  } else if (ArrayBuffer.isView(object)) {\n    // object is a TypeArray viewing into a SharedArrayBuffer (not transferable)\n    // Do not iterate through the content in this case\n  } else if (recursive && typeof object === 'object') {\n    for (const key in object) {\n      // Avoid perf hit - only go one level deep\n      getTransferList(object[key], recursive, transfersSet);\n    }\n  }\n\n  // If transfers is defined, is internal recursive call\n  // Otherwise it's called by the user\n  return transfers === undefined ? Array.from(transfersSet) : [];\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/API/Transferable\nfunction isTransferable(object) {\n  if (!object) {\n    return false;\n  }\n  if (object instanceof ArrayBuffer) {\n    return true;\n  }\n  if (typeof MessagePort !== 'undefined' && object instanceof MessagePort) {\n    return true;\n  }\n  if (typeof ImageBitmap !== 'undefined' && object instanceof ImageBitmap) {\n    return true;\n  }\n  // @ts-ignore\n  if (typeof OffscreenCanvas !== 'undefined' && object instanceof OffscreenCanvas) {\n    return true;\n  }\n  return false;\n}\n","import type {WorkerMessageData, WorkerMessageType, WorkerMessagePayload} from '../../types';\nimport {getTransferList} from '../worker-utils/get-transfer-list';\n\nconst onMessageWrapperMap = new Map();\n\n/**\n * Type safe wrapper for worker code\n */\nexport default class WorkerBody {\n  /*\n   * (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n   */\n  static set onmessage(onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any) {\n    // eslint-disable-next-line no-restricted-globals\n    self.onmessage = (message) => {\n      if (!isKnownMessage(message)) {\n        return;\n      }\n\n      // Confusingly the message itself also has a 'type' field which is always set to 'message'\n      const {type, payload} = message.data;\n      onMessage(type, payload);\n    };\n  }\n\n  static addEventListener(\n    onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n  ) {\n    let onMessageWrapper = onMessageWrapperMap.get(onMessage);\n\n    if (!onMessageWrapper) {\n      onMessageWrapper = (message) => {\n        if (!isKnownMessage(message)) {\n          return;\n        }\n\n        // Confusingly the message itself also has a 'type' field which is always set to 'message'\n        const {type, payload} = message.data;\n        onMessage(type, payload);\n      };\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    self.addEventListener('message', onMessageWrapper);\n  }\n\n  static removeEventListener(\n    onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n  ) {\n    const onMessageWrapper = onMessageWrapperMap.get(onMessage);\n    onMessageWrapperMap.delete(onMessage);\n    // eslint-disable-next-line no-restricted-globals\n    self.removeEventListener('message', onMessageWrapper);\n  }\n\n  /**\n   * Send a message from a worker to creating thread (main thread)\n   * @param type\n   * @param payload\n   */\n  static postMessage(type: WorkerMessageType, payload: WorkerMessagePayload): void {\n    if (self) {\n      const data: WorkerMessageData = {source: 'loaders.gl', type, payload};\n      const transferList = getTransferList(payload);\n      // eslint-disable-next-line no-restricted-globals\n      // @ts-ignore\n      self.postMessage(data, transferList);\n    }\n  }\n}\n\n// Filter out noise messages sent to workers\nfunction isKnownMessage(message) {\n  const {type, data} = message;\n  return (\n    type === 'message' &&\n    data &&\n    typeof data.source === 'string' &&\n    data.source.startsWith('loaders.gl')\n  );\n}\n","/* eslint-disable no-restricted-globals */\nimport type {LoaderWithParser} from '../../types';\nimport {WorkerBody} from '@loaders.gl/worker-utils';\n// import {validateLoaderVersion} from './validate-loader-version';\n\nlet requestId = 0;\n\n/**\n * Set up a WebWorkerGlobalScope to talk with the main thread\n * @param loader\n */\nexport function createLoaderWorker(loader: LoaderWithParser) {\n  // Check that we are actually in a worker thread\n  if (typeof self === 'undefined') {\n    return;\n  }\n\n  WorkerBody.onmessage = async (type, payload) => {\n    switch (type) {\n      case 'process':\n        try {\n          // validateLoaderVersion(loader, data.source.split('@')[1]);\n\n          const {input, options = {}} = payload;\n\n          const result = await parseData({\n            loader,\n            arrayBuffer: input,\n            options,\n            context: {\n              parse: parseOnMainThread\n            }\n          });\n          WorkerBody.postMessage('done', {result});\n        } catch (error) {\n          const message = error instanceof Error ? error.message : '';\n          WorkerBody.postMessage('error', {error: message});\n        }\n        break;\n      default:\n    }\n  };\n}\n\nfunction parseOnMainThread(arrayBuffer: ArrayBuffer, options: {[key: string]: any}): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const id = requestId++;\n\n    /**\n     */\n    const onMessage = (type, payload) => {\n      if (payload.id !== id) {\n        // not ours\n        return;\n      }\n\n      switch (type) {\n        case 'done':\n          WorkerBody.removeEventListener(onMessage);\n          resolve(payload.result);\n          break;\n\n        case 'error':\n          WorkerBody.removeEventListener(onMessage);\n          reject(payload.error);\n          break;\n\n        default:\n        // ignore\n      }\n    };\n\n    WorkerBody.addEventListener(onMessage);\n\n    // Ask the main thread to decode data\n    const payload = {id, input: arrayBuffer, options};\n    WorkerBody.postMessage('process', payload);\n  });\n}\n\n// TODO - Support byteOffset and byteLength (enabling parsing of embedded binaries without copies)\n// TODO - Why not support async loader.parse* funcs here?\n// TODO - Why not reuse a common function instead of reimplementing loader.parse* selection logic? Keeping loader small?\n// TODO - Lack of appropriate parser functions can be detected when we create worker, no need to wait until parse\nasync function parseData({loader, arrayBuffer, options, context}) {\n  let data;\n  let parser;\n  if (loader.parseSync || loader.parse) {\n    data = arrayBuffer;\n    parser = loader.parseSync || loader.parse;\n  } else if (loader.parseTextSync) {\n    const textDecoder = new TextDecoder();\n    data = textDecoder.decode(arrayBuffer);\n    parser = loader.parseTextSync;\n  } else {\n    throw new Error(`Could not load data with ${loader.name} loader`);\n  }\n\n  // TODO - proper merge in of loader options...\n  options = {\n    ...options,\n    modules: (loader && loader.options && loader.options.modules) || {},\n    worker: false\n  };\n\n  return await parser(data, {...options}, context, loader);\n}\n","// __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","import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {NullLoader} from '../null-loader';\n\ncreateLoaderWorker(NullLoader);\n"],"sourceRoot":""}