@loaders.gl/mvt 3.1.0-alpha.4 → 4.0.0-alpha.1

package/dist/esm/lib/parse-mvt.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/parse-mvt.ts"],"names":["VectorTile","BinaryVectorTile","featuresToBinary","Protobuf","parseMVT","arrayBuffer","options","normalizeOptions","features","binary","gis","format","firstPassData","pointPositionsCount","pointFeaturesCount","linePositionsCount","linePathsCount","lineFeaturesCount","polygonPositionsCount","polygonObjectsCount","polygonRingsCount","polygonFeaturesCount","byteLength","tile","loaderOptions","mvt","selectedLayers","Array","isArray","layers","Object","keys","forEach","layerName","vectorTileLayer","featureOptions","i","length","vectorTileFeature","feature","decodedFeature","getDecodedFeatureBinary","getDecodedFeature","push","data","wgs84Coordinates","coordinates","tileIndex","hasTileIndex","Number","isFinite","x","y","z","Error","toGeoJSON","transformToLocalCoordinates","layerProperty","properties","toBinaryCoordinates","transformToLocalCoordinatesBinary","line","extent","p","il"],"mappings":"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","sourcesContent":["// import {VectorTile} from '@mapbox/vector-tile';\nimport VectorTile from './mapbox-vector-tile/vector-tile';\nimport BinaryVectorTile from './binary-vector-tile/vector-tile';\n\nimport {featuresToBinary} from './binary-vector-tile/features-to-binary';\nimport Protobuf from 'pbf';\nimport {MvtBinaryCoordinates, MvtMapboxCoordinates, MvtOptions} from '../lib/types';\nimport VectorTileFeatureBinary from './binary-vector-tile/vector-tile-feature';\nimport VectorTileFeatureMapBox from './mapbox-vector-tile/vector-tile-feature';\nimport {LoaderOptions} from '@loaders.gl/loader-utils/';\n\n/**\n * Parse MVT arrayBuffer and return GeoJSON.\n *\n * @param arrayBuffer A MVT arrayBuffer\n * @param options\n * @returns A GeoJSON geometry object or a binary representation\n */\nexport default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptions) {\n  options = normalizeOptions(options);\n  const features: (MvtBinaryCoordinates | MvtMapboxCoordinates)[] = [];\n\n  if (options) {\n    const binary = options.gis.format === 'binary';\n    const firstPassData = {\n      pointPositionsCount: 0,\n      pointFeaturesCount: 0,\n      linePositionsCount: 0,\n      linePathsCount: 0,\n      lineFeaturesCount: 0,\n      polygonPositionsCount: 0,\n      polygonObjectsCount: 0,\n      polygonRingsCount: 0,\n      polygonFeaturesCount: 0\n    };\n\n    if (arrayBuffer.byteLength > 0) {\n      const tile = binary\n        ? new BinaryVectorTile(new Protobuf(arrayBuffer))\n        : new VectorTile(new Protobuf(arrayBuffer));\n      const loaderOptions = options.mvt;\n\n      const selectedLayers = Array.isArray(loaderOptions.layers)\n        ? loaderOptions.layers\n        : Object.keys(tile.layers);\n\n      selectedLayers.forEach((layerName: string) => {\n        const vectorTileLayer = tile.layers[layerName];\n        const featureOptions = {...loaderOptions, layerName};\n\n        if (!vectorTileLayer) {\n          return;\n        }\n\n        for (let i = 0; i < vectorTileLayer.length; i++) {\n          const vectorTileFeature = vectorTileLayer.feature(i, firstPassData);\n\n          const decodedFeature = binary\n            ? getDecodedFeatureBinary(vectorTileFeature as VectorTileFeatureBinary, featureOptions)\n            : getDecodedFeature(vectorTileFeature as VectorTileFeatureMapBox, featureOptions);\n          features.push(decodedFeature);\n        }\n      });\n    }\n\n    if (binary) {\n      const data = featuresToBinary(features as MvtBinaryCoordinates[], firstPassData);\n      // Add the original byteLength (as a reasonable approximation of the size of the binary data)\n      // TODO decide where to store extra fields like byteLength (header etc) and document\n      // @ts-ignore\n      data.byteLength = arrayBuffer.byteLength;\n      return data;\n    }\n  }\n  return features;\n}\n\n/**\n * @param options\n * @returns options\n */\nfunction normalizeOptions(options: LoaderOptions | undefined) {\n  if (options) {\n    options = {\n      ...options,\n      mvt: options.mvt || {},\n      gis: options.gis || {}\n    };\n\n    // Validate\n    const wgs84Coordinates = options.coordinates === 'wgs84';\n    const {tileIndex} = options;\n    const hasTileIndex =\n      tileIndex &&\n      Number.isFinite(tileIndex.x) &&\n      Number.isFinite(tileIndex.y) &&\n      Number.isFinite(tileIndex.z);\n\n    if (wgs84Coordinates && !hasTileIndex) {\n      throw new Error(\n        'MVT Loader: WGS84 coordinates need tileIndex property. Check documentation.'\n      );\n    }\n  }\n  return options;\n}\n\n/**\n * @param feature\n * @param options\n * @returns decoded feature\n */\nfunction getDecodedFeature(\n  feature: VectorTileFeatureMapBox,\n  options: MvtOptions\n): MvtMapboxCoordinates {\n  const decodedFeature = feature.toGeoJSON(\n    options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinates\n  );\n\n  // Add layer name to GeoJSON properties\n  if (options.layerProperty) {\n    decodedFeature.properties[options.layerProperty] = options.layerName;\n  }\n\n  return decodedFeature;\n}\n\n/**\n * @param feature\n * @param options\n * @returns decoded binary feature\n */\nfunction getDecodedFeatureBinary(\n  feature: VectorTileFeatureBinary,\n  options: MvtOptions\n): MvtBinaryCoordinates {\n  const decodedFeature = feature.toBinaryCoordinates(\n    options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinatesBinary\n  );\n\n  // Add layer name to GeoJSON properties\n  if (options.layerProperty) {\n    decodedFeature.properties[options.layerProperty] = options.layerName;\n  }\n\n  return decodedFeature;\n}\n\n/**\n * @param line\n * @param feature\n */\nfunction transformToLocalCoordinates(line: number[], feature: {extent: any}): void {\n  // This function transforms local coordinates in a\n  // [0 - bufferSize, this.extent + bufferSize] range to a\n  // [0 - (bufferSize / this.extent), 1 + (bufferSize / this.extent)] range.\n  // The resulting extent would be 1.\n  const {extent} = feature;\n  for (let i = 0; i < line.length; i++) {\n    const p = line[i];\n    p[0] /= extent;\n    p[1] /= extent;\n  }\n}\n\nfunction transformToLocalCoordinatesBinary(data: number[], feature: {extent: any}) {\n  // For the binary code path, the feature data is just\n  // one big flat array, so we just divide each value\n  const {extent} = feature;\n  for (let i = 0, il = data.length; i < il; ++i) {\n    data[i] /= extent;\n  }\n}\n"],"file":"parse-mvt.js"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"types.js"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/mvt-loader.ts"],"names":["parseMVT","VERSION","MVTWorkerLoader","name","id","module","version","extensions","mimeTypes","worker","category","options","mvt","coordinates","layerProperty","layers","tileIndex","MVTLoader","parse","arrayBuffer","parseSync","binary"],"mappings":"AACA,OAAOA,QAAP,MAAqB,iBAArB;AAIA,MAAMC,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAKA,OAAO,MAAMC,eAAuB,GAAG;AACrCC,EAAAA,IAAI,EAAE,oBAD+B;AAErCC,EAAAA,EAAE,EAAE,KAFiC;AAGrCC,EAAAA,MAAM,EAAE,KAH6B;AAIrCC,EAAAA,OAAO,EAAEL,OAJ4B;AAMrCM,EAAAA,UAAU,EAAE,CAAC,KAAD,EAAQ,KAAR,CANyB;AAOrCC,EAAAA,SAAS,EAAE,CACT,oCADS,EAET,wBAFS,CAP0B;AAYrCC,EAAAA,MAAM,EAAE,IAZ6B;AAarCC,EAAAA,QAAQ,EAAE,UAb2B;AAcrCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,GAAG,EAAE;AACHC,MAAAA,WAAW,EAAE,OADV;AAEHC,MAAAA,aAAa,EAAE,WAFZ;AAGHC,MAAAA,MAAM,EAAE,IAHL;AAIHC,MAAAA,SAAS,EAAE;AAJR;AADE;AAd4B,CAAhC;AA2BP,OAAO,MAAMC,SAA2B,GAAG,EACzC,GAAGf,eADsC;AAEzCgB,EAAAA,KAAK,EAAE,OAAOC,WAAP,EAAoBR,OAApB,KAAgCX,QAAQ,CAACmB,WAAD,EAAcR,OAAd,CAFN;AAGzCS,EAAAA,SAAS,EAAEpB,QAH8B;AAIzCqB,EAAAA,MAAM,EAAE;AAJiC,CAApC","sourcesContent":["import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport parseMVT from './lib/parse-mvt';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/**\n * Worker loader for the Mapbox Vector Tile format\n */\nexport const MVTWorkerLoader: Loader = {\n  name: 'Mapbox Vector Tile',\n  id: 'mvt',\n  module: 'mvt',\n  version: VERSION,\n  // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'\n  extensions: ['mvt', 'pbf'],\n  mimeTypes: [\n    'application/vnd.mapbox-vector-tile',\n    'application/x-protobuf'\n    // 'application/octet-stream'\n  ],\n  worker: true,\n  category: 'geometry',\n  options: {\n    mvt: {\n      coordinates: 'local',\n      layerProperty: 'layerName',\n      layers: null,\n      tileIndex: null\n    }\n  }\n};\n\n/**\n * Loader for the Mapbox Vector Tile format\n */\nexport const MVTLoader: LoaderWithParser = {\n  ...MVTWorkerLoader,\n  parse: async (arrayBuffer, options) => parseMVT(arrayBuffer, options),\n  parseSync: parseMVT,\n  binary: true\n};\n"],"file":"mvt-loader.js"}

package/dist/esm/workers/mvt-worker.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/workers/mvt-worker.ts"],"names":["MVTLoader","createLoaderWorker"],"mappings":"AAAA,SAAQA,SAAR,QAAwB,eAAxB;AACA,SAAQC,kBAAR,QAAiC,0BAAjC;AAEAA,kBAAkB,CAACD,SAAD,CAAlB","sourcesContent":["import {MVTLoader} from '../mvt-loader';\nimport {createLoaderWorker} from '@loaders.gl/loader-utils';\n\ncreateLoaderWorker(MVTLoader);\n"],"file":"mvt-worker.js"}

