@loaders.gl/ply 3.1.0-alpha.5 → 3.1.0-beta.5

package/dist/ply-worker.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/classCallCheck.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/inherits.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/regenerator/index.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/defineProperty.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/createClass.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/asyncIterator.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/typeof.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/AwaitValue.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/regenerator-runtime/runtime.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/iterableToArray.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@babel/runtime/helpers/setPrototypeOf.js","webpack:////home/user/apps/loaders.gl_duplicate/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/ply-loader.ts","webpack:///../schema/src/lib/schema/impl/schema.ts","webpack:///../schema/src/lib/utils/assert.ts","webpack:///../schema/src/lib/schema/impl/enum.ts","webpack:///../schema/src/lib/schema/impl/field.ts","webpack:///../schema/src/lib/schema/impl/type.ts","webpack:///../schema/src/category/mesh/deduce-mesh-schema.ts","webpack:///../schema/src/lib/arrow/arrow-like-type-utils.ts","webpack:///./src/lib/get-ply-schema.ts","webpack:///./src/lib/normalize-ply.ts","webpack:///../schema/src/category/mesh/mesh-utils.ts","webpack:///./src/lib/parse-ply.ts","webpack:///../loader-utils/src/lib/iterators/text-iterators.ts","webpack:///./src/lib/parse-ply-in-batches.ts","webpack:///../loader-utils/src/lib/iterators/async-iteration.ts","webpack:///./src/index.ts","webpack:///./src/workers/ply-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","instance","Constructor","TypeError","setPrototypeOf","subClass","superClass","constructor","writable","configurable","obj","_defineProperties","target","props","length","descriptor","protoProps","staticProps","AwaitValue","self","ReferenceError","asyncGeneratorStep","gen","resolve","reject","_next","_throw","arg","info","error","done","Promise","then","fn","this","args","arguments","apply","err","undefined","iterable","method","asyncIterator","iterator","_typeof","AsyncGenerator","arrayWithoutHoles","iterableToArray","unsupportedIterableToArray","nonIterableSpread","arr","_getPrototypeOf","getPrototypeOf","__proto__","len","arr2","Array","wrapped","assertThisInitialized","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","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","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","arrayLikeToArray","isArray","from","minLen","test","_setPrototypeOf","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","postMessage","startsWith","requestId","parseOnMainThread","arrayBuffer","options","id","input","parseData","a","loader","parseSync","parse","parser","parseTextSync","textDecoder","TextDecoder","decode","worker","PLYLoader","shapes","version","extensions","mimeTypes","text","binary","tests","ply","Schema","fields","metadata","condition","assert","usedNames","field","console","warn","checkNames","other","compareTo","nameMap","columnNames","selectedFields","filter","columnIndices","map","index","Boolean","schemaOrFields","otherSchema","mergeMaps","fieldMap","m1","m2","Type","Field","nullable","typeId","DataType","NONE","x","Null","Int","Float","Binary","Utf8","Bool","Decimal","Date","Time","Timestamp","Interval","List","Struct","Union","FixedSizeBinary","FixedSizeList","Dictionary","isSigned","bitWidth","Int8","Int16","Int32","Uint8","Uint16","Uint32","Precision","precision","Float32","Float64","listSize","child","children","valueType","deduceMeshSchema","attributes","attributeName","attribute","deduceMeshField","deduceMeshFields","optionalMetadata","array","Int8Array","Uint8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","getArrowTypeFromTypedArray","set","byteOffset","byteStride","normalized","makeMeshAttributeMetadata","size","getPLYSchema","plyHeader","metadataMap","JSON","stringify","comments","elements","format","headerLength","makeMetadataFromPlyHeader","normalizePLY","plyAttributes","accessors","POSITION","vertices","normals","NORMAL","uvs","TEXCOORD_0","colors","COLOR_0","getMeshAttributes","boundingBox","minX","Infinity","minY","minZ","maxX","maxY","maxZ","positions","y","z","getMeshBoundingBox","vertexCount","indices","isTriangles","topology","plyMesh","loaderData","header","schema","parsePLY","parseHeader","parseASCII","parseBinary","headerText","exec","lines","lineType","lineValues","currentElement","line","trim","split","shift","join","count","parseInt","properties","makePLYElementProperty","propertyNameMapping","log","parseHeaderLines","propertValues","countType","itemType","parseASCIINumber","parseFloat","parseASCIIElement","element","list","j","body","currentElementCount","handleElement","elementName","nx","ny","nz","red","green","blue","vertexIndices","vertex_indices","vertex_index","binaryRead","dataview","at","littleEndian","getInt8","getUint8","getInt16","getUint16","getInt32","getUint32","getFloat32","getFloat64","binaryReadElement","read","DataView","makeTextDecoderIterator","arrayBufferIterator","stream","makeLineIterator","textIterator","previous","eolIndex","indexOf","visitor","lineIterator","parsePLYHeader","PLYWorkerLoader","parseInBatches"],"mappings":"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","file":"ply-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 = 26);\n","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;","var setPrototypeOf = require(\"./setPrototypeOf.js\");\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inherits;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","module.exports = require(\"regenerator-runtime\");\n","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 _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;","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 _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nmodule.exports = _assertThisInitialized;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","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;","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;","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;","var arrayWithoutHoles = require(\"./arrayWithoutHoles.js\");\n\nvar iterableToArray = require(\"./iterableToArray.js\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread.js\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  return _getPrototypeOf(o);\n}\n\nmodule.exports = _getPrototypeOf;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nmodule.exports = _arrayLikeToArray;\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;","var _typeof = require(\"@babel/runtime/helpers/typeof\")[\"default\"];\n\nvar assertThisInitialized = require(\"./assertThisInitialized.js\");\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return assertThisInitialized(self);\n}\n\nmodule.exports = _possibleConstructorReturn;\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 arrayLikeToArray = require(\"./arrayLikeToArray.js\");\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\n\nmodule.exports = _unsupportedIterableToArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableSpread;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _setPrototypeOf(o, p) {\n  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  return _setPrototypeOf(o, p);\n}\n\nmodule.exports = _setPrototypeOf;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","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","// PLY Loader\nimport type {Loader} from '@loaders.gl/loader-utils';\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\n/**\n * Worker loader for PLY - Polygon File Format (aka Stanford Triangle Format)'\n * links: ['http://paulbourke.net/dataformats/ply/',\n * 'https://en.wikipedia.org/wiki/PLY_(file_format)']\n */\nexport const PLYLoader = {\n  name: 'PLY',\n  id: 'ply',\n  module: 'ply',\n  shapes: ['mesh', 'gltf', 'columnar-table'],\n  version: VERSION,\n  worker: true,\n  extensions: ['ply'],\n  mimeTypes: ['text/plain', 'application/octet-stream'],\n  text: true,\n  binary: true,\n  tests: ['ply'],\n  options: {\n    ply: {}\n  }\n};\n\nexport const _typecheckPLYLoader: Loader = PLYLoader;\n","import {assert} from '../../utils/assert';\nimport Field from './field';\n\nexport type SchemaMetadata = Map<string, any>;\n\n/**\n * ArrowJS `Schema` API-compatible class for row-based tables (returned from `DataTable`)\n * https://loaders.gl/arrowjs/docs/api-reference/schema\n */\nexport default class Schema {\n  fields: Field[];\n  // TODO - Arrow just allows Map<string, string>\n  metadata: SchemaMetadata;\n\n  constructor(fields: Field[], metadata?: SchemaMetadata) {\n    assert(Array.isArray(fields));\n    checkNames(fields);\n    // For kepler fields, create arrow compatible `Fields` that have kepler fields as `metadata`\n    this.fields = fields;\n    this.metadata = metadata || new Map();\n  }\n\n  // TODO - arrow only seems to compare fields, not metadata\n  compareTo(other: Schema): boolean {\n    if (this.metadata !== other.metadata) {\n      return false;\n    }\n    if (this.fields.length !== other.fields.length) {\n      return false;\n    }\n    for (let i = 0; i < this.fields.length; ++i) {\n      if (!this.fields[i].compareTo(other.fields[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  select(...columnNames: string[]): Schema {\n    // Ensure column names reference valid fields\n    const nameMap = Object.create(null);\n    for (const name of columnNames) {\n      nameMap[name] = true;\n    }\n    const selectedFields = this.fields.filter((field) => nameMap[field.name]);\n    return new Schema(selectedFields, this.metadata);\n  }\n\n  selectAt(...columnIndices: number[]): Schema {\n    // Ensure column indices reference valid fields\n    const selectedFields = columnIndices.map((index) => this.fields[index]).filter(Boolean);\n    return new Schema(selectedFields, this.metadata);\n  }\n\n  assign(schemaOrFields: Schema | Field[]): Schema {\n    let fields: Field[];\n    let metadata: SchemaMetadata = this.metadata;\n\n    if (schemaOrFields instanceof Schema) {\n      const otherSchema = schemaOrFields;\n      fields = otherSchema.fields;\n      metadata = mergeMaps(mergeMaps(new Map(), this.metadata), otherSchema.metadata);\n    } else {\n      fields = schemaOrFields;\n    }\n\n    // Create a merged list of fields, overwrite fields in place, new fields at end\n    const fieldMap: {[key: string]: Field} = Object.create(null);\n\n    for (const field of this.fields) {\n      fieldMap[field.name] = field;\n    }\n\n    for (const field of fields) {\n      fieldMap[field.name] = field;\n    }\n\n    const mergedFields = Object.values(fieldMap);\n\n    return new Schema(mergedFields, metadata);\n  }\n}\n\n// Warn if any duplicated field names\nfunction checkNames(fields) {\n  const usedNames = {};\n  for (const field of fields) {\n    if (usedNames[field.name]) {\n      // eslint-disable-next-line\n      console.warn('Schema: duplicated field name', field.name, field);\n    }\n    usedNames[field.name] = true;\n  }\n}\n\nfunction mergeMaps<T>(m1: T, m2: T): T {\n  // @ts-ignore\n  return new Map([...(m1 || new Map()), ...(m2 || new Map())]);\n}\n","// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\nexport function assert(condition: boolean, message?: string) {\n  if (!condition) {\n    throw new Error(message || 'loader assertion failed.');\n  }\n}\n","// This code is adapted from ArrowJS https://github.com/apache/arrow\n// under Apache license http://www.apache.org/licenses/LICENSE-2.0\n\n/**\n * Main data type enumeration.\n *\n * Data types in this library are all *logical*. They can be expressed as\n * either a primitive physical type (bytes or bits of some fixed size), a\n * nested type consisting of other data types, or another data type (e.g. a\n * timestamp encoded as an int64).\n *\n * **Note**: Only enum values 0-17 (NONE through Map) are written to an Arrow\n * IPC payload.\n *\n * The rest of the values are specified here so TypeScript can narrow the type\n * signatures further beyond the base Arrow Types. The Arrow DataTypes include\n * metadata like `bitWidth` that impact the type signatures of the values we\n * accept and return.\n *\n * For example, the `Int8Vector` reads 1-byte numbers from an `Int8Array`, an\n * `Int32Vector` reads a 4-byte number from an `Int32Array`, and an `Int64Vector`\n * reads a pair of 4-byte lo, hi 32-bit integers as a zero-copy slice from the\n * underlying `Int32Array`.\n *\n * Library consumers benefit by knowing the narrowest type, since we can ensure\n * the types across all public methods are propagated, and never bail to `any`.\n * These values are _never_ used at runtime, and they will _never_ be written\n * to the flatbuffers metadata of serialized Arrow IPC payloads.\n */\nexport enum Type {\n  /** The default placeholder type */\n  NONE = 0,\n  /** A NULL type having no physical storage */\n  Null = 1,\n  /** Signed or unsigned 8, 16, 32, or 64-bit little-endian integer */\n  Int = 2,\n  /** 2, 4, or 8-byte floating point value */\n  Float = 3,\n  /** Variable-length bytes (no guarantee of UTF8-ness) */\n  Binary = 4,\n  /** UTF8 variable-length string as List<Char> */\n  Utf8 = 5,\n  /** Boolean as 1 bit, LSB bit-packed ordering */\n  Bool = 6,\n  /** Precision-and-scale-based decimal type. Storage type depends on the parameters. */\n  Decimal = 7,\n  /** int32_t days or int64_t milliseconds since the UNIX epoch */\n  Date = 8,\n  /** Time as signed 32 or 64-bit integer, representing either seconds, milliseconds, microseconds, or nanoseconds since midnight since midnight */\n  Time = 9,\n  /** Exact timestamp encoded with int64 since UNIX epoch (Default unit millisecond) */\n  Timestamp = 10,\n  /** YEAR_MONTH or DAY_TIME interval in SQL style */\n  Interval = 11,\n  /** A list of some logical data type */\n  List = 12,\n  /** Struct of logical types */\n  Struct = 13,\n  /** Union of logical types */\n  Union = 14,\n  /** Fixed-size binary. Each value occupies the same number of bytes */\n  FixedSizeBinary = 15,\n  /** Fixed-size list. Each value occupies the same number of bytes */\n  FixedSizeList = 16,\n  /** Map of named logical types */\n  Map = 17,\n\n  /** Dictionary aka Category type */\n  Dictionary = -1,\n  Int8 = -2,\n  Int16 = -3,\n  Int32 = -4,\n  Int64 = -5,\n  Uint8 = -6,\n  Uint16 = -7,\n  Uint32 = -8,\n  Uint64 = -9,\n  Float16 = -10,\n  Float32 = -11,\n  Float64 = -12,\n  DateDay = -13,\n  DateMillisecond = -14,\n  TimestampSecond = -15,\n  TimestampMillisecond = -16,\n  TimestampMicrosecond = -17,\n  TimestampNanosecond = -18,\n  TimeSecond = -19,\n  TimeMillisecond = -20,\n  TimeMicrosecond = -21,\n  TimeNanosecond = -22,\n  DenseUnion = -23,\n  SparseUnion = -24,\n  IntervalDayTime = -25,\n  IntervalYearMonth = -26\n}\n","import {DataType} from './type';\n\n/**\n * ArrowJS `Field` API-compatible class for row-based tables\n * https://loaders.gl/arrowjs/docs/api-reference/field\n * A field holds name, nullable, and metadata information about a table \"column\"\n * A Schema is essentially a list of fields\n */\nexport default class Field {\n  name: string;\n  type: DataType;\n  nullable: boolean;\n  metadata: Map<string, string>;\n\n  constructor(\n    name: string,\n    type: DataType,\n    nullable = false,\n    metadata: Map<string, string> = new Map()\n  ) {\n    this.name = name;\n    this.type = type;\n    this.nullable = nullable;\n    this.metadata = metadata;\n  }\n\n  get typeId(): number {\n    return this.type && this.type.typeId;\n  }\n\n  clone(): Field {\n    return new Field(this.name, this.type, this.nullable, this.metadata);\n  }\n\n  compareTo(other: this): boolean {\n    return (\n      this.name === other.name &&\n      this.type === other.type &&\n      this.nullable === other.nullable &&\n      this.metadata === other.metadata\n    );\n  }\n\n  toString(): string {\n    return `${this.type}${this.nullable ? ', nullable' : ''}${\n      this.metadata ? `, metadata: ${this.metadata}` : ''\n    }`;\n  }\n}\n","// This code is adapted from ArrowJS https://github.com/apache/arrow\n// under Apache license http://www.apache.org/licenses/LICENSE-2.0\n\nimport {Type} from './enum';\n\nimport Field from './field';\n\nexport {Type} from './enum';\n\nexport type TypedIntArray =\n  | Int8Array\n  | Uint8Array\n  | Int16Array\n  | Uint16Array\n  | Int32Array\n  | Uint32Array\n  | Int32Array\n  | Uint32Array\n  | Uint8ClampedArray;\n\nexport type TypedFloatArray = Float32Array | Float64Array;\n\nexport type TypedArray = TypedIntArray | TypedFloatArray;\n\nexport type AnyArrayType = Array<any> | TypedIntArray | TypedFloatArray;\n\nexport class DataType {\n  static isNull(x: any): boolean {\n    return x && x.typeId === Type.Null;\n  }\n  static isInt(x: any): boolean {\n    return x && x.typeId === Type.Int;\n  }\n  static isFloat(x: any): boolean {\n    return x && x.typeId === Type.Float;\n  }\n  static isBinary(x: any): boolean {\n    return x && x.typeId === Type.Binary;\n  }\n  static isUtf8(x: any): boolean {\n    return x && x.typeId === Type.Utf8;\n  }\n  static isBool(x: any): boolean {\n    return x && x.typeId === Type.Bool;\n  }\n  static isDecimal(x: any): boolean {\n    return x && x.typeId === Type.Decimal;\n  }\n  static isDate(x: any): boolean {\n    return x && x.typeId === Type.Date;\n  }\n  static isTime(x: any): boolean {\n    return x && x.typeId === Type.Time;\n  }\n  static isTimestamp(x: any): boolean {\n    return x && x.typeId === Type.Timestamp;\n  }\n  static isInterval(x: any): boolean {\n    return x && x.typeId === Type.Interval;\n  }\n  static isList(x: any): boolean {\n    return x && x.typeId === Type.List;\n  }\n  static isStruct(x: any): boolean {\n    return x && x.typeId === Type.Struct;\n  }\n  static isUnion(x: any): boolean {\n    return x && x.typeId === Type.Union;\n  }\n  static isFixedSizeBinary(x: any): boolean {\n    return x && x.typeId === Type.FixedSizeBinary;\n  }\n  static isFixedSizeList(x: any): boolean {\n    return x && x.typeId === Type.FixedSizeList;\n  }\n  static isMap(x: any): boolean {\n    return x && x.typeId === Type.Map;\n  }\n  static isDictionary(x: any): boolean {\n    return x && x.typeId === Type.Dictionary;\n  }\n\n  get typeId(): Type {\n    return Type.NONE;\n  }\n\n  // get ArrayType(): AnyArrayType {\n  //   return Int8Array;\n  // }\n\n  // get ArrayType() { return Array; }\n  compareTo(other: DataType): boolean {\n    // TODO\n    return this === other; // comparer.visit(this, other);\n  }\n}\n\n// NULL\n\nexport class Null extends DataType {\n  get typeId(): Type {\n    return Type.Null;\n  }\n  get [Symbol.toStringTag](): string {\n    return 'Null';\n  }\n  toString(): string {\n    return 'Null';\n  }\n}\n\n// BOOLEANS\n\nexport class Bool extends DataType {\n  get typeId(): Type {\n    return Type.Bool;\n  }\n  // get ArrayType() {\n  //   return Uint8Array;\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Bool';\n  }\n  toString(): string {\n    return 'Bool';\n  }\n}\n\n// INTS\n\nexport class Int extends DataType {\n  readonly isSigned: boolean;\n  readonly bitWidth: number;\n  constructor(isSigned, bitWidth) {\n    super();\n    this.isSigned = isSigned;\n    this.bitWidth = bitWidth;\n  }\n  get typeId(): Type {\n    return Type.Int;\n  }\n  // get ArrayType() {\n  //   switch (this.bitWidth) {\n  //     case 8:\n  //       return this.isSigned ? Int8Array : Uint8Array;\n  //     case 16:\n  //       return this.isSigned ? Int16Array : Uint16Array;\n  //     case 32:\n  //       return this.isSigned ? Int32Array : Uint32Array;\n  //     case 64:\n  //       return this.isSigned ? Int32Array : Uint32Array;\n  //     default:\n  //       throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);\n  //   }\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Int';\n  }\n  toString(): string {\n    return `${this.isSigned ? 'I' : 'Ui'}nt${this.bitWidth}`;\n  }\n}\n\nexport class Int8 extends Int {\n  constructor() {\n    super(true, 8);\n  }\n}\nexport class Int16 extends Int {\n  constructor() {\n    super(true, 16);\n  }\n}\nexport class Int32 extends Int {\n  constructor() {\n    super(true, 32);\n  }\n}\nexport class Int64 extends Int {\n  constructor() {\n    super(true, 64);\n  }\n}\nexport class Uint8 extends Int {\n  constructor() {\n    super(false, 8);\n  }\n}\nexport class Uint16 extends Int {\n  constructor() {\n    super(false, 16);\n  }\n}\nexport class Uint32 extends Int {\n  constructor() {\n    super(false, 32);\n  }\n}\nexport class Uint64 extends Int {\n  constructor() {\n    super(false, 64);\n  }\n}\n\n// FLOATS\n\nconst Precision = {\n  HALF: 16,\n  SINGLE: 32,\n  DOUBLE: 64\n};\n\nexport class Float extends DataType {\n  readonly precision: number;\n  constructor(precision) {\n    super();\n    this.precision = precision;\n  }\n  get typeId(): Type {\n    return Type.Float;\n  }\n  // get ArrayType() {\n  //   switch (this.precision) {\n  //     case Precision.HALF:\n  //       return Uint16Array;\n  //     case Precision.SINGLE:\n  //       return Float32Array;\n  //     case Precision.DOUBLE:\n  //       return Float64Array;\n  //     default:\n  //       throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);\n  //   }\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Float';\n  }\n  toString(): string {\n    return `Float${this.precision}`;\n  }\n}\n\nexport class Float16 extends Float {\n  constructor() {\n    super(Precision.HALF);\n  }\n}\nexport class Float32 extends Float {\n  constructor() {\n    super(Precision.SINGLE);\n  }\n}\nexport class Float64 extends Float {\n  constructor() {\n    super(Precision.DOUBLE);\n  }\n}\n\nexport class Binary extends DataType {\n  constructor() {\n    super();\n  }\n  get typeId() {\n    return Type.Binary;\n  }\n  toString() {\n    return 'Binary';\n  }\n  get [Symbol.toStringTag]() {\n    return 'Binary';\n  }\n}\n\n// STRINGS\n\nexport class Utf8 extends DataType {\n  get typeId(): Type {\n    return Type.Utf8;\n  }\n  // get ArrayType() {\n  //   return Uint8Array;\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Utf8';\n  }\n  toString(): string {\n    return 'Utf8';\n  }\n}\n\n// DATES, TIMES AND INTERVALS\n\nconst DateUnit = {\n  DAY: 0,\n  MILLISECOND: 1\n};\n\nexport class Date extends DataType {\n  readonly unit: number;\n  constructor(unit) {\n    super();\n    this.unit = unit;\n  }\n  get typeId(): Type {\n    return Type.Date;\n  }\n  // get ArrayType() {\n  //   return Int32Array;\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Date';\n  }\n  toString(): string {\n    return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`;\n  }\n}\n\nexport class DateDay extends Date {\n  constructor() {\n    super(DateUnit.DAY);\n  }\n}\nexport class DateMillisecond extends Date {\n  constructor() {\n    super(DateUnit.MILLISECOND);\n  }\n}\n\nconst TimeUnit = {\n  SECOND: 1,\n  MILLISECOND: 1e3,\n  MICROSECOND: 1e6,\n  NANOSECOND: 1e9\n};\n\nexport class Time extends DataType {\n  readonly unit: number;\n  readonly bitWidth: number;\n\n  constructor(unit, bitWidth) {\n    super();\n    this.unit = unit;\n    this.bitWidth = bitWidth;\n  }\n  get typeId(): Type {\n    return Type.Time;\n  }\n  toString(): string {\n    return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`;\n  }\n  get [Symbol.toStringTag](): string {\n    return 'Time';\n  }\n  // get ArrayType() {\n  //   return Int32Array;\n  // }\n}\n\nexport class TimeSecond extends Time {\n  constructor() {\n    super(TimeUnit.SECOND, 32);\n  }\n}\nexport class TimeMillisecond extends Time {\n  constructor() {\n    super(TimeUnit.MILLISECOND, 32);\n  }\n}\n// export class TimeMicrosecond extends Time { constructor() { super(TimeUnit.MICROSECOND, 64); } }\n// export class TimeNanosecond extends Time { constructor() { super(TimeUnit.NANOSECOND, 64); } }\n\nexport class Timestamp extends DataType {\n  readonly unit: any;\n  readonly timezone: any;\n\n  constructor(unit: any, timezone = null) {\n    super();\n    this.unit = unit;\n    this.timezone = timezone;\n  }\n  get typeId(): Type {\n    return Type.Timestamp;\n  }\n  // get ArrayType() {\n  //   return Int32Array;\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Timestamp';\n  }\n  toString(): string {\n    return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ''}>`;\n  }\n}\n\nexport class TimestampSecond extends Timestamp {\n  constructor(timezone = null) {\n    super(TimeUnit.SECOND, timezone);\n  }\n}\nexport class TimestampMillisecond extends Timestamp {\n  constructor(timezone = null) {\n    super(TimeUnit.MILLISECOND, timezone);\n  }\n}\nexport class TimestampMicrosecond extends Timestamp {\n  constructor(timezone = null) {\n    super(TimeUnit.MICROSECOND, timezone);\n  }\n}\nexport class TimestampNanosecond extends Timestamp {\n  constructor(timezone = null) {\n    super(TimeUnit.NANOSECOND, timezone);\n  }\n}\n\nconst IntervalUnit = {\n  DAY_TIME: 0,\n  YEAR_MONTH: 1\n};\n\nexport class Interval extends DataType {\n  readonly unit: number;\n  constructor(unit: number) {\n    super();\n    this.unit = unit;\n  }\n  get typeId(): Type {\n    return Type.Interval;\n  }\n  // get ArrayType() {\n  //   return Int32Array;\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Interval';\n  }\n  toString(): string {\n    return `Interval<${IntervalUnit[this.unit]}>`;\n  }\n}\n\nexport class IntervalDayTime extends Interval {\n  constructor() {\n    super(IntervalUnit.DAY_TIME);\n  }\n}\nexport class IntervalYearMonth extends Interval {\n  constructor() {\n    super(IntervalUnit.YEAR_MONTH);\n  }\n}\n\nexport class FixedSizeList extends DataType {\n  readonly listSize: number;\n  readonly children: Field[];\n\n  constructor(listSize: number, child: Field) {\n    super();\n    this.listSize = listSize;\n    this.children = [child];\n  }\n  get typeId(): Type {\n    return Type.FixedSizeList;\n  }\n  get valueType() {\n    return this.children[0].type;\n  }\n  get valueField() {\n    return this.children[0];\n  }\n  // get ArrayType() {\n  //   return this.valueType.ArrayType;\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'FixedSizeList';\n  }\n  toString(): string {\n    return `FixedSizeList[${this.listSize}]<${this.valueType}>`;\n  }\n}\n\nexport class Struct extends DataType {\n  public readonly children: Field[];\n\n  constructor(children: Field[]) {\n    super();\n    this.children = children;\n  }\n\n  public get typeId() {\n    return Type.Struct;\n  }\n  public toString() {\n    return `Struct<{${this.children.map((f) => `${f.name}:${f.type}`).join(', ')}}>`;\n  }\n  get [Symbol.toStringTag](): string {\n    return 'Struct';\n  }\n}\n","import {MeshAttribute, MeshAttributes} from './mesh-types';\nimport {Schema, Field, FixedSizeList} from '../../lib/schema';\nimport {getArrowTypeFromTypedArray} from '../../lib/arrow/arrow-like-type-utils';\n\n/**\n * Create a schema for mesh attributes data\n * @param attributes\n * @param metadata\n * @returns\n */\nexport function deduceMeshSchema(\n  attributes: MeshAttributes,\n  metadata?: Map<string, string>\n): Schema {\n  const fields = deduceMeshFields(attributes);\n  return new Schema(fields, metadata);\n}\n\n/**\n * Create arrow-like schema field for mesh attribute\n * @param attributeName\n * @param attribute\n * @param optionalMetadata\n * @returns\n */\nexport function deduceMeshField(\n  attributeName: string,\n  attribute: MeshAttribute,\n  optionalMetadata?: Map<string, string>\n): Field {\n  const type = getArrowTypeFromTypedArray(attribute.value);\n  const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);\n  const field = new Field(\n    attributeName,\n    new FixedSizeList(attribute.size, new Field('value', type)),\n    false,\n    metadata\n  );\n  return field;\n}\n\n/**\n * Create fields array for mesh attributes\n * @param attributes\n * @returns\n */\nfunction deduceMeshFields(attributes: MeshAttributes): Field[] {\n  const fields: Field[] = [];\n  for (const attributeName in attributes) {\n    const attribute: MeshAttribute = attributes[attributeName];\n    fields.push(deduceMeshField(attributeName, attribute));\n  }\n  return fields;\n}\n\n/**\n * Make metadata by mesh attribute properties\n * @param attribute\n * @returns\n */\nexport function makeMeshAttributeMetadata(attribute: MeshAttribute): Map<string, string> {\n  const result = new Map();\n  if ('byteOffset' in attribute) {\n    result.set('byteOffset', attribute.byteOffset!.toString(10));\n  }\n  if ('byteStride' in attribute) {\n    result.set('byteStride', attribute.byteStride!.toString(10));\n  }\n  if ('normalized' in attribute) {\n    result.set('normalized', attribute.normalized!.toString());\n  }\n  return result;\n}\n","import type {TypedArray} from '../../types';\nimport {DataType, Float32, Float64, Int16, Int32, Int8, Uint16, Uint32, Uint8} from '../schema';\n\nexport function getArrowTypeFromTypedArray(array: TypedArray): DataType {\n  switch (array.constructor) {\n    case Int8Array:\n      return new Int8();\n    case Uint8Array:\n      return new Uint8();\n    case Int16Array:\n      return new Int16();\n    case Uint16Array:\n      return new Uint16();\n    case Int32Array:\n      return new Int32();\n    case Uint32Array:\n      return new Uint32();\n    case Float32Array:\n      return new Float32();\n    case Float64Array:\n      return new Float64();\n    default:\n      throw new Error('array type not supported');\n  }\n}\n","import {Schema, MeshAttributes, deduceMeshSchema} from '@loaders.gl/schema';\nimport type {PLYHeader} from './ply-types';\n\n/**\n * Gets schema from PLY header\n * @param plyHeader\n * @param metadata\n * @returns Schema\n */\nexport function getPLYSchema(plyHeader: PLYHeader, attributes: MeshAttributes): Schema {\n  const metadataMap = makeMetadataFromPlyHeader(plyHeader);\n  const schema = deduceMeshSchema(attributes, metadataMap);\n  return schema;\n}\n\n/**\n * Make arrow like schema metadata by PlyHeader properties\n * @param plyHeader\n * @returns\n */\nfunction makeMetadataFromPlyHeader(plyHeader: PLYHeader): Map<string, string> {\n  const metadataMap = new Map();\n  metadataMap.set('ply_comments', JSON.stringify(plyHeader.comments));\n  metadataMap.set('ply_elements', JSON.stringify(plyHeader.elements));\n  if (plyHeader.format !== undefined) {\n    metadataMap.set('ply_format', plyHeader.format);\n  }\n  if (plyHeader.version !== undefined) {\n    metadataMap.set('ply_version', plyHeader.version);\n  }\n  if (plyHeader.headerLength !== undefined) {\n    metadataMap.set('ply_headerLength', plyHeader.headerLength.toString(10));\n  }\n  return metadataMap;\n}\n","import type {MeshAttributes} from '@loaders.gl/schema';\nimport {getMeshBoundingBox} from '@loaders.gl/schema';\nimport type {PLYMesh, PLYHeader, PLYAttributes, MeshHeader} from './ply-types';\nimport {getPLYSchema} from './get-ply-schema';\n\n/**\n * @param header\n * @param attributes\n * @returns data and header\n */\nexport default function normalizePLY(\n  plyHeader: MeshHeader & PLYHeader,\n  plyAttributes: PLYAttributes,\n  options?: {}\n): PLYMesh {\n  const attributes = getMeshAttributes(plyAttributes);\n  const boundingBox = getMeshBoundingBox(attributes);\n  const vertexCount = plyAttributes.indices.length || plyAttributes.vertices.length / 3;\n\n  // TODO - how to detect POINT CLOUDS vs MESHES?\n  // TODO - For Meshes, PLY quadrangles must be split?\n  const isTriangles = plyAttributes.indices && plyAttributes.indices.length > 0;\n  const mode = isTriangles ? 4 : 0; // TRIANGLES vs POINTS\n  const topology = isTriangles ? 'triangle-list' : 'point-list';\n\n  const schema = getPLYSchema(plyHeader, attributes);\n\n  const plyMesh: PLYMesh = {\n    loader: 'ply',\n    loaderData: plyHeader,\n    header: {\n      vertexCount,\n      boundingBox\n    },\n    schema,\n    attributes,\n    indices: {value: new Uint32Array(0), size: 0},\n    mode,\n    topology\n  };\n\n  if (plyAttributes.indices.length > 0) {\n    plyMesh.indices = {value: new Uint32Array(plyAttributes.indices), size: 1};\n  }\n\n  return plyMesh;\n}\n\n/**\n * @param attributes\n * @returns accessors []\n */\nfunction getMeshAttributes(attributes: PLYAttributes): MeshAttributes {\n  const accessors: MeshAttributes = {};\n\n  accessors.POSITION = {value: new Float32Array(attributes.vertices), size: 3};\n\n  // optional attributes data\n\n  if (attributes.normals.length > 0) {\n    accessors.NORMAL = {value: new Float32Array(attributes.normals), size: 3};\n  }\n\n  if (attributes.uvs.length > 0) {\n    accessors.TEXCOORD_0 = {value: new Float32Array(attributes.uvs), size: 2};\n  }\n\n  if (attributes.colors.length > 0) {\n    // TODO - normalized shoud be based on `uchar` flag in source data?\n    accessors.COLOR_0 = {value: new Uint8Array(attributes.colors), size: 3, normalized: true};\n  }\n\n  return accessors;\n}\n","// Mesh category utilities\n// TODO - move to mesh category module, or to math.gl/geometry module\nimport {TypedArray} from '../../types';\nimport {MeshAttributes} from './mesh-types';\n\ntype TypedArrays = {[key: string]: TypedArray};\n\n/**\n * Holds an axis aligned bounding box\n * TODO - make sure AxisAlignedBoundingBox in math.gl/culling understands this format (or change this format)\n */\ntype BoundingBox = [[number, number, number], [number, number, number]];\n\n/**\n * Get number of vertices in mesh\n * @param attributes\n */\nexport function getMeshSize(attributes: TypedArrays): number {\n  let size = 0;\n  for (const attributeName in attributes) {\n    const attribute = attributes[attributeName];\n    if (ArrayBuffer.isView(attribute)) {\n      // @ts-ignore DataView doesn't have BYTES_PER_ELEMENT\n      size += attribute.byteLength * attribute.BYTES_PER_ELEMENT;\n    }\n  }\n  return size;\n}\n\n/**\n * Get the (axis aligned) bounding box of a mesh\n * @param attributes\n * @returns array of two vectors representing the axis aligned bounding box\n */\n// eslint-disable-next-line complexity\nexport function getMeshBoundingBox(attributes: MeshAttributes): BoundingBox {\n  let minX = Infinity;\n  let minY = Infinity;\n  let minZ = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let maxZ = -Infinity;\n\n  const positions = attributes.POSITION ? attributes.POSITION.value : [];\n  const len = positions && positions.length;\n\n  for (let i = 0; i < len; i += 3) {\n    const x = positions[i];\n    const y = positions[i + 1];\n    const z = positions[i + 2];\n\n    minX = x < minX ? x : minX;\n    minY = y < minY ? y : minY;\n    minZ = z < minZ ? z : minZ;\n\n    maxX = x > maxX ? x : maxX;\n    maxY = y > maxY ? y : maxY;\n    maxZ = z > maxZ ? z : maxZ;\n  }\n  return [\n    [minX, minY, minZ],\n    [maxX, maxY, maxZ]\n  ];\n}\n","// PLY Loader, adapted from THREE.js (MIT license)\n//\n// Attributions per original THREE.js source file:\n//\n// @author Wei Meng / http://about.me/menway\n//\n// Description: A loader for PLY ASCII files (known as the Polygon File Format\n// or the Stanford Triangle Format).\n//\n// Limitations: ASCII decoding assumes file is UTF-8.\n//\n// If the PLY file uses non standard property names, they can be mapped while\n// loading. For example, the following maps the properties\n// “diffuse_(red|green|blue)” in the file to standard color names.\n//\n// parsePLY(data, {\n//   propertyNameMapping: {\n//     diffuse_red: 'red',\n//     diffuse_green: 'green',\n//     diffuse_blue: 'blue'\n//   }\n// });\nimport type {\n  PLYMesh,\n  PLYHeader,\n  PLYAttributes,\n  MeshHeader,\n  ASCIIElement,\n  PLYProperty\n} from './ply-types';\nimport normalizePLY from './normalize-ply';\n\n/**\n * @param data\n * @param options\n * @returns\n */\nexport default function parsePLY(data: ArrayBuffer | string, options = {}): PLYMesh {\n  let header: PLYHeader & MeshHeader;\n  let attributes: PLYAttributes;\n\n  if (data instanceof ArrayBuffer) {\n    const text = new TextDecoder().decode(data);\n    header = parseHeader(text, options);\n    attributes = header.format === 'ascii' ? parseASCII(text, header) : parseBinary(data, header);\n  } else {\n    header = parseHeader(data, options);\n    attributes = parseASCII(data, header);\n  }\n\n  return normalizePLY(header, attributes);\n}\n\n/**\n * @param data\n * @param options\n * @returns header\n */\nfunction parseHeader(data: any, options: {[index: string]: any}): PLYHeader {\n  const PLY_HEADER_PATTERN = /ply([\\s\\S]*)end_header\\s/;\n\n  let headerText = '';\n  let headerLength = 0;\n\n  const result = PLY_HEADER_PATTERN.exec(data);\n\n  if (result !== null) {\n    headerText = result[1];\n    headerLength = result[0].length;\n  }\n  const lines = headerText.split('\\n');\n  const header = parseHeaderLines(lines, headerLength, options);\n\n  return header;\n}\n\n/**\n * @param lines\n * @param headerLength\n * @param options\n * @returns header\n */\nfunction parseHeaderLines(\n  lines: string[],\n  headerLength: number,\n  options: {[index: string]: any}\n): PLYHeader {\n  const header: PLYHeader = {\n    comments: [],\n    elements: [],\n    headerLength\n  };\n\n  let lineType: string | undefined;\n  let lineValues: string[];\n  let currentElement: ASCIIElement | null = null;\n\n  for (let i = 0; i < lines.length; i++) {\n    let line: string = lines[i];\n    line = line.trim();\n\n    if (line === '') {\n      // eslint-disable-next-line\n      continue;\n    }\n\n    lineValues = line.split(/\\s+/);\n    lineType = lineValues.shift();\n    line = lineValues.join(' ');\n\n    switch (lineType) {\n      case 'format':\n        header.format = lineValues[0];\n        header.version = lineValues[1];\n        break;\n\n      case 'comment':\n        header.comments.push(line);\n        break;\n\n      case 'element':\n        if (currentElement) {\n          header.elements.push(currentElement);\n        }\n\n        currentElement = {\n          name: lineValues[0],\n          count: parseInt(lineValues[1], 10),\n          properties: []\n        };\n        break;\n\n      case 'property':\n        if (!currentElement) {\n          break;\n        }\n        currentElement.properties.push(\n          makePLYElementProperty(lineValues, options.propertyNameMapping)\n        );\n        break;\n\n      default:\n        // eslint-disable-next-line\n        console.log('unhandled', lineType, lineValues);\n    }\n  }\n\n  if (currentElement !== undefined) {\n    header.elements.push(currentElement);\n  }\n\n  return header;\n}\n\n/**\n * @param propertValues\n * @param propertyNameMapping\n * @returns property of ply element\n */\nfunction makePLYElementProperty(propertValues: string[], propertyNameMapping: []): PLYProperty {\n  const property: PLYProperty = {\n    type: propertValues[0]\n  };\n\n  if (property.type === 'list') {\n    property.name = propertValues[3];\n    property.countType = propertValues[1];\n    property.itemType = propertValues[2];\n  } else {\n    property.name = propertValues[1];\n  }\n\n  if (propertyNameMapping && property.name in propertyNameMapping) {\n    property.name = propertyNameMapping[property.name];\n  }\n\n  return property;\n}\n\n/**\n * Parses ASCII number\n * @param n\n * @param type\n * @returns\n */\n// eslint-disable-next-line complexity\nfunction parseASCIINumber(n: string, type: string): number {\n  switch (type) {\n    case 'char':\n    case 'uchar':\n    case 'short':\n    case 'ushort':\n    case 'int':\n    case 'uint':\n    case 'int8':\n    case 'uint8':\n    case 'int16':\n    case 'uint16':\n    case 'int32':\n    case 'uint32':\n      return parseInt(n, 10);\n\n    case 'float':\n    case 'double':\n    case 'float32':\n    case 'float64':\n      return parseFloat(n);\n\n    default:\n      throw new Error(type);\n  }\n}\n\n/**\n * @param properties\n * @param line\n * @returns ASCII element\n */\nfunction parseASCIIElement(properties: any[], line: string) {\n  const values: any = line.split(/\\s+/);\n\n  const element = {};\n\n  for (let i = 0; i < properties.length; i++) {\n    if (properties[i].type === 'list') {\n      const list: any = [];\n      const n = parseASCIINumber(values.shift(), properties[i].countType);\n\n      for (let j = 0; j < n; j++) {\n        list.push(parseASCIINumber(values.shift(), properties[i].itemType));\n      }\n\n      element[properties[i].name] = list;\n    } else {\n      element[properties[i].name] = parseASCIINumber(values.shift(), properties[i].type);\n    }\n  }\n\n  return element;\n}\n\n/**\n * @param data\n * @param header\n * @returns [attributes]\n */\nfunction parseASCII(data: any, header: PLYHeader): PLYAttributes {\n  // PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)\n\n  const attributes: PLYAttributes = {\n    indices: [],\n    vertices: [],\n    normals: [],\n    uvs: [],\n    colors: []\n  };\n\n  let result: RegExpExecArray | null;\n\n  const patternBody = /end_header\\s([\\s\\S]*)$/;\n  let body = '';\n  if ((result = patternBody.exec(data)) !== null) {\n    body = result[1];\n  }\n\n  const lines = body.split('\\n');\n  let currentElement = 0;\n  let currentElementCount = 0;\n\n  for (let i = 0; i < lines.length; i++) {\n    let line = lines[i];\n    line = line.trim();\n\n    if (line !== '') {\n      if (currentElementCount >= header.elements[currentElement].count) {\n        currentElement++;\n        currentElementCount = 0;\n      }\n\n      const element = parseASCIIElement(header.elements[currentElement].properties, line);\n      handleElement(attributes, header.elements[currentElement].name, element);\n      currentElementCount++;\n    }\n  }\n\n  return attributes;\n}\n\n/**\n * @param buffer\n * @param elementName\n * @param element\n */\n// eslint-disable-next-line complexity\nfunction handleElement(\n  buffer: {[index: string]: number[]},\n  elementName: string,\n  element: any = {}\n) {\n  if (elementName === 'vertex') {\n    buffer.vertices.push(element.x, element.y, element.z);\n\n    if ('nx' in element && 'ny' in element && 'nz' in element) {\n      buffer.normals.push(element.nx, element.ny, element.nz);\n    }\n\n    if ('s' in element && 't' in element) {\n      buffer.uvs.push(element.s, element.t);\n    }\n\n    if ('red' in element && 'green' in element && 'blue' in element) {\n      buffer.colors.push(element.red, element.green, element.blue);\n    }\n  } else if (elementName === 'face') {\n    const vertexIndices = element.vertex_indices || element.vertex_index; // issue #9338\n\n    if (vertexIndices.length === 3) {\n      buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[2]);\n    } else if (vertexIndices.length === 4) {\n      buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[3]);\n      buffer.indices.push(vertexIndices[1], vertexIndices[2], vertexIndices[3]);\n    }\n  }\n}\n\n/**\n * Reads binary data\n * @param dataview\n * @param at\n * @param type\n * @param littleEndian\n * @returns [number, number]\n */\n// eslint-disable-next-line complexity\nfunction binaryRead(dataview: DataView, at: number, type: any, littleEndian: boolean): number[] {\n  switch (type) {\n    // corespondences for non-specific length types here match rply:\n    case 'int8':\n    case 'char':\n      return [dataview.getInt8(at), 1];\n    case 'uint8':\n    case 'uchar':\n      return [dataview.getUint8(at), 1];\n    case 'int16':\n    case 'short':\n      return [dataview.getInt16(at, littleEndian), 2];\n    case 'uint16':\n    case 'ushort':\n      return [dataview.getUint16(at, littleEndian), 2];\n    case 'int32':\n    case 'int':\n      return [dataview.getInt32(at, littleEndian), 4];\n    case 'uint32':\n    case 'uint':\n      return [dataview.getUint32(at, littleEndian), 4];\n    case 'float32':\n    case 'float':\n      return [dataview.getFloat32(at, littleEndian), 4];\n    case 'float64':\n    case 'double':\n      return [dataview.getFloat64(at, littleEndian), 8];\n\n    default:\n      throw new Error(type);\n  }\n}\n\n/**\n * Reads binary data\n * @param dataview\n * @param at\n * @param properties\n * @param littleEndian\n * @returns [object, number]\n */\nfunction binaryReadElement(\n  dataview: DataView,\n  at: number,\n  properties: {[index: string]: any},\n  littleEndian: boolean\n): {}[] {\n  const element = {};\n  let result: number[];\n  let read = 0;\n\n  for (let i = 0; i < properties.length; i++) {\n    if (properties[i].type === 'list') {\n      const list = [];\n\n      result = binaryRead(dataview, at + read, properties[i].countType, littleEndian);\n      const n = result[0];\n      read += result[1];\n\n      for (let j = 0; j < n; j++) {\n        result = binaryRead(dataview, at + read, properties[i].itemType, littleEndian);\n        // @ts-ignore\n        list.push(result[0]);\n        read += result[1];\n      }\n\n      element[properties[i].name] = list;\n    } else {\n      result = binaryRead(dataview, at + read, properties[i].type, littleEndian);\n      element[properties[i].name] = result[0];\n      read += result[1];\n    }\n  }\n\n  return [element, read];\n}\n\ntype BinaryAttributes = {\n  [index: string]: number[];\n};\n\n/**\n * Parses binary data\n * @param data\n * @param header\n * @returns [attributes] of data\n */\nfunction parseBinary(data: ArrayBuffer, header: {[index: string]: any}): BinaryAttributes {\n  const attributes: BinaryAttributes = {\n    indices: [],\n    vertices: [],\n    normals: [],\n    uvs: [],\n    colors: []\n  };\n\n  const littleEndian = header.format === 'binary_little_endian';\n  const body = new DataView(data, header.headerLength);\n  let result: any[];\n  let loc = 0;\n\n  for (let currentElement = 0; currentElement < header.elements.length; currentElement++) {\n    const count = header.elements[currentElement].count;\n    for (let currentElementCount = 0; currentElementCount < count; currentElementCount++) {\n      result = binaryReadElement(\n        body,\n        loc,\n        header.elements[currentElement].properties,\n        littleEndian\n      );\n      loc += result[1];\n      const element = result[0];\n\n      handleElement(attributes, header.elements[currentElement].name, element);\n    }\n  }\n\n  return attributes;\n}\n","// TextDecoder iterators\n// TextDecoder will keep any partial undecoded bytes between calls to `decode`\n\nexport async function* makeTextDecoderIterator(\n  arrayBufferIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options: TextDecoderOptions = {}\n): AsyncIterable<string> {\n  const textDecoder = new TextDecoder(undefined, options);\n  for await (const arrayBuffer of arrayBufferIterator) {\n    yield typeof arrayBuffer === 'string'\n      ? arrayBuffer\n      : textDecoder.decode(arrayBuffer, {stream: true});\n  }\n}\n\n// TextEncoder iterator\n// TODO - this is not useful unless min chunk size is given\n// TextEncoder will keep any partial undecoded bytes between calls to `encode`\n// If iterator does not yield strings, assume arrayBuffer and return unencoded\n\nexport async function* makeTextEncoderIterator(\n  textIterator: AsyncIterable<string> | Iterable<ArrayBuffer>\n): AsyncIterable<ArrayBuffer> {\n  const textEncoder = new TextEncoder();\n  for await (const text of textIterator) {\n    yield typeof text === 'string' ? textEncoder.encode(text) : text;\n  }\n}\n\n/**\n * @param textIterator async iterable yielding strings\n * @returns an async iterable over lines\n * See http://2ality.com/2018/04/async-iter-nodejs.html\n */\n\nexport async function* makeLineIterator(\n  textIterator: AsyncIterable<string>\n): AsyncIterable<string> {\n  let previous = '';\n  for await (const textChunk of textIterator) {\n    previous += textChunk;\n    let eolIndex;\n    while ((eolIndex = previous.indexOf('\\n')) >= 0) {\n      // line includes the EOL\n      const line = previous.slice(0, eolIndex + 1);\n      previous = previous.slice(eolIndex + 1);\n      yield line;\n    }\n  }\n\n  if (previous.length > 0) {\n    yield previous;\n  }\n}\n\n/**\n * @param lineIterator async iterable yielding lines\n * @returns async iterable yielding numbered lines\n *\n * See http://2ality.com/2018/04/async-iter-nodejs.html\n */\nexport async function* makeNumberedLineIterator(\n  lineIterator: AsyncIterable<string>\n): AsyncIterable<{counter: number; line: string}> {\n  let counter = 1;\n  for await (const line of lineIterator) {\n    yield {counter, line};\n    counter++;\n  }\n}\n","// PLY Loader, adapted from THREE.js (MIT license)\n//\n// Attributions per original THREE.js source file:\n//\n// @author Wei Meng / http://about.me/menway\n//\n// Description: A loader for PLY ASCII files (known as the Polygon File Format\n// or the Stanford Triangle Format).\n//\n// Limitations: ASCII decoding assumes file is UTF-8.\n//\n// If the PLY file uses non standard property names, they can be mapped while\n// loading. For example, the following maps the properties\n// “diffuse_(red|green|blue)” in the file to standard color names.\n//\n// parsePLY(data, {\n//   propertyNameMapping: {\n//     diffuse_red: 'red',\n//     diffuse_green: 'green',\n//     diffuse_blue: 'blue'\n//   }\n// });\n// @ts-nocheck\n\nimport {makeLineIterator, makeTextDecoderIterator, forEach} from '@loaders.gl/core';\nimport normalizePLY from './normalize-ply';\nimport {PLYMesh, PLYHeader, ASCIIElement, PLYAttributes} from './ply-types';\n\nlet currentElement: ASCIIElement;\n\n/**\n * PARSER\n * @param iterator\n * @param options\n */\nexport default async function* parsePLYInBatches(\n  iterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options: any\n): AsyncIterable<PLYMesh> {\n  const lineIterator = makeLineIterator(makeTextDecoderIterator(iterator));\n  const header = await parsePLYHeader(lineIterator, options);\n\n  let attributes: PLYAttributes;\n  switch (header.format) {\n    case 'ascii':\n      attributes = await parseASCII(lineIterator, header);\n      break;\n    default:\n      throw new Error('Binary PLY can not yet be parsed in streaming mode');\n    // attributes = await parseBinary(lineIterator, header);\n  }\n\n  yield normalizePLY(header, attributes, options);\n}\n\n/**\n * Parses header\n * @param lineIterator\n * @param options\n * @returns\n */\nasync function parsePLYHeader(\n  lineIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options: {[key: string]: any}\n): Promise<PLYHeader> {\n  const header: PLYHeader = {\n    comments: [],\n    elements: []\n    // headerLength\n  };\n\n  // Note: forEach does not reset iterator if exiting loop prematurely\n  // so that iteration can continue in a second loop\n  await forEach(lineIterator, (line: string) => {\n    line = line.trim();\n\n    // End of header\n    if (line === 'end_header') {\n      return true; // Returning true cancels `forEach`\n    }\n\n    // Ignore empty lines\n    if (line === '') {\n      // eslint-disable-next-line\n      return false; // Returning false does not cancel `forEach`\n    }\n\n    const lineValues = line.split(/\\s+/);\n    const lineType = lineValues.shift();\n    line = lineValues.join(' ');\n\n    switch (lineType) {\n      case 'ply':\n        // First line magic characters, ignore\n        break;\n\n      case 'format':\n        header.format = lineValues[0];\n        header.version = lineValues[1];\n        break;\n\n      case 'comment':\n        header.comments.push(line);\n        break;\n\n      case 'element':\n        if (currentElement) {\n          header.elements.push(currentElement);\n        }\n\n        currentElement = {\n          name: lineValues[0],\n          count: parseInt(lineValues[1], 10),\n          properties: []\n        };\n        break;\n\n      case 'property':\n        const property = makePLYElementProperty(lineValues, options.propertyNameMapping);\n        currentElement.properties.push(property);\n        break;\n\n      default:\n        // eslint-disable-next-line\n        console.log('unhandled', lineType, lineValues);\n    }\n\n    return false;\n  });\n\n  if (currentElement) {\n    header.elements.push(currentElement);\n  }\n\n  return header;\n}\n\nfunction makePLYElementProperty(propertValues: string[], propertyNameMapping: []) {\n  const property: {[index: string]: string} = {\n    type: propertValues[0]\n  };\n\n  if (property.type === 'list') {\n    property.name = propertValues[3];\n    property.countType = propertValues[1];\n    property.itemType = propertValues[2];\n  } else {\n    property.name = propertValues[1];\n  }\n\n  if (propertyNameMapping && property.name in propertyNameMapping) {\n    property.name = propertyNameMapping[property.name];\n  }\n\n  return property;\n}\n\n// ASCII PARSING\n/**\n * @param lineIterator\n * @param header\n * @returns\n */\nasync function parseASCII(lineIterator: string, header: PLYHeader) {\n  // PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)\n  const attributes: PLYAttributes = {\n    indices: [],\n    vertices: [],\n    normals: [],\n    uvs: [],\n    colors: []\n  };\n\n  let currentElement = 0;\n  let currentElementCount = 0;\n\n  for await (let line of lineIterator) {\n    line = line.trim();\n\n    if (line !== '') {\n      if (currentElementCount >= header.elements[currentElement].count) {\n        currentElement++;\n        currentElementCount = 0;\n      }\n\n      const element = parseASCIIElement(header.elements[currentElement].properties, line);\n      handleElement(attributes, header.elements[currentElement].name, element);\n      currentElementCount++;\n    }\n  }\n\n  return attributes;\n}\n/**\n * Parses ASCII number\n * @param n\n * @param type\n * @returns ASCII number\n */\n// eslint-disable-next-line complexity\nfunction parseASCIINumber(n: string, type: string): number {\n  switch (type) {\n    case 'char':\n    case 'uchar':\n    case 'short':\n    case 'ushort':\n    case 'int':\n    case 'uint':\n    case 'int8':\n    case 'uint8':\n    case 'int16':\n    case 'uint16':\n    case 'int32':\n    case 'uint32':\n      return parseInt(n, 10);\n\n    case 'float':\n    case 'double':\n    case 'float32':\n    case 'float64':\n      return parseFloat(n);\n\n    default:\n      throw new Error(type);\n  }\n}\n/**\n * Parses ASCII element\n * @param properties\n * @param line\n * @returns element\n */\nfunction parseASCIIElement(properties: any[], line: string) {\n  const values: any = line.split(/\\s+/);\n\n  const element = {};\n\n  for (let i = 0; i < properties.length; i++) {\n    if (properties[i].type === 'list') {\n      const list: any = [];\n      const n = parseASCIINumber(values.shift(), properties[i].countType);\n\n      for (let j = 0; j < n; j++) {\n        list.push(parseASCIINumber(values.shift(), properties[i].itemType));\n      }\n\n      element[properties[i].name] = list;\n    } else {\n      element[properties[i].name] = parseASCIINumber(values.shift(), properties[i].type);\n    }\n  }\n\n  return element;\n}\n/**\n * @param buffer\n * @param elementName\n * @param element\n */\n// HELPER FUNCTIONS\n// eslint-disable-next-line complexity\nfunction handleElement(\n  buffer: {[index: string]: number[]},\n  elementName: string,\n  element: any = {}\n) {\n  switch (elementName) {\n    case 'vertex':\n      buffer.vertices.push(element.x, element.y, element.z);\n      if ('nx' in element && 'ny' in element && 'nz' in element) {\n        buffer.normals.push(element.nx, element.ny, element.nz);\n      }\n      if ('s' in element && 't' in element) {\n        buffer.uvs.push(element.s, element.t);\n      }\n      if ('red' in element && 'green' in element && 'blue' in element) {\n        buffer.colors.push(element.red / 255.0, element.green / 255.0, element.blue / 255.0);\n      }\n      break;\n\n    case 'face':\n      const vertexIndices = element.vertex_indices || element.vertex_index; // issue #9338\n      if (vertexIndices.length === 3) {\n        buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[2]);\n      } else if (vertexIndices.length === 4) {\n        buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[3]);\n        buffer.indices.push(vertexIndices[1], vertexIndices[2], vertexIndices[3]);\n      }\n      break;\n\n    default:\n      break;\n  }\n}\n","import {concatenateArrayBuffers} from '../binary-utils/array-buffer-utils';\n\n// GENERAL UTILITIES\n\n/**\n * Iterate over async iterator, without resetting iterator if end is not reached\n * - forEach intentionally does not reset iterator if exiting loop prematurely\n *   so that iteration can continue in a second loop\n * - It is recommended to use a standard for-await as last loop to ensure\n *   iterator gets properly reset\n *\n * TODO - optimize using sync iteration if argument is an Iterable?\n *\n * @param iterator\n * @param visitor\n */\nexport async function forEach(iterator, visitor) {\n  // eslint-disable-next-line\n  while (true) {\n    const {done, value} = await iterator.next();\n    if (done) {\n      iterator.return();\n      return;\n    }\n    const cancel = visitor(value);\n    if (cancel) {\n      return;\n    }\n  }\n}\n\n// Breaking big data into iterable chunks, concatenating iterable chunks into big data objects\n\n/**\n * Concatenates all data chunks yielded by an (async) iterator\n * This function can e.g. be used to enable atomic parsers to work on (async) iterator inputs\n */\n\nexport async function concatenateArrayBuffersAsync(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n): Promise<ArrayBuffer> {\n  const arrayBuffers: ArrayBuffer[] = [];\n  for await (const chunk of asyncIterator) {\n    arrayBuffers.push(chunk);\n  }\n  return concatenateArrayBuffers(...arrayBuffers);\n}\n\nexport async function concatenateStringsAsync(\n  asyncIterator: AsyncIterable<string> | Iterable<string>\n): Promise<string> {\n  const strings: string[] = [];\n  for await (const chunk of asyncIterator) {\n    strings.push(chunk);\n  }\n  return strings.join('');\n}\n","import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {PLYLoader as PLYWorkerLoader} from './ply-loader';\nimport parsePLY from './lib/parse-ply';\nimport parsePLYInBatches from './lib/parse-ply-in-batches';\n\n// PLYLoader\n\nexport {PLYWorkerLoader};\n\n/**\n * Loader for PLY - Polygon File Format\n */\nexport const PLYLoader = {\n  ...PLYWorkerLoader,\n  // Note: parsePLY supports both text and binary\n  parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options), // TODO - this may not detect text correctly?\n  parseTextSync: parsePLY,\n  parseSync: parsePLY,\n  parseInBatches: parsePLYInBatches\n};\n\nexport const _typecheckPLYLoader: LoaderWithParser = PLYLoader;\n","import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {PLYLoader} from '../index';\n\ncreateLoaderWorker(PLYLoader);\n"],"sourceRoot":""}