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

package/dist/geojson-worker.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/defineProperty.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/regenerator/index.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/classCallCheck.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/createClass.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/asyncIterator.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/typeof.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/AwaitValue.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/slicedToArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/get.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/inherits.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack:////home/user/apps/loaders.gl/node_modules/regenerator-runtime/runtime.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/AsyncGenerator.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/iterableToArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/arrayWithHoles.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/nonIterableRest.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/superPropBase.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/setPrototypeOf.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:///../gis/src/lib/geojson-to-binary.ts","webpack:///./src/lib/parse-json.ts","webpack:///../schema/src/lib/batches/base-table-batch-aggregator.ts","webpack:///../schema/src/lib/batches/row-table-batch-aggregator.ts","webpack:///../schema/src/lib/utils/row-utils.ts","webpack:///../schema/src/lib/batches/columnar-table-batch-aggregator.ts","webpack:///../schema/src/lib/batches/table-batch-builder.ts","webpack:///../loader-utils/src/lib/iterators/text-iterators.ts","webpack:///./src/lib/clarinet/clarinet.js","webpack:///./src/lib/jsonpath/jsonpath.ts","webpack:///./src/lib/parser/streaming-json-parser.ts","webpack:///./src/lib/parser/json-parser.ts","webpack:///./src/lib/parse-json-in-batches.ts","webpack:///./src/geojson-loader.ts","webpack:///./src/workers/geojson-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","obj","configurable","writable","AwaitValue","instance","Constructor","TypeError","_defineProperties","target","props","length","descriptor","protoProps","staticProps","arrayWithoutHoles","iterableToArray","unsupportedIterableToArray","nonIterableSpread","arr","AsyncGenerator","fn","apply","this","arguments","iterable","method","asyncIterator","iterator","self","ReferenceError","_typeof","constructor","asyncGeneratorStep","gen","resolve","reject","_next","_throw","arg","info","error","done","Promise","then","args","err","undefined","_getPrototypeOf","setPrototypeOf","getPrototypeOf","__proto__","wrapped","len","arr2","Array","arrayLikeToArray","minLen","toString","slice","from","test","arrayWithHoles","iterableToArrayLimit","nonIterableRest","superPropBase","_get","receiver","Reflect","base","desc","getOwnPropertyDescriptor","subClass","superClass","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","keys","reverse","pop","skipTempReset","prev","charAt","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","Function","front","back","resume","wrappedAwait","settle","request","isArray","_i","_s","_e","_arr","_n","_d","_setPrototypeOf","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","geojsonToBinary","features","firstPassData","firstPass","secondPass","coordLength","numericPropKeys","PositionDataType","Float32Array","x","pointPositionsCount","pointFeaturesCount","linePositionsCount","linePathsCount","lineFeaturesCount","polygonPositionsCount","polygonObjectsCount","polygonRingsCount","polygonFeaturesCount","coordLengths","feature","geometry","coordinates","point","coord","line","flatten","polygon","properties","val","Number","isFinite","size","Math","max","filter","k","GlobalFeatureIdsDataType","Uint32Array","Uint16Array","points","positions","globalFeatureIds","featureIds","numericProps","fields","lines","pathIndices","polygons","polygonIndices","primitivePolygonIndices","propName","indexMap","pointPosition","pointFeature","linePosition","linePath","lineFeature","polygonPosition","polygonObject","polygonRing","polygonFeature","handlePoint","keepStringProperties","handleMultiPoint","handleLineString","handleMultiLineString","handlePolygon","handleMultiPolygon","returnObj","geomType","numericProp","makeAccessorObjects","coords","set","fillNumericProperties","fillCoords","nPositions","fill","ring","index","numericPropName","numericKeys","includes","array","startVertex","arrays","concat","parseJSONSync","jsonText","json","JSON","table","getFirstArray","RowTableBatchAggregator","schema","_headers","row","cursor","rows","shape","batchType","rowObject","arrayRow","headers","objectRow","convertToObjectRow","addObjectRow","arrayRows","rowArray","convertToArrayRow","addArrayRow","objectRows","ColumnarTableBatchAggregator","_reallocateColumns","fieldName","columns","_pruneColumns","field","allocated","ArrayType","oldColumn","typedArray","entries","columnName","column","DEFAULT_OPTIONS","batchSize","batchDebounceMs","limit","_limitMB","TableBatchBuilder","Date","now","Boolean","totalLength","totalBytes","limitReached","rowBytes","_estimateRowMB","aggregator","TableBatchType","_getTableBatchType","chunk","bytesUsed","byteLength","isChunkComplete","_isFull","_getBatch","rowCount","lastBatchEmittedMs","normalizedBatch","getBatch","count","batchCount","assign","BaseTableBatchAggregator","ArrowBatch","makeTextDecoderIterator","arrayBufferIterator","stream","MAX_BUFFER_LENGTH","MAX_SAFE_INTEGER","DEBUG","CDEBUG","buffers","textNode","numberNode","S","STATE","BEGIN","VALUE","OPEN_OBJECT","CLOSE_OBJECT","OPEN_ARRAY","CLOSE_ARRAY","TEXT_ESCAPE","STRING","BACKSLASH","END","OPEN_KEY","CLOSE_KEY","TRUE","TRUE2","TRUE3","FALSE","FALSE2","FALSE3","FALSE4","NULL","NULL2","NULL3","NUMBER_DECIMAL_POINT","NUMBER_DIGIT","s_","Char","stringTokenPattern","ClarinetParser","_initialize","_clearBuffers","bufferCheckPosition","q","closed","closedRoot","sawRoot","tag","stack","position","slashed","unicodeI","unicodeS","depth","onready","onopenobject","onkey","oncloseobject","onopenarray","onclosearray","onvalue","onerror","onend","onchunkparsed","emit","closeValue","write","end","charCodeAt","console","log","isWhitespace","emitNode","String","fromCharCode","starti","STRING_BIGLOOP","parseInt","substring","lastIndex","reResult","exec","indexOf","closeNumber","maxAllowed","maxActual","closeText","checkBufferLength","event","opt","text","trim","normalize","replace","textopts","parseFloat","er","JSONPath","path","split","join","other","shift","StreamingJSONParser","jsonpaths","jsonPaths","map","jsonpath","_extendParser","streamingArray","topLevelObject","streamingJsonPath","currentPath","getJsonPath","equals","_matchJSONPath","clone","_openArray","_openObject","_initializeParser","previousStates","currentState","freeze","container","close","newContainer","_pushOrSet","_parser","_closeObject","_closeArray","binaryAsyncIterator","metadata","isFirstChunk","tableBatchBuilder","getStreamingJsonPathAsString","initialBatch","getPartialResult","addRow","batch","getFullBatch","chunkComplete","getFinalBatch","finalBatch","DEFAULT_GEOJSON_LOADER_OPTIONS","geojson","gis","format","GeoJSONLoader","version","extensions","mimeTypes","category","parseInBatches","geojsonIterator","parseJSONInBatches","makeBinaryGeometryIterator"],"mappings":"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","file":"geojson-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 = 30);\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;","module.exports = require(\"regenerator-runtime\");\n","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 _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nmodule.exports = _classCallCheck;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nmodule.exports = _createClass;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","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;","var AsyncGenerator = require(\"./AsyncGenerator.js\");\n\nfunction _wrapAsyncGenerator(fn) {\n  return function () {\n    return new AsyncGenerator(fn.apply(this, arguments));\n  };\n}\n\nmodule.exports = _wrapAsyncGenerator;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _asyncIterator(iterable) {\n  var method;\n\n  if (typeof Symbol !== \"undefined\") {\n    if (Symbol.asyncIterator) method = iterable[Symbol.asyncIterator];\n    if (method == null && Symbol.iterator) method = iterable[Symbol.iterator];\n  }\n\n  if (method == null) method = iterable[\"@@asyncIterator\"];\n  if (method == null) method = iterable[\"@@iterator\"];\n  if (method == null) throw new TypeError(\"Object is not async iterable\");\n  return method.call(iterable);\n}\n\nmodule.exports = _asyncIterator;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","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 _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;","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 _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 _AwaitValue(value) {\n  this.wrapped = value;\n}\n\nmodule.exports = _AwaitValue;\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;","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;","var arrayWithHoles = require(\"./arrayWithHoles.js\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit.js\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\n\nvar nonIterableRest = require(\"./nonIterableRest.js\");\n\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var superPropBase = require(\"./superPropBase.js\");\n\nfunction _get(target, property, receiver) {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    module.exports = _get = Reflect.get;\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  } else {\n    module.exports = _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n\n      if (desc.get) {\n        return desc.get.call(receiver);\n      }\n\n      return desc.value;\n    };\n\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  }\n\n  return _get(target, property, receiver || target);\n}\n\nmodule.exports = _get;\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;","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 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;","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;","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 _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _iterableToArrayLimit(arr, i) {\n  var _i = arr && (typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]);\n\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n\n  var _s, _e;\n\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nmodule.exports = _iterableToArrayLimit;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableRest;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var getPrototypeOf = require(\"./getPrototypeOf.js\");\n\nfunction _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n\n  return object;\n}\n\nmodule.exports = _superPropBase;\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;","// 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","import {Feature, GeoJsonProperties} from '@loaders.gl/schema';\nimport type {BinaryFeatures} from '@loaders.gl/schema';\n\nexport type GeojsonToBinaryOptions = {\n  coordLength?: number;\n  numericPropKeys?: string[];\n  PositionDataType?: Function;\n};\n\n/** Convert GeoJSON features to flat binary arrays */\nexport function geojsonToBinary(\n  features: Feature[],\n  options: GeojsonToBinaryOptions = {}\n): BinaryFeatures {\n  const firstPassData = firstPass(features);\n  return secondPass(features, firstPassData, {\n    coordLength: options.coordLength || firstPassData.coordLength,\n    numericPropKeys: options.numericPropKeys || firstPassData.numericPropKeys,\n    PositionDataType: options.PositionDataType || Float32Array\n  });\n}\n\nexport const TEST_EXPORTS = {\n  firstPass,\n  secondPass\n};\n\ntype FirstPassData = {\n  coordLength: number;\n  numericPropKeys: string[];\n\n  pointPositionsCount: number;\n  pointFeaturesCount: number;\n  linePositionsCount: number;\n  linePathsCount: number;\n  lineFeaturesCount: number;\n  polygonPositionsCount: number;\n  polygonObjectsCount: number;\n  polygonRingsCount: number;\n  polygonFeaturesCount: number;\n};\n\n/**\n *  Initial scan over GeoJSON features\n *  Counts number of coordinates of each geometry type and\n *  keeps track of the max coordinate dimensions\n */\n// eslint-disable-next-line complexity, max-statements\nfunction firstPass(features: Feature[]): FirstPassData {\n  // Counts the number of _positions_, so [x, y, z] counts as one\n  let pointPositionsCount = 0;\n  let pointFeaturesCount = 0;\n  let linePositionsCount = 0;\n  let linePathsCount = 0;\n  let lineFeaturesCount = 0;\n  let polygonPositionsCount = 0;\n  let polygonObjectsCount = 0;\n  let polygonRingsCount = 0;\n  let polygonFeaturesCount = 0;\n  const coordLengths = new Set<number>();\n  const numericPropKeys = {};\n\n  for (const feature of features) {\n    const geometry = feature.geometry;\n    switch (geometry.type) {\n      case 'Point':\n        pointFeaturesCount++;\n        pointPositionsCount++;\n        coordLengths.add(geometry.coordinates.length);\n        break;\n      case 'MultiPoint':\n        pointFeaturesCount++;\n        pointPositionsCount += geometry.coordinates.length;\n        for (const point of geometry.coordinates) {\n          coordLengths.add(point.length);\n        }\n        break;\n      case 'LineString':\n        lineFeaturesCount++;\n        linePositionsCount += geometry.coordinates.length;\n        linePathsCount++;\n\n        for (const coord of geometry.coordinates) {\n          coordLengths.add(coord.length);\n        }\n        break;\n      case 'MultiLineString':\n        lineFeaturesCount++;\n        for (const line of geometry.coordinates) {\n          linePositionsCount += line.length;\n          linePathsCount++;\n\n          // eslint-disable-next-line max-depth\n          for (const coord of line) {\n            coordLengths.add(coord.length);\n          }\n        }\n        break;\n      case 'Polygon':\n        polygonFeaturesCount++;\n        polygonObjectsCount++;\n        polygonRingsCount += geometry.coordinates.length;\n        polygonPositionsCount += flatten(geometry.coordinates).length;\n\n        for (const coord of flatten(geometry.coordinates)) {\n          coordLengths.add(coord.length);\n        }\n        break;\n      case 'MultiPolygon':\n        polygonFeaturesCount++;\n        for (const polygon of geometry.coordinates) {\n          polygonObjectsCount++;\n          polygonRingsCount += polygon.length;\n          polygonPositionsCount += flatten(polygon).length;\n\n          // eslint-disable-next-line max-depth\n          for (const coord of flatten(polygon)) {\n            coordLengths.add(coord.length);\n          }\n        }\n        break;\n      default:\n        throw new Error(`Unsupported geometry type: ${geometry.type}`);\n    }\n\n    if (feature.properties) {\n      for (const key in feature.properties) {\n        const val = feature.properties[key];\n\n        // If property has not been seen before, or if property has been numeric\n        // in all previous features, check if numeric in this feature\n        // If not numeric, false is stored to prevent rechecking in the future\n        numericPropKeys[key] =\n          numericPropKeys[key] || numericPropKeys[key] === undefined\n            ? isNumeric(val)\n            : numericPropKeys[key];\n      }\n    }\n  }\n\n  return {\n    coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,\n\n    pointPositionsCount,\n    pointFeaturesCount,\n    linePositionsCount,\n    linePathsCount,\n    lineFeaturesCount,\n    polygonPositionsCount,\n    polygonObjectsCount,\n    polygonRingsCount,\n    polygonFeaturesCount,\n\n    // Array of keys whose values are always numeric\n    numericPropKeys: Object.keys(numericPropKeys).filter((k) => numericPropKeys[k])\n  };\n}\n\n/**\n * Second scan over GeoJSON features\n * Fills coordinates into pre-allocated typed arrays\n */\n// eslint-disable-next-line complexity\nfunction secondPass(\n  features,\n  firstPassData: FirstPassData,\n  options: Required<GeojsonToBinaryOptions>\n) {\n  const {\n    pointPositionsCount,\n    pointFeaturesCount,\n    linePositionsCount,\n    linePathsCount,\n    lineFeaturesCount,\n    polygonPositionsCount,\n    polygonObjectsCount,\n    polygonRingsCount,\n    polygonFeaturesCount\n  } = firstPassData;\n  const {coordLength, numericPropKeys, PositionDataType = Float32Array} = options;\n  const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;\n  const points = {\n    // @ts-ignore Typescript doesn't like dynamic constructors\n    positions: new PositionDataType(pointPositionsCount * coordLength),\n    globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),\n    featureIds:\n      pointFeaturesCount > 65535\n        ? new Uint32Array(pointPositionsCount)\n        : new Uint16Array(pointPositionsCount),\n    numericProps: {},\n    properties: Array<any>(),\n    fields: Array<any>()\n  };\n  const lines = {\n    // @ts-ignore Typescript doesn't like dynamic constructors\n    positions: new PositionDataType(linePositionsCount * coordLength),\n    pathIndices:\n      linePositionsCount > 65535\n        ? new Uint32Array(linePathsCount + 1)\n        : new Uint16Array(linePathsCount + 1),\n    globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),\n    featureIds:\n      lineFeaturesCount > 65535\n        ? new Uint32Array(linePositionsCount)\n        : new Uint16Array(linePositionsCount),\n    numericProps: {},\n    properties: Array<any>(),\n    fields: Array<any>()\n  };\n  const polygons = {\n    // @ts-ignore Typescript doesn't like dynamic constructors\n    positions: new PositionDataType(polygonPositionsCount * coordLength),\n    polygonIndices:\n      polygonPositionsCount > 65535\n        ? new Uint32Array(polygonObjectsCount + 1)\n        : new Uint16Array(polygonObjectsCount + 1),\n    primitivePolygonIndices:\n      polygonPositionsCount > 65535\n        ? new Uint32Array(polygonRingsCount + 1)\n        : new Uint16Array(polygonRingsCount + 1),\n    globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),\n    featureIds:\n      polygonFeaturesCount > 65535\n        ? new Uint32Array(polygonPositionsCount)\n        : new Uint16Array(polygonPositionsCount),\n    numericProps: {},\n    properties: Array<any>(),\n    fields: Array<any>()\n  };\n\n  // Instantiate numeric properties arrays; one value per vertex\n  for (const object of [points, lines, polygons]) {\n    for (const propName of numericPropKeys || []) {\n      // If property has been numeric in all previous features in which the property existed, check\n      // if numeric in this feature\n      object.numericProps[propName] = new Float32Array(object.positions.length / coordLength);\n    }\n  }\n\n  // Set last element of path/polygon indices as positions length\n  lines.pathIndices[linePathsCount] = linePositionsCount;\n  polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;\n  polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;\n\n  const indexMap = {\n    pointPosition: 0,\n    pointFeature: 0,\n    linePosition: 0,\n    linePath: 0,\n    lineFeature: 0,\n    polygonPosition: 0,\n    polygonObject: 0,\n    polygonRing: 0,\n    polygonFeature: 0,\n    feature: 0\n  };\n\n  for (const feature of features) {\n    const geometry = feature.geometry;\n    const properties: GeoJsonProperties = feature.properties || {};\n\n    switch (geometry.type) {\n      case 'Point':\n        handlePoint(geometry.coordinates, points, indexMap, coordLength, properties);\n        points.properties.push(keepStringProperties(properties, numericPropKeys));\n        indexMap.pointFeature++;\n        break;\n      case 'MultiPoint':\n        handleMultiPoint(geometry.coordinates, points, indexMap, coordLength, properties);\n        points.properties.push(keepStringProperties(properties, numericPropKeys));\n        indexMap.pointFeature++;\n        break;\n      case 'LineString':\n        handleLineString(geometry.coordinates, lines, indexMap, coordLength, properties);\n        lines.properties.push(keepStringProperties(properties, numericPropKeys));\n        indexMap.lineFeature++;\n        break;\n      case 'MultiLineString':\n        handleMultiLineString(geometry.coordinates, lines, indexMap, coordLength, properties);\n        lines.properties.push(keepStringProperties(properties, numericPropKeys));\n        indexMap.lineFeature++;\n        break;\n      case 'Polygon':\n        handlePolygon(geometry.coordinates, polygons, indexMap, coordLength, properties);\n        polygons.properties.push(keepStringProperties(properties, numericPropKeys));\n        indexMap.polygonFeature++;\n        break;\n      case 'MultiPolygon':\n        handleMultiPolygon(geometry.coordinates, polygons, indexMap, coordLength, properties);\n        polygons.properties.push(keepStringProperties(properties, numericPropKeys));\n        indexMap.polygonFeature++;\n        break;\n      default:\n        throw new Error('Invalid geometry type');\n    }\n\n    indexMap.feature++;\n  }\n\n  // Wrap each array in an accessor object with value and size keys\n  return makeAccessorObjects(points, lines, polygons, coordLength);\n}\n\n/** Fills Point coordinates into points object of arrays */\nfunction handlePoint(coords, points, indexMap, coordLength, properties) {\n  points.positions.set(coords, indexMap.pointPosition * coordLength);\n  points.globalFeatureIds[indexMap.pointPosition] = indexMap.feature;\n  points.featureIds[indexMap.pointPosition] = indexMap.pointFeature;\n\n  fillNumericProperties(points, properties, indexMap.pointPosition, 1);\n  indexMap.pointPosition++;\n}\n\n/** Fills MultiPoint coordinates into points object of arrays */\nfunction handleMultiPoint(coords, points, indexMap, coordLength, properties) {\n  for (const point of coords) {\n    handlePoint(point, points, indexMap, coordLength, properties);\n  }\n}\n\n/** Fills LineString coordinates into lines object of arrays */\nfunction handleLineString(coords, lines, indexMap, coordLength, properties) {\n  lines.pathIndices[indexMap.linePath] = indexMap.linePosition;\n  indexMap.linePath++;\n\n  fillCoords(lines.positions, coords, indexMap.linePosition, coordLength);\n\n  const nPositions = coords.length;\n  fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);\n\n  lines.globalFeatureIds.set(\n    new Uint32Array(nPositions).fill(indexMap.feature),\n    indexMap.linePosition\n  );\n  lines.featureIds.set(\n    new Uint32Array(nPositions).fill(indexMap.lineFeature),\n    indexMap.linePosition\n  );\n  indexMap.linePosition += nPositions;\n}\n\n/** Fills MultiLineString coordinates into lines object of arrays */\nfunction handleMultiLineString(coords, lines, indexMap, coordLength, properties) {\n  for (const line of coords) {\n    handleLineString(line, lines, indexMap, coordLength, properties);\n  }\n}\n\n/** Fills Polygon coordinates into polygons object of arrays */\nfunction handlePolygon(coords, polygons, indexMap, coordLength, properties) {\n  polygons.polygonIndices[indexMap.polygonObject] = indexMap.polygonPosition;\n  indexMap.polygonObject++;\n\n  for (const ring of coords) {\n    polygons.primitivePolygonIndices[indexMap.polygonRing] = indexMap.polygonPosition;\n    indexMap.polygonRing++;\n\n    fillCoords(polygons.positions, ring, indexMap.polygonPosition, coordLength);\n\n    const nPositions = ring.length;\n    fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);\n\n    polygons.globalFeatureIds.set(\n      new Uint32Array(nPositions).fill(indexMap.feature),\n      indexMap.polygonPosition\n    );\n    polygons.featureIds.set(\n      new Uint32Array(nPositions).fill(indexMap.polygonFeature),\n      indexMap.polygonPosition\n    );\n    indexMap.polygonPosition += nPositions;\n  }\n}\n\n/** Fills MultiPolygon coordinates into polygons object of arrays */\nfunction handleMultiPolygon(coords, polygons, indexMap, coordLength, properties) {\n  for (const polygon of coords) {\n    handlePolygon(polygon, polygons, indexMap, coordLength, properties);\n  }\n}\n\n/** Wrap each array in an accessor object with value and size keys */\nfunction makeAccessorObjects(points, lines, polygons, coordLength): BinaryFeatures {\n  const returnObj = {\n    points: {\n      ...points,\n      positions: {value: points.positions, size: coordLength},\n      globalFeatureIds: {value: points.globalFeatureIds, size: 1},\n      featureIds: {value: points.featureIds, size: 1},\n      type: 'Point'\n    },\n    lines: {\n      ...lines,\n      pathIndices: {value: lines.pathIndices, size: 1},\n      positions: {value: lines.positions, size: coordLength},\n      globalFeatureIds: {value: lines.globalFeatureIds, size: 1},\n      featureIds: {value: lines.featureIds, size: 1},\n      type: 'LineString'\n    },\n    polygons: {\n      ...polygons,\n      polygonIndices: {value: polygons.polygonIndices, size: 1},\n      primitivePolygonIndices: {value: polygons.primitivePolygonIndices, size: 1},\n      positions: {value: polygons.positions, size: coordLength},\n      globalFeatureIds: {value: polygons.globalFeatureIds, size: 1},\n      featureIds: {value: polygons.featureIds, size: 1},\n      type: 'Polygon'\n    }\n  };\n\n  for (const geomType in returnObj) {\n    for (const numericProp in returnObj[geomType].numericProps) {\n      returnObj[geomType].numericProps[numericProp] = {\n        value: returnObj[geomType].numericProps[numericProp],\n        size: 1\n      };\n    }\n  }\n\n  return returnObj as unknown as BinaryFeatures;\n}\n\n/** Add numeric properties to object */\nfunction fillNumericProperties(object, properties, index, length) {\n  for (const numericPropName in object.numericProps) {\n    if (numericPropName in properties) {\n      object.numericProps[numericPropName].set(\n        new Array(length).fill(properties[numericPropName]),\n        index\n      );\n    }\n  }\n}\n\n/** Keep string properties in object */\nfunction keepStringProperties(properties, numericKeys: string[]): GeoJsonProperties {\n  const props = {};\n  for (const key in properties) {\n    if (!numericKeys.includes(key)) {\n      props[key] = properties[key];\n    }\n  }\n  return props;\n}\n\n/** @param coords is expected to be a list of arrays, each with length 2-3 */\nfunction fillCoords(array, coords, startVertex, coordLength): void {\n  let index = startVertex * coordLength;\n  for (const coord of coords) {\n    array.set(coord, index);\n    index += coordLength;\n  }\n}\n\n// TODO - how does this work? Different `coordinates` have different nesting\nfunction flatten(arrays): number[][] {\n  return [].concat(...arrays);\n}\n\nfunction isNumeric(x: any): boolean {\n  return Number.isFinite(x);\n}\n","import type {JSONLoaderOptions} from '../json-loader';\n\nexport default function parseJSONSync(jsonText: string, options: JSONLoaderOptions) {\n  try {\n    const json = JSON.parse(jsonText);\n    if (options.json?.table) {\n      return getFirstArray(json) || json;\n    }\n    return json;\n  } catch (error) {\n    throw new Error('JSONLoader: failed to parse JSON');\n  }\n}\n\nfunction getFirstArray(json) {\n  if (Array.isArray(json)) {\n    return json;\n  }\n  if (json && typeof json === 'object') {\n    for (const value of Object.values(json)) {\n      const array = getFirstArray(value);\n      if (array) {\n        return array;\n      }\n    }\n  }\n  return null;\n}\n","import type {Schema} from '../schema';\nimport type {TableBatch} from '../../category/table/table-types';\nimport {TableBatchAggregator, TableBatchOptions} from './table-batch-aggregator';\n\nconst DEFAULT_ROW_COUNT = 100;\n\nexport default class RowTableBatchAggregator implements TableBatchAggregator {\n  schema: Schema;\n  options: TableBatchOptions;\n\n  length: number = 0;\n  rows: any[] | null = null;\n  cursor: number = 0;\n  private _headers: string[] = [];\n\n  constructor(schema: Schema, options: TableBatchOptions) {\n    this.options = options;\n    this.schema = schema;\n\n    // schema is an array if there're no headers\n    // object if there are headers\n    if (!Array.isArray(schema)) {\n      this._headers = [];\n      for (const key in schema) {\n        this._headers[schema[key].index] = schema[key].name;\n      }\n    }\n  }\n\n  rowCount(): number {\n    return this.length;\n  }\n\n  addArrayRow(row: any[], cursor?: number): void {\n    if (Number.isFinite(cursor)) {\n      this.cursor = cursor as number;\n    }\n\n    this.rows = this.rows || new Array(DEFAULT_ROW_COUNT);\n    this.rows[this.length] = row;\n    this.length++;\n  }\n\n  addObjectRow(row: {[columnName: string]: any}, cursor?: number): void {\n    if (Number.isFinite(cursor)) {\n      this.cursor = cursor as number;\n    }\n\n    this.rows = this.rows || new Array(DEFAULT_ROW_COUNT);\n    this.rows[this.length] = row;\n    this.length++;\n  }\n\n  getBatch(): TableBatch | null {\n    let rows = this.rows;\n    if (!rows) {\n      return null;\n    }\n\n    rows = rows.slice(0, this.length);\n    this.rows = null;\n\n    const batch: TableBatch = {\n      shape: this.options.shape,\n      batchType: 'data',\n      data: rows,\n      length: this.length,\n      schema: this.schema,\n      cursor: this.cursor\n    };\n\n    return batch;\n  }\n}\n","import type {Schema} from '../schema';\nimport type {TableBatch} from '../../category/table/table-types';\n// import type {ArrayRowTableBatch, ObjectRowTableBatch} from '../../category/table';\nimport {convertToArrayRow, convertToObjectRow} from '../utils/row-utils';\nimport {TableBatchAggregator, TableBatchOptions} from './table-batch-aggregator';\n\nconst DEFAULT_ROW_COUNT = 100;\n\nexport default class RowTableBatchAggregator implements TableBatchAggregator {\n  schema: Schema;\n  options: TableBatchOptions;\n\n  length: number = 0;\n  objectRows: {[columnName: string]: any} | null = null;\n  arrayRows: any[] | null = null;\n  cursor: number = 0;\n  private _headers: string[] = [];\n\n  constructor(schema: Schema, options: TableBatchOptions) {\n    this.options = options;\n    this.schema = schema;\n\n    // schema is an array if there're no headers\n    // object if there are headers\n    if (!Array.isArray(schema)) {\n      this._headers = [];\n      for (const key in schema) {\n        this._headers[schema[key].index] = schema[key].name;\n      }\n    }\n  }\n\n  rowCount(): number {\n    return this.length;\n  }\n\n  addArrayRow(row: any[], cursor?: number): void {\n    if (Number.isFinite(cursor)) {\n      this.cursor = cursor as number;\n    }\n\n    // eslint-disable-next-line default-case\n    switch (this.options.shape) {\n      case 'object-row-table':\n        const rowObject = convertToObjectRow(row, this._headers);\n        this.addObjectRow(rowObject, cursor);\n        break;\n      case 'array-row-table':\n        this.arrayRows = this.arrayRows || new Array(DEFAULT_ROW_COUNT);\n        this.arrayRows[this.length] = row;\n        this.length++;\n        break;\n    }\n  }\n\n  addObjectRow(row: {[columnName: string]: any}, cursor?: number): void {\n    if (Number.isFinite(cursor)) {\n      this.cursor = cursor as number;\n    }\n\n    // eslint-disable-next-line default-case\n    switch (this.options.shape) {\n      case 'array-row-table':\n        const rowArray = convertToArrayRow(row, this._headers);\n        this.addArrayRow(rowArray, cursor);\n        break;\n      case 'object-row-table':\n        this.objectRows = this.objectRows || new Array(DEFAULT_ROW_COUNT);\n        this.objectRows[this.length] = row;\n        this.length++;\n        break;\n    }\n  }\n\n  getBatch(): TableBatch | null {\n    let rows = this.arrayRows || this.objectRows;\n    if (!rows) {\n      return null;\n    }\n\n    rows = rows.slice(0, this.length);\n    this.arrayRows = null;\n    this.objectRows = null;\n\n    return {\n      shape: this.options.shape,\n      batchType: 'data',\n      data: rows,\n      length: this.length,\n      schema: this.schema,\n      cursor: this.cursor\n    };\n  }\n}\n","/** Convert an object row to an array row */\nexport function convertToObjectRow(\n  arrayRow: any[],\n  headers: string[]\n): {[columnName: string]: any} {\n  if (!arrayRow) {\n    throw new Error('null row');\n  }\n  if (!headers) {\n    throw new Error('no headers');\n  }\n  const objectRow = {};\n  for (let i = 0; i < headers.length; i++) {\n    objectRow[headers[i]] = arrayRow[i];\n  }\n  return objectRow;\n}\n\n/** Convert an object row to an array row */\nexport function convertToArrayRow(\n  objectRow: {[columnName: string]: any},\n  headers: string[]\n): any[] {\n  if (!objectRow) {\n    throw new Error('null row');\n  }\n  if (!headers) {\n    throw new Error('no headers');\n  }\n  const arrayRow = new Array(headers.length);\n  for (let i = 0; i < headers.length; i++) {\n    arrayRow[i] = objectRow[headers[i]];\n  }\n  return arrayRow;\n}\n","import type {Schema} from '../schema';\nimport type {ColumnarTableBatch, ArrowTableBatch} from '../../category/table/table-types';\nimport {TableBatchAggregator} from './table-batch-aggregator';\n\ntype ColumnarTableBatchOptions = {};\n\nconst DEFAULT_ROW_COUNT = 100;\n\nexport default class ColumnarTableBatchAggregator implements TableBatchAggregator {\n  schema: Schema;\n  length: number = 0;\n  allocated: number = 0;\n  columns: {[columnName: string]: any[]} = {};\n\n  constructor(schema: Schema, options: ColumnarTableBatchOptions) {\n    this.schema = schema;\n    this._reallocateColumns();\n  }\n\n  rowCount(): number {\n    return this.length;\n  }\n\n  addArrayRow(row: any[]) {\n    // If user keeps pushing rows beyond batch size, reallocate\n    this._reallocateColumns();\n    let i = 0;\n    // TODO what if no csv header, columns not populated?\n    for (const fieldName in this.columns) {\n      this.columns[fieldName][this.length] = row[i++];\n    }\n    this.length++;\n  }\n\n  addObjectRow(row: {[columnName: string]: any}): void {\n    // If user keeps pushing rows beyond batch size, reallocate\n    this._reallocateColumns();\n    for (const fieldName in row) {\n      this.columns[fieldName][this.length] = row[fieldName];\n    }\n    this.length++;\n  }\n\n  getBatch(): ColumnarTableBatch | ArrowTableBatch | null {\n    this._pruneColumns();\n    const columns = Array.isArray(this.schema) ? this.columns : {};\n\n    // schema is an array if there're no headers\n    // object if there are headers\n    // columns should match schema format\n    if (!Array.isArray(this.schema)) {\n      for (const fieldName in this.schema) {\n        const field = this.schema[fieldName];\n        columns[field.name] = this.columns[field.index];\n      }\n    }\n\n    this.columns = {};\n\n    const batch: ColumnarTableBatch = {\n      shape: 'columnar-table',\n      batchType: 'data',\n      data: columns,\n      schema: this.schema,\n      length: this.length\n    };\n\n    return batch;\n  }\n\n  // HELPERS\n\n  _reallocateColumns() {\n    if (this.length < this.allocated) {\n      return;\n    }\n\n    // @ts-ignore TODO\n    this.allocated = this.allocated > 0 ? (this.allocated *= 2) : DEFAULT_ROW_COUNT;\n    this.columns = {};\n\n    for (const fieldName in this.schema) {\n      const field = this.schema[fieldName];\n      const ArrayType = field.type || Float32Array;\n      const oldColumn = this.columns[field.index];\n\n      if (oldColumn && ArrayBuffer.isView(oldColumn)) {\n        // Copy the old data to the new array\n        const typedArray = new ArrayType(this.allocated);\n        typedArray.set(oldColumn);\n        this.columns[field.index] = typedArray;\n      } else if (oldColumn) {\n        // Plain array\n        oldColumn.length = this.allocated;\n        this.columns[field.index] = oldColumn;\n      } else {\n        // Create new\n        this.columns[field.index] = new ArrayType(this.allocated);\n      }\n    }\n  }\n\n  _pruneColumns() {\n    for (const [columnName, column] of Object.entries(this.columns)) {\n      this.columns[columnName] = column.slice(0, this.length);\n    }\n  }\n}\n","import type {Schema} from '../schema';\nimport type {TableBatch} from '../../category/table/table-types';\nimport type {TableBatchAggregator, TableBatchConstructor} from './table-batch-aggregator';\nimport BaseTableBatchAggregator from './base-table-batch-aggregator';\nimport RowTableBatchAggregator from './row-table-batch-aggregator';\nimport ColumnarTableBatchAggregator from './columnar-table-batch-aggregator';\n\n// TODO define interface instead\ntype TableBatchBuilderOptions = {\n  shape: 'row-table' | 'array-row-table' | 'object-row-table' | 'columnar-table' | 'arrow-table';\n  batchSize?: number | 'auto';\n  batchDebounceMs?: number;\n  limit: number;\n  _limitMB: number;\n};\n\ntype GetBatchOptions = {\n  bytesUsed?: number;\n  [key: string]: any;\n};\n\nconst DEFAULT_OPTIONS: Required<TableBatchBuilderOptions> = {\n  shape: 'array-row-table',\n  batchSize: 'auto',\n  batchDebounceMs: 0,\n  limit: 0,\n  _limitMB: 0\n};\n\nconst ERR_MESSAGE = 'TableBatchBuilder';\n\n/** Incrementally builds batches from a stream of rows */\nexport default class TableBatchBuilder {\n  schema: Schema;\n  options: Required<TableBatchBuilderOptions>;\n\n  private aggregator: TableBatchAggregator | null = null;\n  private batchCount: number = 0;\n  private bytesUsed: number = 0;\n  private isChunkComplete: boolean = false;\n  private lastBatchEmittedMs: number = Date.now();\n  private totalLength: number = 0;\n  private totalBytes: number = 0;\n  private rowBytes: number = 0;\n\n  static ArrowBatch?: TableBatchConstructor;\n\n  constructor(schema: Schema, options?: TableBatchBuilderOptions) {\n    this.schema = schema;\n    this.options = {...DEFAULT_OPTIONS, ...options};\n  }\n\n  limitReached(): boolean {\n    if (Boolean(this.options?.limit) && this.totalLength >= this.options.limit) {\n      return true;\n    }\n    if (Boolean(this.options?._limitMB) && this.totalBytes / 1e6 >= this.options._limitMB) {\n      return true;\n    }\n    return false;\n  }\n\n  /** @deprecated Use addArrayRow or addObjectRow */\n  addRow(row: any[] | {[columnName: string]: any}): void {\n    if (this.limitReached()) {\n      return;\n    }\n    this.totalLength++;\n    this.rowBytes = this.rowBytes || this._estimateRowMB(row);\n    this.totalBytes += this.rowBytes;\n    if (Array.isArray(row)) {\n      this.addArrayRow(row);\n    } else {\n      this.addObjectRow(row);\n    }\n  }\n\n  /** Add one row to the batch */\n  protected addArrayRow(row: any[]) {\n    if (!this.aggregator) {\n      const TableBatchType = this._getTableBatchType();\n      this.aggregator = new TableBatchType(this.schema, this.options);\n    }\n    this.aggregator.addArrayRow(row);\n  }\n\n  /** Add one row to the batch */\n  protected addObjectRow(row: {[columnName: string]: any}): void {\n    if (!this.aggregator) {\n      const TableBatchType = this._getTableBatchType();\n      this.aggregator = new TableBatchType(this.schema, this.options);\n    }\n    this.aggregator.addObjectRow(row);\n  }\n\n  /** Mark an incoming raw memory chunk has completed */\n  chunkComplete(chunk: ArrayBuffer | string): void {\n    if (chunk instanceof ArrayBuffer) {\n      this.bytesUsed += chunk.byteLength;\n    }\n    if (typeof chunk === 'string') {\n      this.bytesUsed += chunk.length;\n    }\n    this.isChunkComplete = true;\n  }\n\n  getFullBatch(options?: GetBatchOptions): TableBatch | null {\n    return this._isFull() ? this._getBatch(options) : null;\n  }\n\n  getFinalBatch(options?: GetBatchOptions): TableBatch | null {\n    return this._getBatch(options);\n  }\n\n  // INTERNAL\n\n  _estimateRowMB(row) {\n    return Array.isArray(row) ? row.length * 8 : Object.keys(row).length * 8;\n  }\n\n  private _isFull(): boolean {\n    // No batch, not ready\n    if (!this.aggregator || this.aggregator.rowCount() === 0) {\n      return false;\n    }\n\n    // if batchSize === 'auto' we wait for chunk to complete\n    // if batchSize === number, ensure we have enough rows\n    if (this.options.batchSize === 'auto') {\n      if (!this.isChunkComplete) {\n        return false;\n      }\n    } else if (this.options.batchSize > this.aggregator.rowCount()) {\n      return false;\n    }\n\n    // Debounce batches\n    if (this.options.batchDebounceMs > Date.now() - this.lastBatchEmittedMs) {\n      return false;\n    }\n\n    // Emit batch\n    this.isChunkComplete = false;\n    this.lastBatchEmittedMs = Date.now();\n    return true;\n  }\n\n  /**\n   * bytesUsed can be set via chunkComplete or via getBatch*\n   */\n  private _getBatch(options?: GetBatchOptions): TableBatch | null {\n    if (!this.aggregator) {\n      return null;\n    }\n\n    // TODO - this can overly increment bytes used?\n    if (options?.bytesUsed) {\n      this.bytesUsed = options.bytesUsed;\n    }\n    const normalizedBatch = this.aggregator.getBatch() as TableBatch;\n    normalizedBatch.count = this.batchCount;\n    normalizedBatch.bytesUsed = this.bytesUsed;\n    Object.assign(normalizedBatch, options);\n\n    this.batchCount++;\n    this.aggregator = null;\n    return normalizedBatch;\n  }\n\n  private _getTableBatchType(): TableBatchConstructor {\n    switch (this.options.shape) {\n      case 'row-table':\n        return BaseTableBatchAggregator;\n      case 'array-row-table':\n      case 'object-row-table':\n        return RowTableBatchAggregator;\n      case 'columnar-table':\n        return ColumnarTableBatchAggregator;\n      case 'arrow-table':\n        if (!TableBatchBuilder.ArrowBatch) {\n          throw new Error(ERR_MESSAGE);\n        }\n        return TableBatchBuilder.ArrowBatch;\n      default:\n        throw new Error(ERR_MESSAGE);\n    }\n  }\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","/* eslint-disable */\n// @ts-nocheck\nconst env = {};\n\nexport const EVENTS = [\n  'value',\n  'string',\n  'key',\n  'openobject',\n  'closeobject',\n  'openarray',\n  'closearray',\n  'error',\n  'end',\n  'ready'\n];\n\n// Removes the MAX_BUFFER_LENGTH, originally set to 64 * 1024\nconst MAX_BUFFER_LENGTH = Number.MAX_SAFE_INTEGER;\nconst DEBUG = env.CDEBUG === 'debug';\n\nconst buffers = {\n  textNode: undefined,\n  numberNode: ''\n};\n\nlet S = 0;\n\nconst STATE = {\n  BEGIN: S++,\n  VALUE: S++, // general stuff\n  OPEN_OBJECT: S++, // {\n  CLOSE_OBJECT: S++, // }\n  OPEN_ARRAY: S++, // [\n  CLOSE_ARRAY: S++, // ]\n  TEXT_ESCAPE: S++, // \\ stuff\n  STRING: S++, // \"\"\n  BACKSLASH: S++,\n  END: S++, // No more stack\n  OPEN_KEY: S++, // , \"a\"\n  CLOSE_KEY: S++, // :\n  TRUE: S++, // r\n  TRUE2: S++, // u\n  TRUE3: S++, // e\n  FALSE: S++, // a\n  FALSE2: S++, // l\n  FALSE3: S++, // s\n  FALSE4: S++, // e\n  NULL: S++, // u\n  NULL2: S++, // l\n  NULL3: S++, // l\n  NUMBER_DECIMAL_POINT: S++, // .\n  NUMBER_DIGIT: S++ // [0-9]\n};\n\nfor (var s_ in STATE) STATE[STATE[s_]] = s_;\n\n// switcharoo\nS = STATE;\n\nconst Char = {\n  tab: 0x09, // \\t\n  lineFeed: 0x0a, // \\n\n  carriageReturn: 0x0d, // \\r\n  space: 0x20, // \" \"\n\n  doubleQuote: 0x22, // \"\n  plus: 0x2b, // +\n  comma: 0x2c, // ,\n  minus: 0x2d, // -\n  period: 0x2e, // .\n\n  _0: 0x30, // 0\n  _9: 0x39, // 9\n\n  colon: 0x3a, // :\n\n  E: 0x45, // E\n\n  openBracket: 0x5b, // [\n  backslash: 0x5c, // \\\n  closeBracket: 0x5d, // ]\n\n  a: 0x61, // a\n  b: 0x62, // b\n  e: 0x65, // e\n  f: 0x66, // f\n  l: 0x6c, // l\n  n: 0x6e, // n\n  r: 0x72, // r\n  s: 0x73, // s\n  t: 0x74, // t\n  u: 0x75, // u\n\n  openBrace: 0x7b, // {\n  closeBrace: 0x7d // }\n};\n\nfunction checkBufferLength(parser) {\n  const maxAllowed = Math.max(MAX_BUFFER_LENGTH, 10);\n  let maxActual = 0;\n\n  for (var buffer in buffers) {\n    var len = parser[buffer] === undefined ? 0 : parser[buffer].length;\n    if (len > maxAllowed) {\n      switch (buffer) {\n        case 'text':\n          closeText(parser);\n          break;\n\n        default:\n          error(parser, 'Max buffer length exceeded: ' + buffer);\n      }\n    }\n    maxActual = Math.max(maxActual, len);\n  }\n  parser.bufferCheckPosition = MAX_BUFFER_LENGTH - maxActual + parser.position;\n}\n\nvar stringTokenPattern = /[\\\\\"\\n]/g;\n\nexport default class ClarinetParser {\n  constructor(options = {}) {\n    this._initialize(options);\n  }\n\n  _initialize(options) {\n    this._clearBuffers(this);\n    this.bufferCheckPosition = MAX_BUFFER_LENGTH;\n    this.q = '';\n    this.c = '';\n    this.p = '';\n    this.options = options || {};\n    this.closed = false;\n    this.closedRoot = false;\n    this.sawRoot = false;\n    this.tag = null;\n    this.error = null;\n    this.state = S.BEGIN;\n    this.stack = new Array();\n    // mostly just for error reporting\n    this.position = this.column = 0;\n    this.line = 1;\n    this.slashed = false;\n    this.unicodeI = 0;\n    this.unicodeS = null;\n    this.depth = 0;\n\n    // install callbacks\n    if ('onready' in options) {\n      this.onready = options.onready;\n    }\n\n    if ('onopenobject' in options) {\n      this.onopenobject = options.onopenobject;\n    }\n\n    if ('onkey' in options) {\n      this.onkey = options.onkey;\n    }\n\n    if ('oncloseobject' in options) {\n      this.oncloseobject = options.oncloseobject;\n    }\n\n    if ('onopenarray' in options) {\n      this.onopenarray = options.onopenarray;\n    }\n\n    if ('onclosearray' in options) {\n      this.onclosearray = options.onclosearray;\n    }\n\n    if ('onvalue' in options) {\n      this.onvalue = options.onvalue;\n    }\n\n    if ('onerror' in options) {\n      this.onerror = options.onerror;\n    }\n\n    if ('onend' in options) {\n      this.onend = options.onend;\n    }\n\n    if ('onchunkparsed' in options) {\n      this.onchunkparsed = options.onchunkparsed;\n    }\n\n    emit(this, 'onready');\n  }\n\n  _clearBuffers() {\n    for (var buffer in buffers) {\n      this[buffer] = buffers[buffer];\n    }\n  }\n\n  end() {\n    if (this.state !== S.VALUE || this.depth !== 0) error(this, 'Unexpected end');\n\n    closeValue(this);\n    this.c = '';\n    this.closed = true;\n    emit(this, 'onend');\n    this._initialize(this.options);\n    return this;\n  }\n\n  resume() {\n    this.error = null;\n    return this;\n  }\n\n  close() {\n    return this.write(null);\n  }\n\n  write(chunk) {\n    if (this.error) {\n      throw this.error;\n    }\n    if (this.closed) {\n      return error(this, 'Cannot write after close. Assign an onready handler.');\n    }\n    if (chunk === null) {\n      return this.end();\n    }\n    var i = 0,\n      c = chunk.charCodeAt(0),\n      p = this.p;\n    if (DEBUG) console.log('write -> [' + chunk + ']');\n    while (c) {\n      p = c;\n      this.c = c = chunk.charCodeAt(i++);\n      // if chunk doesnt have next, like streaming char by char\n      // this way we need to check if previous is really previous\n      // if not we need to reset to what the this says is the previous\n      // from buffer\n      if (p !== c) {\n        this.p = p;\n      } else {\n        p = this.p;\n      }\n\n      if (!c) break;\n\n      if (DEBUG) console.log(i, c, STATE[this.state]);\n      this.position++;\n      if (c === Char.lineFeed) {\n        this.line++;\n        this.column = 0;\n      } else this.column++;\n\n      switch (this.state) {\n        case S.BEGIN:\n          if (c === Char.openBrace) this.state = S.OPEN_OBJECT;\n          else if (c === Char.openBracket) this.state = S.OPEN_ARRAY;\n          else if (!isWhitespace(c)) {\n            error(this, 'Non-whitespace before {[.');\n          }\n          continue;\n\n        case S.OPEN_KEY:\n        case S.OPEN_OBJECT:\n          if (isWhitespace(c)) continue;\n          if (this.state === S.OPEN_KEY) this.stack.push(S.CLOSE_KEY);\n          else {\n            if (c === Char.closeBrace) {\n              emit(this, 'onopenobject');\n              this.depth++;\n              emit(this, 'oncloseobject');\n              this.depth--;\n              this.state = this.stack.pop() || S.VALUE;\n              continue;\n            } else this.stack.push(S.CLOSE_OBJECT);\n          }\n          if (c === Char.doubleQuote) this.state = S.STRING;\n          else error(this, 'Malformed object key should start with \"');\n          continue;\n\n        case S.CLOSE_KEY:\n        case S.CLOSE_OBJECT:\n          if (isWhitespace(c)) continue;\n          var event = this.state === S.CLOSE_KEY ? 'key' : 'object';\n          if (c === Char.colon) {\n            if (this.state === S.CLOSE_OBJECT) {\n              this.stack.push(S.CLOSE_OBJECT);\n              closeValue(this, 'onopenobject');\n              this.depth++;\n            } else closeValue(this, 'onkey');\n            this.state = S.VALUE;\n          } else if (c === Char.closeBrace) {\n            emitNode(this, 'oncloseobject');\n            this.depth--;\n            this.state = this.stack.pop() || S.VALUE;\n          } else if (c === Char.comma) {\n            if (this.state === S.CLOSE_OBJECT) this.stack.push(S.CLOSE_OBJECT);\n            closeValue(this);\n            this.state = S.OPEN_KEY;\n          } else error(this, 'Bad object');\n          continue;\n\n        case S.OPEN_ARRAY: // after an array there always a value\n        case S.VALUE:\n          if (isWhitespace(c)) continue;\n          if (this.state === S.OPEN_ARRAY) {\n            emit(this, 'onopenarray');\n            this.depth++;\n            this.state = S.VALUE;\n            if (c === Char.closeBracket) {\n              emit(this, 'onclosearray');\n              this.depth--;\n              this.state = this.stack.pop() || S.VALUE;\n              continue;\n            } else {\n              this.stack.push(S.CLOSE_ARRAY);\n            }\n          }\n          if (c === Char.doubleQuote) this.state = S.STRING;\n          else if (c === Char.openBrace) this.state = S.OPEN_OBJECT;\n          else if (c === Char.openBracket) this.state = S.OPEN_ARRAY;\n          else if (c === Char.t) this.state = S.TRUE;\n          else if (c === Char.f) this.state = S.FALSE;\n          else if (c === Char.n) this.state = S.NULL;\n          else if (c === Char.minus) {\n            // keep and continue\n            this.numberNode += '-';\n          } else if (Char._0 <= c && c <= Char._9) {\n            this.numberNode += String.fromCharCode(c);\n            this.state = S.NUMBER_DIGIT;\n          } else error(this, 'Bad value');\n          continue;\n\n        case S.CLOSE_ARRAY:\n          if (c === Char.comma) {\n            this.stack.push(S.CLOSE_ARRAY);\n            closeValue(this, 'onvalue');\n            this.state = S.VALUE;\n          } else if (c === Char.closeBracket) {\n            emitNode(this, 'onclosearray');\n            this.depth--;\n            this.state = this.stack.pop() || S.VALUE;\n          } else if (isWhitespace(c)) continue;\n          else error(this, 'Bad array');\n          continue;\n\n        case S.STRING:\n          if (this.textNode === undefined) {\n            this.textNode = '';\n          }\n\n          // thanks thejh, this is an about 50% performance improvement.\n          var starti = i - 1,\n            slashed = this.slashed,\n            unicodeI = this.unicodeI;\n          STRING_BIGLOOP: while (true) {\n            if (DEBUG) console.log(i, c, STATE[this.state], slashed);\n            // zero means \"no unicode active\". 1-4 mean \"parse some more\". end after 4.\n            while (unicodeI > 0) {\n              this.unicodeS += String.fromCharCode(c);\n              c = chunk.charCodeAt(i++);\n              this.position++;\n              if (unicodeI === 4) {\n                // TODO this might be slow? well, probably not used too often anyway\n                this.textNode += String.fromCharCode(parseInt(this.unicodeS, 16));\n                unicodeI = 0;\n                starti = i - 1;\n              } else {\n                unicodeI++;\n              }\n              // we can just break here: no stuff we skipped that still has to be sliced out or so\n              if (!c) break STRING_BIGLOOP;\n            }\n            if (c === Char.doubleQuote && !slashed) {\n              this.state = this.stack.pop() || S.VALUE;\n              this.textNode += chunk.substring(starti, i - 1);\n              this.position += i - 1 - starti;\n              break;\n            }\n            if (c === Char.backslash && !slashed) {\n              slashed = true;\n              this.textNode += chunk.substring(starti, i - 1);\n              this.position += i - 1 - starti;\n              c = chunk.charCodeAt(i++);\n              this.position++;\n              if (!c) break;\n            }\n            if (slashed) {\n              slashed = false;\n              if (c === Char.n) {\n                this.textNode += '\\n';\n              } else if (c === Char.r) {\n                this.textNode += '\\r';\n              } else if (c === Char.t) {\n                this.textNode += '\\t';\n              } else if (c === Char.f) {\n                this.textNode += '\\f';\n              } else if (c === Char.b) {\n                this.textNode += '\\b';\n              } else if (c === Char.u) {\n                // \\uxxxx. meh!\n                unicodeI = 1;\n                this.unicodeS = '';\n              } else {\n                this.textNode += String.fromCharCode(c);\n              }\n              c = chunk.charCodeAt(i++);\n              this.position++;\n              starti = i - 1;\n              if (!c) break;\n              else continue;\n            }\n\n            stringTokenPattern.lastIndex = i;\n            var reResult = stringTokenPattern.exec(chunk);\n            if (reResult === null) {\n              i = chunk.length + 1;\n              this.textNode += chunk.substring(starti, i - 1);\n              this.position += i - 1 - starti;\n              break;\n            }\n            i = reResult.index + 1;\n            c = chunk.charCodeAt(reResult.index);\n            if (!c) {\n              this.textNode += chunk.substring(starti, i - 1);\n              this.position += i - 1 - starti;\n              break;\n            }\n          }\n          this.slashed = slashed;\n          this.unicodeI = unicodeI;\n          continue;\n\n        case S.TRUE:\n          if (c === Char.r) this.state = S.TRUE2;\n          else error(this, 'Invalid true started with t' + c);\n          continue;\n\n        case S.TRUE2:\n          if (c === Char.u) this.state = S.TRUE3;\n          else error(this, 'Invalid true started with tr' + c);\n          continue;\n\n        case S.TRUE3:\n          if (c === Char.e) {\n            emit(this, 'onvalue', true);\n            this.state = this.stack.pop() || S.VALUE;\n          } else error(this, 'Invalid true started with tru' + c);\n          continue;\n\n        case S.FALSE:\n          if (c === Char.a) this.state = S.FALSE2;\n          else error(this, 'Invalid false started with f' + c);\n          continue;\n\n        case S.FALSE2:\n          if (c === Char.l) this.state = S.FALSE3;\n          else error(this, 'Invalid false started with fa' + c);\n          continue;\n\n        case S.FALSE3:\n          if (c === Char.s) this.state = S.FALSE4;\n          else error(this, 'Invalid false started with fal' + c);\n          continue;\n\n        case S.FALSE4:\n          if (c === Char.e) {\n            emit(this, 'onvalue', false);\n            this.state = this.stack.pop() || S.VALUE;\n          } else error(this, 'Invalid false started with fals' + c);\n          continue;\n\n        case S.NULL:\n          if (c === Char.u) this.state = S.NULL2;\n          else error(this, 'Invalid null started with n' + c);\n          continue;\n\n        case S.NULL2:\n          if (c === Char.l) this.state = S.NULL3;\n          else error(this, 'Invalid null started with nu' + c);\n          continue;\n\n        case S.NULL3:\n          if (c === Char.l) {\n            emit(this, 'onvalue', null);\n            this.state = this.stack.pop() || S.VALUE;\n          } else error(this, 'Invalid null started with nul' + c);\n          continue;\n\n        case S.NUMBER_DECIMAL_POINT:\n          if (c === Char.period) {\n            this.numberNode += '.';\n            this.state = S.NUMBER_DIGIT;\n          } else error(this, 'Leading zero not followed by .');\n          continue;\n\n        case S.NUMBER_DIGIT:\n          if (Char._0 <= c && c <= Char._9) this.numberNode += String.fromCharCode(c);\n          else if (c === Char.period) {\n            if (this.numberNode.indexOf('.') !== -1) error(this, 'Invalid number has two dots');\n            this.numberNode += '.';\n          } else if (c === Char.e || c === Char.E) {\n            if (this.numberNode.indexOf('e') !== -1 || this.numberNode.indexOf('E') !== -1)\n              error(this, 'Invalid number has two exponential');\n            this.numberNode += 'e';\n          } else if (c === Char.plus || c === Char.minus) {\n            if (!(p === Char.e || p === Char.E)) error(this, 'Invalid symbol in number');\n            this.numberNode += String.fromCharCode(c);\n          } else {\n            closeNumber(this);\n            i--; // go back one\n            this.state = this.stack.pop() || S.VALUE;\n          }\n          continue;\n\n        default:\n          error(this, 'Unknown state: ' + this.state);\n      }\n    }\n    if (this.position >= this.bufferCheckPosition) {\n      checkBufferLength(this);\n    }\n\n    emit(this, 'onchunkparsed');\n\n    return this;\n  }\n}\n\nfunction emit(parser, event, data) {\n  if (DEBUG) {\n    console.log('-- emit', event, data);\n  }\n  if (parser[event]) {\n    parser[event](data, parser);\n  }\n}\n\nfunction emitNode(parser, event, data) {\n  closeValue(parser);\n  emit(parser, event, data);\n}\n\nfunction closeValue(parser, event) {\n  parser.textNode = textopts(parser.options, parser.textNode);\n  if (parser.textNode !== undefined) {\n    emit(parser, event ? event : 'onvalue', parser.textNode);\n  }\n  parser.textNode = undefined;\n}\n\nfunction closeNumber(parser) {\n  if (parser.numberNode) emit(parser, 'onvalue', parseFloat(parser.numberNode));\n  parser.numberNode = '';\n}\n\nfunction textopts(opt, text) {\n  if (text === undefined) {\n    return text;\n  }\n  if (opt.trim) text = text.trim();\n  if (opt.normalize) text = text.replace(/\\s+/g, ' ');\n  return text;\n}\n\nfunction error(parser, er) {\n  closeValue(parser);\n  er += '\\nLine: ' + parser.line + '\\nColumn: ' + parser.column + '\\nChar: ' + parser.c;\n  er = new Error(er);\n  parser.error = er;\n  emit(parser, 'onerror', er);\n  return parser;\n}\n\nfunction isWhitespace(c) {\n  return c === Char.carriageReturn || c === Char.lineFeed || c === Char.space || c === Char.tab;\n}\n","/**\n * A parser for a minimal subset of the jsonpath standard\n * Full JSON path parsers for JS exist but are quite large (bundle size)\n *\n * Supports\n *\n *   `$.component.component.component`\n */\nexport default class JSONPath {\n  path: string[];\n\n  constructor(path: JSONPath | string[] | string | null = null) {\n    this.path = ['$'];\n\n    if (path instanceof JSONPath) {\n      // @ts-ignore\n      this.path = [...path.path];\n      return;\n    }\n\n    if (Array.isArray(path)) {\n      this.path.push(...path);\n      return;\n    }\n\n    // Parse a string as a JSONPath\n    if (typeof path === 'string') {\n      this.path = path.split('.');\n      if (this.path[0] !== '$') {\n        throw new Error('JSONPaths must start with $');\n      }\n    }\n  }\n\n  clone(): JSONPath {\n    return new JSONPath(this);\n  }\n\n  toString(): string {\n    return this.path.join('.');\n  }\n\n  push(name: string): void {\n    this.path.push(name);\n  }\n\n  pop() {\n    return this.path.pop();\n  }\n\n  set(name: string): void {\n    this.path[this.path.length - 1] = name;\n  }\n\n  equals(other: JSONPath): boolean {\n    if (!this || !other || this.path.length !== other.path.length) {\n      return false;\n    }\n\n    for (let i = 0; i < this.path.length; ++i) {\n      if (this.path[i] !== other.path[i]) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Sets the value pointed at by path\n   * TODO - handle root path\n   * @param object\n   * @param value\n   */\n  setFieldAtPath(object, value) {\n    const path = [...this.path];\n    path.shift();\n    const field = path.pop();\n    for (const component of path) {\n      object = object[component];\n    }\n    // @ts-ignore\n    object[field] = value;\n  }\n\n  /**\n   * Gets the value pointed at by path\n   * TODO - handle root path\n   * @param object\n   */\n  getFieldAtPath(object) {\n    const path = [...this.path];\n    path.shift();\n    const field = path.pop();\n    for (const component of path) {\n      object = object[component];\n    }\n    // @ts-ignore\n    return object[field];\n  }\n}\n","import {default as JSONParser} from './json-parser';\nimport JSONPath from '../jsonpath/jsonpath';\n\n/**\n * The `StreamingJSONParser` looks for the first array in the JSON structure.\n * and emits an array of chunks\n */\nexport default class StreamingJSONParser extends JSONParser {\n  private jsonPaths: JSONPath[];\n  private streamingJsonPath: JSONPath | null = null;\n  private streamingArray: any[] | null = null;\n  private topLevelObject: object | null = null;\n\n  constructor(options: {[key: string]: any} = {}) {\n    super();\n    const jsonpaths = options.jsonpaths || [];\n    this.jsonPaths = jsonpaths.map((jsonpath) => new JSONPath(jsonpath));\n    this._extendParser();\n  }\n\n  /**\n   * write REDEFINITION\n   * - super.write() chunk to parser\n   * - get the contents (so far) of \"topmost-level\" array as batch of rows\n   * - clear top-level array\n   * - return the batch of rows\\\n   */\n  write(chunk) {\n    super.write(chunk);\n    let array: any[] = [];\n    if (this.streamingArray) {\n      array = [...this.streamingArray];\n      this.streamingArray.length = 0;\n    }\n    return array;\n  }\n\n  /**\n   * Returns a partially formed result object\n   * Useful for returning the \"wrapper\" object when array is not top level\n   * e.g. GeoJSON\n   */\n  getPartialResult() {\n    return this.topLevelObject;\n  }\n\n  getStreamingJsonPath() {\n    return this.streamingJsonPath;\n  }\n\n  getStreamingJsonPathAsString() {\n    return this.streamingJsonPath && this.streamingJsonPath.toString();\n  }\n\n  getJsonPath() {\n    return this.jsonpath;\n  }\n\n  // PRIVATE METHODS\n\n  /**\n   * Checks is this.getJsonPath matches the jsonpaths provided in options\n   */\n  _matchJSONPath() {\n    const currentPath = this.getJsonPath();\n    // console.debug(`Testing JSONPath`, currentPath);\n\n    // Backwards compatibility, match any array\n    // TODO implement using wildcard once that is supported\n    if (this.jsonPaths.length === 0) {\n      return true;\n    }\n\n    for (const jsonPath of this.jsonPaths) {\n      if (jsonPath.equals(currentPath)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  _extendParser() {\n    // Redefine onopenarray to locate and inject value for top-level array\n    this.parser.onopenarray = () => {\n      if (!this.streamingArray) {\n        if (this._matchJSONPath()) {\n          // @ts-ignore\n          this.streamingJsonPath = this.getJsonPath().clone();\n          this.streamingArray = [];\n          this._openArray(this.streamingArray as []);\n          return;\n        }\n      }\n\n      this._openArray();\n    };\n\n    // Redefine onopenarray to inject value for top-level object\n    this.parser.onopenobject = (name) => {\n      if (!this.topLevelObject) {\n        this.topLevelObject = {};\n        this._openObject(this.topLevelObject);\n      } else {\n        this._openObject({});\n      }\n      if (typeof name !== 'undefined') {\n        this.parser.onkey(name);\n      }\n    };\n  }\n}\n","// @ts-nocheck\n\nimport ClarinetParser from '../clarinet/clarinet';\nimport JSONPath from '../jsonpath/jsonpath';\n\n// JSONParser builds a JSON object using the events emitted by the Clarinet parser\n\nexport default class JSONParser {\n  jsonpath: JSONPath;\n  _parser?: ClarinetParser;\n\n  constructor() {\n    this.reset();\n    this._initializeParser();\n  }\n\n  reset(): void {\n    this.result = undefined;\n    this.previousStates = [];\n    this.currentState = Object.freeze({container: [], key: null});\n    this.jsonpath = new JSONPath();\n  }\n\n  write(chunk): void {\n    this.parser.write(chunk);\n  }\n\n  close(): void {\n    this.parser.close();\n  }\n\n  // PRIVATE METHODS\n\n  _pushOrSet(value): void {\n    const {container, key} = this.currentState;\n    if (key !== null) {\n      container[key] = value;\n      this.currentState.key = null;\n    } else {\n      container.push(value);\n    }\n  }\n\n  _openArray(newContainer = []): void {\n    this.jsonpath.push(null);\n    this._pushOrSet(newContainer);\n    this.previousStates.push(this.currentState);\n    this.currentState = {container: newContainer, isArray: true, key: null};\n  }\n\n  _closeArray(): void {\n    this.jsonpath.pop();\n    this.currentState = this.previousStates.pop();\n  }\n\n  _openObject(newContainer = {}): void {\n    this.jsonpath.push(null);\n    this._pushOrSet(newContainer);\n    this.previousStates.push(this.currentState);\n    this.currentState = {container: newContainer, isArray: false, key: null};\n  }\n\n  _closeObject(): void {\n    this.jsonpath.pop();\n    this.currentState = this.previousStates.pop();\n  }\n\n  _initializeParser(): void {\n    this._parser = new ClarinetParser({\n      onready: () => {\n        this.jsonpath = new JSONPath();\n        this.previousStates.length = 0;\n        this.currentState.container.length = 0;\n      },\n\n      onopenobject: (name) => {\n        this._openObject({});\n        if (typeof name !== 'undefined') {\n          this.parser.onkey(name);\n        }\n      },\n\n      onkey: (name) => {\n        this.jsonpath.set(name);\n        this.currentState.key = name;\n      },\n\n      oncloseobject: () => {\n        this._closeObject();\n      },\n\n      onopenarray: () => {\n        this._openArray();\n      },\n\n      onclosearray: () => {\n        this._closeArray();\n      },\n\n      onvalue: (value) => {\n        this._pushOrSet(value);\n      },\n\n      onerror: (error) => {\n        throw error;\n      },\n\n      onend: () => {\n        this.result = this.currentState.container.pop();\n      }\n    });\n  }\n\n  protected get parser(): ClarinetParser {\n    return this._parser as ClarinetParser;\n  }\n}\n","import type {Batch} from '@loaders.gl/schema';\nimport type {JSONLoaderOptions} from '../json-loader';\nimport {TableBatchBuilder} from '@loaders.gl/schema';\nimport {makeTextDecoderIterator} from '@loaders.gl/loader-utils';\nimport StreamingJSONParser from './parser/streaming-json-parser';\n\n// TODO - support batch size 0 = no batching/single batch?\n// eslint-disable-next-line max-statements, complexity\nexport default async function* parseJSONInBatches(\n  binaryAsyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options: JSONLoaderOptions\n): AsyncIterable<Batch> {\n  const asyncIterator = makeTextDecoderIterator(binaryAsyncIterator);\n\n  const {metadata} = options;\n  const {jsonpaths} = options.json || {};\n\n  let isFirstChunk: boolean = true;\n\n  // TODO fix Schema deduction\n  const schema = null; // new Schema([]);\n  const shape = options?.json?.shape || 'row-table';\n  // @ts-ignore\n  const tableBatchBuilder = new TableBatchBuilder(schema, {\n    ...options,\n    shape\n  });\n\n  const parser = new StreamingJSONParser({jsonpaths});\n\n  for await (const chunk of asyncIterator) {\n    const rows = parser.write(chunk);\n\n    const jsonpath = rows.length > 0 && parser.getStreamingJsonPathAsString();\n\n    if (rows.length > 0 && isFirstChunk) {\n      if (metadata) {\n        const initialBatch: Batch = {\n          // Common fields\n          shape,\n          batchType: 'partial-result',\n          data: [],\n          length: 0,\n          bytesUsed: 0,\n          // JSON additions\n          container: parser.getPartialResult(),\n          jsonpath\n        };\n        yield initialBatch;\n      }\n      isFirstChunk = false;\n      // schema = deduceSchema(rows);\n    }\n\n    // Add the row\n    for (const row of rows) {\n      tableBatchBuilder.addRow(row);\n      // If a batch has been completed, emit it\n      const batch = tableBatchBuilder.getFullBatch({jsonpath});\n      if (batch) {\n        yield batch;\n      }\n    }\n\n    tableBatchBuilder.chunkComplete(chunk);\n    const batch = tableBatchBuilder.getFullBatch({jsonpath});\n    if (batch) {\n      yield batch;\n    }\n  }\n\n  // yield final batch\n  const jsonpath = parser.getStreamingJsonPathAsString();\n  const batch = tableBatchBuilder.getFinalBatch({jsonpath});\n  if (batch) {\n    yield batch;\n  }\n\n  if (metadata) {\n    const finalBatch: Batch = {\n      shape,\n      batchType: 'final-result',\n      container: parser.getPartialResult(),\n      jsonpath: parser.getStreamingJsonPathAsString(),\n      data: [],\n      length: 0\n      // schema: null\n    };\n    yield finalBatch;\n  }\n}\n","import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {JSONLoaderOptions} from './json-loader';\nimport {geojsonToBinary} from '@loaders.gl/gis';\nimport parseJSONSync from './lib/parse-json';\nimport parseJSONInBatches from './lib/parse-json-in-batches';\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\nexport type GeoJSONLoaderOptions = JSONLoaderOptions & {\n  geojson?: {\n    shape?: 'object-row-table';\n  };\n  gis?: {\n    format: 'geojson';\n  };\n};\n\nconst DEFAULT_GEOJSON_LOADER_OPTIONS = {\n  geojson: {\n    shape: 'object-row-table'\n  },\n  json: {\n    jsonpaths: ['$', '$.features']\n  },\n  gis: {\n    format: 'geojson'\n  }\n};\n\n/**\n * GeoJSON loader\n */\nexport const GeoJSONWorkerLoader: Loader = {\n  name: 'GeoJSON',\n  id: 'geojson',\n  module: 'geojson',\n  version: VERSION,\n  worker: true,\n  extensions: ['geojson'],\n  mimeTypes: ['application/geo+json'],\n  category: 'geometry',\n  text: true,\n  options: DEFAULT_GEOJSON_LOADER_OPTIONS\n};\n\nexport const GeoJSONLoader: LoaderWithParser = {\n  ...GeoJSONWorkerLoader,\n  parse,\n  parseTextSync,\n  parseInBatches\n};\n\nasync function parse(arrayBuffer, options) {\n  return parseTextSync(new TextDecoder().decode(arrayBuffer), options);\n}\n\nfunction parseTextSync(text, options) {\n  // Apps can call the parse method directly, we so apply default options here\n  options = {...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options};\n  options.json = {...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson};\n  options.gis = options.gis || {};\n  const json = parseJSONSync(text, options);\n  switch (options.gis.format) {\n    case 'binary':\n      return geojsonToBinary(json);\n    default:\n      return json;\n  }\n}\n\nfunction parseInBatches(asyncIterator, options): AsyncIterable<any> {\n  // Apps can call the parse method directly, we so apply default options here\n  options = {...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options};\n  options.json = {...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson};\n\n  const geojsonIterator = parseJSONInBatches(asyncIterator, options);\n\n  switch (options.gis.format) {\n    case 'binary':\n      return makeBinaryGeometryIterator(geojsonIterator);\n    default:\n      return geojsonIterator;\n  }\n}\n\nasync function* makeBinaryGeometryIterator(geojsonIterator) {\n  for await (const batch of geojsonIterator) {\n    batch.data = geojsonToBinary(batch.data);\n    yield batch;\n  }\n}\n","import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {GeoJSONLoader} from '../geojson-loader';\n\ncreateLoaderWorker(GeoJSONLoader);\n"],"sourceRoot":""}