package/dist/mvt-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/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/regenerator/index.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack:////home/user/apps/loaders.gl/node_modules/pbf/index.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/typeof.js","webpack:////home/user/apps/loaders.gl/node_modules/regenerator-runtime/runtime.js","webpack:////home/user/apps/loaders.gl/node_modules/ieee754/index.js","webpack:///./src/helpers/mapbox-util-functions.ts","webpack:///./src/lib/mapbox-vector-tile/vector-tile-feature.ts","webpack:///./src/lib/mapbox-vector-tile/vector-tile-layer.ts","webpack:///./src/lib/mapbox-vector-tile/vector-tile.ts","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/lib/common.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/polygon/dist/esm/polygon-utils.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/polygon/dist/esm/earcut.js","webpack:///./src/helpers/binary-util-functions.ts","webpack:///./src/lib/binary-vector-tile/vector-tile-feature.ts","webpack:///./src/lib/binary-vector-tile/vector-tile-layer.ts","webpack:///./src/lib/binary-vector-tile/vector-tile.ts","webpack:///./src/lib/binary-vector-tile/features-to-binary.ts","webpack:///./src/lib/parse-mvt.ts","webpack:///./src/mvt-loader.ts","webpack:///../worker-utils/src/lib/worker-utils/get-transfer-list.ts","webpack:///../worker-utils/src/lib/worker-farm/worker-body.ts","webpack:///../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts","webpack:///./src/workers/mvt-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","instance","Constructor","TypeError","_defineProperties","target","props","length","descriptor","protoProps","staticProps","asyncGeneratorStep","gen","resolve","reject","_next","_throw","arg","info","error","done","Promise","then","fn","self","this","args","arguments","apply","err","undefined","Pbf","ieee754","buf","ArrayBuffer","isView","Uint8Array","pos","type","Varint","Fixed64","Bytes","Fixed32","utf8TextDecoder","TextDecoder","readPackedEnd","pbf","readVarint","toNum","low","high","isSigned","makeRoomForExtraLength","startPos","len","extraLen","Math","floor","log","LN2","realloc","writePackedVarint","arr","writeVarint","writePackedSVarint","writeSVarint","writePackedFloat","writeFloat","writePackedDouble","writeDouble","writePackedBoolean","writeBoolean","writePackedFixed32","writeFixed32","writePackedSFixed32","writeSFixed32","writePackedFixed64","writeFixed64","writePackedSFixed64","writeSFixed64","readUInt32","writeInt32","val","readInt32","destroy","readFields","readField","result","end","tag","skip","readMessage","readFixed32","readSFixed32","readFixed64","readSFixed64","readFloat","read","readDouble","b","h","Error","readVarintRemainder","readVarint64","readSVarint","num","readBoolean","Boolean","readString","decode","subarray","readUtf8TextDecoder","str","b1","b2","b3","b0","bytesPerSequence","String","fromCharCode","readUtf8","readBytes","buffer","readPackedVarint","push","readPackedSVarint","readPackedBoolean","readPackedFloat","readPackedDouble","readPackedFixed32","readPackedSFixed32","readPackedFixed64","readPackedSFixed64","writeTag","min","set","finish","writeBigVarintLow","lsb","writeBigVarintHigh","writeBigVarint","writeString","lead","charCodeAt","writeUtf8","write","writeBytes","writeRawMessage","writeMessage","writeBytesField","writeFixed32Field","writeSFixed32Field","writeFixed64Field","writeSFixed64Field","writeVarintField","writeSVarintField","writeStringField","writeFloatField","writeDoubleField","writeBooleanField","_typeof","iterator","constructor","runtime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","define","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","context","Context","_invoke","state","method","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","forEach","AsyncIterator","PromiseImpl","previousPromise","callInvokeWithMethodAndArg","invoke","__await","unwrapped","resultName","next","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","displayName","isGeneratorFunction","genFun","ctor","mark","setPrototypeOf","__proto__","awrap","async","iter","toString","keys","reverse","pop","skipTempReset","prev","charAt","slice","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","Function","offset","isLE","mLen","nBytes","e","eLen","eMax","eBias","nBits","NaN","Infinity","pow","rt","abs","signedArea","ring","p1","p2","sum","j","readFeature","feature","id","_keys","_values","properties","readTag","_geometry","VectorTileFeature","extent","_pbf","line","cmd","x","y","lines","cmdLen","x1","x2","y1","y2","transform","coords","loadGeometry","types","points","rings","polygon","ccw","polygons","area","classifyRings","geometry","coordinates","options","_toGeoJSON","z","size","x0","y0","PI","atan","exp","VectorTileLayer","version","_features","readLayer","layer","readValueMessage","VectorTile","layers","readTile","config","EPSILON","debug","precision","printTypes","printDegrees","printRowMajor","getPolygonSignedArea","start","dim","earcut","data","holeIndices","areas","hasHoles","outerLen","outerNode","linkedList","triangles","invSize","maxX","maxY","minX","minY","queue","list","steiner","getLeftmost","sort","compareX","eliminateHole","filterPoints","eliminateHoles","max","earcutLinked","clockwise","last","insertNode","removeNode","again","ear","pass","zOrder","prevZ","nextZ","numMerges","pSize","q","qSize","tail","inSize","sortLinked","indexCurve","isEarHashed","isEar","cureLocalIntersections","splitEarcut","a","pointInTriangle","minTX","minTY","maxTX","maxTY","minZ","maxZ","intersects","locallyInside","isValidDiagonal","splitPolygon","hole","hx","hy","qx","mx","my","tan","tanMin","sectorContainsSector","findHoleBridge","leftmost","ax","ay","bx","by","cx","cy","px","py","intersectsPolygon","inside","middleInside","q1","q2","o1","sign","o2","o3","o4","onSegment","a2","Node","an","bp","geom","endIndex","startIndex","ringAreas","before","after","concat","project","jl","endPos","firstPassData","_firstPassData","pointFeaturesCount","pointPositionsCount","lineFeaturesCount","linePathsCount","linePositionsCount","classified","polygonFeaturesCount","polygonObjectsCount","polygonRingsCount","polygonPositionsCount","_toBinaryCoordinates","extractNumericPropKeys","features","numericPropKeys","numericSoFar","isNumeric","filter","k","fillArrays","PositionDataType","Float32Array","hasGlobalId","GlobalFeatureIdsDataType","Uint32Array","Uint16Array","positions","globalFeatureIds","featureIds","numericProps","fields","pathIndices","polygonIndices","primitivePolygonIndices","propName","indexMap","pointPosition","pointFeature","linePosition","linePath","lineFeature","polygonPosition","polygonObject","polygonRing","polygonFeature","handlePoint","keepStringProperties","handleLineString","handlePolygon","coordLength","returnObj","geomType","numericProp","makeAccessorObjects","nPositions","fillNumericProperties","fill","il","ll","startPosition","nextLines","triangulatePolygon","endPosition","polygonPositions","indices","map","tl","index","numericPropName","numericKeys","includes","Number","isFinite","parseMVT","arrayBuffer","wgs84Coordinates","mvt","gis","tileIndex","hasTileIndex","normalizeOptions","binary","format","byteLength","tile","BinaryVectorTile","Protobuf","loaderOptions","Array","isArray","layerName","vectorTileLayer","featureOptions","vectorTileFeature","decodedFeature","getDecodedFeatureBinary","getDecodedFeature","featuresToBinary","toGeoJSON","transformToLocalCoordinates","layerProperty","toBinaryCoordinates","transformToLocalCoordinatesBinary","MVTLoader","extensions","mimeTypes","worker","category","parse","parseSync","isTransferable","MessagePort","ImageBitmap","OffscreenCanvas","onMessageWrapperMap","Map","WorkerBody","onMessage","onmessage","message","isKnownMessage","payload","onMessageWrapper","addEventListener","removeEventListener","source","transferList","getTransferList","recursive","transfers","transfersSet","Set","add","from","postMessage","startsWith","loader","requestId","parseOnMainThread","input","parseData","parser","parseTextSync","textDecoder"],"mappings":"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","file":"mvt-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 = 10);\n","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nmodule.exports = _defineProperty;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _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;","module.exports = require(\"regenerator-runtime\");\n","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","'use strict';\n\nmodule.exports = Pbf;\n\nvar ieee754 = require('ieee754');\n\nfunction Pbf(buf) {\n    this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);\n    this.pos = 0;\n    this.type = 0;\n    this.length = this.buf.length;\n}\n\nPbf.Varint  = 0; // varint: int32, int64, uint32, uint64, sint32, sint64, bool, enum\nPbf.Fixed64 = 1; // 64-bit: double, fixed64, sfixed64\nPbf.Bytes   = 2; // length-delimited: string, bytes, embedded messages, packed repeated fields\nPbf.Fixed32 = 5; // 32-bit: float, fixed32, sfixed32\n\nvar SHIFT_LEFT_32 = (1 << 16) * (1 << 16),\n    SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;\n\n// Threshold chosen based on both benchmarking and knowledge about browser string\n// data structures (which currently switch structure types at 12 bytes or more)\nvar TEXT_DECODER_MIN_LENGTH = 12;\nvar utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf8');\n\nPbf.prototype = {\n\n    destroy: function() {\n        this.buf = null;\n    },\n\n    // === READING =================================================================\n\n    readFields: function(readField, result, end) {\n        end = end || this.length;\n\n        while (this.pos < end) {\n            var val = this.readVarint(),\n                tag = val >> 3,\n                startPos = this.pos;\n\n            this.type = val & 0x7;\n            readField(tag, result, this);\n\n            if (this.pos === startPos) this.skip(val);\n        }\n        return result;\n    },\n\n    readMessage: function(readField, result) {\n        return this.readFields(readField, result, this.readVarint() + this.pos);\n    },\n\n    readFixed32: function() {\n        var val = readUInt32(this.buf, this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    readSFixed32: function() {\n        var val = readInt32(this.buf, this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)\n\n    readFixed64: function() {\n        var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;\n        this.pos += 8;\n        return val;\n    },\n\n    readSFixed64: function() {\n        var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;\n        this.pos += 8;\n        return val;\n    },\n\n    readFloat: function() {\n        var val = ieee754.read(this.buf, this.pos, true, 23, 4);\n        this.pos += 4;\n        return val;\n    },\n\n    readDouble: function() {\n        var val = ieee754.read(this.buf, this.pos, true, 52, 8);\n        this.pos += 8;\n        return val;\n    },\n\n    readVarint: function(isSigned) {\n        var buf = this.buf,\n            val, b;\n\n        b = buf[this.pos++]; val  =  b & 0x7f;        if (b < 0x80) return val;\n        b = buf[this.pos++]; val |= (b & 0x7f) << 7;  if (b < 0x80) return val;\n        b = buf[this.pos++]; val |= (b & 0x7f) << 14; if (b < 0x80) return val;\n        b = buf[this.pos++]; val |= (b & 0x7f) << 21; if (b < 0x80) return val;\n        b = buf[this.pos];   val |= (b & 0x0f) << 28;\n\n        return readVarintRemainder(val, isSigned, this);\n    },\n\n    readVarint64: function() { // for compatibility with v2.0.1\n        return this.readVarint(true);\n    },\n\n    readSVarint: function() {\n        var num = this.readVarint();\n        return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding\n    },\n\n    readBoolean: function() {\n        return Boolean(this.readVarint());\n    },\n\n    readString: function() {\n        var end = this.readVarint() + this.pos;\n        var pos = this.pos;\n        this.pos = end;\n\n        if (end - pos >= TEXT_DECODER_MIN_LENGTH && utf8TextDecoder) {\n            // longer strings are fast with the built-in browser TextDecoder API\n            return readUtf8TextDecoder(this.buf, pos, end);\n        }\n        // short strings are fast with our custom implementation\n        return readUtf8(this.buf, pos, end);\n    },\n\n    readBytes: function() {\n        var end = this.readVarint() + this.pos,\n            buffer = this.buf.subarray(this.pos, end);\n        this.pos = end;\n        return buffer;\n    },\n\n    // verbose for performance reasons; doesn't affect gzipped size\n\n    readPackedVarint: function(arr, isSigned) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readVarint(isSigned));\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readVarint(isSigned));\n        return arr;\n    },\n    readPackedSVarint: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readSVarint());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readSVarint());\n        return arr;\n    },\n    readPackedBoolean: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readBoolean());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readBoolean());\n        return arr;\n    },\n    readPackedFloat: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readFloat());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readFloat());\n        return arr;\n    },\n    readPackedDouble: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readDouble());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readDouble());\n        return arr;\n    },\n    readPackedFixed32: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readFixed32());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readFixed32());\n        return arr;\n    },\n    readPackedSFixed32: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readSFixed32());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readSFixed32());\n        return arr;\n    },\n    readPackedFixed64: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readFixed64());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readFixed64());\n        return arr;\n    },\n    readPackedSFixed64: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readSFixed64());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readSFixed64());\n        return arr;\n    },\n\n    skip: function(val) {\n        var type = val & 0x7;\n        if (type === Pbf.Varint) while (this.buf[this.pos++] > 0x7f) {}\n        else if (type === Pbf.Bytes) this.pos = this.readVarint() + this.pos;\n        else if (type === Pbf.Fixed32) this.pos += 4;\n        else if (type === Pbf.Fixed64) this.pos += 8;\n        else throw new Error('Unimplemented type: ' + type);\n    },\n\n    // === WRITING =================================================================\n\n    writeTag: function(tag, type) {\n        this.writeVarint((tag << 3) | type);\n    },\n\n    realloc: function(min) {\n        var length = this.length || 16;\n\n        while (length < this.pos + min) length *= 2;\n\n        if (length !== this.length) {\n            var buf = new Uint8Array(length);\n            buf.set(this.buf);\n            this.buf = buf;\n            this.length = length;\n        }\n    },\n\n    finish: function() {\n        this.length = this.pos;\n        this.pos = 0;\n        return this.buf.subarray(0, this.length);\n    },\n\n    writeFixed32: function(val) {\n        this.realloc(4);\n        writeInt32(this.buf, val, this.pos);\n        this.pos += 4;\n    },\n\n    writeSFixed32: function(val) {\n        this.realloc(4);\n        writeInt32(this.buf, val, this.pos);\n        this.pos += 4;\n    },\n\n    writeFixed64: function(val) {\n        this.realloc(8);\n        writeInt32(this.buf, val & -1, this.pos);\n        writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);\n        this.pos += 8;\n    },\n\n    writeSFixed64: function(val) {\n        this.realloc(8);\n        writeInt32(this.buf, val & -1, this.pos);\n        writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);\n        this.pos += 8;\n    },\n\n    writeVarint: function(val) {\n        val = +val || 0;\n\n        if (val > 0xfffffff || val < 0) {\n            writeBigVarint(val, this);\n            return;\n        }\n\n        this.realloc(4);\n\n        this.buf[this.pos++] =           val & 0x7f  | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;\n        this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;\n        this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;\n        this.buf[this.pos++] =   (val >>> 7) & 0x7f;\n    },\n\n    writeSVarint: function(val) {\n        this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);\n    },\n\n    writeBoolean: function(val) {\n        this.writeVarint(Boolean(val));\n    },\n\n    writeString: function(str) {\n        str = String(str);\n        this.realloc(str.length * 4);\n\n        this.pos++; // reserve 1 byte for short string length\n\n        var startPos = this.pos;\n        // write the string directly to the buffer and see how much was written\n        this.pos = writeUtf8(this.buf, str, this.pos);\n        var len = this.pos - startPos;\n\n        if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);\n\n        // finally, write the message length in the reserved place and restore the position\n        this.pos = startPos - 1;\n        this.writeVarint(len);\n        this.pos += len;\n    },\n\n    writeFloat: function(val) {\n        this.realloc(4);\n        ieee754.write(this.buf, val, this.pos, true, 23, 4);\n        this.pos += 4;\n    },\n\n    writeDouble: function(val) {\n        this.realloc(8);\n        ieee754.write(this.buf, val, this.pos, true, 52, 8);\n        this.pos += 8;\n    },\n\n    writeBytes: function(buffer) {\n        var len = buffer.length;\n        this.writeVarint(len);\n        this.realloc(len);\n        for (var i = 0; i < len; i++) this.buf[this.pos++] = buffer[i];\n    },\n\n    writeRawMessage: function(fn, obj) {\n        this.pos++; // reserve 1 byte for short message length\n\n        // write the message directly to the buffer and see how much was written\n        var startPos = this.pos;\n        fn(obj, this);\n        var len = this.pos - startPos;\n\n        if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);\n\n        // finally, write the message length in the reserved place and restore the position\n        this.pos = startPos - 1;\n        this.writeVarint(len);\n        this.pos += len;\n    },\n\n    writeMessage: function(tag, fn, obj) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeRawMessage(fn, obj);\n    },\n\n    writePackedVarint:   function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedVarint, arr);   },\n    writePackedSVarint:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSVarint, arr);  },\n    writePackedBoolean:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedBoolean, arr);  },\n    writePackedFloat:    function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFloat, arr);    },\n    writePackedDouble:   function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedDouble, arr);   },\n    writePackedFixed32:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFixed32, arr);  },\n    writePackedSFixed32: function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSFixed32, arr); },\n    writePackedFixed64:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFixed64, arr);  },\n    writePackedSFixed64: function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSFixed64, arr); },\n\n    writeBytesField: function(tag, buffer) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeBytes(buffer);\n    },\n    writeFixed32Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeFixed32(val);\n    },\n    writeSFixed32Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeSFixed32(val);\n    },\n    writeFixed64Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeFixed64(val);\n    },\n    writeSFixed64Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeSFixed64(val);\n    },\n    writeVarintField: function(tag, val) {\n        this.writeTag(tag, Pbf.Varint);\n        this.writeVarint(val);\n    },\n    writeSVarintField: function(tag, val) {\n        this.writeTag(tag, Pbf.Varint);\n        this.writeSVarint(val);\n    },\n    writeStringField: function(tag, str) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeString(str);\n    },\n    writeFloatField: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeFloat(val);\n    },\n    writeDoubleField: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeDouble(val);\n    },\n    writeBooleanField: function(tag, val) {\n        this.writeVarintField(tag, Boolean(val));\n    }\n};\n\nfunction readVarintRemainder(l, s, p) {\n    var buf = p.buf,\n        h, b;\n\n    b = buf[p.pos++]; h  = (b & 0x70) >> 4;  if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x7f) << 3;  if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x7f) << 10; if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x7f) << 17; if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x7f) << 24; if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x01) << 31; if (b < 0x80) return toNum(l, h, s);\n\n    throw new Error('Expected varint not more than 10 bytes');\n}\n\nfunction readPackedEnd(pbf) {\n    return pbf.type === Pbf.Bytes ?\n        pbf.readVarint() + pbf.pos : pbf.pos + 1;\n}\n\nfunction toNum(low, high, isSigned) {\n    if (isSigned) {\n        return high * 0x100000000 + (low >>> 0);\n    }\n\n    return ((high >>> 0) * 0x100000000) + (low >>> 0);\n}\n\nfunction writeBigVarint(val, pbf) {\n    var low, high;\n\n    if (val >= 0) {\n        low  = (val % 0x100000000) | 0;\n        high = (val / 0x100000000) | 0;\n    } else {\n        low  = ~(-val % 0x100000000);\n        high = ~(-val / 0x100000000);\n\n        if (low ^ 0xffffffff) {\n            low = (low + 1) | 0;\n        } else {\n            low = 0;\n            high = (high + 1) | 0;\n        }\n    }\n\n    if (val >= 0x10000000000000000 || val < -0x10000000000000000) {\n        throw new Error('Given varint doesn\\'t fit into 10 bytes');\n    }\n\n    pbf.realloc(10);\n\n    writeBigVarintLow(low, high, pbf);\n    writeBigVarintHigh(high, pbf);\n}\n\nfunction writeBigVarintLow(low, high, pbf) {\n    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;\n    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;\n    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;\n    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;\n    pbf.buf[pbf.pos]   = low & 0x7f;\n}\n\nfunction writeBigVarintHigh(high, pbf) {\n    var lsb = (high & 0x07) << 4;\n\n    pbf.buf[pbf.pos++] |= lsb         | ((high >>>= 3) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f;\n}\n\nfunction makeRoomForExtraLength(startPos, len, pbf) {\n    var extraLen =\n        len <= 0x3fff ? 1 :\n        len <= 0x1fffff ? 2 :\n        len <= 0xfffffff ? 3 : Math.floor(Math.log(len) / (Math.LN2 * 7));\n\n    // if 1 byte isn't enough for encoding message length, shift the data to the right\n    pbf.realloc(extraLen);\n    for (var i = pbf.pos - 1; i >= startPos; i--) pbf.buf[i + extraLen] = pbf.buf[i];\n}\n\nfunction writePackedVarint(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeVarint(arr[i]);   }\nfunction writePackedSVarint(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeSVarint(arr[i]);  }\nfunction writePackedFloat(arr, pbf)    { for (var i = 0; i < arr.length; i++) pbf.writeFloat(arr[i]);    }\nfunction writePackedDouble(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeDouble(arr[i]);   }\nfunction writePackedBoolean(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeBoolean(arr[i]);  }\nfunction writePackedFixed32(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed32(arr[i]);  }\nfunction writePackedSFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed32(arr[i]); }\nfunction writePackedFixed64(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed64(arr[i]);  }\nfunction writePackedSFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed64(arr[i]); }\n\n// Buffer code below from https://github.com/feross/buffer, MIT-licensed\n\nfunction readUInt32(buf, pos) {\n    return ((buf[pos]) |\n        (buf[pos + 1] << 8) |\n        (buf[pos + 2] << 16)) +\n        (buf[pos + 3] * 0x1000000);\n}\n\nfunction writeInt32(buf, val, pos) {\n    buf[pos] = val;\n    buf[pos + 1] = (val >>> 8);\n    buf[pos + 2] = (val >>> 16);\n    buf[pos + 3] = (val >>> 24);\n}\n\nfunction readInt32(buf, pos) {\n    return ((buf[pos]) |\n        (buf[pos + 1] << 8) |\n        (buf[pos + 2] << 16)) +\n        (buf[pos + 3] << 24);\n}\n\nfunction readUtf8(buf, pos, end) {\n    var str = '';\n    var i = pos;\n\n    while (i < end) {\n        var b0 = buf[i];\n        var c = null; // codepoint\n        var bytesPerSequence =\n            b0 > 0xEF ? 4 :\n            b0 > 0xDF ? 3 :\n            b0 > 0xBF ? 2 : 1;\n\n        if (i + bytesPerSequence > end) break;\n\n        var b1, b2, b3;\n\n        if (bytesPerSequence === 1) {\n            if (b0 < 0x80) {\n                c = b0;\n            }\n        } else if (bytesPerSequence === 2) {\n            b1 = buf[i + 1];\n            if ((b1 & 0xC0) === 0x80) {\n                c = (b0 & 0x1F) << 0x6 | (b1 & 0x3F);\n                if (c <= 0x7F) {\n                    c = null;\n                }\n            }\n        } else if (bytesPerSequence === 3) {\n            b1 = buf[i + 1];\n            b2 = buf[i + 2];\n            if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80) {\n                c = (b0 & 0xF) << 0xC | (b1 & 0x3F) << 0x6 | (b2 & 0x3F);\n                if (c <= 0x7FF || (c >= 0xD800 && c <= 0xDFFF)) {\n                    c = null;\n                }\n            }\n        } else if (bytesPerSequence === 4) {\n            b1 = buf[i + 1];\n            b2 = buf[i + 2];\n            b3 = buf[i + 3];\n            if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {\n                c = (b0 & 0xF) << 0x12 | (b1 & 0x3F) << 0xC | (b2 & 0x3F) << 0x6 | (b3 & 0x3F);\n                if (c <= 0xFFFF || c >= 0x110000) {\n                    c = null;\n                }\n            }\n        }\n\n        if (c === null) {\n            c = 0xFFFD;\n            bytesPerSequence = 1;\n\n        } else if (c > 0xFFFF) {\n            c -= 0x10000;\n            str += String.fromCharCode(c >>> 10 & 0x3FF | 0xD800);\n            c = 0xDC00 | c & 0x3FF;\n        }\n\n        str += String.fromCharCode(c);\n        i += bytesPerSequence;\n    }\n\n    return str;\n}\n\nfunction readUtf8TextDecoder(buf, pos, end) {\n    return utf8TextDecoder.decode(buf.subarray(pos, end));\n}\n\nfunction writeUtf8(buf, str, pos) {\n    for (var i = 0, c, lead; i < str.length; i++) {\n        c = str.charCodeAt(i); // code point\n\n        if (c > 0xD7FF && c < 0xE000) {\n            if (lead) {\n                if (c < 0xDC00) {\n                    buf[pos++] = 0xEF;\n                    buf[pos++] = 0xBF;\n                    buf[pos++] = 0xBD;\n                    lead = c;\n                    continue;\n                } else {\n                    c = lead - 0xD800 << 10 | c - 0xDC00 | 0x10000;\n                    lead = null;\n                }\n            } else {\n                if (c > 0xDBFF || (i + 1 === str.length)) {\n                    buf[pos++] = 0xEF;\n                    buf[pos++] = 0xBF;\n                    buf[pos++] = 0xBD;\n                } else {\n                    lead = c;\n                }\n                continue;\n            }\n        } else if (lead) {\n            buf[pos++] = 0xEF;\n            buf[pos++] = 0xBF;\n            buf[pos++] = 0xBD;\n            lead = null;\n        }\n\n        if (c < 0x80) {\n            buf[pos++] = c;\n        } else {\n            if (c < 0x800) {\n                buf[pos++] = c >> 0x6 | 0xC0;\n            } else {\n                if (c < 0x10000) {\n                    buf[pos++] = c >> 0xC | 0xE0;\n                } else {\n                    buf[pos++] = c >> 0x12 | 0xF0;\n                    buf[pos++] = c >> 0xC & 0x3F | 0x80;\n                }\n                buf[pos++] = c >> 0x6 & 0x3F | 0x80;\n            }\n            buf[pos++] = c & 0x3F | 0x80;\n        }\n    }\n    return pos;\n}\n","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;","/**\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","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","import Protobuf from 'pbf';\nimport {MvtMapboxGeometry} from '../lib/types';\nimport VectorTileFeature from '../lib/mapbox-vector-tile/vector-tile-feature';\n\n/**\n * Classifies an array of rings into polygons with outer rings and holes\n * @param rings\n * @returns polygons\n */\nexport function classifyRings(rings: MvtMapboxGeometry) {\n  const len = rings.length;\n\n  if (len <= 1) return [rings];\n\n  const polygons: number[][][] = [];\n  let polygon: number[][] | undefined;\n  let ccw: boolean | undefined;\n\n  for (let i = 0; i < len; i++) {\n    const area = signedArea(rings[i]);\n    if (area === 0) continue; // eslint-disable-line no-continue\n\n    if (ccw === undefined) ccw = area < 0;\n\n    if (ccw === area < 0) {\n      if (polygon) polygons.push(polygon);\n      polygon = [rings[i]];\n    } else if (polygon) polygon.push(rings[i]);\n  }\n  if (polygon) polygons.push(polygon);\n\n  return polygons;\n}\n\n/**\n *\n * @param ring\n * @returns sum\n */\nexport function signedArea(ring: number[][]) {\n  let sum = 0;\n  for (let i = 0, j = ring.length - 1, p1: number[], p2: number[]; i < ring.length; j = i++) {\n    p1 = ring[i];\n    p2 = ring[j];\n    sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);\n  }\n  return sum;\n}\n\n/**\n *\n * @param tag\n * @param feature\n * @param pbf\n */\nexport function readFeature(tag: number, feature?: VectorTileFeature, pbf?: Protobuf): void {\n  if (feature && pbf) {\n    if (tag === 1) feature.id = pbf.readVarint();\n    else if (tag === 2) readTag(pbf, feature);\n    else if (tag === 3) feature.type = pbf.readVarint();\n    else if (tag === 4) feature._geometry = pbf.pos;\n  }\n}\n\n/**\n *\n * @param pbf\n * @param feature\n */\nexport function readTag(pbf: Protobuf, feature: VectorTileFeature): void {\n  const end = pbf.readVarint() + pbf.pos;\n\n  while (pbf.pos < end) {\n    const key = feature._keys[pbf.readVarint()];\n    const value = feature._values[pbf.readVarint()];\n    feature.properties[key] = value;\n  }\n}\n","// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.\nimport Protobuf from 'pbf';\nimport {MvtMapboxCoordinates, MvtMapboxGeometry} from '../types';\nimport {readFeature, classifyRings} from '../../helpers/mapbox-util-functions';\n\nexport default class VectorTileFeature {\n  properties: {[x: string]: string | number | boolean | null};\n  extent: any;\n  type: number;\n  id: number | null;\n  _pbf: Protobuf;\n  _geometry: number;\n  _keys: string[];\n  _values: (string | number | boolean | null)[];\n  static get types() {\n    return ['Unknown', 'Point', 'LineString', 'Polygon'];\n  }\n\n  constructor(\n    pbf: Protobuf,\n    end: number,\n    extent: any,\n    keys: string[],\n    values: (string | number | boolean | null)[]\n  ) {\n    // Public\n    this.properties = {};\n    this.extent = extent;\n    this.type = 0;\n    this.id = null;\n\n    // Private\n    this._pbf = pbf;\n    this._geometry = -1;\n    this._keys = keys;\n    this._values = values;\n\n    pbf.readFields(readFeature, this, end);\n  }\n\n  // eslint-disable-next-line complexity, max-statements\n  loadGeometry(): MvtMapboxGeometry {\n    const pbf = this._pbf;\n    pbf.pos = this._geometry;\n\n    const end = pbf.readVarint() + pbf.pos;\n    let cmd = 1;\n    let length = 0;\n    let x = 0;\n    let y = 0;\n    const lines: number[][][] = [];\n    let line: number[][] | undefined;\n\n    while (pbf.pos < end) {\n      if (length <= 0) {\n        const cmdLen = pbf.readVarint();\n        cmd = cmdLen & 0x7;\n        length = cmdLen >> 3;\n      }\n\n      length--;\n\n      if (cmd === 1 || cmd === 2) {\n        x += pbf.readSVarint();\n        y += pbf.readSVarint();\n\n        if (cmd === 1) {\n          // moveTo\n          if (line) lines.push(line);\n          line = [];\n        }\n        if (line) line.push([x, y]);\n      } else if (cmd === 7) {\n        // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90\n        if (line) {\n          line.push(line[0].slice()); // closePolygon\n        }\n      } else {\n        throw new Error(`unknown command ${cmd}`);\n      }\n    }\n\n    if (line) lines.push(line);\n\n    return lines;\n  }\n\n  // eslint-disable-next-line max-statements\n  bbox() {\n    const pbf = this._pbf;\n    pbf.pos = this._geometry;\n\n    const end = pbf.readVarint() + pbf.pos;\n    let cmd = 1;\n    let length = 0;\n    let x = 0;\n    let y = 0;\n    let x1 = Infinity;\n    let x2 = -Infinity;\n    let y1 = Infinity;\n    let y2 = -Infinity;\n\n    while (pbf.pos < end) {\n      if (length <= 0) {\n        const cmdLen = pbf.readVarint();\n        cmd = cmdLen & 0x7;\n        length = cmdLen >> 3;\n      }\n\n      length--;\n\n      if (cmd === 1 || cmd === 2) {\n        x += pbf.readSVarint();\n        y += pbf.readSVarint();\n        if (x < x1) x1 = x;\n        if (x > x2) x2 = x;\n        if (y < y1) y1 = y;\n        if (y > y2) y2 = y;\n      } else if (cmd !== 7) {\n        throw new Error(`unknown command ${cmd}`);\n      }\n    }\n\n    return [x1, y1, x2, y2];\n  }\n\n  _toGeoJSON(transform) {\n    let coords = this.loadGeometry();\n    let type = VectorTileFeature.types[this.type];\n    let i: number;\n    let j: number;\n\n    // eslint-disable-next-line default-case\n    switch (this.type) {\n      case 1:\n        const points: number[] = [];\n        for (i = 0; i < coords.length; i++) {\n          points[i] = coords[i][0];\n        }\n        coords = points;\n        transform(coords, this);\n        break;\n\n      case 2:\n        for (i = 0; i < coords.length; i++) {\n          transform(coords[i], this);\n        }\n        break;\n\n      case 3:\n        coords = classifyRings(coords);\n        for (i = 0; i < coords.length; i++) {\n          for (j = 0; j < coords[i].length; j++) {\n            transform(coords[i][j], this);\n          }\n        }\n        break;\n    }\n\n    if (coords.length === 1) {\n      coords = coords[0];\n    } else {\n      type = `Multi${type}`;\n    }\n\n    const result: MvtMapboxCoordinates = {\n      type: 'Feature',\n      geometry: {\n        type,\n        coordinates: coords\n      },\n      properties: this.properties\n    };\n\n    if (this.id !== null) {\n      result.id = this.id;\n    }\n\n    return result;\n  }\n\n  toGeoJSON(\n    options: {x: number; y: number; z: number} | ((data: number[], feature: {extent: any}) => void)\n  ): MvtMapboxCoordinates {\n    if (typeof options === 'function') {\n      return this._toGeoJSON(options);\n    }\n    const {x, y, z} = options;\n    const size = this.extent * Math.pow(2, z);\n    const x0 = this.extent * x;\n    const y0 = this.extent * y;\n\n    function project(line: number[]) {\n      for (let j = 0; j < line.length; j++) {\n        const p = line[j];\n        p[0] = ((p[0] + x0) * 360) / size - 180;\n        const y2 = 180 - ((p[1] + y0) * 360) / size;\n        p[1] = (360 / Math.PI) * Math.atan(Math.exp((y2 * Math.PI) / 180)) - 90;\n      }\n    }\n    return this._toGeoJSON(project);\n  }\n}\n","/* eslint-disable indent */\n// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.\n\nimport Protobuf from 'pbf';\nimport VectorTileFeature from './vector-tile-feature';\n\nexport default class VectorTileLayer {\n  version: number;\n  name: string;\n  extent: number;\n  length: number;\n  _pbf: Protobuf;\n  _keys: string[];\n  _values: (string | number | boolean | null)[];\n  _features: number[];\n  constructor(pbf: Protobuf, end: number) {\n    // Public\n    this.version = 1;\n    this.name = '';\n    this.extent = 4096;\n    this.length = 0;\n\n    // Private\n    this._pbf = pbf;\n    this._keys = [];\n    this._values = [];\n    this._features = [];\n\n    pbf.readFields(readLayer, this, end);\n\n    this.length = this._features.length;\n  }\n\n  /**\n   * return feature `i` from this layer as a `VectorTileFeature`\n   * @param index\n   * @returns feature\n   */\n\n  feature(i: number): VectorTileFeature {\n    if (i < 0 || i >= this._features.length) {\n      throw new Error('feature index out of bounds');\n    }\n\n    this._pbf.pos = this._features[i];\n\n    const end = this._pbf.readVarint() + this._pbf.pos;\n    return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);\n  }\n}\n\n/**\n *\n * @param tag\n * @param layer\n * @param pbf\n */\nfunction readLayer(tag: number, layer?: VectorTileLayer, pbf?: Protobuf): void {\n  if (layer && pbf) {\n    if (tag === 15) layer.version = pbf.readVarint();\n    else if (tag === 1) layer.name = pbf.readString();\n    else if (tag === 5) layer.extent = pbf.readVarint();\n    else if (tag === 2) layer._features.push(pbf.pos);\n    else if (tag === 3) layer._keys.push(pbf.readString());\n    else if (tag === 4) layer._values.push(readValueMessage(pbf));\n  }\n}\n\n/**\n *\n * @param pbf\n * @returns value\n */\nfunction readValueMessage(pbf: Protobuf) {\n  let value: string | number | boolean | null = null;\n  const end = pbf.readVarint() + pbf.pos;\n\n  while (pbf.pos < end) {\n    const tag = pbf.readVarint() >> 3;\n\n    value =\n      tag === 1\n        ? pbf.readString()\n        : tag === 2\n        ? pbf.readFloat()\n        : tag === 3\n        ? pbf.readDouble()\n        : tag === 4\n        ? pbf.readVarint64()\n        : tag === 5\n        ? pbf.readVarint()\n        : tag === 6\n        ? pbf.readSVarint()\n        : tag === 7\n        ? pbf.readBoolean()\n        : null;\n  }\n\n  return value;\n}\n","// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.\n\nimport VectorTileLayer from './vector-tile-layer';\nimport Protobuf from 'pbf';\n\nexport default class VectorTile {\n  layers: {[x: string]: VectorTileLayer};\n  constructor(pbf: Protobuf, end?: number) {\n    this.layers = pbf.readFields(readTile, {}, end);\n  }\n}\n\n/**\n *\n * @param tag\n * @param layers\n * @param pbf\n */\nfunction readTile(tag: number, layers?: {[x: string]: VectorTileLayer}, pbf?: Protobuf): void {\n  if (tag === 3) {\n    if (pbf) {\n      const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);\n      if (layer.length && layers) {\n        layers[layer.name] = layer;\n      }\n    }\n  }\n}\n","import assert from './assert';\nconst RADIANS_TO_DEGREES = 1 / Math.PI * 180;\nconst DEGREES_TO_RADIANS = 1 / 180 * Math.PI;\nconst config = {};\nconfig.EPSILON = 1e-12;\nconfig.debug = false;\nconfig.precision = 4;\nconfig.printTypes = false;\nconfig.printDegrees = false;\nconfig.printRowMajor = true;\nexport { config };\nexport function configure(options = {}) {\n  for (const key in options) {\n    assert(key in config);\n    config[key] = options[key];\n  }\n\n  return config;\n}\n\nfunction round(value) {\n  return Math.round(value / config.EPSILON) * config.EPSILON;\n}\n\nexport function formatValue(value, {\n  precision = config.precision || 4\n} = {}) {\n  value = round(value);\n  return \"\".concat(parseFloat(value.toPrecision(precision)));\n}\nexport function isArray(value) {\n  return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);\n}\n\nfunction duplicateArray(array) {\n  return array.clone ? array.clone() : new Array(array.length);\n}\n\nexport function clone(array) {\n  return array.clone ? array.clone() : new Array(...array);\n}\n\nfunction map(value, func, result) {\n  if (isArray(value)) {\n    result = result || duplicateArray(value);\n\n    for (let i = 0; i < result.length && i < value.length; ++i) {\n      result[i] = func(value[i], i, result);\n    }\n\n    return result;\n  }\n\n  return func(value);\n}\n\nexport function toRadians(degrees) {\n  return radians(degrees);\n}\nexport function toDegrees(radians) {\n  return degrees(radians);\n}\nexport function radians(degrees, result) {\n  return map(degrees, degrees => degrees * DEGREES_TO_RADIANS, result);\n}\nexport function degrees(radians, result) {\n  return map(radians, radians => radians * RADIANS_TO_DEGREES, result);\n}\nexport function sin(radians) {\n  return map(radians, angle => Math.sin(angle));\n}\nexport function cos(radians) {\n  return map(radians, angle => Math.cos(angle));\n}\nexport function tan(radians) {\n  return map(radians, angle => Math.tan(angle));\n}\nexport function asin(radians) {\n  return map(radians, angle => Math.asin(angle));\n}\nexport function acos(radians) {\n  return map(radians, angle => Math.acos(angle));\n}\nexport function atan(radians) {\n  return map(radians, angle => Math.atan(angle));\n}\nexport function clamp(value, min, max) {\n  return map(value, value => Math.max(min, Math.min(max, value)));\n}\nexport function lerp(a, b, t) {\n  if (isArray(a)) {\n    return a.map((ai, i) => lerp(ai, b[i], t));\n  }\n\n  return t * b + (1 - t) * a;\n}\nexport function equals(a, b, epsilon) {\n  const oldEpsilon = config.EPSILON;\n\n  if (epsilon) {\n    config.EPSILON = epsilon;\n  }\n\n  try {\n    if (a === b) {\n      return true;\n    }\n\n    if (isArray(a) && isArray(b)) {\n      if (a.length !== b.length) {\n        return false;\n      }\n\n      for (let i = 0; i < a.length; ++i) {\n        if (!equals(a[i], b[i])) {\n          return false;\n        }\n      }\n\n      return true;\n    }\n\n    if (a && a.equals) {\n      return a.equals(b);\n    }\n\n    if (b && b.equals) {\n      return b.equals(a);\n    }\n\n    if (Number.isFinite(a) && Number.isFinite(b)) {\n      return Math.abs(a - b) <= config.EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));\n    }\n\n    return false;\n  } finally {\n    config.EPSILON = oldEpsilon;\n  }\n}\nexport function exactEquals(a, b) {\n  if (a === b) {\n    return true;\n  }\n\n  if (a && typeof a === 'object' && b && typeof b === 'object') {\n    if (a.constructor !== b.constructor) {\n      return false;\n    }\n\n    if (a.exactEquals) {\n      return a.exactEquals(b);\n    }\n  }\n\n  if (isArray(a) && isArray(b)) {\n    if (a.length !== b.length) {\n      return false;\n    }\n\n    for (let i = 0; i < a.length; ++i) {\n      if (!exactEquals(a[i], b[i])) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  return false;\n}\nexport function withEpsilon(EPSILON, func) {\n  const oldPrecision = config.EPSILON;\n  config.EPSILON = EPSILON;\n  let value;\n\n  try {\n    value = func();\n  } finally {\n    config.EPSILON = oldPrecision;\n  }\n\n  return value;\n}\n//# sourceMappingURL=common.js.map","import { equals } from '@math.gl/core';\nexport const WINDING = {\n  CLOCKWISE: 1,\n  COUNTER_CLOCKWISE: -1\n};\nexport function modifyPolygonWindingDirection(points, direction, options = {}) {\n  const windingDirection = getPolygonWindingDirection(points, options);\n\n  if (windingDirection !== direction) {\n    reversePolygon(points, options);\n    return true;\n  }\n\n  return false;\n}\nexport function getPolygonWindingDirection(points, options = {}) {\n  return Math.sign(getPolygonSignedArea(points, options));\n}\nexport function getPolygonSignedArea(points, options = {}) {\n  const {\n    start = 0,\n    end = points.length\n  } = options;\n  const dim = options.size || 2;\n  let area = 0;\n\n  for (let i = start, j = end - dim; i < end; i += dim) {\n    area += (points[i] - points[j]) * (points[i + 1] + points[j + 1]);\n    j = i;\n  }\n\n  return area / 2;\n}\nexport function forEachSegmentInPolygon(points, visitor, options = {}) {\n  const {\n    start = 0,\n    end = points.length,\n    size = 2,\n    isClosed\n  } = options;\n  const numPoints = (end - start) / size;\n\n  for (let i = 0; i < numPoints - 1; ++i) {\n    visitor(points[start + i * size], points[start + i * size + 1], points[start + (i + 1) * size], points[start + (i + 1) * size + 1], i, i + 1);\n  }\n\n  const endPointIndex = start + (numPoints - 1) * size;\n  const isClosedEx = isClosed || equals(points[start], points[endPointIndex]) && equals(points[start + 1], points[endPointIndex + 1]);\n\n  if (!isClosedEx) {\n    visitor(points[endPointIndex], points[endPointIndex + 1], points[start], points[start + 1], numPoints - 1, 0);\n  }\n}\n\nfunction reversePolygon(points, options) {\n  const {\n    start = 0,\n    end = points.length,\n    size = 2\n  } = options;\n  const numPoints = (end - start) / size;\n  const numSwaps = Math.floor(numPoints / 2);\n\n  for (let i = 0; i < numSwaps; ++i) {\n    const b1 = start + i * size;\n    const b2 = start + (numPoints - 1 - i) * size;\n\n    for (let j = 0; j < size; ++j) {\n      const tmp = points[b1 + j];\n      points[b1 + j] = points[b2 + j];\n      points[b2 + j] = tmp;\n    }\n  }\n}\n\nexport function modifyPolygonWindingDirectionPoints(points, direction, options = {}) {\n  const currentDirection = getPolygonWindingDirectionPoints(points, options);\n\n  if (currentDirection !== direction) {\n    points.reverse();\n    return true;\n  }\n\n  return false;\n}\nexport function getPolygonWindingDirectionPoints(points, options = {}) {\n  return Math.sign(getPolygonSignedAreaPoints(points, options));\n}\nexport function getPolygonSignedAreaPoints(points, options = {}) {\n  const {\n    start = 0,\n    end = points.length\n  } = options;\n  let area = 0;\n\n  for (let i = start, j = end - 1; i < end; ++i) {\n    area += (points[i][0] - points[j][0]) * (points[i][1] + points[j][1]);\n    j = i;\n  }\n\n  return area / 2;\n}\nexport function forEachSegmentInPolygonPoints(points, visitor, options = {}) {\n  const {\n    start = 0,\n    end = points.length,\n    isClosed\n  } = options;\n\n  for (let i = start; i < end - 1; ++i) {\n    visitor(points[i], points[i + 1], i, i + 1);\n  }\n\n  const isClosedEx = isClosed || equals(points[end - 1], points[0]);\n\n  if (!isClosedEx) {\n    visitor(points[end - 1], points[0], end - 1, 0);\n  }\n}\n//# sourceMappingURL=polygon-utils.js.map","import { getPolygonSignedArea } from './polygon-utils';\nexport function earcut(data, holeIndices, dim, areas) {\n  dim = dim || 2;\n  const hasHoles = holeIndices && holeIndices.length;\n  const outerLen = hasHoles ? holeIndices[0] * dim : data.length;\n  let outerNode = linkedList(data, 0, outerLen, dim, true, areas && areas[0]);\n  const triangles = [];\n  if (!outerNode || outerNode.next === outerNode.prev) return triangles;\n  let invSize;\n  let maxX;\n  let maxY;\n  let minX;\n  let minY;\n  let x;\n  let y;\n  if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim, areas);\n\n  if (data.length > 80 * dim) {\n    minX = maxX = data[0];\n    minY = maxY = data[1];\n\n    for (let i = dim; i < outerLen; i += dim) {\n      x = data[i];\n      y = data[i + 1];\n      if (x < minX) minX = x;\n      if (y < minY) minY = y;\n      if (x > maxX) maxX = x;\n      if (y > maxY) maxY = y;\n    }\n\n    invSize = Math.max(maxX - minX, maxY - minY);\n    invSize = invSize !== 0 ? 1 / invSize : 0;\n  }\n\n  earcutLinked(outerNode, triangles, dim, minX, minY, invSize);\n  return triangles;\n}\n\nfunction linkedList(data, start, end, dim, clockwise, area) {\n  let i;\n  let last;\n\n  if (area === undefined) {\n    area = getPolygonSignedArea(data, {\n      start,\n      end,\n      size: dim\n    });\n  }\n\n  if (clockwise === area < 0) {\n    for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);\n  } else {\n    for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);\n  }\n\n  if (last && equals(last, last.next)) {\n    removeNode(last);\n    last = last.next;\n  }\n\n  return last;\n}\n\nfunction filterPoints(start, end) {\n  if (!start) return start;\n  if (!end) end = start;\n  let p = start;\n  let again;\n\n  do {\n    again = false;\n\n    if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {\n      removeNode(p);\n      p = end = p.prev;\n      if (p === p.next) break;\n      again = true;\n    } else {\n      p = p.next;\n    }\n  } while (again || p !== end);\n\n  return end;\n}\n\nfunction earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {\n  if (!ear) return;\n  if (!pass && invSize) indexCurve(ear, minX, minY, invSize);\n  let stop = ear;\n  let prev;\n  let next;\n\n  while (ear.prev !== ear.next) {\n    prev = ear.prev;\n    next = ear.next;\n\n    if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {\n      triangles.push(prev.i / dim);\n      triangles.push(ear.i / dim);\n      triangles.push(next.i / dim);\n      removeNode(ear);\n      ear = next.next;\n      stop = next.next;\n      continue;\n    }\n\n    ear = next;\n\n    if (ear === stop) {\n      if (!pass) {\n        earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);\n      } else if (pass === 1) {\n        ear = cureLocalIntersections(filterPoints(ear), triangles, dim);\n        earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);\n      } else if (pass === 2) {\n        splitEarcut(ear, triangles, dim, minX, minY, invSize);\n      }\n\n      break;\n    }\n  }\n}\n\nfunction isEar(ear) {\n  const a = ear.prev;\n  const b = ear;\n  const c = ear.next;\n  if (area(a, b, c) >= 0) return false;\n  let p = ear.next.next;\n\n  while (p !== ear.prev) {\n    if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;\n    p = p.next;\n  }\n\n  return true;\n}\n\nfunction isEarHashed(ear, minX, minY, invSize) {\n  const a = ear.prev;\n  const b = ear;\n  const c = ear.next;\n  if (area(a, b, c) >= 0) return false;\n  const minTX = a.x < b.x ? a.x < c.x ? a.x : c.x : b.x < c.x ? b.x : c.x;\n  const minTY = a.y < b.y ? a.y < c.y ? a.y : c.y : b.y < c.y ? b.y : c.y;\n  const maxTX = a.x > b.x ? a.x > c.x ? a.x : c.x : b.x > c.x ? b.x : c.x;\n  const maxTY = a.y > b.y ? a.y > c.y ? a.y : c.y : b.y > c.y ? b.y : c.y;\n  const minZ = zOrder(minTX, minTY, minX, minY, invSize);\n  const maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);\n  let p = ear.prevZ;\n  let n = ear.nextZ;\n\n  while (p && p.z >= minZ && n && n.z <= maxZ) {\n    if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;\n    p = p.prevZ;\n    if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;\n    n = n.nextZ;\n  }\n\n  while (p && p.z >= minZ) {\n    if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;\n    p = p.prevZ;\n  }\n\n  while (n && n.z <= maxZ) {\n    if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;\n    n = n.nextZ;\n  }\n\n  return true;\n}\n\nfunction cureLocalIntersections(start, triangles, dim) {\n  let p = start;\n\n  do {\n    const a = p.prev;\n    const b = p.next.next;\n\n    if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {\n      triangles.push(a.i / dim);\n      triangles.push(p.i / dim);\n      triangles.push(b.i / dim);\n      removeNode(p);\n      removeNode(p.next);\n      p = start = b;\n    }\n\n    p = p.next;\n  } while (p !== start);\n\n  return filterPoints(p);\n}\n\nfunction splitEarcut(start, triangles, dim, minX, minY, invSize) {\n  let a = start;\n\n  do {\n    let b = a.next.next;\n\n    while (b !== a.prev) {\n      if (a.i !== b.i && isValidDiagonal(a, b)) {\n        let c = splitPolygon(a, b);\n        a = filterPoints(a, a.next);\n        c = filterPoints(c, c.next);\n        earcutLinked(a, triangles, dim, minX, minY, invSize);\n        earcutLinked(c, triangles, dim, minX, minY, invSize);\n        return;\n      }\n\n      b = b.next;\n    }\n\n    a = a.next;\n  } while (a !== start);\n}\n\nfunction eliminateHoles(data, holeIndices, outerNode, dim, areas) {\n  const queue = [];\n  let i;\n  let len;\n  let start;\n  let end;\n  let list;\n\n  for (i = 0, len = holeIndices.length; i < len; i++) {\n    start = holeIndices[i] * dim;\n    end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;\n    list = linkedList(data, start, end, dim, false, areas && areas[i + 1]);\n    if (list === list.next) list.steiner = true;\n    queue.push(getLeftmost(list));\n  }\n\n  queue.sort(compareX);\n\n  for (i = 0; i < queue.length; i++) {\n    eliminateHole(queue[i], outerNode);\n    outerNode = filterPoints(outerNode, outerNode.next);\n  }\n\n  return outerNode;\n}\n\nfunction compareX(a, b) {\n  return a.x - b.x;\n}\n\nfunction eliminateHole(hole, outerNode) {\n  outerNode = findHoleBridge(hole, outerNode);\n\n  if (outerNode) {\n    const b = splitPolygon(outerNode, hole);\n    filterPoints(outerNode, outerNode.next);\n    filterPoints(b, b.next);\n  }\n}\n\nfunction findHoleBridge(hole, outerNode) {\n  let p = outerNode;\n  const hx = hole.x;\n  const hy = hole.y;\n  let qx = -Infinity;\n  let m;\n\n  do {\n    if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {\n      const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);\n\n      if (x <= hx && x > qx) {\n        qx = x;\n\n        if (x === hx) {\n          if (hy === p.y) return p;\n          if (hy === p.next.y) return p.next;\n        }\n\n        m = p.x < p.next.x ? p : p.next;\n      }\n    }\n\n    p = p.next;\n  } while (p !== outerNode);\n\n  if (!m) return null;\n  if (hx === qx) return m;\n  const stop = m;\n  const mx = m.x;\n  const my = m.y;\n  let tanMin = Infinity;\n  let tan;\n  p = m;\n\n  do {\n    if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {\n      tan = Math.abs(hy - p.y) / (hx - p.x);\n\n      if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {\n        m = p;\n        tanMin = tan;\n      }\n    }\n\n    p = p.next;\n  } while (p !== stop);\n\n  return m;\n}\n\nfunction sectorContainsSector(m, p) {\n  return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;\n}\n\nfunction indexCurve(start, minX, minY, invSize) {\n  let p = start;\n\n  do {\n    if (p.z === null) p.z = zOrder(p.x, p.y, minX, minY, invSize);\n    p.prevZ = p.prev;\n    p.nextZ = p.next;\n    p = p.next;\n  } while (p !== start);\n\n  p.prevZ.nextZ = null;\n  p.prevZ = null;\n  sortLinked(p);\n}\n\nfunction sortLinked(list) {\n  let e;\n  let i;\n  let inSize = 1;\n  let numMerges;\n  let p;\n  let pSize;\n  let q;\n  let qSize;\n  let tail;\n\n  do {\n    p = list;\n    list = null;\n    tail = null;\n    numMerges = 0;\n\n    while (p) {\n      numMerges++;\n      q = p;\n      pSize = 0;\n\n      for (i = 0; i < inSize; i++) {\n        pSize++;\n        q = q.nextZ;\n        if (!q) break;\n      }\n\n      qSize = inSize;\n\n      while (pSize > 0 || qSize > 0 && q) {\n        if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {\n          e = p;\n          p = p.nextZ;\n          pSize--;\n        } else {\n          e = q;\n          q = q.nextZ;\n          qSize--;\n        }\n\n        if (tail) tail.nextZ = e;else list = e;\n        e.prevZ = tail;\n        tail = e;\n      }\n\n      p = q;\n    }\n\n    tail.nextZ = null;\n    inSize *= 2;\n  } while (numMerges > 1);\n\n  return list;\n}\n\nfunction zOrder(x, y, minX, minY, invSize) {\n  x = 32767 * (x - minX) * invSize;\n  y = 32767 * (y - minY) * invSize;\n  x = (x | x << 8) & 0x00ff00ff;\n  x = (x | x << 4) & 0x0f0f0f0f;\n  x = (x | x << 2) & 0x33333333;\n  x = (x | x << 1) & 0x55555555;\n  y = (y | y << 8) & 0x00ff00ff;\n  y = (y | y << 4) & 0x0f0f0f0f;\n  y = (y | y << 2) & 0x33333333;\n  y = (y | y << 1) & 0x55555555;\n  return x | y << 1;\n}\n\nfunction getLeftmost(start) {\n  let p = start;\n  let leftmost = start;\n\n  do {\n    if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y) leftmost = p;\n    p = p.next;\n  } while (p !== start);\n\n  return leftmost;\n}\n\nfunction pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {\n  return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 && (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 && (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;\n}\n\nfunction isValidDiagonal(a, b) {\n  return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && (area(a.prev, a, b.prev) || area(a, b.prev, b)) || equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);\n}\n\nfunction area(p, q, r) {\n  return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);\n}\n\nfunction equals(p1, p2) {\n  return p1.x === p2.x && p1.y === p2.y;\n}\n\nfunction intersects(p1, q1, p2, q2) {\n  const o1 = sign(area(p1, q1, p2));\n  const o2 = sign(area(p1, q1, q2));\n  const o3 = sign(area(p2, q2, p1));\n  const o4 = sign(area(p2, q2, q1));\n  if (o1 !== o2 && o3 !== o4) return true;\n  if (o1 === 0 && onSegment(p1, p2, q1)) return true;\n  if (o2 === 0 && onSegment(p1, q2, q1)) return true;\n  if (o3 === 0 && onSegment(p2, p1, q2)) return true;\n  if (o4 === 0 && onSegment(p2, q1, q2)) return true;\n  return false;\n}\n\nfunction onSegment(p, q, r) {\n  return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);\n}\n\nfunction sign(num) {\n  return num > 0 ? 1 : num < 0 ? -1 : 0;\n}\n\nfunction intersectsPolygon(a, b) {\n  let p = a;\n\n  do {\n    if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b)) return true;\n    p = p.next;\n  } while (p !== a);\n\n  return false;\n}\n\nfunction locallyInside(a, b) {\n  return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;\n}\n\nfunction middleInside(a, b) {\n  let p = a;\n  let inside = false;\n  const px = (a.x + b.x) / 2;\n  const py = (a.y + b.y) / 2;\n\n  do {\n    if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x) inside = !inside;\n    p = p.next;\n  } while (p !== a);\n\n  return inside;\n}\n\nfunction splitPolygon(a, b) {\n  const a2 = new Node(a.i, a.x, a.y);\n  const b2 = new Node(b.i, b.x, b.y);\n  const an = a.next;\n  const bp = b.prev;\n  a.next = b;\n  b.prev = a;\n  a2.next = an;\n  an.prev = a2;\n  b2.next = a2;\n  a2.prev = b2;\n  bp.next = b2;\n  b2.prev = bp;\n  return b2;\n}\n\nfunction insertNode(i, x, y, last) {\n  const p = new Node(i, x, y);\n\n  if (!last) {\n    p.prev = p;\n    p.next = p;\n  } else {\n    p.next = last.next;\n    p.prev = last;\n    last.next.prev = p;\n    last.next = p;\n  }\n\n  return p;\n}\n\nfunction removeNode(p) {\n  p.next.prev = p.prev;\n  p.prev.next = p.next;\n  if (p.prevZ) p.prevZ.nextZ = p.nextZ;\n  if (p.nextZ) p.nextZ.prevZ = p.prevZ;\n}\n\nfunction Node(i, x, y) {\n  this.i = i;\n  this.x = x;\n  this.y = y;\n  this.prev = null;\n  this.next = null;\n  this.z = null;\n  this.prevZ = null;\n  this.nextZ = null;\n  this.steiner = false;\n}\n//# sourceMappingURL=earcut.js.map","import Protobuf from 'pbf';\nimport {getPolygonSignedArea} from '@math.gl/polygon';\nimport {MvtBinaryGeometry} from '../lib/types';\nimport VectorTileFeature from '../lib/binary-vector-tile/vector-tile-feature';\n\n/**\n * Classifies an array of rings into polygons with outer rings and holes\n * The function also detects holes which have zero area and\n * removes them. In doing so it modifies the input\n * `geom.data` array to remove the unneeded data\n *\n * @param geometry\n * @returns object\n */\n// eslint-disable-next-line max-statements\nexport function classifyRings(geom: MvtBinaryGeometry) {\n  const len = geom.lines.length;\n\n  if (len <= 1) {\n    return {\n      data: geom.data,\n      areas: [[getPolygonSignedArea(geom.data)]],\n      lines: [geom.lines]\n    };\n  }\n\n  const areas: any[] = [];\n  const polygons: any[] = [];\n  let ringAreas: number[] = [];\n  let polygon: number[] = [];\n  let ccw: boolean | undefined;\n  let offset = 0;\n\n  for (let endIndex: number, i = 0, startIndex: number; i < len; i++) {\n    startIndex = geom.lines[i] - offset;\n\n    endIndex = geom.lines[i + 1] - offset || geom.data.length;\n    const shape = geom.data.slice(startIndex, endIndex);\n    const area = getPolygonSignedArea(shape);\n\n    if (area === 0) {\n      // This polygon has no area, so remove it from the shape\n      // Remove the section from the data array\n      const before = geom.data.slice(0, startIndex);\n      const after = geom.data.slice(endIndex);\n      geom.data = before.concat(after);\n\n      // Need to offset any remaining indices as we have\n      // modified the data buffer\n      offset += endIndex - startIndex;\n\n      // Do not add this index to the output and process next shape\n      continue; // eslint-disable-line no-continue\n    }\n\n    if (ccw === undefined) ccw = area < 0;\n\n    if (ccw === area < 0) {\n      if (polygon.length) {\n        areas.push(ringAreas);\n        polygons.push(polygon);\n      }\n      polygon = [startIndex];\n      ringAreas = [area];\n    } else {\n      ringAreas.push(area);\n      polygon.push(startIndex);\n    }\n  }\n  if (ringAreas) areas.push(ringAreas);\n  if (polygon.length) polygons.push(polygon);\n\n  return {areas, lines: polygons, data: geom.data};\n}\n\n/**\n *\n * @param data\n * @param x0\n * @param y0\n * @param size\n */\nexport function project(data: number[], x0: number, y0: number, size: number): void {\n  for (let j = 0, jl = data.length; j < jl; j += 2) {\n    data[j] = ((data[j] + x0) * 360) / size - 180;\n    const y2 = 180 - ((data[j + 1] + y0) * 360) / size;\n    data[j + 1] = (360 / Math.PI) * Math.atan(Math.exp((y2 * Math.PI) / 180)) - 90;\n  }\n}\n\n/**\n * All code below is unchanged from the original Mapbox implemenation\n *\n * @param tag\n * @param feature\n * @param pbf\n */\nexport function readFeature(tag: number, feature?: VectorTileFeature, pbf?: Protobuf): void {\n  if (feature && pbf) {\n    if (tag === 1) feature.id = pbf.readVarint();\n    else if (tag === 2) readTag(pbf, feature);\n    else if (tag === 3) feature.type = pbf.readVarint();\n    else if (tag === 4) feature._geometry = pbf.pos;\n  }\n}\n\n/**\n * @param pbf\n * @param feature\n */\nexport function readTag(pbf: Protobuf, feature: VectorTileFeature): void {\n  const end = pbf.readVarint() + pbf.pos;\n\n  while (pbf.pos < end) {\n    const key = feature._keys[pbf.readVarint()];\n    const value = feature._values[pbf.readVarint()];\n    feature.properties[key] = value;\n  }\n}\n","// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.\n\nimport Protobuf from 'pbf';\nimport {MvtBinaryCoordinates, MvtBinaryGeometry, MvtFirstPassedData} from '../types';\nimport {classifyRings, project, readFeature} from '../../helpers/binary-util-functions';\n\n// Reduce GC by reusing variables\nlet endPos: number;\nlet cmd: number;\nlet cmdLen: number;\nlet length: number;\nlet x: number;\nlet y: number;\nlet i: number;\n\nexport const TEST_EXPORTS = {\n  classifyRings\n};\n\nexport default class VectorTileFeature {\n  properties: {[x: string]: string | number | boolean | null};\n  extent: any;\n  type: number;\n  id: number | null;\n  _pbf: Protobuf;\n  _geometry: number;\n  _keys: string[];\n  _values: (string | number | boolean | null)[];\n  _firstPassData: MvtFirstPassedData;\n  static get types() {\n    return ['Unknown', 'Point', 'LineString', 'Polygon'];\n  }\n\n  // eslint-disable-next-line max-params\n  constructor(\n    pbf: Protobuf,\n    end: number,\n    extent: any,\n    keys: string[],\n    values: (string | number | boolean | null)[],\n    firstPassData: MvtFirstPassedData\n  ) {\n    // Public\n    this.properties = {};\n    this.extent = extent;\n    this.type = 0;\n    this.id = null;\n\n    // Private\n    this._pbf = pbf;\n    this._geometry = -1;\n    this._keys = keys;\n    this._values = values;\n    this._firstPassData = firstPassData;\n\n    pbf.readFields(readFeature, this, end);\n  }\n\n  // eslint-disable-next-line complexity, max-statements\n  loadGeometry(): MvtBinaryGeometry {\n    const pbf = this._pbf;\n    pbf.pos = this._geometry;\n\n    endPos = pbf.readVarint() + pbf.pos;\n    cmd = 1;\n    length = 0;\n    x = 0;\n    y = 0;\n    i = 0;\n\n    // Note: I attempted to replace the `data` array with a\n    // Float32Array, but performance was worse, both using\n    // `set()` and direct index access. Also, we cannot\n    // know how large the buffer should be, so it would\n    // increase memory usage\n    const lines: number[] = []; // Indices where lines start\n    const data: number[] = []; // Flat array of coordinate data\n\n    while (pbf.pos < endPos) {\n      if (length <= 0) {\n        cmdLen = pbf.readVarint();\n        cmd = cmdLen & 0x7;\n        length = cmdLen >> 3;\n      }\n\n      length--;\n\n      if (cmd === 1 || cmd === 2) {\n        x += pbf.readSVarint();\n        y += pbf.readSVarint();\n\n        if (cmd === 1) {\n          // New line\n          lines.push(i);\n        }\n        data.push(x, y);\n        i += 2;\n      } else if (cmd === 7) {\n        // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90\n        if (i > 0) {\n          const start = lines[lines.length - 1]; // start index of polygon\n          data.push(data[start], data[start + 1]); // closePolygon\n          i += 2;\n        }\n      } else {\n        throw new Error(`unknown command ${cmd}`);\n      }\n    }\n\n    return {data, lines};\n  }\n\n  /**\n   *\n   * @param transform\n   * @returns result\n   */\n  _toBinaryCoordinates(transform) {\n    // Expands the protobuf data to an intermediate `lines`\n    // data format, which maps closely to the binary data buffers.\n    // It is similar to GeoJSON, but rather than storing the coordinates\n    // in multidimensional arrays, we have a 1D `data` with all the\n    // coordinates, and then index into this using the `lines`\n    // parameter, e.g.\n    //\n    // geometry: {\n    //   type: 'Point', data: [1,2], lines: [0]\n    // }\n    // geometry: {\n    //   type: 'LineString', data: [1,2,3,4,...], lines: [0]\n    // }\n    // geometry: {\n    //   type: 'Polygon', data: [1,2,3,4,...], lines: [[0, 2]]\n    // }\n    // Thus the lines member lets us look up the relevant range\n    // from the data array.\n    // The Multi* versions of the above types share the same data\n    // structure, just with multiple elements in the lines array\n    let geom = this.loadGeometry();\n\n    // Apply the supplied transformation to data\n    transform(geom.data, this);\n\n    const coordLength = 2;\n\n    // eslint-disable-next-line default-case\n    switch (this.type) {\n      case 1: // Point\n        this._firstPassData.pointFeaturesCount++;\n        this._firstPassData.pointPositionsCount += geom.lines.length;\n        break;\n\n      case 2: // LineString\n        this._firstPassData.lineFeaturesCount++;\n        this._firstPassData.linePathsCount += geom.lines.length;\n        this._firstPassData.linePositionsCount += geom.data.length / coordLength;\n        break;\n\n      case 3: // Polygon\n        const classified = classifyRings(geom);\n\n        // Unlike Point & LineString geom.lines is a 2D array, thanks\n        // to the classifyRings method\n        this._firstPassData.polygonFeaturesCount++;\n        this._firstPassData.polygonObjectsCount += classified.lines.length;\n\n        for (const lines of classified.lines) {\n          this._firstPassData.polygonRingsCount += lines.length;\n        }\n        this._firstPassData.polygonPositionsCount += classified.data.length / coordLength;\n\n        geom = classified;\n        break;\n    }\n\n    geom.type = VectorTileFeature.types[this.type];\n    if (geom.lines.length > 1) {\n      geom.type = `Multi${geom.type}`;\n    }\n\n    const result: MvtBinaryCoordinates = {\n      type: 'Feature',\n      geometry: geom,\n      properties: this.properties\n    };\n\n    if (this.id !== null) {\n      result.id = this.id;\n    }\n\n    return result;\n  }\n\n  toBinaryCoordinates(\n    options: {x: number; y: number; z: number} | ((data: number[], feature: {extent: any}) => void)\n  ): MvtBinaryCoordinates {\n    if (typeof options === 'function') {\n      return this._toBinaryCoordinates(options);\n    }\n    return this._toBinaryCoordinates(project);\n  }\n}\n","/* eslint-disable indent */\n// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.\n\nimport VectorTileFeature from './vector-tile-feature';\nimport Protobuf from 'pbf';\nimport {MvtFirstPassedData} from '../types';\n\nexport default class VectorTileLayer {\n  version: number;\n  name: string;\n  extent: number;\n  length: number;\n  _pbf: Protobuf;\n  _keys: string[];\n  _values: (string | number | boolean | null)[];\n  _features: number[];\n  constructor(pbf: Protobuf, end: number) {\n    // Public\n    this.version = 1;\n    this.name = '';\n    this.extent = 4096;\n    this.length = 0;\n\n    // Private\n    this._pbf = pbf;\n    this._keys = [];\n    this._values = [];\n    this._features = [];\n\n    pbf.readFields(readLayer, this, end);\n\n    this.length = this._features.length;\n  }\n\n  /**\n   * return feature `i` from this layer as a `VectorTileFeature`\n   *\n   * @param index\n   * @param firstPassData\n   * @returns {VectorTileFeature}\n   */\n  feature(i: number, firstPassData: MvtFirstPassedData): VectorTileFeature {\n    if (i < 0 || i >= this._features.length) {\n      throw new Error('feature index out of bounds');\n    }\n\n    this._pbf.pos = this._features[i];\n\n    const end = this._pbf.readVarint() + this._pbf.pos;\n    return new VectorTileFeature(\n      this._pbf,\n      end,\n      this.extent,\n      this._keys,\n      this._values,\n      firstPassData\n    );\n  }\n}\n\n/**\n *\n * @param tag\n * @param layer\n * @param pbf\n */\nfunction readLayer(tag: number, layer?: VectorTileLayer, pbf?: Protobuf): void {\n  if (layer && pbf) {\n    if (tag === 15) layer.version = pbf.readVarint();\n    else if (tag === 1) layer.name = pbf.readString();\n    else if (tag === 5) layer.extent = pbf.readVarint();\n    else if (tag === 2) layer._features.push(pbf.pos);\n    else if (tag === 3) layer._keys.push(pbf.readString());\n    else if (tag === 4) layer._values.push(readValueMessage(pbf));\n  }\n}\n\n/**\n *\n * @param pbf\n * @returns value\n */\nfunction readValueMessage(pbf: Protobuf) {\n  let value: string | number | boolean | null = null;\n  const end = pbf.readVarint() + pbf.pos;\n\n  while (pbf.pos < end) {\n    const tag = pbf.readVarint() >> 3;\n\n    value =\n      tag === 1\n        ? pbf.readString()\n        : tag === 2\n        ? pbf.readFloat()\n        : tag === 3\n        ? pbf.readDouble()\n        : tag === 4\n        ? pbf.readVarint64()\n        : tag === 5\n        ? pbf.readVarint()\n        : tag === 6\n        ? pbf.readSVarint()\n        : tag === 7\n        ? pbf.readBoolean()\n        : null;\n  }\n\n  return value;\n}\n","// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.\n\nimport VectorTileLayer from './vector-tile-layer';\nimport Protobuf from 'pbf';\n\nexport default class VectorTile {\n  layers: {[x: string]: VectorTileLayer};\n  constructor(pbf: Protobuf, end?: number) {\n    this.layers = pbf.readFields(readTile, {}, end);\n  }\n}\n\n/**\n *\n * @param tag\n * @param layers\n * @param pbf\n */\nfunction readTile(tag: number, layers?: {[x: string]: VectorTileLayer}, pbf?: Protobuf): void {\n  if (tag === 3) {\n    if (pbf) {\n      const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);\n      if (layer.length && layers) {\n        layers[layer.name] = layer;\n      }\n    }\n  }\n}\n","/* eslint-disable indent */\nimport {earcut} from '@math.gl/polygon';\nimport {\n  MvtBinaryCoordinates,\n  MvtBinaryGeometry,\n  MvtBinaryOptions,\n  MvtFirstPassedData,\n  MvtLines,\n  MvtPoints,\n  MvtPolygons\n} from '../types';\n\n/**\n * Convert binary features to flat binary arrays. Similar to\n * `geojsonToBinary` helper function, except that it expects\n * a binary representation of the feature data, which enables\n * 2X-3X speed increase in parse speed, compared to using\n * geoJSON. See `binary-vector-tile/VectorTileFeature` for\n * data format detais\n *\n * @param features\n * @param firstPassData\n * @param options\n * @returns filled arrays\n */\nexport function featuresToBinary(\n  features: MvtBinaryCoordinates[],\n  firstPassData: MvtFirstPassedData,\n  options?: MvtBinaryOptions\n) {\n  return fillArrays(features, firstPassData, {\n    numericPropKeys: options ? options.numericPropKeys : extractNumericPropKeys(features),\n    PositionDataType: options ? options.PositionDataType : Float32Array\n  });\n}\n\nexport const TEST_EXPORTS = {\n  extractNumericPropKeys,\n  fillArrays\n};\n\n/**\n * Extracts properties that are always numeric\n *\n * @param features\n * @returns object with numeric keys\n */\nfunction extractNumericPropKeys(features: MvtBinaryCoordinates[]): string[] {\n  const numericPropKeys = {};\n  for (const feature of features) {\n    if (feature.properties) {\n      for (const key in feature.properties) {\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        const numericSoFar = numericPropKeys[key];\n        if (numericSoFar || numericSoFar === undefined) {\n          const val = feature.properties[key];\n          numericPropKeys[key] = isNumeric(val);\n        }\n      }\n    }\n  }\n\n  return Object.keys(numericPropKeys).filter((k) => numericPropKeys[k]);\n}\n\n/**\n * Fills coordinates into pre-allocated typed arrays\n *\n * @param features\n * @param firstPassData\n * @param options\n * @returns an accessor object with value and size keys\n */\n// eslint-disable-next-line complexity\nfunction fillArrays(\n  features: MvtBinaryCoordinates[],\n  firstPassData: MvtFirstPassedData,\n  options: MvtBinaryOptions\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 {numericPropKeys, PositionDataType = Float32Array} = options;\n  const hasGlobalId = features[0] && 'id' in features[0];\n  const coordLength = 2;\n  const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;\n  const points: MvtPoints = {\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: [],\n    fields: []\n  };\n  const lines: MvtLines = {\n    pathIndices:\n      linePositionsCount > 65535\n        ? new Uint32Array(linePathsCount + 1)\n        : new Uint16Array(linePathsCount + 1),\n    positions: new PositionDataType(linePositionsCount * coordLength),\n    globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),\n    featureIds:\n      lineFeaturesCount > 65535\n        ? new Uint32Array(linePositionsCount)\n        : new Uint16Array(linePositionsCount),\n    numericProps: {},\n    properties: [],\n    fields: []\n  };\n  const polygons: MvtPolygons = {\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    positions: new PositionDataType(polygonPositionsCount * coordLength),\n    triangles: [],\n    globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),\n    featureIds:\n      polygonFeaturesCount > 65535\n        ? new Uint32Array(polygonPositionsCount)\n        : new Uint16Array(polygonPositionsCount),\n    numericProps: {},\n    properties: [],\n    fields: []\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 = feature.properties || {};\n\n    switch (geometry.type) {\n      case 'Point':\n      case 'MultiPoint':\n        handlePoint(geometry, points, indexMap, coordLength, properties);\n        points.properties.push(keepStringProperties(properties, numericPropKeys));\n        if (hasGlobalId) {\n          points.fields.push({id: feature.id});\n        }\n        indexMap.pointFeature++;\n        break;\n      case 'LineString':\n      case 'MultiLineString':\n        handleLineString(geometry, lines, indexMap, coordLength, properties);\n        lines.properties.push(keepStringProperties(properties, numericPropKeys));\n        if (hasGlobalId) {\n          lines.fields.push({id: feature.id});\n        }\n        indexMap.lineFeature++;\n        break;\n      case 'Polygon':\n      case 'MultiPolygon':\n        handlePolygon(geometry, polygons, indexMap, coordLength, properties);\n        polygons.properties.push(keepStringProperties(properties, numericPropKeys));\n        if (hasGlobalId) {\n          polygons.fields.push({id: feature.id});\n        }\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/**\n * Fills (Multi)Point coordinates into points object of arrays\n *\n * @param geometry\n * @param points\n * @param indexMap\n * @param coordLength\n * @param properties\n */\nfunction handlePoint(\n  geometry: MvtBinaryGeometry,\n  points: MvtPoints,\n  indexMap: {\n    pointPosition: number;\n    pointFeature: number;\n    linePosition?: number;\n    linePath?: number;\n    lineFeature?: number;\n    polygonPosition?: number;\n    polygonObject?: number;\n    polygonRing?: number;\n    polygonFeature?: number;\n    feature: number;\n  },\n  coordLength: number,\n  properties: {[x: string]: string | number | boolean | null}\n): void {\n  points.positions.set(geometry.data, indexMap.pointPosition * coordLength);\n\n  const nPositions = geometry.data.length / coordLength;\n  fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);\n  points.globalFeatureIds.fill(\n    indexMap.feature,\n    indexMap.pointPosition,\n    indexMap.pointPosition + nPositions\n  );\n  points.featureIds.fill(\n    indexMap.pointFeature,\n    indexMap.pointPosition,\n    indexMap.pointPosition + nPositions\n  );\n\n  indexMap.pointPosition += nPositions;\n}\n\n/**\n * Fills (Multi)LineString coordinates into lines object of arrays\n *\n * @param geometry\n * @param lines\n * @param indexMap\n * @param coordLength\n * @param properties\n */\nfunction handleLineString(\n  geometry: MvtBinaryGeometry,\n  lines: MvtLines,\n  indexMap: {\n    pointPosition?: number;\n    pointFeature?: number;\n    linePosition: number;\n    linePath: number;\n    lineFeature: number;\n    polygonPosition?: number;\n    polygonObject?: number;\n    polygonRing?: number;\n    polygonFeature?: number;\n    feature: number;\n  },\n  coordLength: number,\n  properties: {[x: string]: string | number | boolean | null}\n): void {\n  lines.positions.set(geometry.data, indexMap.linePosition * coordLength);\n\n  const nPositions = geometry.data.length / coordLength;\n  fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);\n\n  lines.globalFeatureIds.fill(\n    indexMap.feature,\n    indexMap.linePosition,\n    indexMap.linePosition + nPositions\n  );\n  lines.featureIds.fill(\n    indexMap.lineFeature,\n    indexMap.linePosition,\n    indexMap.linePosition + nPositions\n  );\n\n  for (let i = 0, il = geometry.lines.length; i < il; ++i) {\n    // Extract range of data we are working with, defined by start\n    // and end indices (these index into the geometry.data array)\n    const start = geometry.lines[i];\n    const end =\n      i === il - 1\n        ? geometry.data.length // last line, so read to end of data\n        : geometry.lines[i + 1]; // start index for next line\n\n    lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;\n    indexMap.linePosition += (end - start) / coordLength;\n  }\n}\n\n/**\n * Fills (Multi)Polygon coordinates into polygons object of arrays\n *\n * @param geometry\n * @param polygons\n * @param indexMap\n * @param coordLength\n * @param properties\n */\nfunction handlePolygon(\n  geometry: MvtBinaryGeometry,\n  polygons: MvtPolygons,\n  indexMap: {\n    pointPosition?: number;\n    pointFeature?: number;\n    linePosition?: number;\n    linePath?: number;\n    lineFeature?: number;\n    polygonPosition: number;\n    polygonObject: number;\n    polygonRing: number;\n    polygonFeature: number;\n    feature: number;\n  },\n  coordLength: number,\n  properties: {[x: string]: string | number | boolean | null}\n): void {\n  polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);\n\n  const nPositions = geometry.data.length / coordLength;\n  fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);\n  polygons.globalFeatureIds.fill(\n    indexMap.feature,\n    indexMap.polygonPosition,\n    indexMap.polygonPosition + nPositions\n  );\n  polygons.featureIds.fill(\n    indexMap.polygonFeature,\n    indexMap.polygonPosition,\n    indexMap.polygonPosition + nPositions\n  );\n\n  // Unlike Point & LineString geometry.lines is a 2D array\n  for (let l = 0, ll = geometry.lines.length; l < ll; ++l) {\n    const startPosition = indexMap.polygonPosition;\n    polygons.polygonIndices[indexMap.polygonObject++] = startPosition;\n\n    const areas = geometry.areas![l];\n    const lines = geometry.lines[l];\n    const nextLines = geometry.lines[l + 1];\n\n    for (let i = 0, il = lines.length; i < il; ++i) {\n      const start = lines[i];\n      const end =\n        i === il - 1\n          ? // last line, so either read to:\n            nextLines === undefined\n            ? geometry.data.length // end of data (no next lines)\n            : nextLines[0] // start of first line in nextLines\n          : lines[i + 1]; // start index for next line\n\n      polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;\n      indexMap.polygonPosition += (end - start) / coordLength;\n    }\n\n    const endPosition = indexMap.polygonPosition;\n    triangulatePolygon(polygons, areas, lines, {startPosition, endPosition, coordLength});\n  }\n}\n\n/**\n * Triangulate polygon using earcut\n *\n * @param polygons\n * @param areas\n * @param lines\n * @param param3\n */\nfunction triangulatePolygon(\n  polygons: MvtPolygons,\n  areas: number,\n  lines: number[],\n  {\n    startPosition,\n    endPosition,\n    coordLength\n  }: {startPosition: number; endPosition: number; coordLength: number}\n): void {\n  const start = startPosition * coordLength;\n  const end = endPosition * coordLength;\n\n  // Extract positions and holes for just this polygon\n  const polygonPositions = polygons.positions.subarray(start, end);\n\n  // Holes are referenced relative to outer polygon\n  const offset = lines[0];\n  const holes = lines.slice(1).map((n: number) => (n - offset) / coordLength);\n\n  // Compute triangulation\n  const indices = earcut(polygonPositions, holes, coordLength, areas);\n\n  // Indices returned by triangulation are relative to start\n  // of polygon, so we need to offset\n  for (let t = 0, tl = indices.length; t < tl; ++t) {\n    polygons.triangles.push(startPosition + indices[t]);\n  }\n}\n\n/**\n * Wrap each array in an accessor object with value and size keys\n *\n * @param points\n * @param lines\n * @param polygons\n * @param coordLength\n * @returns object\n */\nfunction makeAccessorObjects(\n  points: MvtPoints,\n  lines: MvtLines,\n  polygons: MvtPolygons,\n  coordLength: number\n) {\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    },\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    },\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      triangles: {value: new Uint32Array(polygons.triangles), size: 1},\n      globalFeatureIds: {value: polygons.globalFeatureIds, size: 1},\n      featureIds: {value: polygons.featureIds, size: 1}\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  return returnObj;\n}\n\n/**\n * Add numeric properties to object\n *\n * @param object\n * @param properties\n * @param index\n * @param length\n */\nfunction fillNumericProperties(\n  object: MvtPoints,\n  properties: {[x: string]: string | number | boolean | null},\n  index: number,\n  length: number\n): void {\n  for (const numericPropName in object.numericProps) {\n    if (numericPropName in properties) {\n      object.numericProps[numericPropName].fill(properties[numericPropName], index, index + length);\n    }\n  }\n}\n\n/**\n * Keep string properties in object\n *\n * @param properties\n * @param numericKeys\n * @returns object\n */\nfunction keepStringProperties(\n  properties: {[x: string]: string | number | boolean | null},\n  numericKeys: string[]\n) {\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\nfunction isNumeric(x: unknown) {\n  return Number.isFinite(x);\n}\n","// import {VectorTile} from '@mapbox/vector-tile';\nimport VectorTile from './mapbox-vector-tile/vector-tile';\nimport BinaryVectorTile from './binary-vector-tile/vector-tile';\n\nimport {featuresToBinary} from './binary-vector-tile/features-to-binary';\nimport Protobuf from 'pbf';\nimport {MvtBinaryCoordinates, MvtMapboxCoordinates, MvtOptions} from '../lib/types';\nimport VectorTileFeatureBinary from './binary-vector-tile/vector-tile-feature';\nimport VectorTileFeatureMapBox from './mapbox-vector-tile/vector-tile-feature';\nimport {LoaderOptions} from '@loaders.gl/loader-utils/';\n\n/**\n * Parse MVT arrayBuffer and return GeoJSON.\n *\n * @param arrayBuffer A MVT arrayBuffer\n * @param options\n * @returns A GeoJSON geometry object or a binary representation\n */\nexport default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptions) {\n  options = normalizeOptions(options);\n  const features: (MvtBinaryCoordinates | MvtMapboxCoordinates)[] = [];\n\n  if (options) {\n    const binary = options.gis.format === 'binary';\n    const firstPassData = {\n      pointPositionsCount: 0,\n      pointFeaturesCount: 0,\n      linePositionsCount: 0,\n      linePathsCount: 0,\n      lineFeaturesCount: 0,\n      polygonPositionsCount: 0,\n      polygonObjectsCount: 0,\n      polygonRingsCount: 0,\n      polygonFeaturesCount: 0\n    };\n\n    if (arrayBuffer.byteLength > 0) {\n      const tile = binary\n        ? new BinaryVectorTile(new Protobuf(arrayBuffer))\n        : new VectorTile(new Protobuf(arrayBuffer));\n      const loaderOptions = options.mvt;\n\n      const selectedLayers = Array.isArray(loaderOptions.layers)\n        ? loaderOptions.layers\n        : Object.keys(tile.layers);\n\n      selectedLayers.forEach((layerName: string) => {\n        const vectorTileLayer = tile.layers[layerName];\n        const featureOptions = {...loaderOptions, layerName};\n\n        if (!vectorTileLayer) {\n          return;\n        }\n\n        for (let i = 0; i < vectorTileLayer.length; i++) {\n          const vectorTileFeature = vectorTileLayer.feature(i, firstPassData);\n\n          const decodedFeature = binary\n            ? getDecodedFeatureBinary(vectorTileFeature as VectorTileFeatureBinary, featureOptions)\n            : getDecodedFeature(vectorTileFeature as VectorTileFeatureMapBox, featureOptions);\n          features.push(decodedFeature);\n        }\n      });\n    }\n\n    if (binary) {\n      const data = featuresToBinary(features as MvtBinaryCoordinates[], firstPassData);\n      // Add the original byteLength (as a reasonable approximation of the size of the binary data)\n      // TODO decide where to store extra fields like byteLength (header etc) and document\n      // @ts-ignore\n      data.byteLength = arrayBuffer.byteLength;\n      return data;\n    }\n  }\n  return features;\n}\n\n/**\n * @param options\n * @returns options\n */\nfunction normalizeOptions(options: LoaderOptions | undefined) {\n  if (options) {\n    options = {\n      ...options,\n      mvt: options.mvt || {},\n      gis: options.gis || {}\n    };\n\n    // Validate\n    const wgs84Coordinates = options.coordinates === 'wgs84';\n    const {tileIndex} = options;\n    const hasTileIndex =\n      tileIndex &&\n      Number.isFinite(tileIndex.x) &&\n      Number.isFinite(tileIndex.y) &&\n      Number.isFinite(tileIndex.z);\n\n    if (wgs84Coordinates && !hasTileIndex) {\n      throw new Error(\n        'MVT Loader: WGS84 coordinates need tileIndex property. Check documentation.'\n      );\n    }\n  }\n  return options;\n}\n\n/**\n * @param feature\n * @param options\n * @returns decoded feature\n */\nfunction getDecodedFeature(\n  feature: VectorTileFeatureMapBox,\n  options: MvtOptions\n): MvtMapboxCoordinates {\n  const decodedFeature = feature.toGeoJSON(\n    options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinates\n  );\n\n  // Add layer name to GeoJSON properties\n  if (options.layerProperty) {\n    decodedFeature.properties[options.layerProperty] = options.layerName;\n  }\n\n  return decodedFeature;\n}\n\n/**\n * @param feature\n * @param options\n * @returns decoded binary feature\n */\nfunction getDecodedFeatureBinary(\n  feature: VectorTileFeatureBinary,\n  options: MvtOptions\n): MvtBinaryCoordinates {\n  const decodedFeature = feature.toBinaryCoordinates(\n    options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinatesBinary\n  );\n\n  // Add layer name to GeoJSON properties\n  if (options.layerProperty) {\n    decodedFeature.properties[options.layerProperty] = options.layerName;\n  }\n\n  return decodedFeature;\n}\n\n/**\n * @param line\n * @param feature\n */\nfunction transformToLocalCoordinates(line: number[], feature: {extent: any}): void {\n  // This function transforms local coordinates in a\n  // [0 - bufferSize, this.extent + bufferSize] range to a\n  // [0 - (bufferSize / this.extent), 1 + (bufferSize / this.extent)] range.\n  // The resulting extent would be 1.\n  const {extent} = feature;\n  for (let i = 0; i < line.length; i++) {\n    const p = line[i];\n    p[0] /= extent;\n    p[1] /= extent;\n  }\n}\n\nfunction transformToLocalCoordinatesBinary(data: number[], feature: {extent: any}) {\n  // For the binary code path, the feature data is just\n  // one big flat array, so we just divide each value\n  const {extent} = feature;\n  for (let i = 0, il = data.length; i < il; ++i) {\n    data[i] /= extent;\n  }\n}\n","import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport parseMVT from './lib/parse-mvt';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/**\n * Worker loader for the Mapbox Vector Tile format\n */\nexport const MVTWorkerLoader: Loader = {\n  name: 'Mapbox Vector Tile',\n  id: 'mvt',\n  module: 'mvt',\n  version: VERSION,\n  // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'\n  extensions: ['mvt', 'pbf'],\n  mimeTypes: [\n    'application/vnd.mapbox-vector-tile',\n    'application/x-protobuf'\n    // 'application/octet-stream'\n  ],\n  worker: true,\n  category: 'geometry',\n  options: {\n    mvt: {\n      coordinates: 'local',\n      layerProperty: 'layerName',\n      layers: null,\n      tileIndex: null\n    }\n  }\n};\n\n/**\n * Loader for the Mapbox Vector Tile format\n */\nexport const MVTLoader: LoaderWithParser = {\n  ...MVTWorkerLoader,\n  parse: async (arrayBuffer, options) => parseMVT(arrayBuffer, options),\n  parseSync: parseMVT,\n  binary: true\n};\n","// 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 {MVTLoader} from '../mvt-loader';\nimport {createLoaderWorker} from '@loaders.gl/loader-utils';\n\ncreateLoaderWorker(MVTLoader);\n"],"sourceRoot":""}