@loaders.gl/terrain 3.1.0-alpha.2 → 4.0.0-alpha.3

package/dist/quantized-mesh-worker.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/regenerator/index.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/typeof.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/slicedToArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/defineProperty.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/classCallCheck.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/createClass.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack:////home/user/apps/loaders.gl/node_modules/regenerator-runtime/runtime.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/arrayWithHoles.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/nonIterableRest.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/iterableToArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack:///../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:///../schema/src/category/mesh/mesh-utils.ts","webpack:///./src/lib/decode-quantized-mesh.js","webpack:///../loader-utils/src/lib/binary-utils/array-buffer-utils.ts","webpack:///./src/lib/helpers/skirt.js","webpack:///./src/lib/parse-quantized-mesh.js","webpack:////home/user/apps/loaders.gl/node_modules/@mapbox/martini/index.js","webpack:///./src/lib/delatin/index.js","webpack:///./src/lib/parse-terrain.js","webpack:///./src/lib/utils/version.js","webpack:///./src/terrain-loader.ts","webpack:///./src/quantized-mesh-loader.ts","webpack:///./src/index.ts","webpack:///./src/workers/quantized-mesh-worker.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","asyncGeneratorStep","gen","resolve","reject","_next","_throw","arg","info","error","done","Promise","then","fn","self","this","args","arguments","apply","err","undefined","_typeof","obj","iterator","constructor","arrayWithHoles","iterableToArrayLimit","unsupportedIterableToArray","nonIterableRest","arr","arrayWithoutHoles","iterableToArray","nonIterableSpread","configurable","writable","instance","Constructor","TypeError","_defineProperties","target","props","length","descriptor","protoProps","staticProps","arrayLikeToArray","minLen","toString","slice","Array","from","test","len","arr2","runtime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","define","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","context","Context","_invoke","state","method","Error","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","type","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","forEach","AsyncIterator","PromiseImpl","previousPromise","callInvokeWithMethodAndArg","invoke","result","__await","unwrapped","resultName","next","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","push","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","displayName","isGeneratorFunction","genFun","ctor","mark","setPrototypeOf","__proto__","awrap","async","iter","keys","reverse","pop","skipTempReset","prev","charAt","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","Function","isArray","_i","_s","_e","_arr","_n","_d","isTransferable","ArrayBuffer","MessagePort","ImageBitmap","OffscreenCanvas","onMessageWrapperMap","Map","WorkerBody","onMessage","onmessage","message","isKnownMessage","data","payload","onMessageWrapper","addEventListener","removeEventListener","source","transferList","getTransferList","recursive","transfers","transfersSet","Set","add","buffer","isView","postMessage","startsWith","requestId","parseOnMainThread","arrayBuffer","options","id","input","parseData","a","loader","parseSync","parse","parser","parseTextSync","textDecoder","TextDecoder","decode","worker","getMeshBoundingBox","attributes","minX","Infinity","minY","minZ","maxX","maxY","maxZ","positions","POSITION","x","y","z","QUANTIZED_MESH_HEADER","Float64Array","BYTES_PER_ELEMENT","Float32Array","decodeZigZag","decodeIndex","position","indicesCount","bytesPerIndex","indices","encoded","Uint16Array","Uint32Array","highest","code","decodeWaterMaskExtension","extensionDataView","byteOffset","byteLength","DECODING_STEPS","DEFAULT_OPTIONS","maxDecodingStep","userOptions","assign","view","DataView","dataView","header","bytesCount","getFloat64","getFloat32","headerEndPosition","decodeHeader","vertexCount","getUint32","vertexData","bytesPerArrayElement","elementArrayLength","uArrayStartPosition","vArrayStartPosition","heightArrayStartPosition","u","v","height","getUint16","vertexDataEndPosition","decodeVertexData","triangleCount","triangleIndicesCount","triangleIndices","triangleIndicesEndPosition","decodeTriangleIndices","westVertexCount","westIndices","southVertexCount","southIndices","eastVertexCount","eastIndices","northVertexCount","northIndices","edgeIndicesEndPosition","decodeEdgeIndices","extensions","indicesEndPosition","extensionsEndPosition","extensionId","getUint8","Uint8Array","extensionLength","extensionView","vertexNormals","waterMask","decodeExtensions","concatenateTypedArrays","typedArrays","arrays","TypedArrayConstructor","sumLength","reduce","acc","offset","array","set","addSkirt","triangles","skirtHeight","outsideIndices","outsideEdges","getOutsideEdgesFromIndices","getOutsideEdgesFromTriangles","newPosition","newTexcoord0","TEXCOORD_0","newTriangles","edge","updateAttributesForNewEdge","edgeIndex","resultTriangles","concat","edges","sort","b","Math","min","max","index","indexGroup","positionsLength","vertex1Offset","vertex2Offset","subarray","triangle1Offset","getTileMesh","bounds","originalTriangleIndices","minHeight","maxHeight","xScale","yScale","zScale","nCoords","texCoords","size","getMeshAttributes","boundingBox","loaderData","loadQuantizedMesh","Martini","gridSize","tileSize","numTriangles","numParentTriangles","coords","ax","ay","bx","by","cx","cy","mx","my","k","terrain","Tile","martini","errors","update","interpolatedHeight","middleIndex","middleError","abs","leftChildIndex","rightChildIndex","maxError","numVertices","countElements","fill","vertices","triIndex","processTriangle","Delatin","width","_halfedges","_candidates","_queueIndices","_queue","_errors","_rms","_pending","_pendingLen","_rmsSum","x1","y1","p0","_addPoint","p1","p2","p3","t0","_addTriangle","_flush","getMaxError","refine","_step","sqrt","_findCandidate","p0x","p0y","p1x","p1y","p2x","p2y","w00","orient","w01","w02","a01","b01","a12","b12","a20","b20","z0","heightAt","z1","z2","rms","dx","floor","w0","w1","w2","wasInside","dz","_queuePush","_queuePop","e0","e1","e2","px","py","pn","_handleCollinear","h0","h1","h2","t1","t2","_legalize","ab","bc","ca","e","a0","b0","al","ar","bl","br","pr","pl","ey","cp","fx","fy","bp","ex","dy","hal","har","hbl","hbr","_queueRemove","t3","_queueUp","_queueSwap","_queueDown","_queuePopBack","it","indexOf","j","pi","pj","j0","_queueLess","i0","j1","j2","getTerrain","imageData","elevationDecoder","tesselator","rScaler","bScaler","gScaler","g","getMesh","terrainImage","terrainOptions","mesh","meshMaxError","getMartiniTileMesh","getDelatinTileMesh","numOfVerticies","pixelIdx","createTile","tin","run","image","baseUri","TerrainLoader","version","mimeTypes","QuantizedMeshLoader","TerrainWorkerLoader","QuantizedMeshWorkerLoader","parseQuantizedMesh"],"mappings":"aACE,IAAIA,EAAmB,GAGvB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAGnC,IAAIC,EAASJ,EAAiBE,GAAY,CACzCG,EAAGH,EACHI,GAAG,EACHH,QAAS,IAUV,OANAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAG/DG,EAAOE,GAAI,EAGJF,EAAOD,QAKfF,EAAoBQ,EAAIF,EAGxBN,EAAoBS,EAAIV,EAGxBC,EAAoBU,EAAI,SAASR,EAASS,EAAMC,GAC3CZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CAAEK,YAAY,EAAMC,IAAKL,KAKhEZ,EAAoBkB,EAAI,SAAShB,GACX,oBAAXiB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAeb,EAAS,aAAc,CAAEmB,OAAO,KAQvDrB,EAAoBsB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQrB,EAAoBqB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,iBAAVF,GAAsBA,GAASA,EAAMG,WAAY,OAAOH,EAChF,IAAII,EAAKX,OAAOY,OAAO,MAGvB,GAFA1B,EAAoBkB,EAAEO,GACtBX,OAAOC,eAAeU,EAAI,UAAW,CAAET,YAAY,EAAMK,MAAOA,IACtD,EAAPE,GAA4B,iBAATF,EAAmB,IAAI,IAAIM,KAAON,EAAOrB,EAAoBU,EAAEe,EAAIE,EAAK,SAASA,GAAO,OAAON,EAAMM,IAAQC,KAAK,KAAMD,IAC9I,OAAOF,GAIRzB,EAAoB6B,EAAI,SAAS1B,GAChC,IAAIS,EAAST,GAAUA,EAAOqB,WAC7B,WAAwB,OAAOrB,EAAgB,SAC/C,WAA8B,OAAOA,GAEtC,OADAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAC5BA,GAIRZ,EAAoBa,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,IAGzG/B,EAAoBkC,EAAI,GAIjBlC,EAAoBA,EAAoBmC,EAAI,I,kBClFrDhC,EAAOD,QAAU,EAAQ,K,cCAzB,SAASkC,EAAmBC,EAAKC,EAASC,EAAQC,EAAOC,EAAQd,EAAKe,GACpE,IACE,IAAIC,EAAON,EAAIV,GAAKe,GAChBrB,EAAQsB,EAAKtB,MACjB,MAAOuB,GAEP,YADAL,EAAOK,GAILD,EAAKE,KACPP,EAAQjB,GAERyB,QAAQR,QAAQjB,GAAO0B,KAAKP,EAAOC,GAwBvCtC,EAAOD,QApBP,SAA2B8C,GACzB,OAAO,WACL,IAAIC,EAAOC,KACPC,EAAOC,UACX,OAAO,IAAIN,SAAQ,SAAUR,EAASC,GACpC,IAAIF,EAAMW,EAAGK,MAAMJ,EAAME,GAEzB,SAASX,EAAMnB,GACbe,EAAmBC,EAAKC,EAASC,EAAQC,EAAOC,EAAQ,OAAQpB,GAGlE,SAASoB,EAAOa,GACdlB,EAAmBC,EAAKC,EAASC,EAAQC,EAAOC,EAAQ,QAASa,GAGnEd,OAAMe,QAMZpD,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCrCxE,SAASgC,EAAQC,GAiBf,MAdsB,mBAAXtC,QAAoD,iBAApBA,OAAOuC,UAChDvD,EAAOD,QAAUsD,EAAU,SAAiBC,GAC1C,cAAcA,GAGhBtD,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,IAExErB,EAAOD,QAAUsD,EAAU,SAAiBC,GAC1C,OAAOA,GAAyB,mBAAXtC,QAAyBsC,EAAIE,cAAgBxC,QAAUsC,IAAQtC,OAAOa,UAAY,gBAAkByB,GAG3HtD,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,GAGnEgC,EAAQC,GAGjBtD,EAAOD,QAAUsD,EACjBrD,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,gBCrBxE,IAAIoC,EAAiB,EAAQ,IAEzBC,EAAuB,EAAQ,IAE/BC,EAA6B,EAAQ,GAErCC,EAAkB,EAAQ,IAM9B5D,EAAOD,QAJP,SAAwB8D,EAAK5D,GAC3B,OAAOwD,EAAeI,IAAQH,EAAqBG,EAAK5D,IAAM0D,EAA2BE,EAAK5D,IAAM2D,KAItG5D,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,gBCbxE,IAAIyC,EAAoB,EAAQ,IAE5BC,EAAkB,EAAQ,IAE1BJ,EAA6B,EAAQ,GAErCK,EAAoB,EAAQ,IAMhChE,EAAOD,QAJP,SAA4B8D,GAC1B,OAAOC,EAAkBD,IAAQE,EAAgBF,IAAQF,EAA2BE,IAAQG,KAI9FhE,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCExErB,EAAOD,QAfP,SAAyBuD,EAAK9B,EAAKN,GAYjC,OAXIM,KAAO8B,EACT3C,OAAOC,eAAe0C,EAAK9B,EAAK,CAC9BN,MAAOA,EACPL,YAAY,EACZoD,cAAc,EACdC,UAAU,IAGZZ,EAAI9B,GAAON,EAGNoC,GAITtD,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCVxErB,EAAOD,QANP,SAAyBoE,EAAUC,GACjC,KAAMD,aAAoBC,GACxB,MAAM,IAAIC,UAAU,sCAKxBrE,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCPxE,SAASiD,EAAkBC,EAAQC,GACjC,IAAK,IAAIvE,EAAI,EAAGA,EAAIuE,EAAMC,OAAQxE,IAAK,CACrC,IAAIyE,EAAaF,EAAMvE,GACvByE,EAAW7D,WAAa6D,EAAW7D,aAAc,EACjD6D,EAAWT,cAAe,EACtB,UAAWS,IAAYA,EAAWR,UAAW,GACjDvD,OAAOC,eAAe2D,EAAQG,EAAWlD,IAAKkD,IAUlD1E,EAAOD,QANP,SAAsBqE,EAAaO,EAAYC,GAG7C,OAFID,GAAYL,EAAkBF,EAAYvC,UAAW8C,GACrDC,GAAaN,EAAkBF,EAAaQ,GACzCR,GAITpE,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,gCCjBxE,IAAIwD,EAAmB,EAAQ,IAW/B7E,EAAOD,QATP,SAAqCW,EAAGoE,GACtC,GAAKpE,EAAL,CACA,GAAiB,iBAANA,EAAgB,OAAOmE,EAAiBnE,EAAGoE,GACtD,IAAIpD,EAAIf,OAAOkB,UAAUkD,SAAS3E,KAAKM,GAAGsE,MAAM,GAAI,GAEpD,MADU,WAANtD,GAAkBhB,EAAE8C,cAAa9B,EAAIhB,EAAE8C,YAAYhD,MAC7C,QAANkB,GAAqB,QAANA,EAAoBuD,MAAMC,KAAKxE,GACxC,cAANgB,GAAqB,2CAA2CyD,KAAKzD,GAAWmD,EAAiBnE,EAAGoE,QAAxG,IAIF9E,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCFxErB,EAAOD,QAVP,SAA2B8D,EAAKuB,IACnB,MAAPA,GAAeA,EAAMvB,EAAIY,UAAQW,EAAMvB,EAAIY,QAE/C,IAAK,IAAIxE,EAAI,EAAGoF,EAAO,IAAIJ,MAAMG,GAAMnF,EAAImF,EAAKnF,IAC9CoF,EAAKpF,GAAK4D,EAAI5D,GAGhB,OAAOoF,GAITrF,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,kBCJxE,IAAIiE,EAAW,SAAUvF,GACvB,aAEA,IAAIwF,EAAK5E,OAAOkB,UACZ2D,EAASD,EAAGzD,eAEZ2D,EAA4B,mBAAXzE,OAAwBA,OAAS,GAClD0E,EAAiBD,EAAQlC,UAAY,aACrCoC,EAAsBF,EAAQG,eAAiB,kBAC/CC,EAAoBJ,EAAQxE,aAAe,gBAE/C,SAAS6E,EAAOxC,EAAK9B,EAAKN,GAOxB,OANAP,OAAOC,eAAe0C,EAAK9B,EAAK,CAC9BN,MAAOA,EACPL,YAAY,EACZoD,cAAc,EACdC,UAAU,IAELZ,EAAI9B,GAEb,IAEEsE,EAAO,GAAI,IACX,MAAO3C,GACP2C,EAAS,SAASxC,EAAK9B,EAAKN,GAC1B,OAAOoC,EAAI9B,GAAON,GAItB,SAAS6E,EAAKC,EAASC,EAASnD,EAAMoD,GAEpC,IAAIC,EAAiBF,GAAWA,EAAQpE,qBAAqBuE,EAAYH,EAAUG,EAC/EC,EAAY1F,OAAOY,OAAO4E,EAAetE,WACzCyE,EAAU,IAAIC,EAAQL,GAAe,IAMzC,OAFAG,EAAUG,QAsMZ,SAA0BR,EAASlD,EAAMwD,GACvC,IAAIG,EA/KuB,iBAiL3B,OAAO,SAAgBC,EAAQnE,GAC7B,GAhLoB,cAgLhBkE,EACF,MAAM,IAAIE,MAAM,gCAGlB,GAnLoB,cAmLhBF,EAA6B,CAC/B,GAAe,UAAXC,EACF,MAAMnE,EAKR,OAAOqE,IAMT,IAHAN,EAAQI,OAASA,EACjBJ,EAAQ/D,IAAMA,IAED,CACX,IAAIsE,EAAWP,EAAQO,SACvB,GAAIA,EAAU,CACZ,IAAIC,EAAiBC,EAAoBF,EAAUP,GACnD,GAAIQ,EAAgB,CAClB,GAAIA,IAAmBE,EAAkB,SACzC,OAAOF,GAIX,GAAuB,SAAnBR,EAAQI,OAGVJ,EAAQW,KAAOX,EAAQY,MAAQZ,EAAQ/D,SAElC,GAAuB,UAAnB+D,EAAQI,OAAoB,CACrC,GAnNqB,mBAmNjBD,EAEF,MADAA,EAjNc,YAkNRH,EAAQ/D,IAGhB+D,EAAQa,kBAAkBb,EAAQ/D,SAEN,WAAnB+D,EAAQI,QACjBJ,EAAQc,OAAO,SAAUd,EAAQ/D,KAGnCkE,EA5NkB,YA8NlB,IAAIY,EAASC,EAAStB,EAASlD,EAAMwD,GACrC,GAAoB,WAAhBe,EAAOE,KAAmB,CAO5B,GAJAd,EAAQH,EAAQ5D,KAjOA,YAFK,iBAuOjB2E,EAAO9E,MAAQyE,EACjB,SAGF,MAAO,CACL9F,MAAOmG,EAAO9E,IACdG,KAAM4D,EAAQ5D,MAGS,UAAhB2E,EAAOE,OAChBd,EA/OgB,YAkPhBH,EAAQI,OAAS,QACjBJ,EAAQ/D,IAAM8E,EAAO9E,OA9QPiF,CAAiBxB,EAASlD,EAAMwD,GAE7CD,EAcT,SAASiB,EAASzE,EAAIS,EAAKf,GACzB,IACE,MAAO,CAAEgF,KAAM,SAAUhF,IAAKM,EAAGzC,KAAKkD,EAAKf,IAC3C,MAAOY,GACP,MAAO,CAAEoE,KAAM,QAAShF,IAAKY,IAhBjCpD,EAAQgG,KAAOA,EAoBf,IAOIiB,EAAmB,GAMvB,SAASZ,KACT,SAASqB,KACT,SAASC,KAIT,IAAIC,EAAoB,GACxBA,EAAkBjC,GAAkB,WAClC,OAAO3C,MAGT,IAAI6E,EAAWjH,OAAOkH,eAClBC,EAA0BF,GAAYA,EAASA,EAASG,EAAO,MAC/DD,GACAA,IAA4BvC,GAC5BC,EAAOpF,KAAK0H,EAAyBpC,KAGvCiC,EAAoBG,GAGtB,IAAIE,EAAKN,EAA2B7F,UAClCuE,EAAUvE,UAAYlB,OAAOY,OAAOoG,GAWtC,SAASM,EAAsBpG,GAC7B,CAAC,OAAQ,QAAS,UAAUqG,SAAQ,SAASxB,GAC3CZ,EAAOjE,EAAW6E,GAAQ,SAASnE,GACjC,OAAOQ,KAAKyD,QAAQE,EAAQnE,SAkClC,SAAS4F,EAAc9B,EAAW+B,GAgChC,IAAIC,EAgCJtF,KAAKyD,QA9BL,SAAiBE,EAAQnE,GACvB,SAAS+F,IACP,OAAO,IAAIF,GAAY,SAASjG,EAASC,IAnC7C,SAASmG,EAAO7B,EAAQnE,EAAKJ,EAASC,GACpC,IAAIiF,EAASC,EAASjB,EAAUK,GAASL,EAAW9D,GACpD,GAAoB,UAAhB8E,EAAOE,KAEJ,CACL,IAAIiB,EAASnB,EAAO9E,IAChBrB,EAAQsH,EAAOtH,MACnB,OAAIA,GACiB,iBAAVA,GACPsE,EAAOpF,KAAKc,EAAO,WACdkH,EAAYjG,QAAQjB,EAAMuH,SAAS7F,MAAK,SAAS1B,GACtDqH,EAAO,OAAQrH,EAAOiB,EAASC,MAC9B,SAASe,GACVoF,EAAO,QAASpF,EAAKhB,EAASC,MAI3BgG,EAAYjG,QAAQjB,GAAO0B,MAAK,SAAS8F,GAI9CF,EAAOtH,MAAQwH,EACfvG,EAAQqG,MACP,SAAS/F,GAGV,OAAO8F,EAAO,QAAS9F,EAAON,EAASC,MAvBzCA,EAAOiF,EAAO9E,KAiCZgG,CAAO7B,EAAQnE,EAAKJ,EAASC,MAIjC,OAAOiG,EAaLA,EAAkBA,EAAgBzF,KAChC0F,EAGAA,GACEA,KAkHV,SAASvB,EAAoBF,EAAUP,GACrC,IAAII,EAASG,EAAStD,SAAS+C,EAAQI,QACvC,QA1TEtD,IA0TEsD,EAAsB,CAKxB,GAFAJ,EAAQO,SAAW,KAEI,UAAnBP,EAAQI,OAAoB,CAE9B,GAAIG,EAAStD,SAAiB,SAG5B+C,EAAQI,OAAS,SACjBJ,EAAQ/D,SArUZa,EAsUI2D,EAAoBF,EAAUP,GAEP,UAAnBA,EAAQI,QAGV,OAAOM,EAIXV,EAAQI,OAAS,QACjBJ,EAAQ/D,IAAM,IAAI8B,UAChB,kDAGJ,OAAO2C,EAGT,IAAIK,EAASC,EAASZ,EAAQG,EAAStD,SAAU+C,EAAQ/D,KAEzD,GAAoB,UAAhB8E,EAAOE,KAIT,OAHAjB,EAAQI,OAAS,QACjBJ,EAAQ/D,IAAM8E,EAAO9E,IACrB+D,EAAQO,SAAW,KACZG,EAGT,IAAIxE,EAAO6E,EAAO9E,IAElB,OAAMC,EAOFA,EAAKE,MAGP4D,EAAQO,EAAS8B,YAAcnG,EAAKtB,MAGpCoF,EAAQsC,KAAO/B,EAASgC,QAQD,WAAnBvC,EAAQI,SACVJ,EAAQI,OAAS,OACjBJ,EAAQ/D,SAzXVa,GAmYFkD,EAAQO,SAAW,KACZG,GANExE,GA3BP8D,EAAQI,OAAS,QACjBJ,EAAQ/D,IAAM,IAAI8B,UAAU,oCAC5BiC,EAAQO,SAAW,KACZG,GAoDX,SAAS8B,EAAaC,GACpB,IAAIC,EAAQ,CAAEC,OAAQF,EAAK,IAEvB,KAAKA,IACPC,EAAME,SAAWH,EAAK,IAGpB,KAAKA,IACPC,EAAMG,WAAaJ,EAAK,GACxBC,EAAMI,SAAWL,EAAK,IAGxBhG,KAAKsG,WAAWC,KAAKN,GAGvB,SAASO,EAAcP,GACrB,IAAI3B,EAAS2B,EAAMQ,YAAc,GACjCnC,EAAOE,KAAO,gBACPF,EAAO9E,IACdyG,EAAMQ,WAAanC,EAGrB,SAASd,EAAQL,GAIfnD,KAAKsG,WAAa,CAAC,CAAEJ,OAAQ,SAC7B/C,EAAYgC,QAAQY,EAAc/F,MAClCA,KAAK0G,OAAM,GA8Bb,SAAS1B,EAAO2B,GACd,GAAIA,EAAU,CACZ,IAAIC,EAAiBD,EAAShE,GAC9B,GAAIiE,EACF,OAAOA,EAAevJ,KAAKsJ,GAG7B,GAA6B,mBAAlBA,EAASd,KAClB,OAAOc,EAGT,IAAKE,MAAMF,EAASjF,QAAS,CAC3B,IAAIxE,GAAK,EAAG2I,EAAO,SAASA,IAC1B,OAAS3I,EAAIyJ,EAASjF,QACpB,GAAIe,EAAOpF,KAAKsJ,EAAUzJ,GAGxB,OAFA2I,EAAK1H,MAAQwI,EAASzJ,GACtB2I,EAAKlG,MAAO,EACLkG,EAOX,OAHAA,EAAK1H,WAzeTkC,EA0eIwF,EAAKlG,MAAO,EAELkG,GAGT,OAAOA,EAAKA,KAAOA,GAKvB,MAAO,CAAEA,KAAMhC,GAIjB,SAASA,IACP,MAAO,CAAE1F,WAzfPkC,EAyfyBV,MAAM,GA+MnC,OA5mBA+E,EAAkB5F,UAAYmG,EAAGxE,YAAckE,EAC/CA,EAA2BlE,YAAciE,EACzCA,EAAkBoC,YAAc/D,EAC9B4B,EACA7B,EACA,qBAaF9F,EAAQ+J,oBAAsB,SAASC,GACrC,IAAIC,EAAyB,mBAAXD,GAAyBA,EAAOvG,YAClD,QAAOwG,IACHA,IAASvC,GAG2B,uBAAnCuC,EAAKH,aAAeG,EAAKxJ,QAIhCT,EAAQkK,KAAO,SAASF,GAQtB,OAPIpJ,OAAOuJ,eACTvJ,OAAOuJ,eAAeH,EAAQrC,IAE9BqC,EAAOI,UAAYzC,EACnB5B,EAAOiE,EAAQlE,EAAmB,sBAEpCkE,EAAOlI,UAAYlB,OAAOY,OAAOyG,GAC1B+B,GAOThK,EAAQqK,MAAQ,SAAS7H,GACvB,MAAO,CAAEkG,QAASlG,IAsEpB0F,EAAsBE,EAActG,WACpCsG,EAActG,UAAU8D,GAAuB,WAC7C,OAAO5C,MAEThD,EAAQoI,cAAgBA,EAKxBpI,EAAQsK,MAAQ,SAASrE,EAASC,EAASnD,EAAMoD,EAAakC,QACxC,IAAhBA,IAAwBA,EAAczF,SAE1C,IAAI2H,EAAO,IAAInC,EACbpC,EAAKC,EAASC,EAASnD,EAAMoD,GAC7BkC,GAGF,OAAOrI,EAAQ+J,oBAAoB7D,GAC/BqE,EACAA,EAAK1B,OAAOhG,MAAK,SAAS4F,GACxB,OAAOA,EAAO9F,KAAO8F,EAAOtH,MAAQoJ,EAAK1B,WAuKjDX,EAAsBD,GAEtBlC,EAAOkC,EAAInC,EAAmB,aAO9BmC,EAAGtC,GAAkB,WACnB,OAAO3C,MAGTiF,EAAGjD,SAAW,WACZ,MAAO,sBAkCThF,EAAQwK,KAAO,SAAS5I,GACtB,IAAI4I,EAAO,GACX,IAAK,IAAI/I,KAAOG,EACd4I,EAAKjB,KAAK9H,GAMZ,OAJA+I,EAAKC,UAIE,SAAS5B,IACd,KAAO2B,EAAK9F,QAAQ,CAClB,IAAIjD,EAAM+I,EAAKE,MACf,GAAIjJ,KAAOG,EAGT,OAFAiH,EAAK1H,MAAQM,EACboH,EAAKlG,MAAO,EACLkG,EAQX,OADAA,EAAKlG,MAAO,EACLkG,IAsCX7I,EAAQgI,OAASA,EAMjBxB,EAAQ1E,UAAY,CAClB2B,YAAa+C,EAEbkD,MAAO,SAASiB,GAcd,GAbA3H,KAAK4H,KAAO,EACZ5H,KAAK6F,KAAO,EAGZ7F,KAAKkE,KAAOlE,KAAKmE,WApgBjB9D,EAqgBAL,KAAKL,MAAO,EACZK,KAAK8D,SAAW,KAEhB9D,KAAK2D,OAAS,OACd3D,KAAKR,SAzgBLa,EA2gBAL,KAAKsG,WAAWnB,QAAQqB,IAEnBmB,EACH,IAAK,IAAIlK,KAAQuC,KAEQ,MAAnBvC,EAAKoK,OAAO,IACZpF,EAAOpF,KAAK2C,KAAMvC,KACjBoJ,OAAOpJ,EAAKwE,MAAM,MACrBjC,KAAKvC,QAnhBX4C,IAyhBFyH,KAAM,WACJ9H,KAAKL,MAAO,EAEZ,IACIoI,EADY/H,KAAKsG,WAAW,GACLG,WAC3B,GAAwB,UAApBsB,EAAWvD,KACb,MAAMuD,EAAWvI,IAGnB,OAAOQ,KAAKgI,MAGd5D,kBAAmB,SAAS6D,GAC1B,GAAIjI,KAAKL,KACP,MAAMsI,EAGR,IAAI1E,EAAUvD,KACd,SAASkI,EAAOC,EAAKC,GAYnB,OAXA9D,EAAOE,KAAO,QACdF,EAAO9E,IAAMyI,EACb1E,EAAQsC,KAAOsC,EAEXC,IAGF7E,EAAQI,OAAS,OACjBJ,EAAQ/D,SApjBZa,KAujBY+H,EAGZ,IAAK,IAAIlL,EAAI8C,KAAKsG,WAAW5E,OAAS,EAAGxE,GAAK,IAAKA,EAAG,CACpD,IAAI+I,EAAQjG,KAAKsG,WAAWpJ,GACxBoH,EAAS2B,EAAMQ,WAEnB,GAAqB,SAAjBR,EAAMC,OAIR,OAAOgC,EAAO,OAGhB,GAAIjC,EAAMC,QAAUlG,KAAK4H,KAAM,CAC7B,IAAIS,EAAW5F,EAAOpF,KAAK4I,EAAO,YAC9BqC,EAAa7F,EAAOpF,KAAK4I,EAAO,cAEpC,GAAIoC,GAAYC,EAAY,CAC1B,GAAItI,KAAK4H,KAAO3B,EAAME,SACpB,OAAO+B,EAAOjC,EAAME,UAAU,GACzB,GAAInG,KAAK4H,KAAO3B,EAAMG,WAC3B,OAAO8B,EAAOjC,EAAMG,iBAGjB,GAAIiC,GACT,GAAIrI,KAAK4H,KAAO3B,EAAME,SACpB,OAAO+B,EAAOjC,EAAME,UAAU,OAG3B,KAAImC,EAMT,MAAM,IAAI1E,MAAM,0CALhB,GAAI5D,KAAK4H,KAAO3B,EAAMG,WACpB,OAAO8B,EAAOjC,EAAMG,gBAU9B/B,OAAQ,SAASG,EAAMhF,GACrB,IAAK,IAAItC,EAAI8C,KAAKsG,WAAW5E,OAAS,EAAGxE,GAAK,IAAKA,EAAG,CACpD,IAAI+I,EAAQjG,KAAKsG,WAAWpJ,GAC5B,GAAI+I,EAAMC,QAAUlG,KAAK4H,MACrBnF,EAAOpF,KAAK4I,EAAO,eACnBjG,KAAK4H,KAAO3B,EAAMG,WAAY,CAChC,IAAImC,EAAetC,EACnB,OAIAsC,IACU,UAAT/D,GACS,aAATA,IACD+D,EAAarC,QAAU1G,GACvBA,GAAO+I,EAAanC,aAGtBmC,EAAe,MAGjB,IAAIjE,EAASiE,EAAeA,EAAa9B,WAAa,GAItD,OAHAnC,EAAOE,KAAOA,EACdF,EAAO9E,IAAMA,EAET+I,GACFvI,KAAK2D,OAAS,OACd3D,KAAK6F,KAAO0C,EAAanC,WAClBnC,GAGFjE,KAAKwI,SAASlE,IAGvBkE,SAAU,SAASlE,EAAQ+B,GACzB,GAAoB,UAAhB/B,EAAOE,KACT,MAAMF,EAAO9E,IAcf,MAXoB,UAAhB8E,EAAOE,MACS,aAAhBF,EAAOE,KACTxE,KAAK6F,KAAOvB,EAAO9E,IACM,WAAhB8E,EAAOE,MAChBxE,KAAKgI,KAAOhI,KAAKR,IAAM8E,EAAO9E,IAC9BQ,KAAK2D,OAAS,SACd3D,KAAK6F,KAAO,OACa,WAAhBvB,EAAOE,MAAqB6B,IACrCrG,KAAK6F,KAAOQ,GAGPpC,GAGTwE,OAAQ,SAASrC,GACf,IAAK,IAAIlJ,EAAI8C,KAAKsG,WAAW5E,OAAS,EAAGxE,GAAK,IAAKA,EAAG,CACpD,IAAI+I,EAAQjG,KAAKsG,WAAWpJ,GAC5B,GAAI+I,EAAMG,aAAeA,EAGvB,OAFApG,KAAKwI,SAASvC,EAAMQ,WAAYR,EAAMI,UACtCG,EAAcP,GACPhC,IAKb,MAAS,SAASiC,GAChB,IAAK,IAAIhJ,EAAI8C,KAAKsG,WAAW5E,OAAS,EAAGxE,GAAK,IAAKA,EAAG,CACpD,IAAI+I,EAAQjG,KAAKsG,WAAWpJ,GAC5B,GAAI+I,EAAMC,SAAWA,EAAQ,CAC3B,IAAI5B,EAAS2B,EAAMQ,WACnB,GAAoB,UAAhBnC,EAAOE,KAAkB,CAC3B,IAAIkE,EAASpE,EAAO9E,IACpBgH,EAAcP,GAEhB,OAAOyC,GAMX,MAAM,IAAI9E,MAAM,0BAGlB+E,cAAe,SAAShC,EAAUf,EAAYE,GAa5C,OAZA9F,KAAK8D,SAAW,CACdtD,SAAUwE,EAAO2B,GACjBf,WAAYA,EACZE,QAASA,GAGS,SAAhB9F,KAAK2D,SAGP3D,KAAKR,SA7rBPa,GAgsBO4D,IAQJjH,EA7sBK,CAotBiBC,EAAOD,SAGtC,IACE4L,mBAAqBrG,EACrB,MAAOsG,GAUPC,SAAS,IAAK,yBAAdA,CAAwCvG,K,cCtuB1CtF,EAAOD,QAJP,SAAyB8D,GACvB,GAAIoB,MAAM6G,QAAQjI,GAAM,OAAOA,GAIjC7D,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCyBxErB,EAAOD,QA9BP,SAA+B8D,EAAK5D,GAClC,IAAI8L,EAAKlI,IAA0B,oBAAX7C,QAA0B6C,EAAI7C,OAAOuC,WAAaM,EAAI,eAE9E,GAAU,MAANkI,EAAJ,CACA,IAIIC,EAAIC,EAJJC,EAAO,GACPC,GAAK,EACLC,GAAK,EAIT,IACE,IAAKL,EAAKA,EAAG3L,KAAKyD,KAAQsI,GAAMH,EAAKD,EAAGnD,QAAQlG,QAC9CwJ,EAAK5C,KAAK0C,EAAG9K,QAETjB,GAAKiM,EAAKzH,SAAWxE,GAH4BkM,GAAK,IAK5D,MAAOhJ,GACPiJ,GAAK,EACLH,EAAK9I,EACL,QACA,IACOgJ,GAAsB,MAAhBJ,EAAW,QAAWA,EAAW,SAC5C,QACA,GAAIK,EAAI,MAAMH,GAIlB,OAAOC,IAITlM,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cC3BxErB,EAAOD,QAJP,WACE,MAAM,IAAIsE,UAAU,8IAItBrE,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,gBCLxE,IAAIwD,EAAmB,EAAQ,IAM/B7E,EAAOD,QAJP,SAA4B8D,GAC1B,GAAIoB,MAAM6G,QAAQjI,GAAM,OAAOgB,EAAiBhB,IAIlD7D,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCHxErB,EAAOD,QAJP,SAA0BuK,GACxB,GAAsB,oBAAXtJ,QAAmD,MAAzBsJ,EAAKtJ,OAAOuC,WAA2C,MAAtB+G,EAAK,cAAuB,OAAOrF,MAAMC,KAAKoF,IAItHtK,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCDxErB,EAAOD,QAJP,WACE,MAAM,IAAIsE,UAAU,yIAItBrE,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,wICqCxE,SAASgL,EAAe1K,GACtB,QAAKA,IAGDA,aAAkB2K,cAGK,oBAAhBC,aAA+B5K,aAAkB4K,cAGjC,oBAAhBC,aAA+B7K,aAAkB6K,aAI7B,oBAApBC,iBAAmC9K,aAAkB8K,mBCrDlE,IAAMC,EAAsB,IAAIC,IAKXC,E,4EAInB,SAAqBC,GAEnB/J,KAAKgK,UAAY,SAACC,GAChB,GAAKC,EAAeD,GAApB,CAKA,MAAwBA,EAAQE,KAAzB1F,EAAP,EAAOA,KAAM2F,EAAb,EAAaA,QACbL,EAAUtF,EAAM2F,O,8BAIpB,SACEL,GAEA,IAAIM,EAAmBT,EAAoB5L,IAAI+L,GAE1CM,IACHA,EAAmB,SAACJ,GAClB,GAAKC,EAAeD,GAApB,CAKA,MAAwBA,EAAQE,KAAzB1F,EAAP,EAAOA,KAAM2F,EAAb,EAAaA,QACbL,EAAUtF,EAAM2F,MAKpBpK,KAAKsK,iBAAiB,UAAWD,K,iCAGnC,SACEN,GAEA,IAAMM,EAAmBT,EAAoB5L,IAAI+L,GACjDH,EAAmB,OAAQG,GAE3B/J,KAAKuK,oBAAoB,UAAWF,K,yBAQtC,SAAmB5F,EAAyB2F,GAC1C,GAAIpK,KAAM,CACR,IAAMmK,EAA0B,CAACK,OAAQ,aAAc/F,OAAM2F,WACvDK,EDpDL,SAASC,EACd7L,GAGgB,IAFhB8L,IAEgB,yDADhBC,EACgB,uCAEVC,EAAeD,GAAa,IAAIE,IAEtC,GAAKjM,GAEE,GAAI0K,EAAe1K,GACxBgM,EAAaE,IAAIlM,QACZ,GAAI0K,EAAe1K,EAAOmM,QAE/BH,EAAaE,IAAIlM,EAAOmM,aACnB,GAAIxB,YAAYyB,OAAOpM,SAGvB,GAAI8L,GAA+B,WAAlB,IAAO9L,GAC7B,IAAK,IAAMH,KAAOG,EAEhB6L,EAAgB7L,EAAOH,GAAMiM,EAAWE,QAM5C,YAAqBvK,IAAdsK,EAA0BzI,MAAMC,KAAKyI,GAAgB,GCyBnCH,CAAgBN,GAGrCpK,KAAKkL,YAAYf,EAAMM,Q,KAM7B,SAASP,EAAeD,GACtB,IAAOxF,EAAcwF,EAAdxF,KAAM0F,EAAQF,EAARE,KACb,MACW,YAAT1F,GACA0F,GACuB,iBAAhBA,EAAKK,QACZL,EAAKK,OAAOW,WAAW,c,ikBCzE3B,IAAIC,EAAY,EAuChB,SAASC,EAAkBC,EAA0BC,GACnD,OAAO,IAAI1L,SAAQ,SAACR,EAASC,GAC3B,IAAMkM,EAAKJ,IA0BXtB,EAAWQ,kBAtBO,SAAZP,EAAatF,EAAM2F,GACvB,GAAIA,EAAQoB,KAAOA,EAKnB,OAAQ/G,GACN,IAAK,OACHqF,EAAWS,oBAAoBR,GAC/B1K,EAAQ+K,EAAQ1E,QAChB,MAEF,IAAK,QACHoE,EAAWS,oBAAoBR,GAC/BzK,EAAO8K,EAAQzK,WAWrB,IAAMyK,EAAU,CAACoB,KAAIC,MAAOH,EAAaC,WACzCzB,EAAWoB,YAAY,UAAWd,M,SAQvBsB,E,sEAAf,yCAAAC,EAAA,yDAA0BC,EAA1B,EAA0BA,OAAQN,EAAlC,EAAkCA,YAAaC,EAA/C,EAA+CA,QAAS/H,EAAxD,EAAwDA,SAGlDoI,EAAOC,YAAaD,EAAOE,MAHjC,gBAII3B,EAAOmB,EACPS,EAASH,EAAOC,WAAaD,EAAOE,MALxC,2BAMaF,EAAOI,cANpB,iBAOUC,EAAc,IAAIC,YACxB/B,EAAO8B,EAAYE,OAAOb,GAC1BS,EAASH,EAAOI,cATpB,8BAWU,IAAInI,MAAJ,mCAAsC+H,EAAOlO,KAA7C,YAXV,eAeE6N,EAAU,EAAH,KACFA,GADE,IAELlO,QAAUuO,GAAUA,EAAOL,SAAWK,EAAOL,QAAQlO,SAAY,GACjE+O,QAAQ,IAlBZ,UAqBeL,EAAO5B,EAAD,KAAWoB,GAAU/H,EAASoI,GArBnD,sF,0CCjDO,SAASS,EAAmBC,GAWjC,IAVA,IAAIC,EAAOC,IACPC,EAAOD,IACPE,EAAOF,IACPG,GAAQH,IACRI,GAAQJ,IACRK,GAAQL,IAENM,EAAYR,EAAWS,SAAWT,EAAWS,SAAS3O,MAAQ,GAC9DkE,EAAMwK,GAAaA,EAAUnL,OAE1BxE,EAAI,EAAGA,EAAImF,EAAKnF,GAAK,EAAG,CAC/B,IAAM6P,EAAIF,EAAU3P,GACd8P,EAAIH,EAAU3P,EAAI,GAClB+P,EAAIJ,EAAU3P,EAAI,GAExBoP,EAAOS,EAAIT,EAAOS,EAAIT,EACtBE,EAAOQ,EAAIR,EAAOQ,EAAIR,EACtBC,EAAOQ,EAAIR,EAAOQ,EAAIR,EAEtBC,EAAOK,EAAIL,EAAOK,EAAIL,EACtBC,EAAOK,EAAIL,EAAOK,EAAIL,EACtBC,EAAOK,EAAIL,EAAOK,EAAIL,EAExB,MAAO,CACL,CAACN,EAAME,EAAMC,GACb,CAACC,EAAMC,EAAMC,I,ohCCzCjB,IAAMM,EAAwB,IAAItD,IAAI,CACpC,CAAC,UAAWuD,aAAaC,mBACzB,CAAC,UAAWD,aAAaC,mBACzB,CAAC,UAAWD,aAAaC,mBAEzB,CAAC,YAAaC,aAAaD,mBAC3B,CAAC,YAAaC,aAAaD,mBAE3B,CAAC,wBAAyBD,aAAaC,mBACvC,CAAC,wBAAyBD,aAAaC,mBACvC,CAAC,wBAAyBD,aAAaC,mBACvC,CAAC,uBAAwBD,aAAaC,mBAEtC,CAAC,yBAA0BD,aAAaC,mBACxC,CAAC,yBAA0BD,aAAaC,mBACxC,CAAC,yBAA0BD,aAAaC,qBAG1C,SAASE,EAAanP,GACpB,OAAQA,GAAS,IAAe,EAARA,GAoD1B,SAASoP,EAAYxC,EAAQyC,EAAUC,EAAcC,GAA+B,IAC9EC,EAD8DC,IAAgB,yDASlF,GALED,EADoB,IAAlBD,EACQ,IAAIG,YAAY9C,EAAQyC,EAAUC,GAElC,IAAIK,YAAY/C,EAAQyC,EAAUC,IAGzCG,EACH,OAAOD,EAKT,IAFA,IAAII,EAAU,EAEL7Q,EAAI,EAAGA,EAAIyQ,EAAQjM,SAAUxE,EAAG,CACvC,IAAM8Q,EAAOL,EAAQzQ,GAErByQ,EAAQzQ,GAAK6Q,EAAUC,EAEV,IAATA,KACAD,EAIN,OAAOJ,EA4FT,SAASM,EAAyBC,GAChC,OAAOA,EAAkBnD,OAAO9I,MAC9BiM,EAAkBC,WAClBD,EAAkBC,WAAaD,EAAkBE,YA4C9C,IAAMC,EAED,EAFCA,EAGM,EAHNA,EAIE,EAJFA,EAKC,EAGRC,EAAkB,CACtBC,gBAAiBF,GAGJ,SAASnC,EAAOhC,EAAMsE,GACnC,IAAMlD,EAAU1N,OAAO6Q,OAAO,GAAIH,EAAiBE,GAC7CE,EAAO,IAAIC,SAASzE,GAC1B,EApOF,SAAsB0E,GACpB,IAD8B,EAC1BpB,EAAW,EACTqB,EAAS,GAFe,IAIE3B,GAJF,IAI9B,2BAAuD,sBAA3CzO,EAA2C,KAAtCqQ,EAAsC,KAC/CpR,EAAwB,IAAfoR,EAAmBF,EAASG,WAAaH,EAASI,WAEjEH,EAAOpQ,GAAOf,EAAOL,KAAKuR,EAAUpB,GAAU,GAC9CA,GAAYsB,GARgB,8BAW9B,MAAO,CAACD,SAAQI,kBAAmBzB,GAyNC0B,CAAaR,GAA1CG,EAAP,EAAOA,OAAQI,EAAf,EAAeA,kBAEf,GAAI3D,EAAQiD,gBAAkBF,EAC5B,MAAO,CAACQ,UAGV,MA5NF,SAA0BD,EAAUK,GAClC,IAAIzB,EAAWyB,EAETE,EAAcP,EAASQ,UAAU5B,GAAU,GAC3C6B,EAAa,IAAIxB,YAFG,EAESsB,GAEnC3B,GAAYM,YAAYV,kBAYxB,IAVA,IAAMkC,EAAuBzB,YAAYT,kBACnCmC,EAAqBJ,EAAcG,EACnCE,EAAsBhC,EACtBiC,EAAsBD,EAAsBD,EAC5CG,EAA2BD,EAAsBF,EAEnDI,EAAI,EACJC,EAAI,EACJC,EAAS,EAEJ3S,EAAI,EAAGA,EAAIiS,EAAajS,IAC/ByS,GAAKrC,EAAasB,EAASkB,UAAUN,EAAsBF,EAAuBpS,GAAG,IACrF0S,GAAKtC,EAAasB,EAASkB,UAAUL,EAAsBH,EAAuBpS,GAAG,IACrF2S,GAAUvC,EACRsB,EAASkB,UAAUJ,EAA2BJ,EAAuBpS,GAAG,IAG1EmS,EAAWnS,GAAKyS,EAChBN,EAAWnS,EAAIiS,GAAeS,EAC9BP,EAAWnS,EAAkB,EAAdiS,GAAmBU,EAKpC,MAAO,CAACR,aAAYU,sBAFpBvC,GAAiC,EAArB+B,GA8LgCS,CAAiBtB,EAAMO,GAA5DI,EAAP,EAAOA,WAAYU,EAAnB,EAAmBA,sBAEnB,GAAIzE,EAAQiD,gBAAkBF,EAC5B,MAAO,CAACQ,SAAQQ,cAGlB,MAnKF,SAA+BT,EAAUS,EAAYU,GACnD,IAAIvC,EAAWuC,EAGTrC,EADc2B,EAAW3N,OADL,EAGV,MAAQoM,YAAYV,kBAAoBS,YAAYT,kBAEhEI,EAAWE,GAAkB,IAC/BF,GAAYE,EAAiBF,EAAWE,GAG1C,IAAMuC,EAAgBrB,EAASQ,UAAU5B,GAAU,GACnDA,GAAYM,YAAYV,kBAExB,IAAM8C,EAAuC,EAAhBD,EACvBE,EAAkB5C,EACtBqB,EAAS7D,OACTyC,EACA0C,EACAxC,GAIF,MAAO,CACL0C,2BAHF5C,GAAY0C,EAAuBxC,EAIjCyC,mBA0IoDE,CACpD3B,EACAW,EACAU,GAHKI,EAAP,EAAOA,gBAAiBC,EAAxB,EAAwBA,2BAMxB,GAAI9E,EAAQiD,gBAAkBF,EAC5B,MAAO,CAACQ,SAAQQ,aAAYc,mBAG9B,MAhJF,SAA2BvB,EAAUS,EAAYe,GAC/C,IAAI5C,EAAW4C,EAGT1C,EADc2B,EAAW3N,OADL,EAGV,MAAQoM,YAAYV,kBAAoBS,YAAYT,kBAE9DkD,EAAkB1B,EAASQ,UAAU5B,GAAU,GACrDA,GAAYM,YAAYV,kBAExB,IAAMmD,EAAchD,EAAYqB,EAAS7D,OAAQyC,EAAU8C,EAAiB5C,GAAe,GAC3FF,GAAY8C,EAAkB5C,EAE9B,IAAM8C,EAAmB5B,EAASQ,UAAU5B,GAAU,GACtDA,GAAYM,YAAYV,kBAExB,IAAMqD,EAAelD,EACnBqB,EAAS7D,OACTyC,EACAgD,EACA9C,GACA,GAEFF,GAAYgD,EAAmB9C,EAE/B,IAAMgD,EAAkB9B,EAASQ,UAAU5B,GAAU,GACrDA,GAAYM,YAAYV,kBAExB,IAAMuD,EAAcpD,EAAYqB,EAAS7D,OAAQyC,EAAUkD,EAAiBhD,GAAe,GAC3FF,GAAYkD,EAAkBhD,EAE9B,IAAMkD,EAAmBhC,EAASQ,UAAU5B,GAAU,GACtDA,GAAYM,YAAYV,kBAExB,IAAMyD,EAAetD,EACnBqB,EAAS7D,OACTyC,EACAoD,EACAlD,GACA,GAIF,MAAO,CACLoD,uBAHFtD,GAAYoD,EAAmBlD,EAI7B6C,cACAE,eACAE,cACAE,gBAiGAE,CAAkBrC,EAAMW,EAAYe,GAD/BG,EAAP,EAAOA,YAAaE,EAApB,EAAoBA,aAAcE,EAAlC,EAAkCA,YAAaE,EAA/C,EAA+CA,aAAcC,EAA7D,EAA6DA,uBAG7D,OAAIxF,EAAQiD,gBAAkBF,EACrB,CACLQ,SACAQ,aACAc,kBACAI,cACAM,eACAF,cACAF,gBAMG,CACL5B,SACAQ,aACAc,kBACAI,cACAM,eACAF,cACAF,eACAO,WAtGJ,SAA0BpC,EAAUqC,GAClC,IAAMD,EAAa,GAEnB,GAAIpC,EAASR,YAAc6C,EACzB,MAAO,CAACD,aAAYE,sBAAuBD,GAK7C,IAFA,IAtBoC/C,EAsBhCV,EAAWyD,EAERzD,EAAWoB,EAASR,YAAY,CACrC,IAAM+C,EAAcvC,EAASwC,SAAS5D,GAAU,GAChDA,GAAY6D,WAAWjE,kBAEvB,IAAMkE,EAAkB1C,EAASQ,UAAU5B,GAAU,GACrDA,GAAYM,YAAYV,kBAExB,IAAMmE,EAAgB,IAAI5C,SAASC,EAAS7D,OAAQyC,EAAU8D,GAE9D,OAAQH,GACN,KAAK,EACHH,EAAWQ,eAnCmBtD,EAmC0BqD,EAlCvD,IAAIF,WACTnD,EAAkBnD,OAClBmD,EAAkBC,WAClBD,EAAkBE,aAiCd,MAEF,KAAK,EACH4C,EAAWS,UAAYxD,EAAyBsD,GASpD/D,GAAY8D,EAGd,MAAO,CAACN,aAAYE,sBAAuB1D,GAuDtBkE,CAAiBhD,EAAMoC,GAArCE,Y,yBCnNF,SAASW,IAAkD,2BAArBC,EAAqB,yBAArBA,EAAqB,gBAEhE,IAAMC,EAASD,EAETE,EAAyBD,GAAUA,EAAOnQ,OAAS,GAAKmQ,EAAO,GAAGpR,aAAgB,KACxF,IAAKqR,EACH,MAAM,IAAIlO,MACR,wGAQJ,IAJA,IAAMmO,EAAYF,EAAOG,QAAO,SAACC,EAAK9T,GAAN,OAAgB8T,EAAM9T,EAAMuD,SAAQ,GAE9D+D,EAAS,IAAIqM,EAAsBC,GACrCG,EAAS,EACb,MAAoBL,EAApB,eAA4B,CAAvB,IAAMM,EAAK,KACd1M,EAAO2M,IAAID,EAAOD,GAClBA,GAAUC,EAAMzQ,OAElB,OAAO+D,ECzGF,SAAS4M,EAAShG,EAAYiG,EAAWC,GAY9C,IAZkF,IAAvBC,EAAuB,uDAAN,KACtEC,EAAeD,EACjBE,EAA2BF,EAAgBnG,EAAWS,SAAS3O,OAC/DwU,EAA6BL,GAG3BM,EAAc,IAAIvG,EAAWS,SAAS3O,MAAMsC,YAAkC,EAAtBgS,EAAa/Q,QACrEmR,EAAe,IAAIxG,EAAWyG,WAAW3U,MAAMsC,YAAkC,EAAtBgS,EAAa/Q,QAGxEqR,EAAe,IAAIT,EAAU7R,YAAkC,EAAtBgS,EAAa/Q,QAEnDxE,EAAI,EAAGA,EAAIuV,EAAa/Q,OAAQxE,IAAK,CAC5C,IAAM8V,EAAOP,EAAavV,GAE1B+V,EAA2B,CACzBD,OACAE,UAAWhW,EACXmP,aACAkG,cACAK,cACAC,eACAE,iBAIJ1G,EAAWS,SAAS3O,MAAQwT,EAAuBtF,EAAWS,SAAS3O,MAAOyU,GAC9EvG,EAAWyG,WAAW3U,MAAQwT,EAAuBtF,EAAWyG,WAAW3U,MAAO0U,GAClF,IAAMM,EACJb,aAAqBpQ,MACjBoQ,EAAUc,OAAOL,GACjBpB,EAAuBW,EAAWS,GAExC,MAAO,CACL1G,aACAiG,UAAWa,GASf,SAASR,EAA6BL,GAEpC,IADA,IAAMe,EAAQ,GACLnW,EAAI,EAAGA,EAAIoV,EAAU5Q,OAAQxE,GAAK,EACzCmW,EAAM9M,KAAK,CAAC+L,EAAUpV,GAAIoV,EAAUpV,EAAI,KACxCmW,EAAM9M,KAAK,CAAC+L,EAAUpV,EAAI,GAAIoV,EAAUpV,EAAI,KAC5CmW,EAAM9M,KAAK,CAAC+L,EAAUpV,EAAI,GAAIoV,EAAUpV,KAG1CmW,EAAMC,MAAK,SAAC5H,EAAG6H,GAAJ,OAAUC,KAAKC,IAAL,MAAAD,KAAI,IAAQ9H,IAAK8H,KAAKC,IAAL,MAAAD,KAAI,IAAQD,KAAMC,KAAKE,IAAL,MAAAF,KAAI,IAAQ9H,IAAK8H,KAAKE,IAAL,MAAAF,KAAI,IAAQD,OAIrF,IAFA,IAAMd,EAAe,GACjBkB,EAAQ,EACLA,EAAQN,EAAM3R,QACf2R,EAAMM,GAAO,KAAON,EAAMM,EAAQ,GAAG,IAAMN,EAAMM,GAAO,KAAON,EAAMM,EAAQ,GAAG,GAClFA,GAAS,GAETlB,EAAalM,KAAK8M,EAAMM,EAAQ,IAChCA,KAGJ,OAAOlB,EAST,SAASC,EAA2B/E,EAASH,GAE3CG,EAAQ4C,YAAY+C,MAAK,SAAC5H,EAAG6H,GAAJ,OAAU/F,EAAS,EAAI9B,EAAI,GAAK8B,EAAS,EAAI+F,EAAI,MAE1E5F,EAAQgD,YAAY2C,MAAK,SAAC5H,EAAG6H,GAAJ,OAAU/F,EAAS,EAAI+F,EAAI,GAAK/F,EAAS,EAAI9B,EAAI,MAC1EiC,EAAQ8C,aAAa6C,MAAK,SAAC5H,EAAG6H,GAAJ,OAAU/F,EAAS,EAAI+F,GAAK/F,EAAS,EAAI9B,MAEnEiC,EAAQkD,aAAayC,MAAK,SAAC5H,EAAG6H,GAAJ,OAAU/F,EAAS,EAAI9B,GAAK8B,EAAS,EAAI+F,MAEnE,IAAMF,EAAQ,GACd,IAAK,IAAMM,KAAShG,EAElB,IADA,IAAMiG,EAAajG,EAAQgG,GAClBzW,EAAI,EAAGA,EAAI0W,EAAWlS,OAAS,EAAGxE,IACzCmW,EAAM9M,KAAK,CAACqN,EAAW1W,GAAI0W,EAAW1W,EAAI,KAG9C,OAAOmW,EAeT,SAASJ,EAAT,GAQG,IAPDD,EAOC,EAPDA,KACAE,EAMC,EANDA,UACA7G,EAKC,EALDA,WACAkG,EAIC,EAJDA,YACAK,EAGC,EAHDA,YACAC,EAEC,EAFDA,aACAE,EACC,EADDA,aAEMc,EAAkBxH,EAAWS,SAAS3O,MAAMuD,OAC5CoS,EAA4B,EAAZZ,EAChBa,EAA4B,EAAZb,EAAgB,EAGtCN,EAAYR,IACV/F,EAAWS,SAAS3O,MAAM6V,SAAmB,EAAVhB,EAAK,GAAkB,EAAVA,EAAK,GAAS,GAC9C,EAAhBc,GAEFlB,EAA4B,EAAhBkB,EAAoB,GAAKlB,EAA4B,EAAhBkB,EAAoB,GAAKvB,EAG1EK,EAAYR,IACV/F,EAAWS,SAAS3O,MAAM6V,SAAmB,EAAVhB,EAAK,GAAkB,EAAVA,EAAK,GAAS,GAC9C,EAAhBe,GAEFnB,EAA4B,EAAhBmB,EAAoB,GAAKnB,EAA4B,EAAhBmB,EAAoB,GAAKxB,EAG1EM,EAAaT,IACX/F,EAAWyG,WAAW3U,MAAM6V,SAAmB,EAAVhB,EAAK,GAAkB,EAAVA,EAAK,GAAS,GAChD,EAAhBc,GAEFjB,EAAaT,IACX/F,EAAWyG,WAAW3U,MAAM6V,SAAmB,EAAVhB,EAAK,GAAkB,EAAVA,EAAK,GAAS,GAChD,EAAhBe,GAIF,IAAME,EAA8B,EAAZf,EAAgB,EACxCH,EAAakB,GAAmBjB,EAAK,GACrCD,EAAakB,EAAkB,GAAKjB,EAAK,GACzCD,EAAakB,EAAkB,GAAKJ,EAAkB,EAAIE,EAE1DhB,EAAakB,EAAkB,GAAKJ,EAAkB,EAAIE,EAC1DhB,EAAakB,EAAkB,GAAKJ,EAAkB,EAAIC,EAC1Df,EAAakB,EAAkB,GAAKjB,EAAK,GCvH3C,SAASkB,EAAY7I,EAAaC,GAChC,IAAKD,EACH,OAAO,KAET,IAAO8I,EAAU7I,EAAV6I,OAEP,EAQIjI,EAAOb,EAAagD,GAPtBQ,EADF,EACEA,OACAQ,EAFF,EAEEA,WACiB+E,EAHnB,EAGEjE,gBACAI,EAJF,EAIEA,YACAM,EALF,EAKEA,aACAF,EANF,EAMEA,YACAF,EAPF,EAOEA,aAEEN,EAAkBiE,EAClB/H,EApDN,SAA2BgD,EAAYR,EAAQsF,GAe7C,IAdA,IAAOE,EAAwBxF,EAAxBwF,UAAWC,EAAazF,EAAbyF,UAClB,EAAiCH,GAAU,CAAC,EAAG,EAAG,EAAG,GAArD,WAAO7H,EAAP,KAAaE,EAAb,KACM+H,EADN,KACsBjI,EAChBkI,EAFN,KAEsBhI,EAChBiI,EAASH,EAAYD,EAErBK,EAAUrF,EAAW3N,OAAS,EAE9BmL,EAAY,IAAIQ,aAAuB,EAAVqH,GAG7BC,EAAY,IAAItH,aAAuB,EAAVqH,GAG1BxX,EAAI,EAAGA,EAAIwX,EAASxX,IAAK,CAChC,IAAM6P,EAAIsC,EAAWnS,GAAK,MACpB8P,EAAIqC,EAAWnS,EAAIwX,GAAW,MAC9BzH,EAAIoC,EAAWnS,EAAc,EAAVwX,GAAe,MAExC7H,EAAU,EAAI3P,EAAI,GAAK6P,EAAIwH,EAASjI,EACpCO,EAAU,EAAI3P,EAAI,GAAK8P,EAAIwH,EAAShI,EACpCK,EAAU,EAAI3P,EAAI,GAAK+P,EAAIwH,EAASJ,EAEpCM,EAAU,EAAIzX,EAAI,GAAK6P,EACvB4H,EAAU,EAAIzX,EAAI,GAAK8P,EAGzB,MAAO,CACLF,SAAU,CAAC3O,MAAO0O,EAAW+H,KAAM,GACnC9B,WAAY,CAAC3U,MAAOwW,EAAWC,KAAM,IAsBtBC,CAAkBxF,EAAYR,EAAQsF,GAKjDW,EAAc1I,EAAmBC,GAEvC,GAAIf,EAAQiH,YAAa,CACvB,MAA6DF,EAC3DhG,EACA8D,EACA7E,EAAQiH,YACR,CACEhC,cACAM,eACAF,cACAF,iBAGJpE,EAXA,EAAOA,WAYP8D,EAZA,EAAkCmC,UAepC,MAAO,CAELyC,WAAY,CACVlG,OAAQ,IAEVA,OAAQ,CAENM,YAAagB,EAAgBzO,OAC7BoT,eAEFzW,KAAM,EACNsP,QAAS,CAACxP,MAAOgS,EAAiByE,KAAM,GACxCvI,cAIW,SAAS2I,EAAkB3J,EAAaC,GACrD,OAAO4I,EAAY7I,EAAaC,EAAQ,mBC/F3B,MAAM2J,EACjB,YAAYC,EAAW,KACnBlV,KAAKkV,SAAWA,EAChB,MAAMC,EAAWD,EAAW,EAC5B,GAAIC,EAAYA,EAAW,EAAI,MAAM,IAAIvR,MACrC,uCAAuCsR,MAE3ClV,KAAKoV,aAAeD,EAAWA,EAAW,EAAI,EAC9CnV,KAAKqV,mBAAqBrV,KAAKoV,aAAeD,EAAWA,EAEzDnV,KAAK2N,QAAU,IAAIG,YAAY9N,KAAKkV,SAAWlV,KAAKkV,UAGpDlV,KAAKsV,OAAS,IAAIzH,YAAgC,EAApB7N,KAAKoV,cAGnC,IAAK,IAAIlY,EAAI,EAAGA,EAAI8C,KAAKoV,aAAclY,IAAK,CACxC,IAAIqO,EAAKrO,EAAI,EACTqY,EAAK,EAAGC,EAAK,EAAGC,EAAK,EAAGC,EAAK,EAAGC,EAAK,EAAGC,EAAK,EAMjD,IALS,EAALrK,EACAkK,EAAKC,EAAKC,EAAKR,EAEfI,EAAKC,EAAKI,EAAKT,GAEX5J,IAAO,GAAK,GAAG,CACnB,MAAMsK,EAAMN,EAAKE,GAAO,EAClBK,EAAMN,EAAKE,GAAO,EAEf,EAALnK,GACAkK,EAAKF,EAAIG,EAAKF,EACdD,EAAKI,EAAIH,EAAKI,IAEdL,EAAKE,EAAID,EAAKE,EACdD,EAAKE,EAAID,EAAKE,GAElBD,EAAKE,EAAID,EAAKE,EAElB,MAAMC,EAAQ,EAAJ7Y,EACV8C,KAAKsV,OAAOS,EAAI,GAAKR,EACrBvV,KAAKsV,OAAOS,EAAI,GAAKP,EACrBxV,KAAKsV,OAAOS,EAAI,GAAKN,EACrBzV,KAAKsV,OAAOS,EAAI,GAAKL,GAI7B,WAAWM,GACP,OAAO,IAAIC,EAAKD,EAAShW,OAIjC,MAAMiW,EACF,YAAYD,EAASE,GACjB,MAAMtB,EAAOsB,EAAQhB,SACrB,GAAIc,EAAQtU,SAAWkT,EAAOA,EAAM,MAAM,IAAIhR,MAC1C,mCAAmCgR,EAAOA,MAASA,OAAUA,WAAcoB,EAAQtU,WAEvF1B,KAAKgW,QAAUA,EACfhW,KAAKkW,QAAUA,EACflW,KAAKmW,OAAS,IAAI9I,aAAa2I,EAAQtU,QACvC1B,KAAKoW,SAGT,SACI,MAAM,aAAChB,EAAY,mBAAEC,EAAkB,OAAEC,EAAQJ,SAAUN,GAAQ5U,KAAKkW,SAClE,QAACF,EAAO,OAAEG,GAAUnW,KAG1B,IAAK,IAAI9C,EAAIkY,EAAe,EAAGlY,GAAK,EAAGA,IAAK,CACxC,MAAM6Y,EAAQ,EAAJ7Y,EACJqY,EAAKD,EAAOS,EAAI,GAChBP,EAAKF,EAAOS,EAAI,GAChBN,EAAKH,EAAOS,EAAI,GAChBL,EAAKJ,EAAOS,EAAI,GAChBF,EAAMN,EAAKE,GAAO,EAClBK,EAAMN,EAAKE,GAAO,EAClBC,EAAKE,EAAKC,EAAKN,EACfI,EAAKE,EAAKP,EAAKM,EAGfQ,GAAsBL,EAAQR,EAAKZ,EAAOW,GAAMS,EAAQN,EAAKd,EAAOa,IAAO,EAC3Ea,EAAcR,EAAKlB,EAAOiB,EAC1BU,EAAc/C,KAAKgD,IAAIH,EAAqBL,EAAQM,IAI1D,GAFAH,EAAOG,GAAe9C,KAAKE,IAAIyC,EAAOG,GAAcC,GAEhDrZ,EAAImY,EAAoB,CACxB,MAAMoB,GAAmBjB,EAAKI,GAAO,GAAKhB,GAASW,EAAKI,GAAO,GACzDe,GAAoBhB,EAAKE,GAAO,GAAKhB,GAASa,EAAKE,GAAO,GAChEQ,EAAOG,GAAe9C,KAAKE,IAAIyC,EAAOG,GAAcH,EAAOM,GAAiBN,EAAOO,MAK/F,QAAQC,EAAW,GACf,MAAOzB,SAAUN,EAAI,QAAEjH,GAAW3N,KAAKkW,SACjC,OAACC,GAAUnW,KACjB,IAAI4W,EAAc,EACdxB,EAAe,EACnB,MAAM1B,EAAMkB,EAAO,EASnB,SAASiC,EAActB,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GACvC,MAAMC,EAAMN,EAAKE,GAAO,EAClBK,EAAMN,EAAKE,GAAO,EAEpBlC,KAAKgD,IAAIjB,EAAKI,GAAMnC,KAAKgD,IAAIhB,EAAKI,GAAM,GAAKO,EAAOL,EAAKlB,EAAOiB,GAAMc,GACtEE,EAAclB,EAAIC,EAAIL,EAAIC,EAAIK,EAAIC,GAClCe,EAAcpB,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,KAElCnI,EAAQ6H,EAAKZ,EAAOW,GAAM5H,EAAQ6H,EAAKZ,EAAOW,MAASqB,EACvDjJ,EAAQ+H,EAAKd,EAAOa,GAAM9H,EAAQ+H,EAAKd,EAAOa,MAASmB,EACvDjJ,EAAQiI,EAAKhB,EAAOe,GAAMhI,EAAQiI,EAAKhB,EAAOe,MAASiB,EACvDxB,KAjBRzH,EAAQmJ,KAAK,GAoBbD,EAAc,EAAG,EAAGnD,EAAKA,EAAKA,EAAK,GACnCmD,EAAcnD,EAAKA,EAAK,EAAG,EAAG,EAAGA,GAEjC,MAAMqD,EAAW,IAAIlJ,YAA0B,EAAd+I,GAC3BtE,EAAY,IAAIxE,YAA2B,EAAfsH,GAClC,IAAI4B,EAAW,EAEf,SAASC,EAAgB1B,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GACzC,MAAMC,EAAMN,EAAKE,GAAO,EAClBK,EAAMN,EAAKE,GAAO,EAExB,GAAIlC,KAAKgD,IAAIjB,EAAKI,GAAMnC,KAAKgD,IAAIhB,EAAKI,GAAM,GAAKO,EAAOL,EAAKlB,EAAOiB,GAAMc,EAEtEM,EAAgBtB,EAAIC,EAAIL,EAAIC,EAAIK,EAAIC,GACpCmB,EAAgBxB,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,OAEjC,CAEH,MAAMpK,EAAIiC,EAAQ6H,EAAKZ,EAAOW,GAAM,EAC9BhC,EAAI5F,EAAQ+H,EAAKd,EAAOa,GAAM,EAC9BlY,EAAIoQ,EAAQiI,EAAKhB,EAAOe,GAAM,EAEpCoB,EAAS,EAAIrL,GAAK6J,EAClBwB,EAAS,EAAIrL,EAAI,GAAK8J,EAEtBuB,EAAS,EAAIxD,GAAKkC,EAClBsB,EAAS,EAAIxD,EAAI,GAAKmC,EAEtBqB,EAAS,EAAIxZ,GAAKoY,EAClBoB,EAAS,EAAIxZ,EAAI,GAAKqY,EAEtBtD,EAAU0E,KAActL,EACxB4G,EAAU0E,KAAczD,EACxBjB,EAAU0E,KAAczZ,GAMhC,OAHA0Z,EAAgB,EAAG,EAAGvD,EAAKA,EAAKA,EAAK,GACrCuD,EAAgBvD,EAAKA,EAAK,EAAG,EAAG,EAAGA,GAE5B,CAACqD,WAAUzE,c,IChJL4E,E,WACnB,WAAYhN,EAAMiN,GAAuB,IAAhBtH,EAAgB,uDAAPsH,EAAO,YACvCnX,KAAKkK,KAAOA,EACZlK,KAAKmX,MAAQA,EACbnX,KAAK6P,OAASA,EAEd7P,KAAKsV,OAAS,GACdtV,KAAKsS,UAAY,GAGjBtS,KAAKoX,WAAa,GAClBpX,KAAKqX,YAAc,GACnBrX,KAAKsX,cAAgB,GAErBtX,KAAKuX,OAAS,GACdvX,KAAKwX,QAAU,GACfxX,KAAKyX,KAAO,GACZzX,KAAK0X,SAAW,GAChB1X,KAAK2X,YAAc,EAEnB3X,KAAK4X,QAAU,EAEf,IAAMC,EAAKV,EAAQ,EACbW,EAAKjI,EAAS,EACdkI,EAAK/X,KAAKgY,UAAU,EAAG,GACvBC,EAAKjY,KAAKgY,UAAUH,EAAI,GACxBK,EAAKlY,KAAKgY,UAAU,EAAGF,GACvBK,EAAKnY,KAAKgY,UAAUH,EAAIC,GAGxBM,EAAKpY,KAAKqY,aAAaF,EAAIJ,EAAIG,GAAK,GAAI,GAAI,GAClDlY,KAAKqY,aAAaN,EAAII,EAAIF,EAAIG,GAAK,GAAI,GACvCpY,KAAKsY,S,+BAIP,WACE,IADgB,IAAd3B,EAAc,uDAAH,EACN3W,KAAKuY,cAAgB5B,GAC1B3W,KAAKwY,W,oBAKT,WACExY,KAAKyY,QACLzY,KAAKsY,W,yBAIP,WACE,OAAOtY,KAAKwX,QAAQ,K,qBAItB,WACE,OAAOxX,KAAK4X,QAAU,EAAIpE,KAAKkF,KAAK1Y,KAAK4X,SAAW5X,KAAKmX,MAAQnX,KAAK6P,SAAW,I,sBAInF,SAAS9C,EAAGC,GACV,OAAOhN,KAAKkK,KAAKlK,KAAKmX,MAAQnK,EAAID,K,oBAIpC,WAEE,IADA,IAAMuI,EAAStV,KAAKsV,OACXpY,EAAI,EAAGA,EAAI8C,KAAK2X,YAAaza,IAAK,CACzC,IAAMkB,EAAI4B,KAAK0X,SAASxa,GAElBwO,EAAI,EAAI1L,KAAKsS,UAAc,EAAJlU,EAAQ,GAC/BmV,EAAI,EAAIvT,KAAKsS,UAAc,EAAJlU,EAAQ,GAC/Bb,EAAI,EAAIyC,KAAKsS,UAAc,EAAJlU,EAAQ,GACrC4B,KAAK2Y,eACHrD,EAAO5J,GACP4J,EAAO5J,EAAI,GACX4J,EAAO/B,GACP+B,EAAO/B,EAAI,GACX+B,EAAO/X,GACP+X,EAAO/X,EAAI,GACXa,GAGJ4B,KAAK2X,YAAc,I,4BAIrB,SAAeiB,EAAKC,EAAKC,EAAKC,EAAKC,EAAKC,EAAK7a,GA6B3C,IA3BA,IAAMkO,EAAOkH,KAAKC,IAAImF,EAAKE,EAAKE,GAC1BxM,EAAOgH,KAAKC,IAAIoF,EAAKE,EAAKE,GAC1BvM,EAAO8G,KAAKE,IAAIkF,EAAKE,EAAKE,GAC1BrM,EAAO6G,KAAKE,IAAImF,EAAKE,EAAKE,GAG5BC,EAAMC,EAAOL,EAAKC,EAAKC,EAAKC,EAAK3M,EAAME,GACvC4M,EAAMD,EAAOH,EAAKC,EAAKL,EAAKC,EAAKvM,EAAME,GACvC6M,EAAMF,EAAOP,EAAKC,EAAKC,EAAKC,EAAKzM,EAAME,GACrC8M,EAAMP,EAAMF,EACZU,EAAMX,EAAME,EACZU,EAAMP,EAAMF,EACZU,EAAMX,EAAME,EACZU,EAAMb,EAAMI,EACZU,EAAMX,EAAMJ,EAGZlN,EAAIyN,EAAOP,EAAKC,EAAKC,EAAKC,EAAKC,EAAKC,GACpCW,EAAK5Z,KAAK6Z,SAASjB,EAAKC,GAAOnN,EAC/BoO,EAAK9Z,KAAK6Z,SAASf,EAAKC,GAAOrN,EAC/BqO,EAAK/Z,KAAK6Z,SAASb,EAAKC,GAAOvN,EAGjCiL,EAAW,EACXd,EAAK,EACLC,EAAK,EACLkE,EAAM,EACDhN,EAAIR,EAAMQ,GAAKL,EAAMK,IAAK,CAEjC,IAAIiN,EAAK,EACLf,EAAM,GAAa,IAARM,IACbS,EAAKzG,KAAKE,IAAIuG,EAAIzG,KAAK0G,OAAOhB,EAAMM,KAElCJ,EAAM,GAAa,IAARM,IACbO,EAAKzG,KAAKE,IAAIuG,EAAIzG,KAAK0G,OAAOd,EAAMM,KAElCL,EAAM,GAAa,IAARC,IACbW,EAAKzG,KAAKE,IAAIuG,EAAIzG,KAAK0G,OAAOb,EAAMC,KAStC,IANA,IAAIa,EAAKjB,EAAMM,EAAMS,EACjBG,EAAKhB,EAAMM,EAAMO,EACjBI,EAAKhB,EAAMC,EAAMW,EAEjBK,GAAY,EAEPvN,EAAIT,EAAO2N,EAAIlN,GAAKL,EAAMK,IAAK,CAEtC,GAAIoN,GAAM,GAAKC,GAAM,GAAKC,GAAM,EAAG,CACjCC,GAAY,EAGZ,IAAMrN,EAAI2M,EAAKO,EAAKL,EAAKM,EAAKL,EAAKM,EAC7BE,EAAK/G,KAAKgD,IAAIvJ,EAAIjN,KAAK6Z,SAAS9M,EAAGC,IACzCgN,GAAOO,EAAKA,EACRA,EAAK5D,IACPA,EAAW4D,EACX1E,EAAK9I,EACL+I,EAAK9I,QAEF,GAAIsN,EACT,MAGFH,GAAMX,EACNY,GAAMV,EACNW,GAAMf,EAGRJ,GAAOO,EACPL,GAAOO,EACPN,GAAOE,GAGJ1D,IAAO+C,GAAO9C,IAAO+C,GAAShD,IAAOiD,GAAOhD,IAAOiD,GAASlD,IAAOmD,GAAOlD,IAAOmD,KACpFtC,EAAW,GAIb3W,KAAKqX,YAAY,EAAIjZ,GAAKyX,EAC1B7V,KAAKqX,YAAY,EAAIjZ,EAAI,GAAK0X,EAC9B9V,KAAKyX,KAAKrZ,GAAK4b,EAGfha,KAAKwa,WAAWpc,EAAGuY,EAAUqD,K,mBAI/B,WAEE,IAAM5b,EAAI4B,KAAKya,YAETC,EAAS,EAAJtc,EAAQ,EACbuc,EAAS,EAAJvc,EAAQ,EACbwc,EAAS,EAAJxc,EAAQ,EAEb2Z,EAAK/X,KAAKsS,UAAUoI,GACpBzC,EAAKjY,KAAKsS,UAAUqI,GACpBzC,EAAKlY,KAAKsS,UAAUsI,GAEpBrF,EAAKvV,KAAKsV,OAAO,EAAIyC,GACrBvC,EAAKxV,KAAKsV,OAAO,EAAIyC,EAAK,GAC1BtC,EAAKzV,KAAKsV,OAAO,EAAI2C,GACrBvC,EAAK1V,KAAKsV,OAAO,EAAI2C,EAAK,GAC1BtC,EAAK3V,KAAKsV,OAAO,EAAI4C,GACrBtC,EAAK5V,KAAKsV,OAAO,EAAI4C,EAAK,GAC1B2C,EAAK7a,KAAKqX,YAAY,EAAIjZ,GAC1B0c,EAAK9a,KAAKqX,YAAY,EAAIjZ,EAAI,GAE9B2c,EAAK/a,KAAKgY,UAAU6C,EAAIC,GAE9B,GAAuC,IAAnC3B,EAAO5D,EAAIC,EAAIC,EAAIC,EAAImF,EAAIC,GAC7B9a,KAAKgb,iBAAiBD,EAAIL,QACrB,GAAuC,IAAnCvB,EAAO1D,EAAIC,EAAIC,EAAIC,EAAIiF,EAAIC,GACpC9a,KAAKgb,iBAAiBD,EAAIJ,QACrB,GAAuC,IAAnCxB,EAAOxD,EAAIC,EAAIL,EAAIC,EAAIqF,EAAIC,GACpC9a,KAAKgb,iBAAiBD,EAAIH,OACrB,CACL,IAAMK,EAAKjb,KAAKoX,WAAWsD,GACrBQ,EAAKlb,KAAKoX,WAAWuD,GACrBQ,EAAKnb,KAAKoX,WAAWwD,GAErBxC,EAAKpY,KAAKqY,aAAaN,EAAIE,EAAI8C,EAAIE,GAAK,GAAI,EAAGP,GAC/CU,EAAKpb,KAAKqY,aAAaJ,EAAIC,EAAI6C,EAAIG,GAAK,EAAG9C,EAAK,GAChDiD,EAAKrb,KAAKqY,aAAaH,EAAIH,EAAIgD,EAAII,EAAI/C,EAAK,EAAGgD,EAAK,GAE1Dpb,KAAKsb,UAAUlD,GACfpY,KAAKsb,UAAUF,GACfpb,KAAKsb,UAAUD,M,uBAKnB,SAAUtO,EAAGC,GACX,IAAM9P,EAAI8C,KAAKsV,OAAO5T,QAAU,EAEhC,OADA1B,KAAKsV,OAAO/O,KAAKwG,EAAGC,GACb9P,I,0BAIT,SAAawO,EAAG6H,EAAGhW,EAAGge,EAAIC,EAAIC,GAA+B,IAA3BC,EAA2B,uDAAvB1b,KAAKsS,UAAU5Q,OAC7CtD,EAAIsd,EAAI,EAiCd,OA9BA1b,KAAKsS,UAAUoJ,EAAI,GAAKhQ,EACxB1L,KAAKsS,UAAUoJ,EAAI,GAAKnI,EACxBvT,KAAKsS,UAAUoJ,EAAI,GAAKne,EAGxByC,KAAKoX,WAAWsE,EAAI,GAAKH,EACzBvb,KAAKoX,WAAWsE,EAAI,GAAKF,EACzBxb,KAAKoX,WAAWsE,EAAI,GAAKD,EAGrBF,GAAM,IACRvb,KAAKoX,WAAWmE,GAAMG,EAAI,GAExBF,GAAM,IACRxb,KAAKoX,WAAWoE,GAAME,EAAI,GAExBD,GAAM,IACRzb,KAAKoX,WAAWqE,GAAMC,EAAI,GAI5B1b,KAAKqX,YAAY,EAAIjZ,EAAI,GAAK,EAC9B4B,KAAKqX,YAAY,EAAIjZ,EAAI,GAAK,EAC9B4B,KAAKsX,cAAclZ,IAAM,EACzB4B,KAAKyX,KAAKrZ,GAAK,EAGf4B,KAAK0X,SAAS1X,KAAK2X,eAAiBvZ,EAG7Bsd,I,uBAGT,SAAUhQ,GAgBR,IAAM6H,EAAIvT,KAAKoX,WAAW1L,GAE1B,KAAI6H,EAAI,GAAR,CAIA,IAAMoI,EAAKjQ,EAAKA,EAAI,EACdkQ,EAAKrI,EAAKA,EAAI,EACdsI,EAAKF,GAAOjQ,EAAI,GAAK,EACrBoQ,EAAKH,GAAOjQ,EAAI,GAAK,EACrBqQ,EAAKH,GAAOrI,EAAI,GAAK,EACrByI,EAAKJ,GAAOrI,EAAI,GAAK,EACrBwE,EAAK/X,KAAKsS,UAAUwJ,GACpBG,EAAKjc,KAAKsS,UAAU5G,GACpBwQ,EAAKlc,KAAKsS,UAAUuJ,GACpB5D,EAAKjY,KAAKsS,UAAUyJ,GACpBzG,EAAStV,KAAKsV,OAEpB,GA4KcC,EA1KVD,EAAO,EAAIyC,GA0KGvC,EAzKdF,EAAO,EAAIyC,EAAK,GAyKEtC,EAxKlBH,EAAO,EAAI2G,GAwKWvG,EAvKtBJ,EAAO,EAAI2G,EAAK,GAuKUtG,EAtK1BL,EAAO,EAAI4G,GAsKmBtG,EArK9BN,EAAO,EAAI4G,EAAK,GAqKkBrB,EApKlCvF,EAAO,EAAI2C,GAoK2B6C,EAnKtCxF,EAAO,EAAI2C,EAAK,IAoKhBgC,EAAK1E,EAAKsF,KAGVsB,EAAKzG,EAAKoF,IAMVsB,GALAC,EAAK1G,EAAKkF,GAKAwB,GAJVC,EAAK1G,EAAKkF,GAIUwB,IADpBC,GANAC,EAAK/G,EAAKoF,GAMA2B,EAAKL,EAAKA,GAGEG,IAVtBG,EAAKjH,EAAKsF,IAUwB0B,EAAKJ,EAAKG,EAAKF,IAJ5CpC,EAAKA,EAAKwC,EAAKA,IAIyCD,EAAKF,EAAKH,EAAKE,GAAM,EAxLtF,CA4KJ,IAAkB9G,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIiF,EAAIC,EACtCb,EACAwC,EACAD,EACAL,EACAE,EACAC,EAGAC,EACAH,EAvKEM,EAAM1c,KAAKoX,WAAWyE,GACtBc,EAAM3c,KAAKoX,WAAW0E,GACtBc,EAAM5c,KAAKoX,WAAW2E,GACtBc,EAAM7c,KAAKoX,WAAW4E,GAE5Bhc,KAAK8c,aAAanB,EAAK,GACvB3b,KAAK8c,aAAalB,EAAK,GAEvB,IAAMxD,EAAKpY,KAAKqY,aAAaN,EAAIE,EAAIiE,GAAK,EAAGU,EAAKF,EAAKf,GACjDP,EAAKpb,KAAKqY,aAAaJ,EAAIF,EAAIkE,EAAI7D,EAAIuE,EAAKE,EAAKjB,GAEvD5b,KAAKsb,UAAUlD,EAAK,GACpBpY,KAAKsb,UAAUF,EAAK,O,8BAItB,SAAiBL,EAAIrP,GACnB,IAAMiQ,EAAKjQ,EAAKA,EAAI,EACdmQ,EAAKF,GAAOjQ,EAAI,GAAK,EACrBoQ,EAAKH,GAAOjQ,EAAI,GAAK,EACrBqM,EAAK/X,KAAKsS,UAAUwJ,GACpBG,EAAKjc,KAAKsS,UAAU5G,GACpBwQ,EAAKlc,KAAKsS,UAAUuJ,GACpBa,EAAM1c,KAAKoX,WAAWyE,GACtBc,EAAM3c,KAAKoX,WAAW0E,GAEtBvI,EAAIvT,KAAKoX,WAAW1L,GAE1B,GAAI6H,EAAI,EAAG,CACT,IAAM6E,EAAKpY,KAAKqY,aAAa0C,EAAIhD,EAAIkE,GAAK,EAAGU,GAAM,EAAGhB,GAChDP,EAAKpb,KAAKqY,aAAaN,EAAIgD,EAAImB,EAAI9D,GAAK,EAAGsE,GAGjD,OAFA1c,KAAKsb,UAAUlD,EAAK,QACpBpY,KAAKsb,UAAUF,EAAK,GAItB,IAAMQ,EAAKrI,EAAKA,EAAI,EACdwI,EAAKH,GAAOrI,EAAI,GAAK,EACrByI,EAAKJ,GAAOrI,EAAI,GAAK,EACrB0E,EAAKjY,KAAKsS,UAAUyJ,GACpBa,EAAM5c,KAAKoX,WAAW2E,GACtBc,EAAM7c,KAAKoX,WAAW4E,GAE5Bhc,KAAK8c,aAAalB,EAAK,GAEvB,IAAMxD,EAAKpY,KAAKqY,aAAaN,EAAIkE,EAAIlB,EAAI4B,GAAM,GAAI,EAAGhB,GAChDP,EAAKpb,KAAKqY,aAAa4D,EAAIhE,EAAI8C,EAAI8B,GAAM,EAAGzE,EAAK,EAAGwD,GACpDP,EAAKrb,KAAKqY,aAAaJ,EAAIiE,EAAInB,EAAI6B,GAAM,EAAGxB,EAAK,GACjD2B,EAAK/c,KAAKqY,aAAa6D,EAAInE,EAAIgD,EAAI2B,EAAKtE,EAAK,EAAGiD,EAAK,GAE3Drb,KAAKsb,UAAUlD,GACfpY,KAAKsb,UAAUF,GACfpb,KAAKsb,UAAUD,GACfrb,KAAKsb,UAAUyB,K,wBAKjB,SAAW3e,EAAGsB,EAAOsa,GACnB,IAAM9c,EAAI8C,KAAKuX,OAAO7V,OACtB1B,KAAKsX,cAAclZ,GAAKlB,EACxB8C,KAAKuX,OAAOhR,KAAKnI,GACjB4B,KAAKwX,QAAQjR,KAAK7G,GAClBM,KAAK4X,SAAWoC,EAChBha,KAAKgd,SAAS9f,K,uBAGhB,WACE,IAAMyB,EAAIqB,KAAKuX,OAAO7V,OAAS,EAG/B,OAFA1B,KAAKid,WAAW,EAAGte,GACnBqB,KAAKkd,WAAW,EAAGve,GACZqB,KAAKmd,kB,2BAGd,WACE,IAAM/e,EAAI4B,KAAKuX,OAAO7P,MAItB,OAHA1H,KAAKwX,QAAQ9P,MACb1H,KAAK4X,SAAW5X,KAAKyX,KAAKrZ,GAC1B4B,KAAKsX,cAAclZ,IAAM,EAClBA,I,0BAGT,SAAaA,GACX,IAAMlB,EAAI8C,KAAKsX,cAAclZ,GAC7B,GAAIlB,EAAI,EAAR,CACE,IAAMkgB,EAAKpd,KAAK0X,SAAS2F,QAAQjf,GACjC,IAAY,IAARgf,EAGF,MAAM,IAAIxZ,MAAM,gDAFhB5D,KAAK0X,SAAS0F,GAAMpd,KAAK0X,WAAW1X,KAAK2X,iBAH7C,CASA,IAAMhZ,EAAIqB,KAAKuX,OAAO7V,OAAS,EAC3B/C,IAAMzB,IACR8C,KAAKid,WAAW/f,EAAGyB,GACdqB,KAAKkd,WAAWhgB,EAAGyB,IACtBqB,KAAKgd,SAAS9f,IAGlB8C,KAAKmd,mB,wBAGP,SAAWjgB,EAAGogB,GACZ,OAAOtd,KAAKwX,QAAQta,GAAK8C,KAAKwX,QAAQ8F,K,wBAGxC,SAAWpgB,EAAGogB,GACZ,IAAMC,EAAKvd,KAAKuX,OAAOra,GACjBsgB,EAAKxd,KAAKuX,OAAO+F,GACvBtd,KAAKuX,OAAOra,GAAKsgB,EACjBxd,KAAKuX,OAAO+F,GAAKC,EACjBvd,KAAKsX,cAAciG,GAAMD,EACzBtd,KAAKsX,cAAckG,GAAMtgB,EACzB,IAAMwe,EAAI1b,KAAKwX,QAAQta,GACvB8C,KAAKwX,QAAQta,GAAK8C,KAAKwX,QAAQ8F,GAC/Btd,KAAKwX,QAAQ8F,GAAK5B,I,sBAGpB,SAAS+B,GAEP,IADA,IAAIH,EAAIG,IACK,CACX,IAAMvgB,EAAKogB,EAAI,GAAM,EACrB,GAAIpgB,IAAMogB,IAAMtd,KAAK0d,WAAWJ,EAAGpgB,GACjC,MAEF8C,KAAKid,WAAW/f,EAAGogB,GACnBA,EAAIpgB,K,wBAIR,SAAWygB,EAAIhf,GAEb,IADA,IAAIzB,EAAIygB,IACK,CACX,IAAMC,EAAK,EAAI1gB,EAAI,EACnB,GAAI0gB,GAAMjf,GAAKif,EAAK,EAClB,MAEF,IAAMC,EAAKD,EAAK,EACZN,EAAIM,EAIR,GAHIC,EAAKlf,GAAKqB,KAAK0d,WAAWG,EAAID,KAChCN,EAAIO,IAED7d,KAAK0d,WAAWJ,EAAGpgB,GACtB,MAEF8C,KAAKid,WAAW/f,EAAGogB,GACnBpgB,EAAIogB,EAEN,OAAOpgB,EAAIygB,M,KAIf,SAASxE,EAAO5D,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GAClC,OAAQH,EAAKE,IAAOH,EAAKI,IAAOF,EAAKE,IAAOL,EAAKI,GChenD,SAASmI,EAAWC,EAAW5G,EAAOtH,EAAQmO,EAAkBC,GAO9D,IANA,IAAOC,EAAqCF,EAArCE,QAASC,EAA4BH,EAA5BG,QAASC,EAAmBJ,EAAnBI,QAASlM,EAAU8L,EAAV9L,OAI5B8D,EAAU,IAAI3I,cAAc8J,EAAQ,IAAMtH,EAAS,IAEhD3S,EAAI,EAAG8P,EAAI,EAAGA,EAAI6C,EAAQ7C,IACjC,IAAK,IAAID,EAAI,EAAGA,EAAIoK,EAAOpK,IAAK7P,IAAK,CACnC,IAAM6Y,EAAQ,EAAJ7Y,EACJc,EAAI+f,EAAUhI,EAAI,GAClBsI,EAAIN,EAAUhI,EAAI,GAClBxC,EAAIwK,EAAUhI,EAAI,GACxBC,EAAQ9Y,EAAI8P,GAAKhP,EAAIkgB,EAAUG,EAAID,EAAU7K,EAAI4K,EAAUjM,EAI/D,GAAmB,YAAf+L,EAA0B,CAE5B,IAAK,IAAI/gB,GAAKia,EAAQ,GAAKA,EAAOpK,EAAI,EAAGA,EAAIoK,EAAOpK,IAAK7P,IACvD8Y,EAAQ9Y,GAAK8Y,EAAQ9Y,EAAIia,EAAQ,GAGnC,IAAK,IAAIja,EAAI2S,EAAQ7C,EAAI,EAAGA,EAAI6C,EAAS,EAAG7C,IAAK9P,GAAK2S,EAAS,EAC7DmG,EAAQ9Y,GAAK8Y,EAAQ9Y,EAAI,GAI7B,OAAO8Y,EA0CT,SAASsI,GAAQC,EAAcC,GAC7B,GAAqB,OAAjBD,EACF,OAAO,KAET,IAIIvI,EACAyI,EALGC,EAA0CF,EAA1CE,aAAcvK,EAA4BqK,EAA5BrK,OAAQ6J,EAAoBQ,EAApBR,iBAEtB9T,EAAuBqU,EAAvBrU,KAAMiN,EAAiBoH,EAAjBpH,MAAOtH,EAAU0O,EAAV1O,OAIpB,OAAQ2O,EAAeP,YACrB,IAAK,UAEHQ,EAAOE,GAAmBD,EAAcvH,EADxCnB,EAAU8H,EAAW5T,EAAMiN,EAAOtH,EAAQmO,EAAkBQ,EAAeP,aAE3E,MACF,IAAK,UAEHQ,EAAOG,GAAmBF,EAAcvH,EAAOtH,EAD/CmG,EAAU8H,EAAW5T,EAAMiN,EAAOtH,EAAQmO,EAAkBQ,EAAeP,aAE3E,MAEF,QAMIQ,EALEtH,IAAUtH,GAAYA,EAAUsH,EAAQ,EAKnCyH,GAAmBF,EAAcvH,EAAOtH,EAD/CmG,EAAU8H,EAAW5T,EAAMiN,EAAOtH,EAAQmO,EAAkB,YAFrDW,GAAmBD,EAAcvH,EADxCnB,EAAU8H,EAAW5T,EAAMiN,EAAOtH,EAAQmO,EAAkB,YASlE,IAAOjH,EAAY0H,EAAZ1H,SACFzE,EAAamM,EAAbnM,UACDjG,EAxEN,SAA2B0K,EAAUf,EAASmB,EAAOtH,EAAQsE,GAY3D,IAXA,IAAMe,EAAWiC,EAAQ,EACnB0H,EAAiB9H,EAASrV,OAAS,EAEnCmL,EAAY,IAAIQ,aAA8B,EAAjBwR,GAE7BlK,EAAY,IAAItH,aAA8B,EAAjBwR,GAEnC,EAAiC1K,GAAU,CAAC,EAAG,EAAGgD,EAAOtH,GAAzD,WAAOvD,EAAP,KAAaE,EAAb,KAAmBE,EAAnB,KAAyBC,EAAzB,KACM4H,GAAU7H,EAAOJ,GAAQ6K,EACzB3C,GAAU7H,EAAOH,GAAQqD,EAEtB3S,EAAI,EAAGA,EAAI2hB,EAAgB3hB,IAAK,CACvC,IAAM6P,EAAIgK,EAAa,EAAJ7Z,GACb8P,EAAI+J,EAAa,EAAJ7Z,EAAQ,GACrB4hB,EAAW9R,EAAIkI,EAAWnI,EAEhCF,EAAU,EAAI3P,EAAI,GAAK6P,EAAIwH,EAASjI,EACpCO,EAAU,EAAI3P,EAAI,IAAM8P,EAAIwH,EAAS7H,EACrCE,EAAU,EAAI3P,EAAI,GAAK8Y,EAAQ8I,GAE/BnK,EAAU,EAAIzX,EAAI,GAAK6P,EAAIoK,EAC3BxC,EAAU,EAAIzX,EAAI,GAAK8P,EAAI6C,EAG7B,MAAO,CACL/C,SAAU,CAAC3O,MAAO0O,EAAW+H,KAAM,GACnC9B,WAAY,CAAC3U,MAAOwW,EAAWC,KAAM,IA6CtBC,CAAkBkC,EAAUf,EAASmB,EAAOtH,EAAQsE,GAG/DW,EAAc1I,EAAmBC,GAEvC,GAAImS,EAAejM,YAAa,CAC9B,MAA6DF,EAC3DhG,EACAiG,EACAkM,EAAejM,aAEjBlG,EALA,EAAOA,WAMPiG,EANA,EAAkCA,UASpC,MAAO,CAELyC,WAAY,CACVlG,OAAQ,IAEVA,OAAQ,CACNM,YAAamD,EAAU5Q,OACvBoT,eAEFzW,KAAM,EACNsP,QAAS,CAACxP,MAAO2P,YAAY3L,KAAKmQ,GAAYsC,KAAM,GACpDvI,cAYJ,SAASsS,GAAmBD,EAAcvH,EAAOnB,GAC/C,IAGA,EAFgB,IAAIf,EADHkC,EAAQ,GAEJ4H,WAAW/I,GACGsI,QAAQI,GAE3C,MAAO,CAAC3H,SAFR,EAAOA,SAEWzE,UAFlB,EAAiBA,WAcnB,SAASsM,GAAmBF,EAAcvH,EAAOtH,EAAQmG,GACvD,IAAMgJ,EAAM,IAAI9H,EAAQlB,EAASmB,EAAQ,EAAGtH,EAAS,GAIrD,OAHAmP,EAAIC,IAAIP,GAGD,CAAC3H,SAFoBiI,EAArB1J,OAEWhD,UAFU0M,EAAb1M,W,sCAKF,WAA2BjH,EAAaC,EAAS/H,GAAjD,eAAAmI,EAAA,6DACbJ,EAAQ4T,MAAQ5T,EAAQ4T,OAAS,GACjC5T,EAAQ4T,MAAM1a,KAAO,OAFR,SAGOjB,EAAQsI,MAAMR,EAAaC,EAASA,EAAQ6T,SAHnD,cAGPD,EAHO,yBAKNZ,GAAQY,EAAO5T,EAAQ0K,UALjB,4C,sBCzKR,ICGMoJ,GAAgB,CAC3B3hB,KAAM,UACN8N,GAAI,UACJtO,OAAQ,UACRoiB,QDPqB,gBCQrBlT,QAAQ,EACR6E,WAAY,CAAC,MAAO,UACpBsO,UAAW,CAAC,aACZhU,QAAS,CACP0K,QAAS,CACPiI,WAAY,OACZ9J,OAAQ,KACRuK,aAAc,GACdV,iBAAkB,CAChBE,QAAS,EACTE,QAAS,EACTD,QAAS,EACTjM,OAAQ,GAEVK,YAAa,QCnBNgN,GAAsB,CACjC9hB,KAAM,iBACN8N,GAAI,iBACJtO,OAAQ,UACRoiB,QFPqB,gBEQrBlT,QAAQ,EACR6E,WAAY,CAAC,WACbsO,UAAW,CAAC,kCACZhU,QAAS,CACP,iBAAkB,CAChB6I,OAAQ,CAAC,EAAG,EAAG,EAAG,GAClB5B,YAAa,Q,qkBCNU,SACxBiN,IADqB,IAExB3T,MJ+Ja,SAAf,0CIjKO,IAiBA,GZjB4BF,GYctB4T,GAAsB,SAC9BE,IAD2B,IAE9B7T,UAAW8T,EACX7T,OAAK,iBAAE,WAAOR,EAAaC,GAApB,SAAAI,EAAA,+EAAgCgU,EAAmBrU,EAAaC,IAAhE,2CAAF,kDZjB4BK,GaRhB4T,GbUG,oBAATxf,OAIX8J,EAAWE,UAAX,+BAAuB,WAAOvF,EAAM2F,GAAb,uBAAAuB,EAAA,2DACblH,EADa,OAEd,YAFc,uCAMRgH,EAAuBrB,EAAvBqB,MANQ,EAMerB,EAAhBmB,eANC,MAMS,GANT,WAQMG,EAAU,CAC7BE,UACAN,YAAaG,EACbF,UACA/H,QAAS,CACPsI,MAAOT,KAbI,OAQT3F,EARS,OAgBfoE,EAAWoB,YAAY,OAAQ,CAACxF,WAhBjB,kDAkBTuE,EAAU,gBAAiBpG,MAAQ,KAAMoG,QAAU,GACzDH,EAAWoB,YAAY,QAAS,CAACvL,MAAOsK,IAnBzB,8FAAvB","file":"quantized-mesh-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 = 20);\n","module.exports = require(\"regenerator-runtime\");\n","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    module.exports = _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  } else {\n    module.exports = _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  }\n\n  return _typeof(obj);\n}\n\nmodule.exports = _typeof;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var arrayWithHoles = require(\"./arrayWithHoles.js\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit.js\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\n\nvar nonIterableRest = require(\"./nonIterableRest.js\");\n\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var arrayWithoutHoles = require(\"./arrayWithoutHoles.js\");\n\nvar iterableToArray = require(\"./iterableToArray.js\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread.js\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _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;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\n\nmodule.exports = _unsupportedIterableToArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nmodule.exports = _arrayLikeToArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","/**\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","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _iterableToArrayLimit(arr, i) {\n  var _i = arr && (typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]);\n\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n\n  var _s, _e;\n\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nmodule.exports = _iterableToArrayLimit;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableRest;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableSpread;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","// 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","// Mesh category utilities\n// TODO - move to mesh category module, or to math.gl/geometry module\nimport {TypedArray} from '../../types';\nimport {MeshAttributes} from './mesh-types';\n\ntype TypedArrays = {[key: string]: TypedArray};\n\n/**\n * Holds an axis aligned bounding box\n * TODO - make sure AxisAlignedBoundingBox in math.gl/culling understands this format (or change this format)\n */\ntype BoundingBox = [[number, number, number], [number, number, number]];\n\n/**\n * Get number of vertices in mesh\n * @param attributes\n */\nexport function getMeshSize(attributes: TypedArrays): number {\n  let size = 0;\n  for (const attributeName in attributes) {\n    const attribute = attributes[attributeName];\n    if (ArrayBuffer.isView(attribute)) {\n      // @ts-ignore DataView doesn't have BYTES_PER_ELEMENT\n      size += attribute.byteLength * attribute.BYTES_PER_ELEMENT;\n    }\n  }\n  return size;\n}\n\n/**\n * Get the (axis aligned) bounding box of a mesh\n * @param attributes\n * @returns array of two vectors representing the axis aligned bounding box\n */\n// eslint-disable-next-line complexity\nexport function getMeshBoundingBox(attributes: MeshAttributes): BoundingBox {\n  let minX = Infinity;\n  let minY = Infinity;\n  let minZ = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let maxZ = -Infinity;\n\n  const positions = attributes.POSITION ? attributes.POSITION.value : [];\n  const len = positions && positions.length;\n\n  for (let i = 0; i < len; i += 3) {\n    const x = positions[i];\n    const y = positions[i + 1];\n    const z = positions[i + 2];\n\n    minX = x < minX ? x : minX;\n    minY = y < minY ? y : minY;\n    minZ = z < minZ ? z : minZ;\n\n    maxX = x > maxX ? x : maxX;\n    maxY = y > maxY ? y : maxY;\n    maxZ = z > maxZ ? z : maxZ;\n  }\n  return [\n    [minX, minY, minZ],\n    [maxX, maxY, maxZ]\n  ];\n}\n","// Copyright (C) 2018-2019 HERE Europe B.V.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\nconst QUANTIZED_MESH_HEADER = new Map([\n  ['centerX', Float64Array.BYTES_PER_ELEMENT],\n  ['centerY', Float64Array.BYTES_PER_ELEMENT],\n  ['centerZ', Float64Array.BYTES_PER_ELEMENT],\n\n  ['minHeight', Float32Array.BYTES_PER_ELEMENT],\n  ['maxHeight', Float32Array.BYTES_PER_ELEMENT],\n\n  ['boundingSphereCenterX', Float64Array.BYTES_PER_ELEMENT],\n  ['boundingSphereCenterY', Float64Array.BYTES_PER_ELEMENT],\n  ['boundingSphereCenterZ', Float64Array.BYTES_PER_ELEMENT],\n  ['boundingSphereRadius', Float64Array.BYTES_PER_ELEMENT],\n\n  ['horizonOcclusionPointX', Float64Array.BYTES_PER_ELEMENT],\n  ['horizonOcclusionPointY', Float64Array.BYTES_PER_ELEMENT],\n  ['horizonOcclusionPointZ', Float64Array.BYTES_PER_ELEMENT]\n]);\n\nfunction decodeZigZag(value) {\n  return (value >> 1) ^ -(value & 1);\n}\n\nfunction decodeHeader(dataView) {\n  let position = 0;\n  const header = {};\n\n  for (const [key, bytesCount] of QUANTIZED_MESH_HEADER) {\n    const getter = bytesCount === 8 ? dataView.getFloat64 : dataView.getFloat32;\n\n    header[key] = getter.call(dataView, position, true);\n    position += bytesCount;\n  }\n\n  return {header, headerEndPosition: position};\n}\n\nfunction decodeVertexData(dataView, headerEndPosition) {\n  let position = headerEndPosition;\n  const elementsPerVertex = 3;\n  const vertexCount = dataView.getUint32(position, true);\n  const vertexData = new Uint16Array(vertexCount * elementsPerVertex);\n\n  position += Uint32Array.BYTES_PER_ELEMENT;\n\n  const bytesPerArrayElement = Uint16Array.BYTES_PER_ELEMENT;\n  const elementArrayLength = vertexCount * bytesPerArrayElement;\n  const uArrayStartPosition = position;\n  const vArrayStartPosition = uArrayStartPosition + elementArrayLength;\n  const heightArrayStartPosition = vArrayStartPosition + elementArrayLength;\n\n  let u = 0;\n  let v = 0;\n  let height = 0;\n\n  for (let i = 0; i < vertexCount; i++) {\n    u += decodeZigZag(dataView.getUint16(uArrayStartPosition + bytesPerArrayElement * i, true));\n    v += decodeZigZag(dataView.getUint16(vArrayStartPosition + bytesPerArrayElement * i, true));\n    height += decodeZigZag(\n      dataView.getUint16(heightArrayStartPosition + bytesPerArrayElement * i, true)\n    );\n\n    vertexData[i] = u;\n    vertexData[i + vertexCount] = v;\n    vertexData[i + vertexCount * 2] = height;\n  }\n\n  position += elementArrayLength * 3;\n\n  return {vertexData, vertexDataEndPosition: position};\n}\n\nfunction decodeIndex(buffer, position, indicesCount, bytesPerIndex, encoded = true) {\n  let indices;\n\n  if (bytesPerIndex === 2) {\n    indices = new Uint16Array(buffer, position, indicesCount);\n  } else {\n    indices = new Uint32Array(buffer, position, indicesCount);\n  }\n\n  if (!encoded) {\n    return indices;\n  }\n\n  let highest = 0;\n\n  for (let i = 0; i < indices.length; ++i) {\n    const code = indices[i];\n\n    indices[i] = highest - code;\n\n    if (code === 0) {\n      ++highest;\n    }\n  }\n\n  return indices;\n}\n\nfunction decodeTriangleIndices(dataView, vertexData, vertexDataEndPosition) {\n  let position = vertexDataEndPosition;\n  const elementsPerVertex = 3;\n  const vertexCount = vertexData.length / elementsPerVertex;\n  const bytesPerIndex =\n    vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;\n\n  if (position % bytesPerIndex !== 0) {\n    position += bytesPerIndex - (position % bytesPerIndex);\n  }\n\n  const triangleCount = dataView.getUint32(position, true);\n  position += Uint32Array.BYTES_PER_ELEMENT;\n\n  const triangleIndicesCount = triangleCount * 3;\n  const triangleIndices = decodeIndex(\n    dataView.buffer,\n    position,\n    triangleIndicesCount,\n    bytesPerIndex\n  );\n  position += triangleIndicesCount * bytesPerIndex;\n\n  return {\n    triangleIndicesEndPosition: position,\n    triangleIndices\n  };\n}\n\nfunction decodeEdgeIndices(dataView, vertexData, triangleIndicesEndPosition) {\n  let position = triangleIndicesEndPosition;\n  const elementsPerVertex = 3;\n  const vertexCount = vertexData.length / elementsPerVertex;\n  const bytesPerIndex =\n    vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;\n\n  const westVertexCount = dataView.getUint32(position, true);\n  position += Uint32Array.BYTES_PER_ELEMENT;\n\n  const westIndices = decodeIndex(dataView.buffer, position, westVertexCount, bytesPerIndex, false);\n  position += westVertexCount * bytesPerIndex;\n\n  const southVertexCount = dataView.getUint32(position, true);\n  position += Uint32Array.BYTES_PER_ELEMENT;\n\n  const southIndices = decodeIndex(\n    dataView.buffer,\n    position,\n    southVertexCount,\n    bytesPerIndex,\n    false\n  );\n  position += southVertexCount * bytesPerIndex;\n\n  const eastVertexCount = dataView.getUint32(position, true);\n  position += Uint32Array.BYTES_PER_ELEMENT;\n\n  const eastIndices = decodeIndex(dataView.buffer, position, eastVertexCount, bytesPerIndex, false);\n  position += eastVertexCount * bytesPerIndex;\n\n  const northVertexCount = dataView.getUint32(position, true);\n  position += Uint32Array.BYTES_PER_ELEMENT;\n\n  const northIndices = decodeIndex(\n    dataView.buffer,\n    position,\n    northVertexCount,\n    bytesPerIndex,\n    false\n  );\n  position += northVertexCount * bytesPerIndex;\n\n  return {\n    edgeIndicesEndPosition: position,\n    westIndices,\n    southIndices,\n    eastIndices,\n    northIndices\n  };\n}\n\nfunction decodeVertexNormalsExtension(extensionDataView) {\n  return new Uint8Array(\n    extensionDataView.buffer,\n    extensionDataView.byteOffset,\n    extensionDataView.byteLength\n  );\n}\n\nfunction decodeWaterMaskExtension(extensionDataView) {\n  return extensionDataView.buffer.slice(\n    extensionDataView.byteOffset,\n    extensionDataView.byteOffset + extensionDataView.byteLength\n  );\n}\n\nfunction decodeExtensions(dataView, indicesEndPosition) {\n  const extensions = {};\n\n  if (dataView.byteLength <= indicesEndPosition) {\n    return {extensions, extensionsEndPosition: indicesEndPosition};\n  }\n\n  let position = indicesEndPosition;\n\n  while (position < dataView.byteLength) {\n    const extensionId = dataView.getUint8(position, true);\n    position += Uint8Array.BYTES_PER_ELEMENT;\n\n    const extensionLength = dataView.getUint32(position, true);\n    position += Uint32Array.BYTES_PER_ELEMENT;\n\n    const extensionView = new DataView(dataView.buffer, position, extensionLength);\n\n    switch (extensionId) {\n      case 1: {\n        extensions.vertexNormals = decodeVertexNormalsExtension(extensionView);\n\n        break;\n      }\n      case 2: {\n        extensions.waterMask = decodeWaterMaskExtension(extensionView);\n\n        break;\n      }\n      default: {\n        // console.warn(`Unknown extension with id ${extensionId}`)\n      }\n    }\n\n    position += extensionLength;\n  }\n\n  return {extensions, extensionsEndPosition: position};\n}\n\nexport const DECODING_STEPS = {\n  header: 0,\n  vertices: 1,\n  triangleIndices: 2,\n  edgeIndices: 3,\n  extensions: 4\n};\n\nconst DEFAULT_OPTIONS = {\n  maxDecodingStep: DECODING_STEPS.extensions\n};\n\nexport default function decode(data, userOptions) {\n  const options = Object.assign({}, DEFAULT_OPTIONS, userOptions);\n  const view = new DataView(data);\n  const {header, headerEndPosition} = decodeHeader(view);\n\n  if (options.maxDecodingStep < DECODING_STEPS.vertices) {\n    return {header};\n  }\n\n  const {vertexData, vertexDataEndPosition} = decodeVertexData(view, headerEndPosition);\n\n  if (options.maxDecodingStep < DECODING_STEPS.triangleIndices) {\n    return {header, vertexData};\n  }\n\n  const {triangleIndices, triangleIndicesEndPosition} = decodeTriangleIndices(\n    view,\n    vertexData,\n    vertexDataEndPosition\n  );\n\n  if (options.maxDecodingStep < DECODING_STEPS.edgeIndices) {\n    return {header, vertexData, triangleIndices};\n  }\n\n  const {westIndices, southIndices, eastIndices, northIndices, edgeIndicesEndPosition} =\n    decodeEdgeIndices(view, vertexData, triangleIndicesEndPosition);\n\n  if (options.maxDecodingStep < DECODING_STEPS.extensions) {\n    return {\n      header,\n      vertexData,\n      triangleIndices,\n      westIndices,\n      northIndices,\n      eastIndices,\n      southIndices\n    };\n  }\n\n  const {extensions} = decodeExtensions(view, edgeIndicesEndPosition);\n\n  return {\n    header,\n    vertexData,\n    triangleIndices,\n    westIndices,\n    northIndices,\n    eastIndices,\n    southIndices,\n    extensions\n  };\n}\n","import {TypedArray} from '../../types';\nimport {isBuffer, bufferToArrayBuffer} from './buffer-utils';\n\n/**\n * Convert an object to an array buffer\n */\nexport function toArrayBuffer(data: any): ArrayBuffer {\n  // Note: Should be called first, Buffers can trigger other detections below\n  if (isBuffer(data)) {\n    return bufferToArrayBuffer(data);\n  }\n\n  if (data instanceof ArrayBuffer) {\n    return data;\n  }\n\n  // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)\n  if (ArrayBuffer.isView(data)) {\n    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {\n      return data.buffer;\n    }\n    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);\n  }\n\n  if (typeof data === 'string') {\n    const text = data;\n    const uint8Array = new TextEncoder().encode(text);\n    return uint8Array.buffer;\n  }\n\n  // HACK to support Blob polyfill\n  if (data && typeof data === 'object' && data._toArrayBuffer) {\n    return data._toArrayBuffer();\n  }\n\n  throw new Error('toArrayBuffer');\n}\n\n/**\n * compare two binary arrays for equality\n * @param {ArrayBuffer} a\n * @param {ArrayBuffer} b\n * @param {number} byteLength\n */\nexport function compareArrayBuffers(\n  arrayBuffer1: ArrayBuffer,\n  arrayBuffer2: ArrayBuffer,\n  byteLength?: number\n): boolean {\n  byteLength = byteLength || arrayBuffer1.byteLength;\n  if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {\n    return false;\n  }\n  const array1 = new Uint8Array(arrayBuffer1);\n  const array2 = new Uint8Array(arrayBuffer2);\n  for (let i = 0; i < array1.length; ++i) {\n    if (array1[i] !== array2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Concatenate a sequence of ArrayBuffers\n * @return A concatenated ArrayBuffer\n */\nexport function concatenateArrayBuffers(...sources: (ArrayBuffer | Uint8Array)[]): ArrayBuffer {\n  // Make sure all inputs are wrapped in typed arrays\n  const sourceArrays = sources.map((source2) =>\n    source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2\n  );\n\n  // Get length of all inputs\n  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);\n\n  // Allocate array with space for all inputs\n  const result = new Uint8Array(byteLength);\n\n  // Copy the subarrays\n  let offset = 0;\n  for (const sourceArray of sourceArrays) {\n    result.set(sourceArray, offset);\n    offset += sourceArray.byteLength;\n  }\n\n  // We work with ArrayBuffers, discard the typed array wrapper\n  return result.buffer;\n}\n\n/**\n * Concatenate arbitrary count of typed arrays\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays\n * @param {...*} arrays - list of arrays. All arrays should be the same type\n * @return A concatenated TypedArray\n */\nexport function concatenateTypedArrays<T>(...typedArrays: T[]): T {\n  // @ts-ignore\n  const arrays = typedArrays as TypedArray[];\n  // @ts-ignore\n  const TypedArrayConstructor = (arrays && arrays.length > 1 && arrays[0].constructor) || null;\n  if (!TypedArrayConstructor) {\n    throw new Error(\n      '\"concatenateTypedArrays\" - incorrect quantity of arguments or arguments have incompatible data types'\n    );\n  }\n\n  const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);\n  // @ts-ignore typescript does not like dynamic constructors\n  const result = new TypedArrayConstructor(sumLength);\n  let offset = 0;\n  for (const array of arrays) {\n    result.set(array, offset);\n    offset += array.length;\n  }\n  return result;\n}\n\n/**\n * Copy a view of an ArrayBuffer into new ArrayBuffer with byteOffset = 0\n * @param arrayBuffer\n * @param byteOffset\n * @param byteLength\n */\nexport function sliceArrayBuffer(\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number,\n  byteLength?: number\n): ArrayBuffer {\n  const subArray =\n    byteLength !== undefined\n      ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength)\n      : new Uint8Array(arrayBuffer).subarray(byteOffset);\n  const arrayCopy = new Uint8Array(subArray);\n  return arrayCopy.buffer;\n}\n","import {concatenateTypedArrays} from '@loaders.gl/loader-utils';\n\n/**\n * Add skirt to existing mesh\n * @param {object} attributes - POSITION and TEXCOOD_0 attributes data\n * @param {any} triangles - indices array of the mesh geometry\n * @param {number} skirtHeight - height of the skirt geometry\n * @param {object} outsideIndices - edge indices from quantized mesh data\n * @returns - geometry data with added skirt\n */\nexport function addSkirt(attributes, triangles, skirtHeight, outsideIndices = null) {\n  const outsideEdges = outsideIndices\n    ? getOutsideEdgesFromIndices(outsideIndices, attributes.POSITION.value)\n    : getOutsideEdgesFromTriangles(triangles);\n\n  // 2 new vertices for each outside edge\n  const newPosition = new attributes.POSITION.value.constructor(outsideEdges.length * 6);\n  const newTexcoord0 = new attributes.TEXCOORD_0.value.constructor(outsideEdges.length * 4);\n\n  // 2 new triangles for each outside edge\n  const newTriangles = new triangles.constructor(outsideEdges.length * 6);\n\n  for (let i = 0; i < outsideEdges.length; i++) {\n    const edge = outsideEdges[i];\n\n    updateAttributesForNewEdge({\n      edge,\n      edgeIndex: i,\n      attributes,\n      skirtHeight,\n      newPosition,\n      newTexcoord0,\n      newTriangles\n    });\n  }\n\n  attributes.POSITION.value = concatenateTypedArrays(attributes.POSITION.value, newPosition);\n  attributes.TEXCOORD_0.value = concatenateTypedArrays(attributes.TEXCOORD_0.value, newTexcoord0);\n  const resultTriangles =\n    triangles instanceof Array\n      ? triangles.concat(newTriangles)\n      : concatenateTypedArrays(triangles, newTriangles);\n\n  return {\n    attributes,\n    triangles: resultTriangles\n  };\n}\n\n/**\n * Get geometry edges that located on a border of the mesh\n * @param {any} triangles - indices array of the mesh geometry\n * @returns {number[][]} - outside edges data\n */\nfunction getOutsideEdgesFromTriangles(triangles) {\n  const edges = [];\n  for (let i = 0; i < triangles.length; i += 3) {\n    edges.push([triangles[i], triangles[i + 1]]);\n    edges.push([triangles[i + 1], triangles[i + 2]]);\n    edges.push([triangles[i + 2], triangles[i]]);\n  }\n\n  edges.sort((a, b) => Math.min(...a) - Math.min(...b) || Math.max(...a) - Math.max(...b));\n\n  const outsideEdges = [];\n  let index = 1;\n  while (index < edges.length) {\n    if (edges[index][0] === edges[index - 1][1] && edges[index][1] === edges[index - 1][0]) {\n      index += 2;\n    } else {\n      outsideEdges.push(edges[index - 1]);\n      index++;\n    }\n  }\n  return outsideEdges;\n}\n\n/**\n * Get geometry edges that located on a border of the mesh\n * @param {object} indices - edge indices from quantized mesh data\n * @param {TypedArray} position - position attribute geometry data\n * @returns {number[][]} - outside edges data\n */\nfunction getOutsideEdgesFromIndices(indices, position) {\n  // Sort skirt indices to create adjacent triangles\n  indices.westIndices.sort((a, b) => position[3 * a + 1] - position[3 * b + 1]);\n  // Reverse (b - a) to match triangle winding\n  indices.eastIndices.sort((a, b) => position[3 * b + 1] - position[3 * a + 1]);\n  indices.southIndices.sort((a, b) => position[3 * b] - position[3 * a]);\n  // Reverse (b - a) to match triangle winding\n  indices.northIndices.sort((a, b) => position[3 * a] - position[3 * b]);\n\n  const edges = [];\n  for (const index in indices) {\n    const indexGroup = indices[index];\n    for (let i = 0; i < indexGroup.length - 1; i++) {\n      edges.push([indexGroup[i], indexGroup[i + 1]]);\n    }\n  }\n  return edges;\n}\n\n/**\n * Get geometry edges that located on a border of the mesh\n * @param {object} args\n * @param {number[]} args.edge - edge indices in geometry\n * @param {number} args.edgeIndex - edge index in outsideEdges array\n * @param {object} args.attributes - POSITION and TEXCOORD_0 attributes\n * @param {number} args.skirtHeight - height of the skirt geometry\n * @param {TypedArray} args.newPosition - POSITION array for skirt data\n * @param {TypedArray} args.newTexcoord0 - TEXCOORD_0 array for skirt data\n * @param {TypedArray | Array} args.newTriangles - trinagle indices array for skirt data\n * @returns {void}\n */\nfunction updateAttributesForNewEdge({\n  edge,\n  edgeIndex,\n  attributes,\n  skirtHeight,\n  newPosition,\n  newTexcoord0,\n  newTriangles\n}) {\n  const positionsLength = attributes.POSITION.value.length;\n  const vertex1Offset = edgeIndex * 2;\n  const vertex2Offset = edgeIndex * 2 + 1;\n\n  // Define POSITION for new 1st vertex\n  newPosition.set(\n    attributes.POSITION.value.subarray(edge[0] * 3, edge[0] * 3 + 3),\n    vertex1Offset * 3\n  );\n  newPosition[vertex1Offset * 3 + 2] = newPosition[vertex1Offset * 3 + 2] - skirtHeight; // put down elevation on the skirt height\n\n  // Define POSITION for new 2nd vertex\n  newPosition.set(\n    attributes.POSITION.value.subarray(edge[1] * 3, edge[1] * 3 + 3),\n    vertex2Offset * 3\n  );\n  newPosition[vertex2Offset * 3 + 2] = newPosition[vertex2Offset * 3 + 2] - skirtHeight; // put down elevation on the skirt height\n\n  // Use same TEXCOORDS for skirt vertices\n  newTexcoord0.set(\n    attributes.TEXCOORD_0.value.subarray(edge[0] * 2, edge[0] * 2 + 2),\n    vertex1Offset * 2\n  );\n  newTexcoord0.set(\n    attributes.TEXCOORD_0.value.subarray(edge[1] * 2, edge[1] * 2 + 2),\n    vertex2Offset * 2\n  );\n\n  // Define new triangles\n  const triangle1Offset = edgeIndex * 2 * 3;\n  newTriangles[triangle1Offset] = edge[0];\n  newTriangles[triangle1Offset + 1] = edge[1];\n  newTriangles[triangle1Offset + 2] = positionsLength / 3 + vertex2Offset;\n\n  newTriangles[triangle1Offset + 3] = positionsLength / 3 + vertex2Offset;\n  newTriangles[triangle1Offset + 4] = positionsLength / 3 + vertex1Offset;\n  newTriangles[triangle1Offset + 5] = edge[0];\n}\n","import {getMeshBoundingBox} from '@loaders.gl/schema';\nimport decode, {DECODING_STEPS} from './decode-quantized-mesh';\nimport {addSkirt} from './helpers/skirt';\n\nfunction getMeshAttributes(vertexData, header, bounds) {\n  const {minHeight, maxHeight} = header;\n  const [minX, minY, maxX, maxY] = bounds || [0, 0, 1, 1];\n  const xScale = maxX - minX;\n  const yScale = maxY - minY;\n  const zScale = maxHeight - minHeight;\n\n  const nCoords = vertexData.length / 3;\n  // vec3. x, y defined by bounds, z in meters\n  const positions = new Float32Array(nCoords * 3);\n\n  // vec2. 1 to 1 relationship with position. represents the uv on the texture image. 0,0 to 1,1.\n  const texCoords = new Float32Array(nCoords * 2);\n\n  // Data is not interleaved; all u, then all v, then all heights\n  for (let i = 0; i < nCoords; i++) {\n    const x = vertexData[i] / 32767;\n    const y = vertexData[i + nCoords] / 32767;\n    const z = vertexData[i + nCoords * 2] / 32767;\n\n    positions[3 * i + 0] = x * xScale + minX;\n    positions[3 * i + 1] = y * yScale + minY;\n    positions[3 * i + 2] = z * zScale + minHeight;\n\n    texCoords[2 * i + 0] = x;\n    texCoords[2 * i + 1] = y;\n  }\n\n  return {\n    POSITION: {value: positions, size: 3},\n    TEXCOORD_0: {value: texCoords, size: 2}\n    // TODO: Parse normals if they exist in the file\n    // NORMAL: {}, - optional, but creates the high poly look with lighting\n  };\n}\n\nfunction getTileMesh(arrayBuffer, options) {\n  if (!arrayBuffer) {\n    return null;\n  }\n  const {bounds} = options;\n  // Don't parse edge indices or format extensions\n  const {\n    header,\n    vertexData,\n    triangleIndices: originalTriangleIndices,\n    westIndices,\n    northIndices,\n    eastIndices,\n    southIndices\n  } = decode(arrayBuffer, DECODING_STEPS.triangleIndices);\n  let triangleIndices = originalTriangleIndices;\n  let attributes = getMeshAttributes(vertexData, header, bounds);\n\n  // Compute bounding box before adding skirt so that z values are not skewed\n  // TODO: Find bounding box from header, instead of doing extra pass over\n  // vertices.\n  const boundingBox = getMeshBoundingBox(attributes);\n\n  if (options.skirtHeight) {\n    const {attributes: newAttributes, triangles: newTriangles} = addSkirt(\n      attributes,\n      triangleIndices,\n      options.skirtHeight,\n      {\n        westIndices,\n        northIndices,\n        eastIndices,\n        southIndices\n      }\n    );\n    attributes = newAttributes;\n    triangleIndices = newTriangles;\n  }\n\n  return {\n    // Data return by this loader implementation\n    loaderData: {\n      header: {}\n    },\n    header: {\n      // @ts-ignore\n      vertexCount: triangleIndices.length,\n      boundingBox\n    },\n    mode: 4, // TRIANGLES\n    indices: {value: triangleIndices, size: 1},\n    attributes\n  };\n}\n\nexport default function loadQuantizedMesh(arrayBuffer, options) {\n  return getTileMesh(arrayBuffer, options['quantized-mesh']);\n}\n","\nexport default class Martini {\n    constructor(gridSize = 257) {\n        this.gridSize = gridSize;\n        const tileSize = gridSize - 1;\n        if (tileSize & (tileSize - 1)) throw new Error(\n            `Expected grid size to be 2^n+1, got ${gridSize}.`);\n\n        this.numTriangles = tileSize * tileSize * 2 - 2;\n        this.numParentTriangles = this.numTriangles - tileSize * tileSize;\n\n        this.indices = new Uint32Array(this.gridSize * this.gridSize);\n\n        // coordinates for all possible triangles in an RTIN tile\n        this.coords = new Uint16Array(this.numTriangles * 4);\n\n        // get triangle coordinates from its index in an implicit binary tree\n        for (let i = 0; i < this.numTriangles; i++) {\n            let id = i + 2;\n            let ax = 0, ay = 0, bx = 0, by = 0, cx = 0, cy = 0;\n            if (id & 1) {\n                bx = by = cx = tileSize; // bottom-left triangle\n            } else {\n                ax = ay = cy = tileSize; // top-right triangle\n            }\n            while ((id >>= 1) > 1) {\n                const mx = (ax + bx) >> 1;\n                const my = (ay + by) >> 1;\n\n                if (id & 1) { // left half\n                    bx = ax; by = ay;\n                    ax = cx; ay = cy;\n                } else { // right half\n                    ax = bx; ay = by;\n                    bx = cx; by = cy;\n                }\n                cx = mx; cy = my;\n            }\n            const k = i * 4;\n            this.coords[k + 0] = ax;\n            this.coords[k + 1] = ay;\n            this.coords[k + 2] = bx;\n            this.coords[k + 3] = by;\n        }\n    }\n\n    createTile(terrain) {\n        return new Tile(terrain, this);\n    }\n}\n\nclass Tile {\n    constructor(terrain, martini) {\n        const size = martini.gridSize;\n        if (terrain.length !== size * size) throw new Error(\n            `Expected terrain data of length ${size * size} (${size} x ${size}), got ${terrain.length}.`);\n\n        this.terrain = terrain;\n        this.martini = martini;\n        this.errors = new Float32Array(terrain.length);\n        this.update();\n    }\n\n    update() {\n        const {numTriangles, numParentTriangles, coords, gridSize: size} = this.martini;\n        const {terrain, errors} = this;\n\n        // iterate over all possible triangles, starting from the smallest level\n        for (let i = numTriangles - 1; i >= 0; i--) {\n            const k = i * 4;\n            const ax = coords[k + 0];\n            const ay = coords[k + 1];\n            const bx = coords[k + 2];\n            const by = coords[k + 3];\n            const mx = (ax + bx) >> 1;\n            const my = (ay + by) >> 1;\n            const cx = mx + my - ay;\n            const cy = my + ax - mx;\n\n            // calculate error in the middle of the long edge of the triangle\n            const interpolatedHeight = (terrain[ay * size + ax] + terrain[by * size + bx]) / 2;\n            const middleIndex = my * size + mx;\n            const middleError = Math.abs(interpolatedHeight - terrain[middleIndex]);\n\n            errors[middleIndex] = Math.max(errors[middleIndex], middleError);\n\n            if (i < numParentTriangles) { // bigger triangles; accumulate error with children\n                const leftChildIndex = ((ay + cy) >> 1) * size + ((ax + cx) >> 1);\n                const rightChildIndex = ((by + cy) >> 1) * size + ((bx + cx) >> 1);\n                errors[middleIndex] = Math.max(errors[middleIndex], errors[leftChildIndex], errors[rightChildIndex]);\n            }\n        }\n    }\n\n    getMesh(maxError = 0) {\n        const {gridSize: size, indices} = this.martini;\n        const {errors} = this;\n        let numVertices = 0;\n        let numTriangles = 0;\n        const max = size - 1;\n\n        // use an index grid to keep track of vertices that were already used to avoid duplication\n        indices.fill(0);\n\n        // retrieve mesh in two stages that both traverse the error map:\n        // - countElements: find used vertices (and assign each an index), and count triangles (for minimum allocation)\n        // - processTriangle: fill the allocated vertices & triangles typed arrays\n\n        function countElements(ax, ay, bx, by, cx, cy) {\n            const mx = (ax + bx) >> 1;\n            const my = (ay + by) >> 1;\n\n            if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * size + mx] > maxError) {\n                countElements(cx, cy, ax, ay, mx, my);\n                countElements(bx, by, cx, cy, mx, my);\n            } else {\n                indices[ay * size + ax] = indices[ay * size + ax] || ++numVertices;\n                indices[by * size + bx] = indices[by * size + bx] || ++numVertices;\n                indices[cy * size + cx] = indices[cy * size + cx] || ++numVertices;\n                numTriangles++;\n            }\n        }\n        countElements(0, 0, max, max, max, 0);\n        countElements(max, max, 0, 0, 0, max);\n\n        const vertices = new Uint16Array(numVertices * 2);\n        const triangles = new Uint32Array(numTriangles * 3);\n        let triIndex = 0;\n\n        function processTriangle(ax, ay, bx, by, cx, cy) {\n            const mx = (ax + bx) >> 1;\n            const my = (ay + by) >> 1;\n\n            if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * size + mx] > maxError) {\n                // triangle doesn't approximate the surface well enough; drill down further\n                processTriangle(cx, cy, ax, ay, mx, my);\n                processTriangle(bx, by, cx, cy, mx, my);\n\n            } else {\n                // add a triangle\n                const a = indices[ay * size + ax] - 1;\n                const b = indices[by * size + bx] - 1;\n                const c = indices[cy * size + cx] - 1;\n\n                vertices[2 * a] = ax;\n                vertices[2 * a + 1] = ay;\n\n                vertices[2 * b] = bx;\n                vertices[2 * b + 1] = by;\n\n                vertices[2 * c] = cx;\n                vertices[2 * c + 1] = cy;\n\n                triangles[triIndex++] = a;\n                triangles[triIndex++] = b;\n                triangles[triIndex++] = c;\n            }\n        }\n        processTriangle(0, 0, max, max, max, 0);\n        processTriangle(max, max, 0, 0, 0, max);\n\n        return {vertices, triangles};\n    }\n}\n","// ISC License\n\n// Copyright(c) 2019, Michael Fogleman, Vladimir Agafonkin\n\n// Permission to use, copy, modify, and / or distribute this software for any purpose\n// with or without fee is hereby granted, provided that the above copyright notice\n// and this permission notice appear in all copies.\n\n// THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND\n// FITNESS.IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n//   INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS\n// OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER\n// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF\n// THIS SOFTWARE.\n\n/* eslint-disable complexity, max-params, max-statements, max-depth, no-constant-condition */\nexport default class Delatin {\n  constructor(data, width, height = width) {\n    this.data = data; // height data\n    this.width = width;\n    this.height = height;\n\n    this.coords = []; // vertex coordinates (x, y)\n    this.triangles = []; // mesh triangle indices\n\n    // additional triangle data\n    this._halfedges = [];\n    this._candidates = [];\n    this._queueIndices = [];\n\n    this._queue = []; // queue of added triangles\n    this._errors = [];\n    this._rms = [];\n    this._pending = []; // triangles pending addition to queue\n    this._pendingLen = 0;\n\n    this._rmsSum = 0;\n\n    const x1 = width - 1;\n    const y1 = height - 1;\n    const p0 = this._addPoint(0, 0);\n    const p1 = this._addPoint(x1, 0);\n    const p2 = this._addPoint(0, y1);\n    const p3 = this._addPoint(x1, y1);\n\n    // add initial two triangles\n    const t0 = this._addTriangle(p3, p0, p2, -1, -1, -1);\n    this._addTriangle(p0, p3, p1, t0, -1, -1);\n    this._flush();\n  }\n\n  // refine the mesh until its maximum error gets below the given one\n  run(maxError = 1) {\n    while (this.getMaxError() > maxError) {\n      this.refine();\n    }\n  }\n\n  // refine the mesh with a single point\n  refine() {\n    this._step();\n    this._flush();\n  }\n\n  // max error of the current mesh\n  getMaxError() {\n    return this._errors[0];\n  }\n\n  // root-mean-square deviation of the current mesh\n  getRMSD() {\n    return this._rmsSum > 0 ? Math.sqrt(this._rmsSum / (this.width * this.height)) : 0;\n  }\n\n  // height value at a given position\n  heightAt(x, y) {\n    return this.data[this.width * y + x];\n  }\n\n  // rasterize and queue all triangles that got added or updated in _step\n  _flush() {\n    const coords = this.coords;\n    for (let i = 0; i < this._pendingLen; i++) {\n      const t = this._pending[i];\n      // rasterize triangle to find maximum pixel error\n      const a = 2 * this.triangles[t * 3 + 0];\n      const b = 2 * this.triangles[t * 3 + 1];\n      const c = 2 * this.triangles[t * 3 + 2];\n      this._findCandidate(\n        coords[a],\n        coords[a + 1],\n        coords[b],\n        coords[b + 1],\n        coords[c],\n        coords[c + 1],\n        t\n      );\n    }\n    this._pendingLen = 0;\n  }\n\n  // rasterize a triangle, find its max error, and queue it for processing\n  _findCandidate(p0x, p0y, p1x, p1y, p2x, p2y, t) {\n    // triangle bounding box\n    const minX = Math.min(p0x, p1x, p2x);\n    const minY = Math.min(p0y, p1y, p2y);\n    const maxX = Math.max(p0x, p1x, p2x);\n    const maxY = Math.max(p0y, p1y, p2y);\n\n    // forward differencing variables\n    let w00 = orient(p1x, p1y, p2x, p2y, minX, minY);\n    let w01 = orient(p2x, p2y, p0x, p0y, minX, minY);\n    let w02 = orient(p0x, p0y, p1x, p1y, minX, minY);\n    const a01 = p1y - p0y;\n    const b01 = p0x - p1x;\n    const a12 = p2y - p1y;\n    const b12 = p1x - p2x;\n    const a20 = p0y - p2y;\n    const b20 = p2x - p0x;\n\n    // pre-multiplied z values at vertices\n    const a = orient(p0x, p0y, p1x, p1y, p2x, p2y);\n    const z0 = this.heightAt(p0x, p0y) / a;\n    const z1 = this.heightAt(p1x, p1y) / a;\n    const z2 = this.heightAt(p2x, p2y) / a;\n\n    // iterate over pixels in bounding box\n    let maxError = 0;\n    let mx = 0;\n    let my = 0;\n    let rms = 0;\n    for (let y = minY; y <= maxY; y++) {\n      // compute starting offset\n      let dx = 0;\n      if (w00 < 0 && a12 !== 0) {\n        dx = Math.max(dx, Math.floor(-w00 / a12));\n      }\n      if (w01 < 0 && a20 !== 0) {\n        dx = Math.max(dx, Math.floor(-w01 / a20));\n      }\n      if (w02 < 0 && a01 !== 0) {\n        dx = Math.max(dx, Math.floor(-w02 / a01));\n      }\n\n      let w0 = w00 + a12 * dx;\n      let w1 = w01 + a20 * dx;\n      let w2 = w02 + a01 * dx;\n\n      let wasInside = false;\n\n      for (let x = minX + dx; x <= maxX; x++) {\n        // check if inside triangle\n        if (w0 >= 0 && w1 >= 0 && w2 >= 0) {\n          wasInside = true;\n\n          // compute z using barycentric coordinates\n          const z = z0 * w0 + z1 * w1 + z2 * w2;\n          const dz = Math.abs(z - this.heightAt(x, y));\n          rms += dz * dz;\n          if (dz > maxError) {\n            maxError = dz;\n            mx = x;\n            my = y;\n          }\n        } else if (wasInside) {\n          break;\n        }\n\n        w0 += a12;\n        w1 += a20;\n        w2 += a01;\n      }\n\n      w00 += b12;\n      w01 += b20;\n      w02 += b01;\n    }\n\n    if ((mx === p0x && my === p0y) || (mx === p1x && my === p1y) || (mx === p2x && my === p2y)) {\n      maxError = 0;\n    }\n\n    // update triangle metadata\n    this._candidates[2 * t] = mx;\n    this._candidates[2 * t + 1] = my;\n    this._rms[t] = rms;\n\n    // add triangle to priority queue\n    this._queuePush(t, maxError, rms);\n  }\n\n  // process the next triangle in the queue, splitting it with a new point\n  _step() {\n    // pop triangle with highest error from priority queue\n    const t = this._queuePop();\n\n    const e0 = t * 3 + 0;\n    const e1 = t * 3 + 1;\n    const e2 = t * 3 + 2;\n\n    const p0 = this.triangles[e0];\n    const p1 = this.triangles[e1];\n    const p2 = this.triangles[e2];\n\n    const ax = this.coords[2 * p0];\n    const ay = this.coords[2 * p0 + 1];\n    const bx = this.coords[2 * p1];\n    const by = this.coords[2 * p1 + 1];\n    const cx = this.coords[2 * p2];\n    const cy = this.coords[2 * p2 + 1];\n    const px = this._candidates[2 * t];\n    const py = this._candidates[2 * t + 1];\n\n    const pn = this._addPoint(px, py);\n\n    if (orient(ax, ay, bx, by, px, py) === 0) {\n      this._handleCollinear(pn, e0);\n    } else if (orient(bx, by, cx, cy, px, py) === 0) {\n      this._handleCollinear(pn, e1);\n    } else if (orient(cx, cy, ax, ay, px, py) === 0) {\n      this._handleCollinear(pn, e2);\n    } else {\n      const h0 = this._halfedges[e0];\n      const h1 = this._halfedges[e1];\n      const h2 = this._halfedges[e2];\n\n      const t0 = this._addTriangle(p0, p1, pn, h0, -1, -1, e0);\n      const t1 = this._addTriangle(p1, p2, pn, h1, -1, t0 + 1);\n      const t2 = this._addTriangle(p2, p0, pn, h2, t0 + 2, t1 + 1);\n\n      this._legalize(t0);\n      this._legalize(t1);\n      this._legalize(t2);\n    }\n  }\n\n  // add coordinates for a new vertex\n  _addPoint(x, y) {\n    const i = this.coords.length >> 1;\n    this.coords.push(x, y);\n    return i;\n  }\n\n  // add or update a triangle in the mesh\n  _addTriangle(a, b, c, ab, bc, ca, e = this.triangles.length) {\n    const t = e / 3; // new triangle index\n\n    // add triangle vertices\n    this.triangles[e + 0] = a;\n    this.triangles[e + 1] = b;\n    this.triangles[e + 2] = c;\n\n    // add triangle halfedges\n    this._halfedges[e + 0] = ab;\n    this._halfedges[e + 1] = bc;\n    this._halfedges[e + 2] = ca;\n\n    // link neighboring halfedges\n    if (ab >= 0) {\n      this._halfedges[ab] = e + 0;\n    }\n    if (bc >= 0) {\n      this._halfedges[bc] = e + 1;\n    }\n    if (ca >= 0) {\n      this._halfedges[ca] = e + 2;\n    }\n\n    // init triangle metadata\n    this._candidates[2 * t + 0] = 0;\n    this._candidates[2 * t + 1] = 0;\n    this._queueIndices[t] = -1;\n    this._rms[t] = 0;\n\n    // add triangle to pending queue for later rasterization\n    this._pending[this._pendingLen++] = t;\n\n    // return first halfedge index\n    return e;\n  }\n\n  _legalize(a) {\n    // if the pair of triangles doesn't satisfy the Delaunay condition\n    // (p1 is inside the circumcircle of [p0, pl, pr]), flip them,\n    // then do the same check/flip recursively for the new pair of triangles\n    //\n    //           pl                    pl\n    //          /||\\                  /  \\\n    //       al/ || \\bl            al/    \\a\n    //        /  ||  \\              /      \\\n    //       /  a||b  \\    flip    /___ar___\\\n    //     p0\\   ||   /p1   =>   p0\\---bl---/p1\n    //        \\  ||  /              \\      /\n    //       ar\\ || /br             b\\    /br\n    //          \\||/                  \\  /\n    //           pr                    pr\n\n    const b = this._halfedges[a];\n\n    if (b < 0) {\n      return;\n    }\n\n    const a0 = a - (a % 3);\n    const b0 = b - (b % 3);\n    const al = a0 + ((a + 1) % 3);\n    const ar = a0 + ((a + 2) % 3);\n    const bl = b0 + ((b + 2) % 3);\n    const br = b0 + ((b + 1) % 3);\n    const p0 = this.triangles[ar];\n    const pr = this.triangles[a];\n    const pl = this.triangles[al];\n    const p1 = this.triangles[bl];\n    const coords = this.coords;\n\n    if (\n      !inCircle(\n        coords[2 * p0],\n        coords[2 * p0 + 1],\n        coords[2 * pr],\n        coords[2 * pr + 1],\n        coords[2 * pl],\n        coords[2 * pl + 1],\n        coords[2 * p1],\n        coords[2 * p1 + 1]\n      )\n    ) {\n      return;\n    }\n\n    const hal = this._halfedges[al];\n    const har = this._halfedges[ar];\n    const hbl = this._halfedges[bl];\n    const hbr = this._halfedges[br];\n\n    this._queueRemove(a0 / 3);\n    this._queueRemove(b0 / 3);\n\n    const t0 = this._addTriangle(p0, p1, pl, -1, hbl, hal, a0);\n    const t1 = this._addTriangle(p1, p0, pr, t0, har, hbr, b0);\n\n    this._legalize(t0 + 1);\n    this._legalize(t1 + 2);\n  }\n\n  // handle a case where new vertex is on the edge of a triangle\n  _handleCollinear(pn, a) {\n    const a0 = a - (a % 3);\n    const al = a0 + ((a + 1) % 3);\n    const ar = a0 + ((a + 2) % 3);\n    const p0 = this.triangles[ar];\n    const pr = this.triangles[a];\n    const pl = this.triangles[al];\n    const hal = this._halfedges[al];\n    const har = this._halfedges[ar];\n\n    const b = this._halfedges[a];\n\n    if (b < 0) {\n      const t0 = this._addTriangle(pn, p0, pr, -1, har, -1, a0);\n      const t1 = this._addTriangle(p0, pn, pl, t0, -1, hal);\n      this._legalize(t0 + 1);\n      this._legalize(t1 + 2);\n      return;\n    }\n\n    const b0 = b - (b % 3);\n    const bl = b0 + ((b + 2) % 3);\n    const br = b0 + ((b + 1) % 3);\n    const p1 = this.triangles[bl];\n    const hbl = this._halfedges[bl];\n    const hbr = this._halfedges[br];\n\n    this._queueRemove(b0 / 3);\n\n    const t0 = this._addTriangle(p0, pr, pn, har, -1, -1, a0);\n    const t1 = this._addTriangle(pr, p1, pn, hbr, -1, t0 + 1, b0);\n    const t2 = this._addTriangle(p1, pl, pn, hbl, -1, t1 + 1);\n    const t3 = this._addTriangle(pl, p0, pn, hal, t0 + 2, t2 + 1);\n\n    this._legalize(t0);\n    this._legalize(t1);\n    this._legalize(t2);\n    this._legalize(t3);\n  }\n\n  // priority queue methods\n\n  _queuePush(t, error, rms) {\n    const i = this._queue.length;\n    this._queueIndices[t] = i;\n    this._queue.push(t);\n    this._errors.push(error);\n    this._rmsSum += rms;\n    this._queueUp(i);\n  }\n\n  _queuePop() {\n    const n = this._queue.length - 1;\n    this._queueSwap(0, n);\n    this._queueDown(0, n);\n    return this._queuePopBack();\n  }\n\n  _queuePopBack() {\n    const t = this._queue.pop();\n    this._errors.pop();\n    this._rmsSum -= this._rms[t];\n    this._queueIndices[t] = -1;\n    return t;\n  }\n\n  _queueRemove(t) {\n    const i = this._queueIndices[t];\n    if (i < 0) {\n      const it = this._pending.indexOf(t);\n      if (it !== -1) {\n        this._pending[it] = this._pending[--this._pendingLen];\n      } else {\n        throw new Error('Broken triangulation (something went wrong).');\n      }\n      return;\n    }\n    const n = this._queue.length - 1;\n    if (n !== i) {\n      this._queueSwap(i, n);\n      if (!this._queueDown(i, n)) {\n        this._queueUp(i);\n      }\n    }\n    this._queuePopBack();\n  }\n\n  _queueLess(i, j) {\n    return this._errors[i] > this._errors[j];\n  }\n\n  _queueSwap(i, j) {\n    const pi = this._queue[i];\n    const pj = this._queue[j];\n    this._queue[i] = pj;\n    this._queue[j] = pi;\n    this._queueIndices[pi] = j;\n    this._queueIndices[pj] = i;\n    const e = this._errors[i];\n    this._errors[i] = this._errors[j];\n    this._errors[j] = e;\n  }\n\n  _queueUp(j0) {\n    let j = j0;\n    while (true) {\n      const i = (j - 1) >> 1;\n      if (i === j || !this._queueLess(j, i)) {\n        break;\n      }\n      this._queueSwap(i, j);\n      j = i;\n    }\n  }\n\n  _queueDown(i0, n) {\n    let i = i0;\n    while (true) {\n      const j1 = 2 * i + 1;\n      if (j1 >= n || j1 < 0) {\n        break;\n      }\n      const j2 = j1 + 1;\n      let j = j1;\n      if (j2 < n && this._queueLess(j2, j1)) {\n        j = j2;\n      }\n      if (!this._queueLess(j, i)) {\n        break;\n      }\n      this._queueSwap(i, j);\n      i = j;\n    }\n    return i > i0;\n  }\n}\n\nfunction orient(ax, ay, bx, by, cx, cy) {\n  return (bx - cx) * (ay - cy) - (by - cy) * (ax - cx);\n}\n\nfunction inCircle(ax, ay, bx, by, cx, cy, px, py) {\n  const dx = ax - px;\n  const dy = ay - py;\n  const ex = bx - px;\n  const ey = by - py;\n  const fx = cx - px;\n  const fy = cy - py;\n\n  const ap = dx * dx + dy * dy;\n  const bp = ex * ex + ey * ey;\n  const cp = fx * fx + fy * fy;\n\n  return dx * (ey * cp - bp * fy) - dy * (ex * cp - bp * fx) + ap * (ex * fy - ey * fx) < 0;\n}\n","import {getMeshBoundingBox} from '@loaders.gl/schema';\nimport Martini from '@mapbox/martini';\nimport Delatin from './delatin';\nimport {addSkirt} from './helpers/skirt';\n\nfunction getTerrain(imageData, width, height, elevationDecoder, tesselator) {\n  const {rScaler, bScaler, gScaler, offset} = elevationDecoder;\n\n  // From Martini demo\n  // https://observablehq.com/@mourner/martin-real-time-rtin-terrain-mesh\n  const terrain = new Float32Array((width + 1) * (height + 1));\n  // decode terrain values\n  for (let i = 0, y = 0; y < height; y++) {\n    for (let x = 0; x < width; x++, i++) {\n      const k = i * 4;\n      const r = imageData[k + 0];\n      const g = imageData[k + 1];\n      const b = imageData[k + 2];\n      terrain[i + y] = r * rScaler + g * gScaler + b * bScaler + offset;\n    }\n  }\n\n  if (tesselator === 'martini') {\n    // backfill bottom border\n    for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {\n      terrain[i] = terrain[i - width - 1];\n    }\n    // backfill right border\n    for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {\n      terrain[i] = terrain[i - 1];\n    }\n  }\n\n  return terrain;\n}\n\nfunction getMeshAttributes(vertices, terrain, width, height, bounds) {\n  const gridSize = width + 1;\n  const numOfVerticies = vertices.length / 2;\n  // vec3. x, y in pixels, z in meters\n  const positions = new Float32Array(numOfVerticies * 3);\n  // vec2. 1 to 1 relationship with position. represents the uv on the texture image. 0,0 to 1,1.\n  const texCoords = new Float32Array(numOfVerticies * 2);\n\n  const [minX, minY, maxX, maxY] = bounds || [0, 0, width, height];\n  const xScale = (maxX - minX) / width;\n  const yScale = (maxY - minY) / height;\n\n  for (let i = 0; i < numOfVerticies; i++) {\n    const x = vertices[i * 2];\n    const y = vertices[i * 2 + 1];\n    const pixelIdx = y * gridSize + x;\n\n    positions[3 * i + 0] = x * xScale + minX;\n    positions[3 * i + 1] = -y * yScale + maxY;\n    positions[3 * i + 2] = terrain[pixelIdx];\n\n    texCoords[2 * i + 0] = x / width;\n    texCoords[2 * i + 1] = y / height;\n  }\n\n  return {\n    POSITION: {value: positions, size: 3},\n    TEXCOORD_0: {value: texCoords, size: 2}\n    // NORMAL: {}, - optional, but creates the high poly look with lighting\n  };\n}\n\n/**\n * Returns generated mesh object from image data\n *\n * @param {object} terrainImage terrain image data\n * @param {object} terrainOptions terrain options\n * @returns mesh object\n */\nfunction getMesh(terrainImage, terrainOptions) {\n  if (terrainImage === null) {\n    return null;\n  }\n  const {meshMaxError, bounds, elevationDecoder} = terrainOptions;\n\n  const {data, width, height} = terrainImage;\n\n  let terrain;\n  let mesh;\n  switch (terrainOptions.tesselator) {\n    case 'martini':\n      terrain = getTerrain(data, width, height, elevationDecoder, terrainOptions.tesselator);\n      mesh = getMartiniTileMesh(meshMaxError, width, terrain);\n      break;\n    case 'delatin':\n      terrain = getTerrain(data, width, height, elevationDecoder, terrainOptions.tesselator);\n      mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);\n      break;\n    // auto\n    default:\n      if (width === height && !(height & (width - 1))) {\n        terrain = getTerrain(data, width, height, elevationDecoder, 'martini');\n        mesh = getMartiniTileMesh(meshMaxError, width, terrain);\n      } else {\n        terrain = getTerrain(data, width, height, elevationDecoder, 'delatin');\n        mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);\n      }\n      break;\n  }\n\n  const {vertices} = mesh;\n  let {triangles} = mesh;\n  let attributes = getMeshAttributes(vertices, terrain, width, height, bounds);\n\n  // Compute bounding box before adding skirt so that z values are not skewed\n  const boundingBox = getMeshBoundingBox(attributes);\n\n  if (terrainOptions.skirtHeight) {\n    const {attributes: newAttributes, triangles: newTriangles} = addSkirt(\n      attributes,\n      triangles,\n      terrainOptions.skirtHeight\n    );\n    attributes = newAttributes;\n    triangles = newTriangles;\n  }\n\n  return {\n    // Data return by this loader implementation\n    loaderData: {\n      header: {}\n    },\n    header: {\n      vertexCount: triangles.length,\n      boundingBox\n    },\n    mode: 4, // TRIANGLES\n    indices: {value: Uint32Array.from(triangles), size: 1},\n    attributes\n  };\n}\n\n/**\n * Get Martini generated vertices and triangles\n *\n * @param {number} meshMaxError threshold for simplifying mesh\n * @param {number} width width of the input data\n * @param {number[] | Float32Array} terrain elevation data\n * @returns {{vertices: Uint16Array, triangles: Uint32Array}} vertices and triangles data\n */\nfunction getMartiniTileMesh(meshMaxError, width, terrain) {\n  const gridSize = width + 1;\n  const martini = new Martini(gridSize);\n  const tile = martini.createTile(terrain);\n  const {vertices, triangles} = tile.getMesh(meshMaxError);\n\n  return {vertices, triangles};\n}\n\n/**\n * Get Delatin generated vertices and triangles\n *\n * @param {number} meshMaxError threshold for simplifying mesh\n * @param {number} width width of the input data array\n * @param {number} height height of the input data array\n * @param {number[] | Float32Array} terrain elevation data\n * @returns {{vertices: number[], triangles: number[]}} vertices and triangles data\n */\nfunction getDelatinTileMesh(meshMaxError, width, height, terrain) {\n  const tin = new Delatin(terrain, width + 1, height + 1);\n  tin.run(meshMaxError);\n  const {coords, triangles} = tin;\n  const vertices = coords;\n  return {vertices, triangles};\n}\n\nexport default async function loadTerrain(arrayBuffer, options, context) {\n  options.image = options.image || {};\n  options.image.type = 'data';\n  const image = await context.parse(arrayBuffer, options, options.baseUri);\n  // Extend function to support additional mesh generation options (square grid or delatin)\n  return getMesh(image, options.terrain);\n}\n","// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n","import type {Loader} from '@loaders.gl/loader-utils';\nimport {VERSION} from './lib/utils/version';\n\n/**\n * Worker loader for quantized meshes\n */\nexport const TerrainLoader = {\n  name: 'Terrain',\n  id: 'terrain',\n  module: 'terrain',\n  version: VERSION,\n  worker: true,\n  extensions: ['png', 'pngraw'],\n  mimeTypes: ['image/png'],\n  options: {\n    terrain: {\n      tesselator: 'auto',\n      bounds: null,\n      meshMaxError: 10,\n      elevationDecoder: {\n        rScaler: 1,\n        gScaler: 0,\n        bScaler: 0,\n        offset: 0\n      },\n      skirtHeight: null\n    }\n  }\n};\n\n/**\n * Loader for quantized meshes\n */\nexport const _typecheckTerrainWorkerLoader: Loader = TerrainLoader;\n","import type {Loader} from '@loaders.gl/loader-utils';\nimport {VERSION} from './lib/utils/version';\n\n/**\n * Worker loader for quantized meshes\n */\nexport const QuantizedMeshLoader = {\n  name: 'Quantized Mesh',\n  id: 'quantized-mesh',\n  module: 'terrain',\n  version: VERSION,\n  worker: true,\n  extensions: ['terrain'],\n  mimeTypes: ['application/vnd.quantized-mesh'],\n  options: {\n    'quantized-mesh': {\n      bounds: [0, 0, 1, 1],\n      skirtHeight: null\n    }\n  }\n};\n\nexport const _typecheckQuantizedMeshLoader: Loader = QuantizedMeshLoader;\n","import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport parseQuantizedMesh from './lib/parse-quantized-mesh';\nimport loadTerrain from './lib/parse-terrain';\n\nimport {TerrainLoader as TerrainWorkerLoader} from './terrain-loader';\nimport {QuantizedMeshLoader as QuantizedMeshWorkerLoader} from './quantized-mesh-loader';\n\n// TerrainLoader\n\nexport {TerrainWorkerLoader};\n\nexport const TerrainLoader = {\n  ...TerrainWorkerLoader,\n  parse: loadTerrain\n};\n\nexport const _typecheckTerrainLoader: LoaderWithParser = TerrainLoader; // eslint-disable-line\n\n// QuantizedMeshLoader\n\nexport {QuantizedMeshWorkerLoader};\n\n/**\n * Loader for quantized meshes\n */\nexport const QuantizedMeshLoader = {\n  ...QuantizedMeshWorkerLoader,\n  parseSync: parseQuantizedMesh,\n  parse: async (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options)\n};\n\nexport const _typecheckQuantizedMeshLoader: LoaderWithParser = QuantizedMeshLoader;\n","import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {QuantizedMeshLoader} from '../index';\n\ncreateLoaderWorker(QuantizedMeshLoader);\n"],"sourceRoot":""}