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

package/dist/draco-worker.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/classCallCheck.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/inherits.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/defineProperty.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/createClass.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/regenerator/index.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack:///../worker-utils/src/lib/env-utils/globals.ts","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/typeof.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/slicedToArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack:////home/user/apps/loaders.gl/node_modules/regenerator-runtime/runtime.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/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:///(webpack)/buildin/global.js","webpack:////home/user/apps/loaders.gl/node_modules/process/browser.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/iterableToArray.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack:////home/user/apps/loaders.gl/node_modules/@babel/runtime/helpers/setPrototypeOf.js","webpack:///../worker-utils/src/lib/worker-utils/get-transfer-list.ts","webpack:///../worker-utils/src/lib/worker-farm/worker-body.ts","webpack:///../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts","webpack:///./src/lib/utils/version.ts","webpack:///./src/draco-loader.ts","webpack:///../schema/src/category/mesh/mesh-utils.ts","webpack:///../schema/src/lib/schema/impl/schema.ts","webpack:///../schema/src/lib/utils/assert.ts","webpack:///../schema/src/lib/schema/impl/enum.ts","webpack:///../schema/src/lib/schema/impl/field.ts","webpack:///../schema/src/lib/schema/impl/type.ts","webpack:///../schema/src/category/mesh/deduce-mesh-schema.ts","webpack:///../schema/src/lib/arrow/arrow-like-type-utils.ts","webpack:///./src/lib/utils/get-draco-schema.ts","webpack:///./src/lib/draco-parser.ts","webpack:///../worker-utils/src/lib/library-utils/library-utils.ts","webpack:///../worker-utils/src/lib/env-utils/assert.ts","webpack:///./src/lib/draco-module-loader.ts","webpack:///./src/index.ts","webpack:///./src/workers/draco-worker.ts"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","instance","Constructor","TypeError","setPrototypeOf","subClass","superClass","constructor","writable","configurable","obj","_defineProperties","target","props","length","descriptor","protoProps","staticProps","self","ReferenceError","asyncGeneratorStep","gen","resolve","reject","_next","_throw","arg","info","error","done","Promise","then","fn","this","args","arguments","apply","err","undefined","globals","window","global","document","global_","isBrowser","process","String","browser","isWorker","importScripts","matches","orientation","version","exec","parseFloat","_typeof","iterator","arrayWithoutHoles","iterableToArray","unsupportedIterableToArray","nonIterableSpread","arr","arrayWithHoles","iterableToArrayLimit","nonIterableRest","_getPrototypeOf","getPrototypeOf","__proto__","arrayLikeToArray","minLen","toString","slice","Array","from","test","len","arr2","assertThisInitialized","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","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","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","g","e","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","concat","drainQueue","timeout","run","marker","runClearTimeout","Item","array","noop","nextTick","title","env","argv","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","_setPrototypeOf","isTransferable","ArrayBuffer","MessagePort","ImageBitmap","OffscreenCanvas","onMessageWrapperMap","Map","WorkerBody","onMessage","onmessage","message","isKnownMessage","data","payload","onMessageWrapper","addEventListener","removeEventListener","source","transferList","getTransferList","recursive","transfers","transfersSet","Set","add","buffer","isView","postMessage","startsWith","requestId","parseOnMainThread","arrayBuffer","options","id","input","parseData","a","loader","parseSync","parse","parser","parseTextSync","textDecoder","TextDecoder","decode","worker","DracoLoader","shapes","extensions","mimeTypes","binary","tests","draco","decoderType","WebAssembly","libraryPath","extraAttributes","attributeNameEntry","getMeshBoundingBox","attributes","minX","Infinity","minY","minZ","maxX","maxY","maxZ","positions","POSITION","x","y","z","Schema","fields","metadata","condition","assert","usedNames","field","console","warn","checkNames","other","compareTo","nameMap","columnNames","selectedFields","filter","columnIndices","map","index","Boolean","schemaOrFields","otherSchema","mergeMaps","fieldMap","m1","m2","Type","Field","nullable","typeId","DataType","NONE","Null","Int","Float","Binary","Utf8","Bool","Decimal","Date","Time","Timestamp","Interval","List","Struct","Union","FixedSizeBinary","FixedSizeList","Dictionary","isSigned","bitWidth","Int8","Int16","Int32","Uint8","Uint16","Uint32","Precision","precision","Float32","Float64","listSize","child","children","valueType","deduceMeshField","attributeName","attribute","optionalMetadata","Int8Array","Uint8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","getArrowTypeFromTypedArray","set","byteOffset","byteStride","normalized","makeMeshAttributeMetadata","size","getDracoSchema","loaderData","indices","metadataMap","makeMetadata","namedLoaderDataAttributes","dracoAttribute","transformAttributesLoaderData","getArrowFieldFromAttribute","indicesField","JSON","stringify","DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP","NORMAL","COLOR","TEX_COORD","DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP","1","2","3","4","5","6","9","DracoParser","decoder","Decoder","metadataQuerier","MetadataQuerier","destroy","DecoderBuffer","Init","byteLength","_disableAttributeTransforms","geometry_type","GetEncodedGeometryType","dracoGeometry","TRIANGULAR_MESH","Mesh","PointCloud","dracoStatus","DecodeBufferToMesh","POINT_CLOUD","DecodeBufferToPointCloud","ok","ptr","error_msg","_getDracoLoaderData","geometry","_getMeshData","boundingBox","schema","header","vertexCount","num_points","_getTopLevelMetadata","_getDracoAttributes","num_attributes","num_faces","dracoAttributes","attributeId","GetAttribute","_getAttributeMetadata","unique_id","attribute_type","data_type","num_components","byte_offset","byte_stride","attribute_index","quantization","_getQuantizationTransform","quantization_transform","octahedron","_getOctahedronTransform","octahedron_transform","_getMeshAttributes","topology","_getTriangleStripIndices","_getTriangleListIndices","loaderAttribute","_deduceAttributeName","_getAttributeValues","numIndices","_malloc","GetTrianglesUInt32Array","HEAPF32","_free","dracoArray","DracoInt32Array","GetTriangleStripsFromMesh","numValues","intArray","GetValue","getUint32Array","TypedArrayCtor","numComponents","BYTES_PER_ELEMENT","dataType","attributeType","DT_FLOAT32","DT_INT8","DT_INT16","DT_INT32","DT_UINT8","DT_UINT16","DT_UINT32","DT_INVALID","getDracoDataType","GetAttributeDataArrayForAllPoints","uniqueId","entries","thisAttributeType","dracoAttributeConstant","entryName","string","dracoMetadata","GetMetadata","_getDracoMetadata","GetAttributeMetadata","numEntries","NumEntries","entryIndex","GetEntryName","_getDracoMetadataField","GetIntEntryArray","getInt32Array","int","GetIntEntry","GetStringEntry","double","GetDoubleEntry","quantizedAttributes","octahedronAttributes","dracoAttributeName","SkipAttributeTransform","includes","transform","AttributeQuantizationTransform","InitFromAttribute","quantization_bits","range","min_values","min_value","loadLibraryPromises","loadLibrary","libraryUrl","moduleName","getLibraryUrl","loadLibraryFromFile","library","CDN","endsWith","fetch","response","node","text","scriptSource","loadLibraryFromString","eval","script","createElement","appendChild","createTextNode","body","loadDecoderPromise","DRACO_JS_DECODER_URL","DRACO_WASM_WRAPPER_URL","DRACO_WASM_DECODER_URL","loadDracoDecoderModule","draco3d","createDecoderModule","loadDracoDecoder","DracoDecoderModule","all","wasmBinary","globalThis","initializeDracoDecoder","onModuleLoaded","DracoWorkerLoader","dracoParser"],"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,gBC5ErDhC,EAAOD,QANP,SAAyBkC,EAAUC,GACjC,KAAMD,aAAoBC,GACxB,MAAM,IAAIC,UAAU,sCAKxBnC,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,gBCPxE,IAAIe,EAAiB,EAAQ,IAiB7BpC,EAAOD,QAfP,SAAmBsC,EAAUC,GAC3B,GAA0B,mBAAfA,GAA4C,OAAfA,EACtC,MAAM,IAAIH,UAAU,sDAGtBE,EAASR,UAAYlB,OAAOY,OAAOe,GAAcA,EAAWT,UAAW,CACrEU,YAAa,CACXrB,MAAOmB,EACPG,UAAU,EACVC,cAAc,KAGdH,GAAYF,EAAeC,EAAUC,IAI3CtC,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCHxErB,EAAOD,QAfP,SAAyB2C,EAAKlB,EAAKN,GAYjC,OAXIM,KAAOkB,EACT/B,OAAOC,eAAe8B,EAAKlB,EAAK,CAC9BN,MAAOA,EACPL,YAAY,EACZ4B,cAAc,EACdD,UAAU,IAGZE,EAAIlB,GAAON,EAGNwB,GAIT1C,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cChBxE,SAASsB,EAAkBC,EAAQC,GACjC,IAAK,IAAI5C,EAAI,EAAGA,EAAI4C,EAAMC,OAAQ7C,IAAK,CACrC,IAAI8C,EAAaF,EAAM5C,GACvB8C,EAAWlC,WAAakC,EAAWlC,aAAc,EACjDkC,EAAWN,cAAe,EACtB,UAAWM,IAAYA,EAAWP,UAAW,GACjD7B,OAAOC,eAAegC,EAAQG,EAAWvB,IAAKuB,IAUlD/C,EAAOD,QANP,SAAsBmC,EAAac,EAAYC,GAG7C,OAFID,GAAYL,EAAkBT,EAAYL,UAAWmB,GACrDC,GAAaN,EAAkBT,EAAae,GACzCf,GAITlC,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,gBCjBxErB,EAAOD,QAAU,EAAQ,K,cCQzBC,EAAOD,QARP,SAAgCmD,GAC9B,QAAa,IAATA,EACF,MAAM,IAAIC,eAAe,6DAG3B,OAAOD,GAITlD,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCTxE,SAAS+B,EAAmBC,EAAKC,EAASC,EAAQC,EAAOC,EAAQjC,EAAKkC,GACpE,IACE,IAAIC,EAAON,EAAI7B,GAAKkC,GAChBxC,EAAQyC,EAAKzC,MACjB,MAAO0C,GAEP,YADAL,EAAOK,GAILD,EAAKE,KACPP,EAAQpC,GAER4C,QAAQR,QAAQpC,GAAO6C,KAAKP,EAAOC,GAwBvCzD,EAAOD,QApBP,SAA2BiE,GACzB,OAAO,WACL,IAAId,EAAOe,KACPC,EAAOC,UACX,OAAO,IAAIL,SAAQ,SAAUR,EAASC,GACpC,IAAIF,EAAMW,EAAGI,MAAMlB,EAAMgB,GAEzB,SAASV,EAAMtC,GACbkC,EAAmBC,EAAKC,EAASC,EAAQC,EAAOC,EAAQ,OAAQvC,GAGlE,SAASuC,EAAOY,GACdjB,EAAmBC,EAAKC,EAASC,EAAQC,EAAOC,EAAQ,QAASY,GAGnEb,OAAMc,QAMZtE,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,6JCjClEkD,EAAU,CACdrB,KAAsB,oBAATA,MAAwBA,KACrCsB,OAA0B,oBAAXA,QAA0BA,OACzCC,YAA0B,IAAXA,GAA0BA,EACzCC,SAA8B,oBAAbA,UAA4BA,UAKzCC,EAAgCJ,EAAQE,QAAUF,EAAQrB,MAAQqB,EAAQC,QAAU,GAM7EI,EAEQ,iBAAnB,IAAOC,EAAP,Y,MAAA,GAAOA,KAA4C,qBAApBC,OAAOD,IAAmCA,EAAQE,QAGtEC,EAA6C,mBAAlBC,cAOlCC,GAHc,oBAAXV,QAAiCA,OAAOW,iBAI5B,IAAZN,GAA2BA,EAAQO,SAAW,YAAYC,KAAKR,EAAQO,UAG5CF,GAAWI,WAAWJ,EAAQ,M,sCCnClE,SAASK,EAAQ7C,GAiBf,MAdsB,mBAAX1B,QAAoD,iBAApBA,OAAOwE,UAChDxF,EAAOD,QAAUwF,EAAU,SAAiB7C,GAC1C,cAAcA,GAGhB1C,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,IAExErB,EAAOD,QAAUwF,EAAU,SAAiB7C,GAC1C,OAAOA,GAAyB,mBAAX1B,QAAyB0B,EAAIH,cAAgBvB,QAAU0B,IAAQ1B,OAAOa,UAAY,gBAAkBa,GAG3H1C,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,GAGnEkE,EAAQ7C,GAGjB1C,EAAOD,QAAUwF,EACjBvF,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,gBCrBxE,IAAIoE,EAAoB,EAAQ,IAE5BC,EAAkB,EAAQ,IAE1BC,EAA6B,EAAQ,IAErCC,EAAoB,EAAQ,IAMhC5F,EAAOD,QAJP,SAA4B8F,GAC1B,OAAOJ,EAAkBI,IAAQH,EAAgBG,IAAQF,EAA2BE,IAAQD,KAI9F5F,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,gCCbxE,IAAIyE,EAAiB,EAAQ,IAEzBC,EAAuB,EAAQ,IAE/BJ,EAA6B,EAAQ,IAErCK,EAAkB,EAAQ,IAM9BhG,EAAOD,QAJP,SAAwB8F,EAAK5F,GAC3B,OAAO6F,EAAeD,IAAQE,EAAqBF,EAAK5F,IAAM0F,EAA2BE,EAAK5F,IAAM+F,KAItGhG,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCbxE,SAAS4E,EAAgBvF,GAKvB,OAJAV,EAAOD,QAAUkG,EAAkBtF,OAAOyB,eAAiBzB,OAAOuF,eAAiB,SAAyBxF,GAC1G,OAAOA,EAAEyF,WAAaxF,OAAOuF,eAAexF,IAE9CV,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,EACjE4E,EAAgBvF,GAGzBV,EAAOD,QAAUkG,EACjBjG,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,iBCTxE,IAAI+E,EAAmB,EAAQ,IAW/BpG,EAAOD,QATP,SAAqCW,EAAG2F,GACtC,GAAK3F,EAAL,CACA,GAAiB,iBAANA,EAAgB,OAAO0F,EAAiB1F,EAAG2F,GACtD,IAAI3E,EAAIf,OAAOkB,UAAUyE,SAASlG,KAAKM,GAAG6F,MAAM,GAAI,GAEpD,MADU,WAAN7E,GAAkBhB,EAAE6B,cAAab,EAAIhB,EAAE6B,YAAY/B,MAC7C,QAANkB,GAAqB,QAANA,EAAoB8E,MAAMC,KAAK/F,GACxC,cAANgB,GAAqB,2CAA2CgF,KAAKhF,GAAW0E,EAAiB1F,EAAG2F,QAAxG,IAIFrG,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCFxErB,EAAOD,QAVP,SAA2B8F,EAAKc,IACnB,MAAPA,GAAeA,EAAMd,EAAI/C,UAAQ6D,EAAMd,EAAI/C,QAE/C,IAAK,IAAI7C,EAAI,EAAG2G,EAAO,IAAIJ,MAAMG,GAAM1G,EAAI0G,EAAK1G,IAC9C2G,EAAK3G,GAAK4F,EAAI5F,GAGhB,OAAO2G,GAIT5G,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,gBCXxE,IAAIkE,EAAU,EAAQ,GAA0C,QAE5DsB,EAAwB,EAAQ,GAUpC7G,EAAOD,QARP,SAAoCmD,EAAM9C,GACxC,OAAIA,GAA2B,WAAlBmF,EAAQnF,IAAsC,mBAATA,EAI3CyG,EAAsB3D,GAHpB9C,GAOXJ,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,mBCNxE,IAAIyF,EAAW,SAAU/G,GACvB,aAEA,IAAIgH,EAAKpG,OAAOkB,UACZmF,EAASD,EAAGjF,eAEZmF,EAA4B,mBAAXjG,OAAwBA,OAAS,GAClDkG,EAAiBD,EAAQzB,UAAY,aACrC2B,EAAsBF,EAAQG,eAAiB,kBAC/CC,EAAoBJ,EAAQhG,aAAe,gBAE/C,SAASqG,EAAO5E,EAAKlB,EAAKN,GAOxB,OANAP,OAAOC,eAAe8B,EAAKlB,EAAK,CAC9BN,MAAOA,EACPL,YAAY,EACZ4B,cAAc,EACdD,UAAU,IAELE,EAAIlB,GAEb,IAEE8F,EAAO,GAAI,IACX,MAAOjD,GACPiD,EAAS,SAAS5E,EAAKlB,EAAKN,GAC1B,OAAOwB,EAAIlB,GAAON,GAItB,SAASqG,EAAKC,EAASC,EAASvE,EAAMwE,GAEpC,IAAIC,EAAiBF,GAAWA,EAAQ5F,qBAAqB+F,EAAYH,EAAUG,EAC/EC,EAAYlH,OAAOY,OAAOoG,EAAe9F,WACzCiG,EAAU,IAAIC,EAAQL,GAAe,IAMzC,OAFAG,EAAUG,QAsMZ,SAA0BR,EAAStE,EAAM4E,GACvC,IAAIG,EA/KuB,iBAiL3B,OAAO,SAAgBC,EAAQxE,GAC7B,GAhLoB,cAgLhBuE,EACF,MAAM,IAAIE,MAAM,gCAGlB,GAnLoB,cAmLhBF,EAA6B,CAC/B,GAAe,UAAXC,EACF,MAAMxE,EAKR,OAAO0E,IAMT,IAHAN,EAAQI,OAASA,EACjBJ,EAAQpE,IAAMA,IAED,CACX,IAAI2E,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,EAAQpE,SAElC,GAAuB,UAAnBoE,EAAQI,OAAoB,CACrC,GAnNqB,mBAmNjBD,EAEF,MADAA,EAjNc,YAkNRH,EAAQpE,IAGhBoE,EAAQa,kBAAkBb,EAAQpE,SAEN,WAAnBoE,EAAQI,QACjBJ,EAAQc,OAAO,SAAUd,EAAQpE,KAGnCuE,EA5NkB,YA8NlB,IAAIY,EAASC,EAAStB,EAAStE,EAAM4E,GACrC,GAAoB,WAAhBe,EAAOE,KAAmB,CAO5B,GAJAd,EAAQH,EAAQjE,KAjOA,YAFK,iBAuOjBgF,EAAOnF,MAAQ8E,EACjB,SAGF,MAAO,CACLtH,MAAO2H,EAAOnF,IACdG,KAAMiE,EAAQjE,MAGS,UAAhBgF,EAAOE,OAChBd,EA/OgB,YAkPhBH,EAAQI,OAAS,QACjBJ,EAAQpE,IAAMmF,EAAOnF,OA9QPsF,CAAiBxB,EAAStE,EAAM4E,GAE7CD,EAcT,SAASiB,EAAS9E,EAAItB,EAAKgB,GACzB,IACE,MAAO,CAAEqF,KAAM,SAAUrF,IAAKM,EAAG5D,KAAKsC,EAAKgB,IAC3C,MAAOW,GACP,MAAO,CAAE0E,KAAM,QAASrF,IAAKW,IAhBjCtE,EAAQwH,KAAOA,EAoBf,IAOIiB,EAAmB,GAMvB,SAASZ,KACT,SAASqB,KACT,SAASC,KAIT,IAAIC,EAAoB,GACxBA,EAAkBjC,GAAkB,WAClC,OAAOjD,MAGT,IAAImF,EAAWzI,OAAOuF,eAClBmD,EAA0BD,GAAYA,EAASA,EAASE,EAAO,MAC/DD,GACAA,IAA4BtC,GAC5BC,EAAO5G,KAAKiJ,EAAyBnC,KAGvCiC,EAAoBE,GAGtB,IAAIE,EAAKL,EAA2BrH,UAClC+F,EAAU/F,UAAYlB,OAAOY,OAAO4H,GAWtC,SAASK,EAAsB3H,GAC7B,CAAC,OAAQ,QAAS,UAAU4H,SAAQ,SAASvB,GAC3CZ,EAAOzF,EAAWqG,GAAQ,SAASxE,GACjC,OAAOO,KAAK+D,QAAQE,EAAQxE,SAkClC,SAASgG,EAAc7B,EAAW8B,GAgChC,IAAIC,EAgCJ3F,KAAK+D,QA9BL,SAAiBE,EAAQxE,GACvB,SAASmG,IACP,OAAO,IAAIF,GAAY,SAASrG,EAASC,IAnC7C,SAASuG,EAAO5B,EAAQxE,EAAKJ,EAASC,GACpC,IAAIsF,EAASC,EAASjB,EAAUK,GAASL,EAAWnE,GACpD,GAAoB,UAAhBmF,EAAOE,KAEJ,CACL,IAAIgB,EAASlB,EAAOnF,IAChBxC,EAAQ6I,EAAO7I,MACnB,OAAIA,GACiB,iBAAVA,GACP8F,EAAO5G,KAAKc,EAAO,WACdyI,EAAYrG,QAAQpC,EAAM8I,SAASjG,MAAK,SAAS7C,GACtD4I,EAAO,OAAQ5I,EAAOoC,EAASC,MAC9B,SAASc,GACVyF,EAAO,QAASzF,EAAKf,EAASC,MAI3BoG,EAAYrG,QAAQpC,GAAO6C,MAAK,SAASkG,GAI9CF,EAAO7I,MAAQ+I,EACf3G,EAAQyG,MACP,SAASnG,GAGV,OAAOkG,EAAO,QAASlG,EAAON,EAASC,MAvBzCA,EAAOsF,EAAOnF,KAiCZoG,CAAO5B,EAAQxE,EAAKJ,EAASC,MAIjC,OAAOqG,EAaLA,EAAkBA,EAAgB7F,KAChC8F,EAGAA,GACEA,KAkHV,SAAStB,EAAoBF,EAAUP,GACrC,IAAII,EAASG,EAAS7C,SAASsC,EAAQI,QACvC,QA1TE5D,IA0TE4D,EAAsB,CAKxB,GAFAJ,EAAQO,SAAW,KAEI,UAAnBP,EAAQI,OAAoB,CAE9B,GAAIG,EAAS7C,SAAiB,SAG5BsC,EAAQI,OAAS,SACjBJ,EAAQpE,SArUZY,EAsUIiE,EAAoBF,EAAUP,GAEP,UAAnBA,EAAQI,QAGV,OAAOM,EAIXV,EAAQI,OAAS,QACjBJ,EAAQpE,IAAM,IAAIvB,UAChB,kDAGJ,OAAOqG,EAGT,IAAIK,EAASC,EAASZ,EAAQG,EAAS7C,SAAUsC,EAAQpE,KAEzD,GAAoB,UAAhBmF,EAAOE,KAIT,OAHAjB,EAAQI,OAAS,QACjBJ,EAAQpE,IAAMmF,EAAOnF,IACrBoE,EAAQO,SAAW,KACZG,EAGT,IAAI7E,EAAOkF,EAAOnF,IAElB,OAAMC,EAOFA,EAAKE,MAGPiE,EAAQO,EAAS6B,YAAcvG,EAAKzC,MAGpC4G,EAAQqC,KAAO9B,EAAS+B,QAQD,WAAnBtC,EAAQI,SACVJ,EAAQI,OAAS,OACjBJ,EAAQpE,SAzXVY,GAmYFwD,EAAQO,SAAW,KACZG,GANE7E,GA3BPmE,EAAQI,OAAS,QACjBJ,EAAQpE,IAAM,IAAIvB,UAAU,oCAC5B2F,EAAQO,SAAW,KACZG,GAoDX,SAAS6B,EAAaC,GACpB,IAAIC,EAAQ,CAAEC,OAAQF,EAAK,IAEvB,KAAKA,IACPC,EAAME,SAAWH,EAAK,IAGpB,KAAKA,IACPC,EAAMG,WAAaJ,EAAK,GACxBC,EAAMI,SAAWL,EAAK,IAGxBrG,KAAK2G,WAAWC,KAAKN,GAGvB,SAASO,EAAcP,GACrB,IAAI1B,EAAS0B,EAAMQ,YAAc,GACjClC,EAAOE,KAAO,gBACPF,EAAOnF,IACd6G,EAAMQ,WAAalC,EAGrB,SAASd,EAAQL,GAIfzD,KAAK2G,WAAa,CAAC,CAAEJ,OAAQ,SAC7B9C,EAAY+B,QAAQY,EAAcpG,MAClCA,KAAK+G,OAAM,GA8Bb,SAAS1B,EAAO2B,GACd,GAAIA,EAAU,CACZ,IAAIC,EAAiBD,EAAS/D,GAC9B,GAAIgE,EACF,OAAOA,EAAe9K,KAAK6K,GAG7B,GAA6B,mBAAlBA,EAASd,KAClB,OAAOc,EAGT,IAAKE,MAAMF,EAASnI,QAAS,CAC3B,IAAI7C,GAAK,EAAGkK,EAAO,SAASA,IAC1B,OAASlK,EAAIgL,EAASnI,QACpB,GAAIkE,EAAO5G,KAAK6K,EAAUhL,GAGxB,OAFAkK,EAAKjJ,MAAQ+J,EAAShL,GACtBkK,EAAKtG,MAAO,EACLsG,EAOX,OAHAA,EAAKjJ,WAzeToD,EA0eI6F,EAAKtG,MAAO,EAELsG,GAGT,OAAOA,EAAKA,KAAOA,GAKvB,MAAO,CAAEA,KAAM/B,GAIjB,SAASA,IACP,MAAO,CAAElH,WAzfPoD,EAyfyBT,MAAM,GA+MnC,OA5mBAoF,EAAkBpH,UAAY0H,EAAGhH,YAAc2G,EAC/CA,EAA2B3G,YAAc0G,EACzCA,EAAkBmC,YAAc9D,EAC9B4B,EACA7B,EACA,qBAaFtH,EAAQsL,oBAAsB,SAASC,GACrC,IAAIC,EAAyB,mBAAXD,GAAyBA,EAAO/I,YAClD,QAAOgJ,IACHA,IAAStC,GAG2B,uBAAnCsC,EAAKH,aAAeG,EAAK/K,QAIhCT,EAAQyL,KAAO,SAASF,GAQtB,OAPI3K,OAAOyB,eACTzB,OAAOyB,eAAekJ,EAAQpC,IAE9BoC,EAAOnF,UAAY+C,EACnB5B,EAAOgE,EAAQjE,EAAmB,sBAEpCiE,EAAOzJ,UAAYlB,OAAOY,OAAOgI,GAC1B+B,GAOTvL,EAAQ0L,MAAQ,SAAS/H,GACvB,MAAO,CAAEsG,QAAStG,IAsEpB8F,EAAsBE,EAAc7H,WACpC6H,EAAc7H,UAAUsF,GAAuB,WAC7C,OAAOlD,MAETlE,EAAQ2J,cAAgBA,EAKxB3J,EAAQ2L,MAAQ,SAASlE,EAASC,EAASvE,EAAMwE,EAAaiC,QACxC,IAAhBA,IAAwBA,EAAc7F,SAE1C,IAAI6H,EAAO,IAAIjC,EACbnC,EAAKC,EAASC,EAASvE,EAAMwE,GAC7BiC,GAGF,OAAO5J,EAAQsL,oBAAoB5D,GAC/BkE,EACAA,EAAKxB,OAAOpG,MAAK,SAASgG,GACxB,OAAOA,EAAOlG,KAAOkG,EAAO7I,MAAQyK,EAAKxB,WAuKjDX,EAAsBD,GAEtBjC,EAAOiC,EAAIlC,EAAmB,aAO9BkC,EAAGrC,GAAkB,WACnB,OAAOjD,MAGTsF,EAAGjD,SAAW,WACZ,MAAO,sBAkCTvG,EAAQ6L,KAAO,SAASjK,GACtB,IAAIiK,EAAO,GACX,IAAK,IAAIpK,KAAOG,EACdiK,EAAKf,KAAKrJ,GAMZ,OAJAoK,EAAKC,UAIE,SAAS1B,IACd,KAAOyB,EAAK9I,QAAQ,CAClB,IAAItB,EAAMoK,EAAKE,MACf,GAAItK,KAAOG,EAGT,OAFAwI,EAAKjJ,MAAQM,EACb2I,EAAKtG,MAAO,EACLsG,EAQX,OADAA,EAAKtG,MAAO,EACLsG,IAsCXpK,EAAQuJ,OAASA,EAMjBvB,EAAQlG,UAAY,CAClBU,YAAawF,EAEbiD,MAAO,SAASe,GAcd,GAbA9H,KAAK+H,KAAO,EACZ/H,KAAKkG,KAAO,EAGZlG,KAAKwE,KAAOxE,KAAKyE,WApgBjBpE,EAqgBAL,KAAKJ,MAAO,EACZI,KAAKoE,SAAW,KAEhBpE,KAAKiE,OAAS,OACdjE,KAAKP,SAzgBLY,EA2gBAL,KAAK2G,WAAWnB,QAAQqB,IAEnBiB,EACH,IAAK,IAAIvL,KAAQyD,KAEQ,MAAnBzD,EAAKyL,OAAO,IACZjF,EAAO5G,KAAK6D,KAAMzD,KACjB2K,OAAO3K,EAAK+F,MAAM,MACrBtC,KAAKzD,QAnhBX8D,IAyhBF4H,KAAM,WACJjI,KAAKJ,MAAO,EAEZ,IACIsI,EADYlI,KAAK2G,WAAW,GACLG,WAC3B,GAAwB,UAApBoB,EAAWpD,KACb,MAAMoD,EAAWzI,IAGnB,OAAOO,KAAKmI,MAGdzD,kBAAmB,SAAS0D,GAC1B,GAAIpI,KAAKJ,KACP,MAAMwI,EAGR,IAAIvE,EAAU7D,KACd,SAASqI,EAAOC,EAAKC,GAYnB,OAXA3D,EAAOE,KAAO,QACdF,EAAOnF,IAAM2I,EACbvE,EAAQqC,KAAOoC,EAEXC,IAGF1E,EAAQI,OAAS,OACjBJ,EAAQpE,SApjBZY,KAujBYkI,EAGZ,IAAK,IAAIvM,EAAIgE,KAAK2G,WAAW9H,OAAS,EAAG7C,GAAK,IAAKA,EAAG,CACpD,IAAIsK,EAAQtG,KAAK2G,WAAW3K,GACxB4I,EAAS0B,EAAMQ,WAEnB,GAAqB,SAAjBR,EAAMC,OAIR,OAAO8B,EAAO,OAGhB,GAAI/B,EAAMC,QAAUvG,KAAK+H,KAAM,CAC7B,IAAIS,EAAWzF,EAAO5G,KAAKmK,EAAO,YAC9BmC,EAAa1F,EAAO5G,KAAKmK,EAAO,cAEpC,GAAIkC,GAAYC,EAAY,CAC1B,GAAIzI,KAAK+H,KAAOzB,EAAME,SACpB,OAAO6B,EAAO/B,EAAME,UAAU,GACzB,GAAIxG,KAAK+H,KAAOzB,EAAMG,WAC3B,OAAO4B,EAAO/B,EAAMG,iBAGjB,GAAI+B,GACT,GAAIxI,KAAK+H,KAAOzB,EAAME,SACpB,OAAO6B,EAAO/B,EAAME,UAAU,OAG3B,KAAIiC,EAMT,MAAM,IAAIvE,MAAM,0CALhB,GAAIlE,KAAK+H,KAAOzB,EAAMG,WACpB,OAAO4B,EAAO/B,EAAMG,gBAU9B9B,OAAQ,SAASG,EAAMrF,GACrB,IAAK,IAAIzD,EAAIgE,KAAK2G,WAAW9H,OAAS,EAAG7C,GAAK,IAAKA,EAAG,CACpD,IAAIsK,EAAQtG,KAAK2G,WAAW3K,GAC5B,GAAIsK,EAAMC,QAAUvG,KAAK+H,MACrBhF,EAAO5G,KAAKmK,EAAO,eACnBtG,KAAK+H,KAAOzB,EAAMG,WAAY,CAChC,IAAIiC,EAAepC,EACnB,OAIAoC,IACU,UAAT5D,GACS,aAATA,IACD4D,EAAanC,QAAU9G,GACvBA,GAAOiJ,EAAajC,aAGtBiC,EAAe,MAGjB,IAAI9D,EAAS8D,EAAeA,EAAa5B,WAAa,GAItD,OAHAlC,EAAOE,KAAOA,EACdF,EAAOnF,IAAMA,EAETiJ,GACF1I,KAAKiE,OAAS,OACdjE,KAAKkG,KAAOwC,EAAajC,WAClBlC,GAGFvE,KAAK2I,SAAS/D,IAGvB+D,SAAU,SAAS/D,EAAQ8B,GACzB,GAAoB,UAAhB9B,EAAOE,KACT,MAAMF,EAAOnF,IAcf,MAXoB,UAAhBmF,EAAOE,MACS,aAAhBF,EAAOE,KACT9E,KAAKkG,KAAOtB,EAAOnF,IACM,WAAhBmF,EAAOE,MAChB9E,KAAKmI,KAAOnI,KAAKP,IAAMmF,EAAOnF,IAC9BO,KAAKiE,OAAS,SACdjE,KAAKkG,KAAO,OACa,WAAhBtB,EAAOE,MAAqB4B,IACrC1G,KAAKkG,KAAOQ,GAGPnC,GAGTqE,OAAQ,SAASnC,GACf,IAAK,IAAIzK,EAAIgE,KAAK2G,WAAW9H,OAAS,EAAG7C,GAAK,IAAKA,EAAG,CACpD,IAAIsK,EAAQtG,KAAK2G,WAAW3K,GAC5B,GAAIsK,EAAMG,aAAeA,EAGvB,OAFAzG,KAAK2I,SAASrC,EAAMQ,WAAYR,EAAMI,UACtCG,EAAcP,GACP/B,IAKb,MAAS,SAASgC,GAChB,IAAK,IAAIvK,EAAIgE,KAAK2G,WAAW9H,OAAS,EAAG7C,GAAK,IAAKA,EAAG,CACpD,IAAIsK,EAAQtG,KAAK2G,WAAW3K,GAC5B,GAAIsK,EAAMC,SAAWA,EAAQ,CAC3B,IAAI3B,EAAS0B,EAAMQ,WACnB,GAAoB,UAAhBlC,EAAOE,KAAkB,CAC3B,IAAI+D,EAASjE,EAAOnF,IACpBoH,EAAcP,GAEhB,OAAOuC,GAMX,MAAM,IAAI3E,MAAM,0BAGlB4E,cAAe,SAAS9B,EAAUf,EAAYE,GAa5C,OAZAnG,KAAKoE,SAAW,CACd7C,SAAU8D,EAAO2B,GACjBf,WAAYA,EACZE,QAASA,GAGS,SAAhBnG,KAAKiE,SAGPjE,KAAKP,SA7rBPY,GAgsBOkE,IAQJzI,EA7sBK,CAotBiBC,EAAOD,SAGtC,IACEiN,mBAAqBlG,EACrB,MAAOmG,GAUPC,SAAS,IAAK,yBAAdA,CAAwCpG,K,cCtuB1C9G,EAAOD,QAJP,SAAyB8F,GACvB,GAAIW,MAAM2G,QAAQtH,GAAM,OAAOA,GAIjC7F,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCyBxErB,EAAOD,QA9BP,SAA+B8F,EAAK5F,GAClC,IAAImN,EAAKvH,IAA0B,oBAAX7E,QAA0B6E,EAAI7E,OAAOwE,WAAaK,EAAI,eAE9E,GAAU,MAANuH,EAAJ,CACA,IAIIC,EAAIC,EAJJC,EAAO,GACPC,GAAK,EACLC,GAAK,EAIT,IACE,IAAKL,EAAKA,EAAGhN,KAAKyF,KAAQ2H,GAAMH,EAAKD,EAAGjD,QAAQtG,QAC9C0J,EAAK1C,KAAKwC,EAAGnM,QAETjB,GAAKsN,EAAKzK,SAAW7C,GAH4BuN,GAAK,IAK5D,MAAOnJ,GACPoJ,GAAK,EACLH,EAAKjJ,EACL,QACA,IACOmJ,GAAsB,MAAhBJ,EAAW,QAAWA,EAAW,SAC5C,QACA,GAAIK,EAAI,MAAMH,GAIlB,OAAOC,IAITvN,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cC3BxErB,EAAOD,QAJP,WACE,MAAM,IAAIoC,UAAU,8IAItBnC,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCLxE,IAAIqM,EAGJA,EAAI,WACH,OAAOzJ,KADJ,GAIJ,IAECyJ,EAAIA,GAAK,IAAIR,SAAS,cAAb,GACR,MAAOS,GAEc,iBAAXnJ,SAAqBkJ,EAAIlJ,QAOrCxE,EAAOD,QAAU2N,G,cClBjB,IAOIE,EACAC,EARAhJ,EAAU7E,EAAOD,QAAU,GAU/B,SAAS+N,IACL,MAAM,IAAI3F,MAAM,mCAEpB,SAAS4F,IACL,MAAM,IAAI5F,MAAM,qCAsBpB,SAAS6F,EAAWC,GAChB,GAAIL,IAAqBM,WAErB,OAAOA,WAAWD,EAAK,GAG3B,IAAKL,IAAqBE,IAAqBF,IAAqBM,WAEhE,OADAN,EAAmBM,WACZA,WAAWD,EAAK,GAE3B,IAEI,OAAOL,EAAiBK,EAAK,GAC/B,MAAMN,GACJ,IAEI,OAAOC,EAAiBxN,KAAK,KAAM6N,EAAK,GAC1C,MAAMN,GAEJ,OAAOC,EAAiBxN,KAAK6D,KAAMgK,EAAK,MAvCnD,WACG,IAEQL,EADsB,mBAAfM,WACYA,WAEAJ,EAEzB,MAAOH,GACLC,EAAmBE,EAEvB,IAEQD,EADwB,mBAAjBM,aACcA,aAEAJ,EAE3B,MAAOJ,GACLE,EAAqBE,GAjB7B,GAwEA,IAEIK,EAFAC,EAAQ,GACRC,GAAW,EAEXC,GAAc,EAElB,SAASC,IACAF,GAAaF,IAGlBE,GAAW,EACPF,EAAatL,OACbuL,EAAQD,EAAaK,OAAOJ,GAE5BE,GAAc,EAEdF,EAAMvL,QACN4L,KAIR,SAASA,IACL,IAAIJ,EAAJ,CAGA,IAAIK,EAAUX,EAAWQ,GACzBF,GAAW,EAGX,IADA,IAAI3H,EAAM0H,EAAMvL,OACV6D,GAAK,CAGP,IAFAyH,EAAeC,EACfA,EAAQ,KACCE,EAAa5H,GACdyH,GACAA,EAAaG,GAAYK,MAGjCL,GAAc,EACd5H,EAAM0H,EAAMvL,OAEhBsL,EAAe,KACfE,GAAW,EAnEf,SAAyBO,GACrB,GAAIhB,IAAuBM,aAEvB,OAAOA,aAAaU,GAGxB,IAAKhB,IAAuBE,IAAwBF,IAAuBM,aAEvE,OADAN,EAAqBM,aACdA,aAAaU,GAExB,IAEWhB,EAAmBgB,GAC5B,MAAOlB,GACL,IAEI,OAAOE,EAAmBzN,KAAK,KAAMyO,GACvC,MAAOlB,GAGL,OAAOE,EAAmBzN,KAAK6D,KAAM4K,KAgD7CC,CAAgBH,IAiBpB,SAASI,EAAKd,EAAKe,GACf/K,KAAKgK,IAAMA,EACXhK,KAAK+K,MAAQA,EAYjB,SAASC,KA5BTpK,EAAQqK,SAAW,SAAUjB,GACzB,IAAI/J,EAAO,IAAIsC,MAAMrC,UAAUrB,OAAS,GACxC,GAAIqB,UAAUrB,OAAS,EACnB,IAAK,IAAI7C,EAAI,EAAGA,EAAIkE,UAAUrB,OAAQ7C,IAClCiE,EAAKjE,EAAI,GAAKkE,UAAUlE,GAGhCoO,EAAMxD,KAAK,IAAIkE,EAAKd,EAAK/J,IACJ,IAAjBmK,EAAMvL,QAAiBwL,GACvBN,EAAWU,IASnBK,EAAKlN,UAAU+M,IAAM,WACjB3K,KAAKgK,IAAI7J,MAAM,KAAMH,KAAK+K,QAE9BnK,EAAQsK,MAAQ,UAChBtK,EAAQE,SAAU,EAClBF,EAAQuK,IAAM,GACdvK,EAAQwK,KAAO,GACfxK,EAAQO,QAAU,GAClBP,EAAQyK,SAAW,GAInBzK,EAAQ0K,GAAKN,EACbpK,EAAQ2K,YAAcP,EACtBpK,EAAQ4K,KAAOR,EACfpK,EAAQ6K,IAAMT,EACdpK,EAAQ8K,eAAiBV,EACzBpK,EAAQ+K,mBAAqBX,EAC7BpK,EAAQgL,KAAOZ,EACfpK,EAAQiL,gBAAkBb,EAC1BpK,EAAQkL,oBAAsBd,EAE9BpK,EAAQmL,UAAY,SAAUxP,GAAQ,MAAO,IAE7CqE,EAAQoL,QAAU,SAAUzP,GACxB,MAAM,IAAI2H,MAAM,qCAGpBtD,EAAQqL,IAAM,WAAc,MAAO,KACnCrL,EAAQsL,MAAQ,SAAUC,GACtB,MAAM,IAAIjI,MAAM,mCAEpBtD,EAAQwL,MAAQ,WAAa,OAAO,I,gBCvLpC,IAAIjK,EAAmB,EAAQ,IAM/BpG,EAAOD,QAJP,SAA4B8F,GAC1B,GAAIW,MAAM2G,QAAQtH,GAAM,OAAOO,EAAiBP,IAIlD7F,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCHxErB,EAAOD,QAJP,SAA0B4L,GACxB,GAAsB,oBAAX3K,QAAmD,MAAzB2K,EAAK3K,OAAOwE,WAA2C,MAAtBmG,EAAK,cAAuB,OAAOnF,MAAMC,KAAKkF,IAItH3L,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCDxErB,EAAOD,QAJP,WACE,MAAM,IAAIoC,UAAU,yIAItBnC,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,cCLxE,SAASiP,EAAgB5P,EAAGqB,GAO1B,OANA/B,EAAOD,QAAUuQ,EAAkB3P,OAAOyB,gBAAkB,SAAyB1B,EAAGqB,GAEtF,OADArB,EAAEyF,UAAYpE,EACPrB,GAGTV,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,EACjEiP,EAAgB5P,EAAGqB,GAG5B/B,EAAOD,QAAUuQ,EACjBtQ,EAAOD,QAAiB,QAAIC,EAAOD,QAASC,EAAOD,QAAQsB,YAAa,G,wIC+BxE,SAASkP,EAAe5O,GACtB,QAAKA,IAGDA,aAAkB6O,cAGK,oBAAhBC,aAA+B9O,aAAkB8O,cAGjC,oBAAhBC,aAA+B/O,aAAkB+O,aAI7B,oBAApBC,iBAAmChP,aAAkBgP,mBCrDlE,IAAMC,EAAsB,IAAIC,IAKXC,E,4EAInB,SAAqBC,GAEnB7N,KAAK8N,UAAY,SAACC,GAChB,GAAKC,EAAeD,GAApB,CAKA,MAAwBA,EAAQE,KAAzBpI,EAAP,EAAOA,KAAMqI,EAAb,EAAaA,QACbL,EAAUhI,EAAMqI,O,8BAIpB,SACEL,GAEA,IAAIM,EAAmBT,EAAoB9P,IAAIiQ,GAE1CM,IACHA,EAAmB,SAACJ,GAClB,GAAKC,EAAeD,GAApB,CAKA,MAAwBA,EAAQE,KAAzBpI,EAAP,EAAOA,KAAMqI,EAAb,EAAaA,QACbL,EAAUhI,EAAMqI,MAKpBlO,KAAKoO,iBAAiB,UAAWD,K,iCAGnC,SACEN,GAEA,IAAMM,EAAmBT,EAAoB9P,IAAIiQ,GACjDH,EAAmB,OAAQG,GAE3B7N,KAAKqO,oBAAoB,UAAWF,K,yBAQtC,SAAmBtI,EAAyBqI,GAC1C,GAAIlO,KAAM,CACR,IAAMiO,EAA0B,CAACK,OAAQ,aAAczI,OAAMqI,WACvDK,EDpDL,SAASC,EACd/P,GAGgB,IAFhBgQ,IAEgB,yDADhBC,EACgB,uCAEVC,EAAeD,GAAa,IAAIE,IAEtC,GAAKnQ,GAEE,GAAI4O,EAAe5O,GACxBkQ,EAAaE,IAAIpQ,QACZ,GAAI4O,EAAe5O,EAAOqQ,QAE/BH,EAAaE,IAAIpQ,EAAOqQ,aACnB,GAAIxB,YAAYyB,OAAOtQ,SAGvB,GAAIgQ,GAA+B,WAAlB,IAAOhQ,GAC7B,IAAK,IAAMH,KAAOG,EAEhB+P,EAAgB/P,EAAOH,GAAMmQ,EAAWE,QAM5C,YAAqBvN,IAAdsN,EAA0BpL,MAAMC,KAAKoL,GAAgB,GCyBnCH,CAAgBN,GAGrClO,KAAKgP,YAAYf,EAAMM,Q,KAM7B,SAASP,EAAeD,GACtB,IAAOlI,EAAckI,EAAdlI,KAAMoI,EAAQF,EAARE,KACb,MACW,YAATpI,GACAoI,GACuB,iBAAhBA,EAAKK,QACZL,EAAKK,OAAOW,WAAW,c,ikBCzE3B,IAAIC,EAAY,EAuChB,SAASC,EAAkBC,EAA0BC,GACnD,OAAO,IAAIzO,SAAQ,SAACR,EAASC,GAC3B,IAAMiP,EAAKJ,IA0BXtB,EAAWQ,kBAtBO,SAAZP,EAAahI,EAAMqI,GACvB,GAAIA,EAAQoB,KAAOA,EAKnB,OAAQzJ,GACN,IAAK,OACH+H,EAAWS,oBAAoBR,GAC/BzN,EAAQ8N,EAAQrH,QAChB,MAEF,IAAK,QACH+G,EAAWS,oBAAoBR,GAC/BxN,EAAO6N,EAAQxN,WAWrB,IAAMwN,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,QAASzK,EAAxD,EAAwDA,SAGlD8K,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,IAAI7K,MAAJ,mCAAsCyK,EAAOpS,KAA7C,YAXV,eAeE+R,EAAU,EAAH,KACFA,GADE,IAELpS,QAAUyS,GAAUA,EAAOL,SAAWK,EAAOL,QAAQpS,SAAY,GACjEiT,QAAQ,IAlBZ,UAqBeL,EAAO5B,EAAD,KAAWoB,GAAUzK,EAAS8K,GArBnD,sF,sBCjFO,ICuBMS,EAAc,CACzB7S,KAAM,QACNgS,GAAI,QACJxS,OAAQ,QACRsT,OAAQ,CAAC,QACTlO,QD5BqB,gBC6BrBgO,QAAQ,EACRG,WAAY,CAAC,OACbC,UAAW,CAAC,4BACZC,QAAQ,EACRC,MAAO,CAAC,SACRnB,QAvBgD,CAChDoB,MAAO,CACLC,YAAoC,YAAvB,oBAAOC,YAAP,gBAAOA,cAA2B,OAAS,KACxDC,YAAa,QACbC,gBAAiB,GACjBC,wBAAoB1P,K,iCCgBjB,SAAS2P,EAAmBC,GAWjC,IAVA,IAAIC,EAAOC,IACPC,EAAOD,IACPE,EAAOF,IACPG,GAAQH,IACRI,GAAQJ,IACRK,GAAQL,IAENM,EAAYR,EAAWS,SAAWT,EAAWS,SAASzT,MAAQ,GAC9DyF,EAAM+N,GAAaA,EAAU5R,OAE1B7C,EAAI,EAAGA,EAAI0G,EAAK1G,GAAK,EAAG,CAC/B,IAAM2U,EAAIF,EAAUzU,GACd4U,EAAIH,EAAUzU,EAAI,GAClB6U,EAAIJ,EAAUzU,EAAI,GAExBkU,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,whCCpDIM,E,WAKnB,WAAYC,EAAiBC,GAA2B,kECXnD,SAAgBC,EAAoBjE,GACzC,IAAKiE,EACH,MAAM,IAAI/M,MAAM8I,GAAW,4BDU3BkE,CAAO3O,MAAM2G,QAAQ6H,IAqEzB,SAAoBA,GAClB,IAD0B,EACpBI,EAAY,GADQ,IAENJ,GAFM,IAE1B,2BAA4B,KAAjBK,EAAiB,QACtBD,EAAUC,EAAM7U,OAElB8U,QAAQC,KAAK,gCAAiCF,EAAM7U,KAAM6U,GAE5DD,EAAUC,EAAM7U,OAAQ,GAPA,+BApExBgV,CAAWR,GAEX/Q,KAAK+Q,OAASA,EACd/Q,KAAKgR,SAAWA,GAAY,IAAIpE,I,qCAIlC,SAAU4E,GACR,GAAIxR,KAAKgR,WAAaQ,EAAMR,SAC1B,OAAO,EAET,GAAIhR,KAAK+Q,OAAOlS,SAAW2S,EAAMT,OAAOlS,OACtC,OAAO,EAET,IAAK,IAAI7C,EAAI,EAAGA,EAAIgE,KAAK+Q,OAAOlS,SAAU7C,EACxC,IAAKgE,KAAK+Q,OAAO/U,GAAGyV,UAAUD,EAAMT,OAAO/U,IACzC,OAAO,EAGX,OAAO,I,oBAGT,WAAyC,IAEvC,IAAM0V,EAAUhV,OAAOY,OAAO,MAFS,mBAA/BqU,EAA+B,yBAA/BA,EAA+B,gBAGvC,cAAmBA,EAAnB,eAAgC,CAA3B,IAAMpV,EAAI,KACbmV,EAAQnV,IAAQ,EAElB,IAAMqV,EAAiB5R,KAAK+Q,OAAOc,QAAO,SAACT,GAAD,OAAWM,EAAQN,EAAM7U,SACnE,OAAO,IAAIuU,EAAOc,EAAgB5R,KAAKgR,Y,sBAGzC,WAA6C,kCAAjCc,EAAiC,yBAAjCA,EAAiC,gBAE3C,IAAMF,EAAiBE,EAAcC,KAAI,SAACC,GAAD,OAAW,EAAKjB,OAAOiB,MAAQH,OAAOI,SAC/E,OAAO,IAAInB,EAAOc,EAAgB5R,KAAKgR,Y,oBAGzC,SAAOkB,GACL,IAAInB,EACAC,EAA2BhR,KAAKgR,SAEpC,GAAIkB,aAA0BpB,EAAQ,CACpC,IAAMqB,EAAcD,EACpBnB,EAASoB,EAAYpB,OACrBC,EAAWoB,EAAUA,EAAU,IAAIxF,IAAO5M,KAAKgR,UAAWmB,EAAYnB,eAEtED,EAASmB,EAIX,IAb+C,EAazCG,EAAmC3V,OAAOY,OAAO,MAbR,IAe3B0C,KAAK+Q,QAfsB,IAe/C,2BAAiC,KAAtBK,EAAsB,QAC/BiB,EAASjB,EAAM7U,MAAQ6U,GAhBsB,wCAmB3BL,GAnB2B,IAmB/C,2BAA4B,KAAjBK,EAAiB,QAC1BiB,EAASjB,EAAM7U,MAAQ6U,GApBsB,8BAyB/C,OAAO,IAAIN,EAFUpU,OAAO2I,OAAOgN,GAEHrB,O,KAgBpC,SAASoB,EAAaE,EAAOC,GAE3B,OAAO,IAAI3F,IAAJ,cAAa0F,GAAM,IAAI1F,KAAvB,IAAmC2F,GAAM,IAAI3F,O,IEpE1C4F,E,MCrBSC,E,WAMnB,WACElW,EACAuI,GAGA,IAFA4N,EAEA,wDADA1B,EACA,uDADgC,IAAIpE,IACpC,oHACA5M,KAAKzD,KAAOA,EACZyD,KAAK8E,KAAOA,EACZ9E,KAAK0S,SAAWA,EAChB1S,KAAKgR,SAAWA,E,gCAGlB,WACE,OAAOhR,KAAK8E,MAAQ9E,KAAK8E,KAAK6N,S,mBAGhC,WACE,OAAO,IAAIF,EAAMzS,KAAKzD,KAAMyD,KAAK8E,KAAM9E,KAAK0S,SAAU1S,KAAKgR,Y,uBAG7D,SAAUQ,GACR,OACExR,KAAKzD,OAASiV,EAAMjV,MACpByD,KAAK8E,OAAS0M,EAAM1M,MACpB9E,KAAK0S,WAAalB,EAAMkB,UACxB1S,KAAKgR,WAAaQ,EAAMR,W,sBAI5B,WACE,gBAAUhR,KAAK8E,MAAf,OAAsB9E,KAAK0S,SAAW,aAAe,IAArD,OACE1S,KAAKgR,SAAL,sBAA+BhR,KAAKgR,UAAa,Q,8fDhB3CwB,O,eAAAA,I,eAAAA,I,aAAAA,I,iBAAAA,I,mBAAAA,I,eAAAA,I,eAAAA,I,qBAAAA,I,eAAAA,I,eAAAA,I,0BAAAA,I,wBAAAA,I,gBAAAA,I,oBAAAA,I,kBAAAA,I,sCAAAA,I,kCAAAA,I,cAAAA,I,4BAAAA,I,gBAAAA,I,kBAAAA,I,kBAAAA,I,kBAAAA,I,kBAAAA,I,oBAAAA,I,oBAAAA,I,oBAAAA,I,uBAAAA,I,uBAAAA,I,uBAAAA,I,uBAAAA,I,uCAAAA,I,uCAAAA,I,iDAAAA,I,iDAAAA,I,+CAAAA,I,6BAAAA,I,uCAAAA,I,uCAAAA,I,qCAAAA,I,6BAAAA,I,+BAAAA,I,uCAAAA,I,4CAAAA,M,KEHL,IAAMI,EAAb,oEAwDE,WACE,OAAOJ,EAAKK,OAzDhB,uBAiEE,SAAUrB,GAER,OAAOxR,OAASwR,KAnEpB,qBACE,SAAcb,GACZ,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKM,OAFlC,mBAIE,SAAanC,GACX,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKO,MALlC,qBAOE,SAAepC,GACb,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKQ,QARlC,sBAUE,SAAgBrC,GACd,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKS,SAXlC,oBAaE,SAActC,GACZ,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKU,OAdlC,oBAgBE,SAAcvC,GACZ,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKW,OAjBlC,uBAmBE,SAAiBxC,GACf,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKY,UApBlC,oBAsBE,SAAczC,GACZ,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKa,OAvBlC,oBAyBE,SAAc1C,GACZ,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKc,OA1BlC,yBA4BE,SAAmB3C,GACjB,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKe,YA7BlC,wBA+BE,SAAkB5C,GAChB,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKgB,WAhClC,oBAkCE,SAAc7C,GACZ,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKiB,OAnClC,sBAqCE,SAAgB9C,GACd,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKkB,SAtClC,qBAwCE,SAAe/C,GACb,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKmB,QAzClC,+BA2CE,SAAyBhD,GACvB,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKoB,kBA5ClC,6BA8CE,SAAuBjD,GACrB,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKqB,gBA/ClC,mBAiDE,SAAalD,GACX,OAAOA,GAAKA,EAAEgC,SAAWH,EAAK5F,MAlDlC,0BAoDE,SAAoB+D,GAClB,OAAOA,GAAKA,EAAEgC,SAAWH,EAAKsB,eArDlC,K,EAiIO/W,OAAOC,YAzBP,IAAM+V,EAAb,gCAGE,WAAYgB,EAAUC,GAAU,yBAC9B,eAD8B,4DAE9B,EAAKD,SAAWA,EAChB,EAAKC,SAAWA,EAHc,EAHlC,gCAQE,WACE,OAAOxB,EAAKO,MAThB,WAyBE,WACE,MAAO,QA1BX,sBA4BE,WACE,gBAAU/S,KAAK+T,SAAW,IAAM,KAAhC,aAAyC/T,KAAKgU,cA7BlD,GAAyBpB,GAiCZqB,EAAb,gCACE,aAAc,gCACN,EAAM,GAFhB,UAA0BlB,GAKbmB,EAAb,gCACE,aAAc,gCACN,EAAM,IAFhB,UAA2BnB,GAKdoB,EAAb,gCACE,aAAc,gCACN,EAAM,IAFhB,UAA2BpB,GAUdqB,GAAb,gCACE,aAAc,gCACN,EAAO,GAFjB,UAA2BrB,GAKdsB,GAAb,gCACE,aAAc,gCACN,EAAO,IAFjB,UAA4BtB,GAKfuB,GAAb,gCACE,aAAc,gCACN,EAAO,IAFjB,UAA4BvB,GAatBwB,GAEI,GAFJA,GAGI,G,EAwBHxX,OAAOC,YArBP,IAAMgW,GAAb,gCAEE,WAAYwB,GAAW,yBACrB,eADqB,+BAErB,EAAKA,UAAYA,EAFI,EAFzB,gCAME,WACE,OAAOhC,EAAKQ,QAPhB,WAqBE,WACE,MAAO,UAtBX,sBAwBE,WACE,qBAAehT,KAAKwU,eAzBxB,GAA2B5B,GAkCd6B,GAAb,gCACE,aAAc,+BACNF,IAFV,UAA6BvB,IAKhB0B,GAAb,gCACE,aAAc,+BACNH,IAFV,UAA6BvB,IAyDtBjW,OAAOC,YAyCPD,OAAOC,YAoCPD,OAAOC,YA8CPD,OAAOC,Y,EAwCPD,OAAOC,YArBP,IAAM6W,GAAb,gCAIE,WAAYc,EAAkBC,GAAc,yBAC1C,eAD0C,4DAE1C,EAAKD,SAAWA,EAChB,EAAKE,SAAW,CAACD,GAHyB,EAJ9C,gCASE,WACE,OAAOpC,EAAKqB,gBAVhB,qBAYE,WACE,OAAO7T,KAAK6U,SAAS,GAAG/P,OAb5B,sBAeE,WACE,OAAO9E,KAAK6U,SAAS,KAhBzB,WAqBE,WACE,MAAO,kBAtBX,sBAwBE,WACE,8BAAwB7U,KAAK2U,SAA7B,aAA0C3U,KAAK8U,UAA/C,SAzBJ,GAAmClC,GA2C5B7V,OAAOC,YCpdP,SAAS+X,GACdC,EACAC,EACAC,GAEA,IAAMpQ,EC3BD,SAAoCiG,GACzC,OAAQA,EAAMzM,aACZ,KAAK6W,UACH,OAAO,IAAIlB,EACb,KAAKmB,WACH,OAAO,IAAIhB,GACb,KAAKiB,WACH,OAAO,IAAInB,EACb,KAAKoB,YACH,OAAO,IAAIjB,GACb,KAAKkB,WACH,OAAO,IAAIpB,EACb,KAAKqB,YACH,OAAO,IAAIlB,GACb,KAAKmB,aACH,OAAO,IAAIhB,GACb,KAAKiB,aACH,OAAO,IAAIhB,GACb,QACE,MAAM,IAAIxQ,MAAM,6BDQPyR,CAA2BV,EAAUhY,OAC5C+T,EAAWkE,GA6BZ,SAAmCD,GACxC,IAAMnP,EAAS,IAAI8G,IACf,eAAgBqI,GAClBnP,EAAO8P,IAAI,aAAcX,EAAUY,WAAYxT,SAAS,KAEtD,eAAgB4S,GAClBnP,EAAO8P,IAAI,aAAcX,EAAUa,WAAYzT,SAAS,KAEtD,eAAgB4S,GAClBnP,EAAO8P,IAAI,aAAcX,EAAUc,WAAY1T,YAEjD,OAAOyD,EAxCgDkQ,CAA0Bf,GAOjF,OANc,IAAIxC,EAChBuC,EACA,IAAInB,GAAcoB,EAAUgB,KAAM,IAAIxD,EAAM,QAAS3N,KACrD,EACAkM,GE/BG,SAASkF,GACdjG,EACAkG,EACAC,GAEA,IAAMC,EAAcC,GAAaH,EAAWnF,UACtCD,EAAkB,GAClBwF,EAiBR,SAAuCJ,GAGrC,IAAMrQ,EAAoD,GAC1D,IAAK,IAAMvI,KAAO4Y,EAAY,CAC5B,IAAMK,EAAiBL,EAAW5Y,GAClCuI,EAAO0Q,EAAeja,MAAQ,aAAeia,EAE/C,OAAO1Q,EAzB2B2Q,CAA8BN,EAAWlG,YAC3E,IAAK,IAAM+E,KAAiB/E,EAAY,CACtC,IACMmB,EAAQsF,GACZ1B,EAFgB/E,EAAW+E,GAI3BuB,EAA0BvB,IAE5BjE,EAAOnK,KAAKwK,GAEd,GAAIgF,EAAS,CACX,IAAMO,EAAeD,GAA2B,UAAWN,GAC3DrF,EAAOnK,KAAK+P,GAEd,OAAO,IAAI7F,EAAOC,EAAQsF,GAc5B,SAASK,GACP1B,EACAC,EACAkB,GAIA,OADcpB,GAAgBC,EAAeC,EADzBkB,EAAaG,GAAaH,EAAWnF,eAAY3Q,GAKvE,SAASiW,GAAatF,GACpB,IAAMqF,EAAc,IAAIzJ,IACxB,IAAK,IAAMrP,KAAOyT,EAChBqF,EAAYT,IAAZ,UAAmBrY,EAAnB,WAAiCqZ,KAAKC,UAAU7F,EAASzT,KAE3D,OAAO8Y,E,6lDCRT,IAMMS,GAAmC,CACvCpG,SAAU,WACVqG,OAAQ,SACRC,MAAO,UACPC,UAAW,cAGPC,GAAqC,CACzCC,EAAGhC,UACHiC,EAAGhC,WACHiC,EAAGhC,WACHiC,EAAGhC,YACHiC,EAAGhC,WACHiC,EAAGhC,YACHiC,EAAGhC,cAKgBiC,G,WAMnB,WAAYhI,GAAgB,mGAC1B1P,KAAK0P,MAAQA,EACb1P,KAAK2X,QAAU,IAAI3X,KAAK0P,MAAMkI,QAC9B5X,KAAK6X,gBAAkB,IAAI7X,KAAK0P,MAAMoI,gB,mCAMxC,WACE9X,KAAK0P,MAAMqI,QAAQ/X,KAAK2X,SACxB3X,KAAK0P,MAAMqI,QAAQ/X,KAAK6X,mB,uBAQ1B,SAAUxJ,GAAsE,IAA5CC,EAA4C,uDAAf,GACzDP,EAAS,IAAI/N,KAAK0P,MAAMsI,cAC9BjK,EAAOkK,KAAK,IAAI9C,UAAU9G,GAAcA,EAAY6J,YAEpDlY,KAAKmY,4BAA4B7J,GAEjC,IAAM8J,EAAgBpY,KAAK2X,QAAQU,uBAAuBtK,GACpDuK,EACJF,IAAkBpY,KAAK0P,MAAM6I,gBACzB,IAAIvY,KAAK0P,MAAM8I,KACf,IAAIxY,KAAK0P,MAAM+I,WAErB,IACE,IAAIC,EACJ,OAAQN,GACN,KAAKpY,KAAK0P,MAAM6I,gBACdG,EAAc1Y,KAAK2X,QAAQgB,mBAAmB5K,EAAQuK,GACtD,MAEF,KAAKtY,KAAK0P,MAAMkJ,YACdF,EAAc1Y,KAAK2X,QAAQkB,yBAAyB9K,EAAQuK,GAC5D,MAEF,QACE,MAAM,IAAIpU,MAAM,iCAGpB,IAAKwU,EAAYI,OAASR,EAAcS,IAAK,CAC3C,IAAM/L,EAAU,+BAAH,OAAkC0L,EAAYM,aAE3D,MAAM,IAAI9U,MAAM8I,GAGlB,IAAMmJ,EAAanW,KAAKiZ,oBAAoBX,EAAeF,EAAe9J,GAEpE4K,EAAWlZ,KAAKmZ,aAAab,EAAenC,EAAY7H,GAExD8K,EAAcpJ,EAAmBkJ,EAASjJ,YAE1CoJ,EAASnD,GAAegD,EAASjJ,WAAYkG,EAAY+C,EAAS9C,SAElElJ,EAAkB,OACtByB,OAAQ,QACRwH,aACAmD,OAAQ,CACNC,YAAajB,EAAckB,aAC3BJ,gBAECF,GAPgB,IAQnBG,WAEF,OAAOnM,EAvCT,QAyCElN,KAAK0P,MAAMqI,QAAQhK,GACfuK,GACFtY,KAAK0P,MAAMqI,QAAQO,M,iCAczB,SACEA,EACAF,EACA9J,GAEA,IAAM0C,EAAWhR,KAAKyZ,qBAAqBnB,GACrCrI,EAAajQ,KAAK0Z,oBAAoBpB,EAAehK,GAE3D,MAAO,CACL8J,gBACAuB,eAAgBrB,EAAcqB,iBAC9BH,WAAYlB,EAAckB,aAC1BI,UAAWtB,aAAyBtY,KAAK0P,MAAM8I,KAAOF,EAAcsB,YAAc,EAClF5I,WACAf,gB,iCAUJ,SACEqI,EACAhK,GAIA,IAFA,IAAMuL,EAAyD,GAEtDC,EAAc,EAAGA,EAAcxB,EAAcqB,iBAAkBG,IAAe,CAGrF,IAAMtD,EAAiBxW,KAAK2X,QAAQoC,aAAazB,EAAewB,GAE1D9I,EAAWhR,KAAKga,sBAAsB1B,EAAewB,GAE3DD,EAAgBrD,EAAeyD,aAAe,CAC5CA,UAAWzD,EAAeyD,YAC1BC,eAAgB1D,EAAe0D,iBAC/BC,UAAW3D,EAAe2D,YAC1BC,eAAgB5D,EAAe4D,iBAE/BC,YAAa7D,EAAe6D,cAC5BC,YAAa9D,EAAe8D,cAC5BvE,WAAYS,EAAeT,aAC3BwE,gBAAiBT,EAEjB9I,YAIF,IAAMwJ,EAAexa,KAAKya,0BAA0BjE,EAAgBlI,GAChEkM,IACFX,EAAgBrD,EAAeyD,aAAaS,uBAAyBF,GAGvE,IAAMG,EAAa3a,KAAK4a,wBAAwBpE,EAAgBlI,GAC5DqM,IACFd,EAAgBrD,EAAeyD,aAAaY,qBAAuBF,GAIvE,OAAOd,I,0BAST,SACEvB,EACAnC,EACA7H,GAEA,IAAM2B,EAAajQ,KAAK8a,mBAAmB3E,EAAYmC,EAAehK,GAGtE,IAD0B2B,EAAWS,SAEnC,MAAM,IAAIxM,MAAM,uCAIlB,GAAIoU,aAAyBtY,KAAK0P,MAAM8I,KACtC,OAAQlK,EAAQyM,UACd,IAAK,iBACH,MAAO,CACLA,SAAU,iBACV5d,KAAM,EACN8S,aACAmG,QAAS,CACPnZ,MAAO+C,KAAKgb,yBAAyB1C,GACrCrC,KAAM,IAGZ,IAAK,gBACL,QACE,MAAO,CACL8E,SAAU,gBACV5d,KAAM,EACN8S,aACAmG,QAAS,CACPnZ,MAAO+C,KAAKib,wBAAwB3C,GACpCrC,KAAM,IAOhB,MAAO,CACL8E,SAAU,aACV5d,KAAM,EACN8S,gB,gCAIJ,SACEkG,EACAmC,EACAhK,GAIA,IAFA,IAAM2B,EAA6C,GAEnD,MAA8BvT,OAAO2I,OAAO8Q,EAAWlG,YAAvD,eAAoE,CAA/D,IAAMiL,EAAe,KAClBlG,EAAgBhV,KAAKmb,qBAAqBD,EAAiB5M,GACjE4M,EAAgB3e,KAAOyY,EACvB,MAAsBhV,KAAKob,oBAAoB9C,EAAe4C,GAAvDje,EAAP,EAAOA,MAAOgZ,EAAd,EAAcA,KACdhG,EAAW+E,GAAiB,CAC1B/X,QACAgZ,OACAJ,WAAYqF,EAAgBb,YAC5BvE,WAAYoF,EAAgBZ,YAC5BvE,WAAYmF,EAAgBnF,YAIhC,OAAO9F,I,qCAST,SAAwBqI,GAEtB,IACM+C,EAAwB,EADb/C,EAAcsB,YAEzB1B,EAxPc,EAwPDmD,EAEbtC,EAAM/Y,KAAK0P,MAAM4L,QAAQpD,GAC/B,IAEE,OADAlY,KAAK2X,QAAQ4D,wBAAwBjD,EAAeJ,EAAYa,GACzD,IAAIvD,YAAYxV,KAAK0P,MAAM8L,QAAQzN,OAAQgL,EAAKsC,GAAY/Y,QAFrE,QAIEtC,KAAK0P,MAAM+L,MAAM1C,M,sCAQrB,SAAyBT,GACvB,IAAMoD,EAAa,IAAI1b,KAAK0P,MAAMiM,gBAClC,IAEE,OADwB3b,KAAK2X,QAAQiE,0BAA0BtD,EAAeoD,GA0QpF,SAAwBA,GAGtB,IAFA,IAAMG,EAAYH,EAAWzF,OACvB6F,EAAW,IAAIvG,WAAWsG,GACvB7f,EAAI,EAAGA,EAAI6f,EAAW7f,IAC7B8f,EAAS9f,GAAK0f,EAAWK,SAAS/f,GAEpC,OAAO8f,EA/QIE,CAAeN,GAFxB,QAIE1b,KAAK0P,MAAMqI,QAAQ2D,M,iCAUvB,SACEpD,EACArD,GAEA,IAQIhY,EAREgf,EAAiB/E,GAAmCjC,EAAUkF,WAC9D+B,EAAgBjH,EAAUmF,eAE1ByB,EADYvD,EAAckB,aACF0C,EAExBhE,EAAa2D,EAAYI,EAAeE,kBACxCC,EA+MV,SAA0B1M,EAAgB2M,GACxC,OAAQA,GACN,KAAK5G,aACH,OAAO/F,EAAM4M,WACf,KAAKnH,UACH,OAAOzF,EAAM6M,QACf,KAAKlH,WACH,OAAO3F,EAAM8M,SACf,KAAKjH,WACH,OAAO7F,EAAM+M,SACf,KAAKrH,WACH,OAAO1F,EAAMgN,SACf,KAAKpH,YACH,OAAO5F,EAAMiN,UACf,KAAKnH,YACH,OAAO9F,EAAMkN,UACf,QACE,OAAOlN,EAAMmN,YAhOEC,CAAiB9c,KAAK0P,MAAOuM,GAIxClD,EAAM/Y,KAAK0P,MAAM4L,QAAQpD,GAC/B,IACE,IAAM1B,EAAiBxW,KAAK2X,QAAQoC,aAAazB,EAAerD,EAAUsF,iBAC1Eva,KAAK2X,QAAQoF,kCACXzE,EACA9B,EACA4F,EACAlE,EACAa,GAEF9b,EAAQ,IAAIgf,EAAejc,KAAK0P,MAAM8L,QAAQzN,OAAQgL,EAAK8C,GAAWvZ,QATxE,QAWEtC,KAAK0P,MAAM+L,MAAM1C,GAGnB,MAAO,CAAC9b,QAAOgZ,KAAMiG,K,kCA6BvB,SAAqBjH,EAA2B3G,GAG9C,IADA,IAAM0O,EAAW/H,EAAUgF,UAC3B,MAAiDvd,OAAOugB,QACtD3O,EAAQwB,iBAAmB,IAD7B,eAEG,CAFE,kBAAOkF,EAAP,KAGH,GAHG,OAGuBgI,EACxB,OAAOhI,EAKX,IAAMkI,EAAoBjI,EAAUiF,eACpC,IAAK,IAAMiD,KAA0BrG,GAAkC,CAErE,GADsB9W,KAAK0P,MAAMyN,KACXD,EAGpB,OAAOpG,GAAiCqG,GAM5C,IAAMC,EAAY9O,EAAQyB,oBAAsB,OAChD,OAAIkF,EAAUjE,SAASoM,GACdnI,EAAUjE,SAASoM,GAAWC,OAIvC,2BAA2BL,K,kCAM7B,SAAqB1E,GACnB,IAAMgF,EAAgBtd,KAAK2X,QAAQ4F,YAAYjF,GAC/C,OAAOtY,KAAKwd,kBAAkBF,K,mCAIhC,SAAsBhF,EAAkCwB,GACtD,IAAMwD,EAAgBtd,KAAK2X,QAAQ8F,qBAAqBnF,EAAewB,GACvE,OAAO9Z,KAAKwd,kBAAkBF,K,+BAQhC,SAAkBA,GAEhB,IAAKA,IAAkBA,EAAcvE,IACnC,MAAO,GAIT,IAFA,IAAMjT,EAAS,GACT4X,EAAa1d,KAAK6X,gBAAgB8F,WAAWL,GAC1CM,EAAa,EAAGA,EAAaF,EAAYE,IAAc,CAC9D,IAAMR,EAAYpd,KAAK6X,gBAAgBgG,aAAaP,EAAeM,GACnE9X,EAAOsX,GAAapd,KAAK8d,uBAAuBR,EAAeF,GAEjE,OAAOtX,I,oCAQT,SAAuBwX,EAAyBF,GAC9C,IAAM1B,EAAa,IAAI1b,KAAK0P,MAAMiM,gBAClC,IAEE3b,KAAK6X,gBAAgBkG,iBAAiBT,EAAeF,EAAW1B,GAChE,IAAMI,EA2GZ,SAAuBJ,GAGrB,IAFA,IAAMG,EAAYH,EAAWzF,OACvB6F,EAAW,IAAIvG,WAAWsG,GACvB7f,EAAI,EAAGA,EAAI6f,EAAW7f,IAC7B8f,EAAS9f,GAAK0f,EAAWK,SAAS/f,GAEpC,OAAO8f,EAjHckC,CAActC,GAC/B,MAAO,CACLuC,IAAKje,KAAK6X,gBAAgBqG,YAAYZ,EAAeF,GACrDC,OAAQrd,KAAK6X,gBAAgBsG,eAAeb,EAAeF,GAC3DgB,OAAQpe,KAAK6X,gBAAgBwG,eAAef,EAAeF,GAC3DtB,YARJ,QAWE9b,KAAK0P,MAAMqI,QAAQ2D,M,yCAOvB,SAA4BpN,GAC1B,IADsD,EACtD,EAA8DA,EAAvDgQ,2BAAP,MAA6B,GAA7B,IAA8DhQ,EAA7BiQ,4BAAjC,MAAwD,GAAxD,EADsD,KAE/B,GAAH,WAAOD,GAAP,IAA+BC,KAFG,IAGtD,2BAAiD,KAAtCC,EAAsC,QAC/Cxe,KAAK2X,QAAQ8G,uBAAuBze,KAAK0P,MAAM8O,KAJK,iC,uCAYxD,SACEhI,EACAlI,GACmC,WACnC,EAAmCA,EAA5BgQ,2BAAP,MAA6B,GAA7B,EACMpE,EAAiB1D,EAAe0D,iBAEtC,GADaoE,EAAoBvM,KAAI,SAACjN,GAAD,OAAU,EAAK6S,QAAQ7S,MAAO4Z,SAASxE,GAClE,CACR,IAAMyE,EAAY,IAAI3e,KAAK0P,MAAMkP,+BACjC,IACE,GAAID,EAAUE,kBAAkBrI,GAC9B,MAAO,CACLsI,kBAAmBH,EAAUG,oBAC7BC,MAAOJ,EAAUI,QACjBC,WAAY,IAAIvJ,aAAa,CAAC,EAAG,EAAG,IAAI1D,KAAI,SAAC/V,GAAD,OAAO2iB,EAAUM,UAAUjjB,OAL7E,QASEgE,KAAK0P,MAAMqI,QAAQ4G,IAGvB,OAAO,O,qCAGT,SACEnI,EACAlI,GACiC,WACjC,EAAoCA,EAA7BiQ,4BAAP,MAA8B,GAA9B,EACMrE,EAAiB1D,EAAe0D,iBAItC,GAHmBqE,EAChBxM,KAAI,SAACjN,GAAD,OAAU,EAAK6S,QAAQ7S,MAC3B4Z,SAASxE,GACI,CACd,IAAMyE,EAAY,IAAI3e,KAAK0P,MAAMkP,+BACjC,IACE,GAAID,EAAUE,kBAAkBrI,GAC9B,MAAO,CACLsI,kBAAmBH,EAAUG,qBAHnC,QAOE9e,KAAK0P,MAAMqI,QAAQ4G,IAGvB,OAAO,S,0BCpiBX,IAGMO,GAAsB,GAiBrB,SAAeC,GAAtB,mC,sCAAO,WACLC,GADK,6BAAA1Q,EAAA,6DAEL2Q,EAFK,+BAEuB,KAC5B/Q,EAHK,+BAGa,GAEd+Q,IACFD,EAAaE,GAAcF,EAAYC,EAAY/Q,IAIrD4Q,GAAoBE,GAClBF,GAAoBE,IAAeG,GAAoBH,GAXpD,SAYQF,GAAoBE,GAZ5B,oF,sBAgBA,SAASE,GAAcE,EAASH,EAAqB/Q,GAE1D,GAAIkR,EAAQtR,WAAW,QACrB,OAAOsR,EAIT,IAAMtjB,EAAUoS,EAAQpS,SAAW,GACnC,OAAIA,EAAQsjB,GACHtjB,EAAQsjB,GAKZ7e,KAKD2N,EAAQmR,KCzDP,SAAgBxO,EAAgBjE,GACrC,IAAKiE,EACH,MAAM,IAAI/M,MAAM8I,GAAW,gCDwD3BkE,CAAO5C,EAAQmR,IAAIvR,WAAW,SAC9B,UAAUI,EAAQmR,IAAlB,YAAyBJ,EAAzB,YAxDY,gBAwDZ,sBAA4DG,IAI1Dze,KACF,sBAAsBye,GAGxB,kBAAkBH,EAAlB,qBAAyCG,GAdvC,kBAAkBH,EAAlB,sBAA0CG,G,SAiB/BD,G,yEAAf,WAAmCH,GAAnC,mBAAA1Q,EAAA,0DACM0Q,EAAWM,SAAS,QAD1B,gCAE2BC,MAAMP,GAFjC,cAEUQ,EAFV,gBAGiBA,EAASvR,cAH1B,kDAMO1N,KANP,yBAOWkf,oBAPX,uCAO0CA,mBAAqBT,GAP/D,uEASMre,KATN,0CAUWC,cAAcoe,IAVzB,yBAiByBO,MAAMP,GAjB/B,eAiBQQ,EAjBR,iBAkB6BA,EAASE,OAlBtC,eAkBQC,EAlBR,yBAmBSC,GAAsBD,EAAcX,IAnB7C,6C,sBAwCA,SAASY,GAAsBD,EAAcxR,GAC3C,IAAK5N,KACH,OAAOkf,sBAA0BA,qBAAuBE,EAAcxR,GAGxE,GAAIxN,KAKF,OAHAkf,KAAK9jB,KAAKqE,KAAQuf,GAGX,KAGT,IAAMG,EAASzf,SAAS0f,cAAc,UACtCD,EAAO3R,GAAKA,EAEZ,IACE2R,EAAOE,YAAY3f,SAAS4f,eAAeN,IAC3C,MAAOrW,GACPwW,EAAOJ,KAAOC,EAGhB,OADAtf,SAAS6f,KAAKF,YAAYF,GACnB,K,qkBEnIT,IAOIK,GANEC,GAAuB,oDAAH,OADJ,QACI,qBACpBC,GAAyB,oDAAH,OAFN,QAEM,0BACtBC,GAAyB,oDAAH,OAHN,QAGM,uBAEF,kDAAH,OALD,QAKC,gCAKhB,SAAeC,GAAtB,mC,sCAAO,WAAsCrS,GAAtC,eAAAI,EAAA,6DACCxS,EAAUoS,EAAQpS,SAAW,GAIjCqkB,GADErkB,EAAQ0kB,QAERL,IACArkB,EAAQ0kB,QAAQC,oBAAoB,IAAI/gB,MAAK,SAAC4P,GAC5C,MAAO,CAACA,YAIS6Q,IAAsBO,GAAiBxS,GAZzD,SAcQiS,GAdR,oF,+BAoCQO,G,yEAAf,WAAgCxS,GAAhC,qBAAAI,EAAA,2DAGUJ,EAAQoB,OAASpB,EAAQoB,MAAMC,YAHzC,OAIS,OAJT,6CAKiCwP,GAAYqB,GAAsB,QAASlS,GAL5E,cAKMyS,EALN,+CAU+ClhB,QAV/C,UAWcsf,GAAYsB,GAAwB,QAASnS,GAX3D,qCAYc6Q,GAAYuB,GAAwB,QAASpS,GAZ3D,2DAUuD0S,IAVvD,4CAUOD,EAVP,KAU2BE,EAV3B,oBAiBEF,EAAqBA,GAAsBG,WAAWH,mBAjBxD,UAkBeI,GAAuBJ,EAAoBE,GAlB1D,sF,sBAqBA,SAASE,GAAuBJ,EAAoBE,GAClD,IAAM3S,EAA8B,GAKpC,OAJI2S,IACF3S,EAAQ2S,WAAaA,GAGhB,IAAIphB,SAAQ,SAACR,GAClB0hB,EAAmB,SACdzS,GADa,IAEhB8S,eAAgB,SAAC1R,GAAD,OAAWrQ,EAAQ,CAACqQ,iB,qkBC1DnC,IAAMN,GAAc,SACtBiS,GADmB,IAEtBxS,M,uFAGF,WAAqBR,EAA0BC,GAA/C,mBAAAI,EAAA,sEACwBiS,GAAuBrS,GAD/C,uBACSoB,EADT,EACSA,MACD4R,EAAc,IAAI5J,GAAYhI,GAFtC,2BAIW4R,EAAY1S,UAAUP,EAAaC,aAAnC,EAAmCA,EAASoB,QAJvD,uBAMI4R,EAAYvJ,UANhB,0E,sBAWO,IhB7B4BpJ,MiBRhBS,GjBUG,oBAATnQ,OAIX4N,EAAWE,UAAX,+BAAuB,WAAOjI,EAAMqI,GAAb,uBAAAuB,EAAA,2DACb5J,EADa,OAEd,YAFc,uCAMR0J,EAAuBrB,EAAvBqB,MANQ,EAMerB,EAAhBmB,eANC,MAMS,GANT,WAQMG,EAAU,CAC7BE,UACAN,YAAaG,EACbF,UACAzK,QAAS,CACPgL,MAAOT,KAbI,OAQTtI,EARS,OAgBf+G,EAAWoB,YAAY,OAAQ,CAACnI,WAhBjB,kDAkBTkH,EAAU,gBAAiB9I,MAAQ,KAAM8I,QAAU,GACzDH,EAAWoB,YAAY,QAAS,CAACtO,MAAOqN,IAnBzB,8FAAvB","file":"draco-worker.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 30);\n","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nmodule.exports = _classCallCheck;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var setPrototypeOf = require(\"./setPrototypeOf.js\");\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inherits;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nmodule.exports = _defineProperty;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nmodule.exports = _createClass;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","module.exports = require(\"regenerator-runtime\");\n","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nmodule.exports = _assertThisInitialized;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","// Purpose: include this in your module to avoids adding dependencies on\n// micro modules like 'global' and 'is-browser';\n\n/* eslint-disable no-restricted-globals */\nconst globals = {\n  self: typeof self !== 'undefined' && self,\n  window: typeof window !== 'undefined' && window,\n  global: typeof global !== 'undefined' && global,\n  document: typeof document !== 'undefined' && document\n};\n\nconst self_: {[key: string]: any} = globals.self || globals.window || globals.global || {};\nconst window_: {[key: string]: any} = globals.window || globals.self || globals.global || {};\nconst global_: {[key: string]: any} = globals.global || globals.self || globals.window || {};\nconst document_: {[key: string]: any} = globals.document || {};\n\nexport {self_ as self, window_ as window, global_ as global, document_ as document};\n\n/** true if running in the browser, false if running in Node.js */\nexport const isBrowser: boolean =\n  // @ts-ignore process.browser\n  typeof process !== 'object' || String(process) !== '[object process]' || process.browser;\n\n/** true if running on a worker thread */\nexport const isWorker: boolean = typeof importScripts === 'function';\n\n/** true if running on a mobile device */\nexport const isMobile: boolean =\n  typeof window !== 'undefined' && typeof window.orientation !== 'undefined';\n\n// Extract node major version\nconst matches =\n  typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);\n\n/** Version of Node.js if running under Node, otherwise 0 */\nexport const nodeVersion: number = (matches && parseFloat(matches[1])) || 0;\n","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    module.exports = _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  } else {\n    module.exports = _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  }\n\n  return _typeof(obj);\n}\n\nmodule.exports = _typeof;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var arrayWithoutHoles = require(\"./arrayWithoutHoles.js\");\n\nvar iterableToArray = require(\"./iterableToArray.js\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread.js\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var 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;","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  return _getPrototypeOf(o);\n}\n\nmodule.exports = _getPrototypeOf;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","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;","var _typeof = require(\"@babel/runtime/helpers/typeof\")[\"default\"];\n\nvar assertThisInitialized = require(\"./assertThisInitialized.js\");\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return assertThisInitialized(self);\n}\n\nmodule.exports = _possibleConstructorReturn;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","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 g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableSpread;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _setPrototypeOf(o, p) {\n  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  return _setPrototypeOf(o, p);\n}\n\nmodule.exports = _setPrototypeOf;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","// NOTE - there is a copy of this function is both in core and loader-utils\n// core does not need all the utils in loader-utils, just this one.\n\n/**\n * Returns an array of Transferrable objects that can be used with postMessage\n * https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage\n * @param object data to be sent via postMessage\n * @param recursive - not for application use\n * @param transfers - not for application use\n * @returns a transfer list that can be passed to postMessage\n */\nexport function getTransferList(\n  object: any,\n  recursive: boolean = true,\n  transfers?: Set<any>\n): Transferable[] {\n  // Make sure that items in the transfer list is unique\n  const transfersSet = transfers || new Set();\n\n  if (!object) {\n    // ignore\n  } else if (isTransferable(object)) {\n    transfersSet.add(object);\n  } else if (isTransferable(object.buffer)) {\n    // Typed array\n    transfersSet.add(object.buffer);\n  } else if (ArrayBuffer.isView(object)) {\n    // object is a TypeArray viewing into a SharedArrayBuffer (not transferable)\n    // Do not iterate through the content in this case\n  } else if (recursive && typeof object === 'object') {\n    for (const key in object) {\n      // Avoid perf hit - only go one level deep\n      getTransferList(object[key], recursive, transfersSet);\n    }\n  }\n\n  // If transfers is defined, is internal recursive call\n  // Otherwise it's called by the user\n  return transfers === undefined ? Array.from(transfersSet) : [];\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/API/Transferable\nfunction isTransferable(object) {\n  if (!object) {\n    return false;\n  }\n  if (object instanceof ArrayBuffer) {\n    return true;\n  }\n  if (typeof MessagePort !== 'undefined' && object instanceof MessagePort) {\n    return true;\n  }\n  if (typeof ImageBitmap !== 'undefined' && object instanceof ImageBitmap) {\n    return true;\n  }\n  // @ts-ignore\n  if (typeof OffscreenCanvas !== 'undefined' && object instanceof OffscreenCanvas) {\n    return true;\n  }\n  return false;\n}\n","import type {WorkerMessageData, WorkerMessageType, WorkerMessagePayload} from '../../types';\nimport {getTransferList} from '../worker-utils/get-transfer-list';\n\nconst onMessageWrapperMap = new Map();\n\n/**\n * Type safe wrapper for worker code\n */\nexport default class WorkerBody {\n  /*\n   * (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n   */\n  static set onmessage(onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any) {\n    // eslint-disable-next-line no-restricted-globals\n    self.onmessage = (message) => {\n      if (!isKnownMessage(message)) {\n        return;\n      }\n\n      // Confusingly the message itself also has a 'type' field which is always set to 'message'\n      const {type, payload} = message.data;\n      onMessage(type, payload);\n    };\n  }\n\n  static addEventListener(\n    onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n  ) {\n    let onMessageWrapper = onMessageWrapperMap.get(onMessage);\n\n    if (!onMessageWrapper) {\n      onMessageWrapper = (message) => {\n        if (!isKnownMessage(message)) {\n          return;\n        }\n\n        // Confusingly the message itself also has a 'type' field which is always set to 'message'\n        const {type, payload} = message.data;\n        onMessage(type, payload);\n      };\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    self.addEventListener('message', onMessageWrapper);\n  }\n\n  static removeEventListener(\n    onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n  ) {\n    const onMessageWrapper = onMessageWrapperMap.get(onMessage);\n    onMessageWrapperMap.delete(onMessage);\n    // eslint-disable-next-line no-restricted-globals\n    self.removeEventListener('message', onMessageWrapper);\n  }\n\n  /**\n   * Send a message from a worker to creating thread (main thread)\n   * @param type\n   * @param payload\n   */\n  static postMessage(type: WorkerMessageType, payload: WorkerMessagePayload): void {\n    if (self) {\n      const data: WorkerMessageData = {source: 'loaders.gl', type, payload};\n      const transferList = getTransferList(payload);\n      // eslint-disable-next-line no-restricted-globals\n      // @ts-ignore\n      self.postMessage(data, transferList);\n    }\n  }\n}\n\n// Filter out noise messages sent to workers\nfunction isKnownMessage(message) {\n  const {type, data} = message;\n  return (\n    type === 'message' &&\n    data &&\n    typeof data.source === 'string' &&\n    data.source.startsWith('loaders.gl')\n  );\n}\n","/* eslint-disable no-restricted-globals */\nimport type {LoaderWithParser} from '../../types';\nimport {WorkerBody} from '@loaders.gl/worker-utils';\n// import {validateLoaderVersion} from './validate-loader-version';\n\nlet requestId = 0;\n\n/**\n * Set up a WebWorkerGlobalScope to talk with the main thread\n * @param loader\n */\nexport function createLoaderWorker(loader: LoaderWithParser) {\n  // Check that we are actually in a worker thread\n  if (typeof self === 'undefined') {\n    return;\n  }\n\n  WorkerBody.onmessage = async (type, payload) => {\n    switch (type) {\n      case 'process':\n        try {\n          // validateLoaderVersion(loader, data.source.split('@')[1]);\n\n          const {input, options = {}} = payload;\n\n          const result = await parseData({\n            loader,\n            arrayBuffer: input,\n            options,\n            context: {\n              parse: parseOnMainThread\n            }\n          });\n          WorkerBody.postMessage('done', {result});\n        } catch (error) {\n          const message = error instanceof Error ? error.message : '';\n          WorkerBody.postMessage('error', {error: message});\n        }\n        break;\n      default:\n    }\n  };\n}\n\nfunction parseOnMainThread(arrayBuffer: ArrayBuffer, options: {[key: string]: any}): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const id = requestId++;\n\n    /**\n     */\n    const onMessage = (type, payload) => {\n      if (payload.id !== id) {\n        // not ours\n        return;\n      }\n\n      switch (type) {\n        case 'done':\n          WorkerBody.removeEventListener(onMessage);\n          resolve(payload.result);\n          break;\n\n        case 'error':\n          WorkerBody.removeEventListener(onMessage);\n          reject(payload.error);\n          break;\n\n        default:\n        // ignore\n      }\n    };\n\n    WorkerBody.addEventListener(onMessage);\n\n    // Ask the main thread to decode data\n    const payload = {id, input: arrayBuffer, options};\n    WorkerBody.postMessage('process', payload);\n  });\n}\n\n// TODO - Support byteOffset and byteLength (enabling parsing of embedded binaries without copies)\n// TODO - Why not support async loader.parse* funcs here?\n// TODO - Why not reuse a common function instead of reimplementing loader.parse* selection logic? Keeping loader small?\n// TODO - Lack of appropriate parser functions can be detected when we create worker, no need to wait until parse\nasync function parseData({loader, arrayBuffer, options, context}) {\n  let data;\n  let parser;\n  if (loader.parseSync || loader.parse) {\n    data = arrayBuffer;\n    parser = loader.parseSync || loader.parse;\n  } else if (loader.parseTextSync) {\n    const textDecoder = new TextDecoder();\n    data = textDecoder.decode(arrayBuffer);\n    parser = loader.parseTextSync;\n  } else {\n    throw new Error(`Could not load data with ${loader.name} loader`);\n  }\n\n  // TODO - proper merge in of loader options...\n  options = {\n    ...options,\n    modules: (loader && loader.options && loader.options.modules) || {},\n    worker: false\n  };\n\n  return await parser(data, {...options}, context, loader);\n}\n","// Version 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, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {DracoParseOptions} from './lib/draco-parser';\n// import type {DracoMeshData} from './types';\nimport {VERSION} from './lib/utils/version';\n\nexport type DracoLoaderOptions = LoaderOptions & {\n  draco?: DracoParseOptions & {\n    decoderType?: 'wasm' | 'js';\n    libraryPath?: string;\n    extraAttributes?;\n    attributeNameEntry?: string;\n  };\n};\n\nconst DEFAULT_DRACO_OPTIONS: DracoLoaderOptions = {\n  draco: {\n    decoderType: typeof WebAssembly === 'object' ? 'wasm' : 'js', // 'js' for IE11\n    libraryPath: 'libs/',\n    extraAttributes: {},\n    attributeNameEntry: undefined\n  }\n};\n\n/**\n * Worker loader for Draco3D compressed geometries\n */\nexport const DracoLoader = {\n  name: 'Draco',\n  id: 'draco',\n  module: 'draco',\n  shapes: ['mesh'],\n  version: VERSION,\n  worker: true,\n  extensions: ['drc'],\n  mimeTypes: ['application/octet-stream'],\n  binary: true,\n  tests: ['DRACO'],\n  options: DEFAULT_DRACO_OPTIONS\n};\n\nexport const _TypecheckDracoLoader: Loader = DracoLoader;\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","import {assert} from '../../utils/assert';\nimport Field from './field';\n\nexport type SchemaMetadata = Map<string, any>;\n\n/**\n * ArrowJS `Schema` API-compatible class for row-based tables (returned from `DataTable`)\n * https://loaders.gl/arrowjs/docs/api-reference/schema\n */\nexport default class Schema {\n  fields: Field[];\n  // TODO - Arrow just allows Map<string, string>\n  metadata: SchemaMetadata;\n\n  constructor(fields: Field[], metadata?: SchemaMetadata) {\n    assert(Array.isArray(fields));\n    checkNames(fields);\n    // For kepler fields, create arrow compatible `Fields` that have kepler fields as `metadata`\n    this.fields = fields;\n    this.metadata = metadata || new Map();\n  }\n\n  // TODO - arrow only seems to compare fields, not metadata\n  compareTo(other: Schema): boolean {\n    if (this.metadata !== other.metadata) {\n      return false;\n    }\n    if (this.fields.length !== other.fields.length) {\n      return false;\n    }\n    for (let i = 0; i < this.fields.length; ++i) {\n      if (!this.fields[i].compareTo(other.fields[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  select(...columnNames: string[]): Schema {\n    // Ensure column names reference valid fields\n    const nameMap = Object.create(null);\n    for (const name of columnNames) {\n      nameMap[name] = true;\n    }\n    const selectedFields = this.fields.filter((field) => nameMap[field.name]);\n    return new Schema(selectedFields, this.metadata);\n  }\n\n  selectAt(...columnIndices: number[]): Schema {\n    // Ensure column indices reference valid fields\n    const selectedFields = columnIndices.map((index) => this.fields[index]).filter(Boolean);\n    return new Schema(selectedFields, this.metadata);\n  }\n\n  assign(schemaOrFields: Schema | Field[]): Schema {\n    let fields: Field[];\n    let metadata: SchemaMetadata = this.metadata;\n\n    if (schemaOrFields instanceof Schema) {\n      const otherSchema = schemaOrFields;\n      fields = otherSchema.fields;\n      metadata = mergeMaps(mergeMaps(new Map(), this.metadata), otherSchema.metadata);\n    } else {\n      fields = schemaOrFields;\n    }\n\n    // Create a merged list of fields, overwrite fields in place, new fields at end\n    const fieldMap: {[key: string]: Field} = Object.create(null);\n\n    for (const field of this.fields) {\n      fieldMap[field.name] = field;\n    }\n\n    for (const field of fields) {\n      fieldMap[field.name] = field;\n    }\n\n    const mergedFields = Object.values(fieldMap);\n\n    return new Schema(mergedFields, metadata);\n  }\n}\n\n// Warn if any duplicated field names\nfunction checkNames(fields) {\n  const usedNames = {};\n  for (const field of fields) {\n    if (usedNames[field.name]) {\n      // eslint-disable-next-line\n      console.warn('Schema: duplicated field name', field.name, field);\n    }\n    usedNames[field.name] = true;\n  }\n}\n\nfunction mergeMaps<T>(m1: T, m2: T): T {\n  // @ts-ignore\n  return new Map([...(m1 || new Map()), ...(m2 || new Map())]);\n}\n","// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\nexport function assert(condition: boolean, message?: string) {\n  if (!condition) {\n    throw new Error(message || 'loader assertion failed.');\n  }\n}\n","// This code is adapted from ArrowJS https://github.com/apache/arrow\n// under Apache license http://www.apache.org/licenses/LICENSE-2.0\n\n/**\n * Main data type enumeration.\n *\n * Data types in this library are all *logical*. They can be expressed as\n * either a primitive physical type (bytes or bits of some fixed size), a\n * nested type consisting of other data types, or another data type (e.g. a\n * timestamp encoded as an int64).\n *\n * **Note**: Only enum values 0-17 (NONE through Map) are written to an Arrow\n * IPC payload.\n *\n * The rest of the values are specified here so TypeScript can narrow the type\n * signatures further beyond the base Arrow Types. The Arrow DataTypes include\n * metadata like `bitWidth` that impact the type signatures of the values we\n * accept and return.\n *\n * For example, the `Int8Vector` reads 1-byte numbers from an `Int8Array`, an\n * `Int32Vector` reads a 4-byte number from an `Int32Array`, and an `Int64Vector`\n * reads a pair of 4-byte lo, hi 32-bit integers as a zero-copy slice from the\n * underlying `Int32Array`.\n *\n * Library consumers benefit by knowing the narrowest type, since we can ensure\n * the types across all public methods are propagated, and never bail to `any`.\n * These values are _never_ used at runtime, and they will _never_ be written\n * to the flatbuffers metadata of serialized Arrow IPC payloads.\n */\nexport enum Type {\n  /** The default placeholder type */\n  NONE = 0,\n  /** A NULL type having no physical storage */\n  Null = 1,\n  /** Signed or unsigned 8, 16, 32, or 64-bit little-endian integer */\n  Int = 2,\n  /** 2, 4, or 8-byte floating point value */\n  Float = 3,\n  /** Variable-length bytes (no guarantee of UTF8-ness) */\n  Binary = 4,\n  /** UTF8 variable-length string as List<Char> */\n  Utf8 = 5,\n  /** Boolean as 1 bit, LSB bit-packed ordering */\n  Bool = 6,\n  /** Precision-and-scale-based decimal type. Storage type depends on the parameters. */\n  Decimal = 7,\n  /** int32_t days or int64_t milliseconds since the UNIX epoch */\n  Date = 8,\n  /** Time as signed 32 or 64-bit integer, representing either seconds, milliseconds, microseconds, or nanoseconds since midnight since midnight */\n  Time = 9,\n  /** Exact timestamp encoded with int64 since UNIX epoch (Default unit millisecond) */\n  Timestamp = 10,\n  /** YEAR_MONTH or DAY_TIME interval in SQL style */\n  Interval = 11,\n  /** A list of some logical data type */\n  List = 12,\n  /** Struct of logical types */\n  Struct = 13,\n  /** Union of logical types */\n  Union = 14,\n  /** Fixed-size binary. Each value occupies the same number of bytes */\n  FixedSizeBinary = 15,\n  /** Fixed-size list. Each value occupies the same number of bytes */\n  FixedSizeList = 16,\n  /** Map of named logical types */\n  Map = 17,\n\n  /** Dictionary aka Category type */\n  Dictionary = -1,\n  Int8 = -2,\n  Int16 = -3,\n  Int32 = -4,\n  Int64 = -5,\n  Uint8 = -6,\n  Uint16 = -7,\n  Uint32 = -8,\n  Uint64 = -9,\n  Float16 = -10,\n  Float32 = -11,\n  Float64 = -12,\n  DateDay = -13,\n  DateMillisecond = -14,\n  TimestampSecond = -15,\n  TimestampMillisecond = -16,\n  TimestampMicrosecond = -17,\n  TimestampNanosecond = -18,\n  TimeSecond = -19,\n  TimeMillisecond = -20,\n  TimeMicrosecond = -21,\n  TimeNanosecond = -22,\n  DenseUnion = -23,\n  SparseUnion = -24,\n  IntervalDayTime = -25,\n  IntervalYearMonth = -26\n}\n","import {DataType} from './type';\n\n/**\n * ArrowJS `Field` API-compatible class for row-based tables\n * https://loaders.gl/arrowjs/docs/api-reference/field\n * A field holds name, nullable, and metadata information about a table \"column\"\n * A Schema is essentially a list of fields\n */\nexport default class Field {\n  name: string;\n  type: DataType;\n  nullable: boolean;\n  metadata: Map<string, string>;\n\n  constructor(\n    name: string,\n    type: DataType,\n    nullable = false,\n    metadata: Map<string, string> = new Map()\n  ) {\n    this.name = name;\n    this.type = type;\n    this.nullable = nullable;\n    this.metadata = metadata;\n  }\n\n  get typeId(): number {\n    return this.type && this.type.typeId;\n  }\n\n  clone(): Field {\n    return new Field(this.name, this.type, this.nullable, this.metadata);\n  }\n\n  compareTo(other: this): boolean {\n    return (\n      this.name === other.name &&\n      this.type === other.type &&\n      this.nullable === other.nullable &&\n      this.metadata === other.metadata\n    );\n  }\n\n  toString(): string {\n    return `${this.type}${this.nullable ? ', nullable' : ''}${\n      this.metadata ? `, metadata: ${this.metadata}` : ''\n    }`;\n  }\n}\n","// This code is adapted from ArrowJS https://github.com/apache/arrow\n// under Apache license http://www.apache.org/licenses/LICENSE-2.0\n\nimport {Type} from './enum';\n\nimport Field from './field';\n\nexport {Type} from './enum';\n\nexport type TypedIntArray =\n  | Int8Array\n  | Uint8Array\n  | Int16Array\n  | Uint16Array\n  | Int32Array\n  | Uint32Array\n  | Int32Array\n  | Uint32Array\n  | Uint8ClampedArray;\n\nexport type TypedFloatArray = Float32Array | Float64Array;\n\nexport type TypedArray = TypedIntArray | TypedFloatArray;\n\nexport type AnyArrayType = Array<any> | TypedIntArray | TypedFloatArray;\n\nexport class DataType {\n  static isNull(x: any): boolean {\n    return x && x.typeId === Type.Null;\n  }\n  static isInt(x: any): boolean {\n    return x && x.typeId === Type.Int;\n  }\n  static isFloat(x: any): boolean {\n    return x && x.typeId === Type.Float;\n  }\n  static isBinary(x: any): boolean {\n    return x && x.typeId === Type.Binary;\n  }\n  static isUtf8(x: any): boolean {\n    return x && x.typeId === Type.Utf8;\n  }\n  static isBool(x: any): boolean {\n    return x && x.typeId === Type.Bool;\n  }\n  static isDecimal(x: any): boolean {\n    return x && x.typeId === Type.Decimal;\n  }\n  static isDate(x: any): boolean {\n    return x && x.typeId === Type.Date;\n  }\n  static isTime(x: any): boolean {\n    return x && x.typeId === Type.Time;\n  }\n  static isTimestamp(x: any): boolean {\n    return x && x.typeId === Type.Timestamp;\n  }\n  static isInterval(x: any): boolean {\n    return x && x.typeId === Type.Interval;\n  }\n  static isList(x: any): boolean {\n    return x && x.typeId === Type.List;\n  }\n  static isStruct(x: any): boolean {\n    return x && x.typeId === Type.Struct;\n  }\n  static isUnion(x: any): boolean {\n    return x && x.typeId === Type.Union;\n  }\n  static isFixedSizeBinary(x: any): boolean {\n    return x && x.typeId === Type.FixedSizeBinary;\n  }\n  static isFixedSizeList(x: any): boolean {\n    return x && x.typeId === Type.FixedSizeList;\n  }\n  static isMap(x: any): boolean {\n    return x && x.typeId === Type.Map;\n  }\n  static isDictionary(x: any): boolean {\n    return x && x.typeId === Type.Dictionary;\n  }\n\n  get typeId(): Type {\n    return Type.NONE;\n  }\n\n  // get ArrayType(): AnyArrayType {\n  //   return Int8Array;\n  // }\n\n  // get ArrayType() { return Array; }\n  compareTo(other: DataType): boolean {\n    // TODO\n    return this === other; // comparer.visit(this, other);\n  }\n}\n\n// NULL\n\nexport class Null extends DataType {\n  get typeId(): Type {\n    return Type.Null;\n  }\n  get [Symbol.toStringTag](): string {\n    return 'Null';\n  }\n  toString(): string {\n    return 'Null';\n  }\n}\n\n// BOOLEANS\n\nexport class Bool extends DataType {\n  get typeId(): Type {\n    return Type.Bool;\n  }\n  // get ArrayType() {\n  //   return Uint8Array;\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Bool';\n  }\n  toString(): string {\n    return 'Bool';\n  }\n}\n\n// INTS\n\nexport class Int extends DataType {\n  readonly isSigned: boolean;\n  readonly bitWidth: number;\n  constructor(isSigned, bitWidth) {\n    super();\n    this.isSigned = isSigned;\n    this.bitWidth = bitWidth;\n  }\n  get typeId(): Type {\n    return Type.Int;\n  }\n  // get ArrayType() {\n  //   switch (this.bitWidth) {\n  //     case 8:\n  //       return this.isSigned ? Int8Array : Uint8Array;\n  //     case 16:\n  //       return this.isSigned ? Int16Array : Uint16Array;\n  //     case 32:\n  //       return this.isSigned ? Int32Array : Uint32Array;\n  //     case 64:\n  //       return this.isSigned ? Int32Array : Uint32Array;\n  //     default:\n  //       throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);\n  //   }\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Int';\n  }\n  toString(): string {\n    return `${this.isSigned ? 'I' : 'Ui'}nt${this.bitWidth}`;\n  }\n}\n\nexport class Int8 extends Int {\n  constructor() {\n    super(true, 8);\n  }\n}\nexport class Int16 extends Int {\n  constructor() {\n    super(true, 16);\n  }\n}\nexport class Int32 extends Int {\n  constructor() {\n    super(true, 32);\n  }\n}\nexport class Int64 extends Int {\n  constructor() {\n    super(true, 64);\n  }\n}\nexport class Uint8 extends Int {\n  constructor() {\n    super(false, 8);\n  }\n}\nexport class Uint16 extends Int {\n  constructor() {\n    super(false, 16);\n  }\n}\nexport class Uint32 extends Int {\n  constructor() {\n    super(false, 32);\n  }\n}\nexport class Uint64 extends Int {\n  constructor() {\n    super(false, 64);\n  }\n}\n\n// FLOATS\n\nconst Precision = {\n  HALF: 16,\n  SINGLE: 32,\n  DOUBLE: 64\n};\n\nexport class Float extends DataType {\n  readonly precision: number;\n  constructor(precision) {\n    super();\n    this.precision = precision;\n  }\n  get typeId(): Type {\n    return Type.Float;\n  }\n  // get ArrayType() {\n  //   switch (this.precision) {\n  //     case Precision.HALF:\n  //       return Uint16Array;\n  //     case Precision.SINGLE:\n  //       return Float32Array;\n  //     case Precision.DOUBLE:\n  //       return Float64Array;\n  //     default:\n  //       throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);\n  //   }\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Float';\n  }\n  toString(): string {\n    return `Float${this.precision}`;\n  }\n}\n\nexport class Float16 extends Float {\n  constructor() {\n    super(Precision.HALF);\n  }\n}\nexport class Float32 extends Float {\n  constructor() {\n    super(Precision.SINGLE);\n  }\n}\nexport class Float64 extends Float {\n  constructor() {\n    super(Precision.DOUBLE);\n  }\n}\n\nexport class Binary extends DataType {\n  constructor() {\n    super();\n  }\n  get typeId() {\n    return Type.Binary;\n  }\n  toString() {\n    return 'Binary';\n  }\n  get [Symbol.toStringTag]() {\n    return 'Binary';\n  }\n}\n\n// STRINGS\n\nexport class Utf8 extends DataType {\n  get typeId(): Type {\n    return Type.Utf8;\n  }\n  // get ArrayType() {\n  //   return Uint8Array;\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Utf8';\n  }\n  toString(): string {\n    return 'Utf8';\n  }\n}\n\n// DATES, TIMES AND INTERVALS\n\nconst DateUnit = {\n  DAY: 0,\n  MILLISECOND: 1\n};\n\nexport class Date extends DataType {\n  readonly unit: number;\n  constructor(unit) {\n    super();\n    this.unit = unit;\n  }\n  get typeId(): Type {\n    return Type.Date;\n  }\n  // get ArrayType() {\n  //   return Int32Array;\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Date';\n  }\n  toString(): string {\n    return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`;\n  }\n}\n\nexport class DateDay extends Date {\n  constructor() {\n    super(DateUnit.DAY);\n  }\n}\nexport class DateMillisecond extends Date {\n  constructor() {\n    super(DateUnit.MILLISECOND);\n  }\n}\n\nconst TimeUnit = {\n  SECOND: 1,\n  MILLISECOND: 1e3,\n  MICROSECOND: 1e6,\n  NANOSECOND: 1e9\n};\n\nexport class Time extends DataType {\n  readonly unit: number;\n  readonly bitWidth: number;\n\n  constructor(unit, bitWidth) {\n    super();\n    this.unit = unit;\n    this.bitWidth = bitWidth;\n  }\n  get typeId(): Type {\n    return Type.Time;\n  }\n  toString(): string {\n    return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`;\n  }\n  get [Symbol.toStringTag](): string {\n    return 'Time';\n  }\n  // get ArrayType() {\n  //   return Int32Array;\n  // }\n}\n\nexport class TimeSecond extends Time {\n  constructor() {\n    super(TimeUnit.SECOND, 32);\n  }\n}\nexport class TimeMillisecond extends Time {\n  constructor() {\n    super(TimeUnit.MILLISECOND, 32);\n  }\n}\n// export class TimeMicrosecond extends Time { constructor() { super(TimeUnit.MICROSECOND, 64); } }\n// export class TimeNanosecond extends Time { constructor() { super(TimeUnit.NANOSECOND, 64); } }\n\nexport class Timestamp extends DataType {\n  readonly unit: any;\n  readonly timezone: any;\n\n  constructor(unit: any, timezone = null) {\n    super();\n    this.unit = unit;\n    this.timezone = timezone;\n  }\n  get typeId(): Type {\n    return Type.Timestamp;\n  }\n  // get ArrayType() {\n  //   return Int32Array;\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Timestamp';\n  }\n  toString(): string {\n    return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ''}>`;\n  }\n}\n\nexport class TimestampSecond extends Timestamp {\n  constructor(timezone = null) {\n    super(TimeUnit.SECOND, timezone);\n  }\n}\nexport class TimestampMillisecond extends Timestamp {\n  constructor(timezone = null) {\n    super(TimeUnit.MILLISECOND, timezone);\n  }\n}\nexport class TimestampMicrosecond extends Timestamp {\n  constructor(timezone = null) {\n    super(TimeUnit.MICROSECOND, timezone);\n  }\n}\nexport class TimestampNanosecond extends Timestamp {\n  constructor(timezone = null) {\n    super(TimeUnit.NANOSECOND, timezone);\n  }\n}\n\nconst IntervalUnit = {\n  DAY_TIME: 0,\n  YEAR_MONTH: 1\n};\n\nexport class Interval extends DataType {\n  readonly unit: number;\n  constructor(unit: number) {\n    super();\n    this.unit = unit;\n  }\n  get typeId(): Type {\n    return Type.Interval;\n  }\n  // get ArrayType() {\n  //   return Int32Array;\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'Interval';\n  }\n  toString(): string {\n    return `Interval<${IntervalUnit[this.unit]}>`;\n  }\n}\n\nexport class IntervalDayTime extends Interval {\n  constructor() {\n    super(IntervalUnit.DAY_TIME);\n  }\n}\nexport class IntervalYearMonth extends Interval {\n  constructor() {\n    super(IntervalUnit.YEAR_MONTH);\n  }\n}\n\nexport class FixedSizeList extends DataType {\n  readonly listSize: number;\n  readonly children: Field[];\n\n  constructor(listSize: number, child: Field) {\n    super();\n    this.listSize = listSize;\n    this.children = [child];\n  }\n  get typeId(): Type {\n    return Type.FixedSizeList;\n  }\n  get valueType() {\n    return this.children[0].type;\n  }\n  get valueField() {\n    return this.children[0];\n  }\n  // get ArrayType() {\n  //   return this.valueType.ArrayType;\n  // }\n  get [Symbol.toStringTag](): string {\n    return 'FixedSizeList';\n  }\n  toString(): string {\n    return `FixedSizeList[${this.listSize}]<${this.valueType}>`;\n  }\n}\n\nexport class Struct extends DataType {\n  public readonly children: Field[];\n\n  constructor(children: Field[]) {\n    super();\n    this.children = children;\n  }\n\n  public get typeId() {\n    return Type.Struct;\n  }\n  public toString() {\n    return `Struct<{${this.children.map((f) => `${f.name}:${f.type}`).join(', ')}}>`;\n  }\n  get [Symbol.toStringTag](): string {\n    return 'Struct';\n  }\n}\n","import {MeshAttribute, MeshAttributes} from './mesh-types';\nimport {Schema, Field, FixedSizeList} from '../../lib/schema';\nimport {getArrowTypeFromTypedArray} from '../../lib/arrow/arrow-like-type-utils';\n\n/**\n * Create a schema for mesh attributes data\n * @param attributes\n * @param metadata\n * @returns\n */\nexport function deduceMeshSchema(\n  attributes: MeshAttributes,\n  metadata?: Map<string, string>\n): Schema {\n  const fields = deduceMeshFields(attributes);\n  return new Schema(fields, metadata);\n}\n\n/**\n * Create arrow-like schema field for mesh attribute\n * @param attributeName\n * @param attribute\n * @param optionalMetadata\n * @returns\n */\nexport function deduceMeshField(\n  attributeName: string,\n  attribute: MeshAttribute,\n  optionalMetadata?: Map<string, string>\n): Field {\n  const type = getArrowTypeFromTypedArray(attribute.value);\n  const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);\n  const field = new Field(\n    attributeName,\n    new FixedSizeList(attribute.size, new Field('value', type)),\n    false,\n    metadata\n  );\n  return field;\n}\n\n/**\n * Create fields array for mesh attributes\n * @param attributes\n * @returns\n */\nfunction deduceMeshFields(attributes: MeshAttributes): Field[] {\n  const fields: Field[] = [];\n  for (const attributeName in attributes) {\n    const attribute: MeshAttribute = attributes[attributeName];\n    fields.push(deduceMeshField(attributeName, attribute));\n  }\n  return fields;\n}\n\n/**\n * Make metadata by mesh attribute properties\n * @param attribute\n * @returns\n */\nexport function makeMeshAttributeMetadata(attribute: MeshAttribute): Map<string, string> {\n  const result = new Map();\n  if ('byteOffset' in attribute) {\n    result.set('byteOffset', attribute.byteOffset!.toString(10));\n  }\n  if ('byteStride' in attribute) {\n    result.set('byteStride', attribute.byteStride!.toString(10));\n  }\n  if ('normalized' in attribute) {\n    result.set('normalized', attribute.normalized!.toString());\n  }\n  return result;\n}\n","import type {TypedArray} from '../../types';\nimport {DataType, Float32, Float64, Int16, Int32, Int8, Uint16, Uint32, Uint8} from '../schema';\n\nexport function getArrowTypeFromTypedArray(array: TypedArray): DataType {\n  switch (array.constructor) {\n    case Int8Array:\n      return new Int8();\n    case Uint8Array:\n      return new Uint8();\n    case Int16Array:\n      return new Int16();\n    case Uint16Array:\n      return new Uint16();\n    case Int32Array:\n      return new Int32();\n    case Uint32Array:\n      return new Uint32();\n    case Float32Array:\n      return new Float32();\n    case Float64Array:\n      return new Float64();\n    default:\n      throw new Error('array type not supported');\n  }\n}\n","import {deduceMeshField, MeshAttribute} from '@loaders.gl/schema';\nimport {Schema, Field} from '@loaders.gl/schema';\nimport type {DracoAttribute, DracoLoaderData, DracoMetadataEntry} from '../draco-types';\n\n/** Extract an arrow-like schema from a Draco mesh */\nexport function getDracoSchema(\n  attributes: {[attributeName: string]: MeshAttribute},\n  loaderData: DracoLoaderData,\n  indices?: MeshAttribute\n): Schema {\n  const metadataMap = makeMetadata(loaderData.metadata);\n  const fields: Field[] = [];\n  const namedLoaderDataAttributes = transformAttributesLoaderData(loaderData.attributes);\n  for (const attributeName in attributes) {\n    const attribute = attributes[attributeName];\n    const field = getArrowFieldFromAttribute(\n      attributeName,\n      attribute,\n      namedLoaderDataAttributes[attributeName]\n    );\n    fields.push(field);\n  }\n  if (indices) {\n    const indicesField = getArrowFieldFromAttribute('indices', indices);\n    fields.push(indicesField);\n  }\n  return new Schema(fields, metadataMap);\n}\n\nfunction transformAttributesLoaderData(loaderData: {[key: number]: DracoAttribute}): {\n  [attributeName: string]: DracoAttribute;\n} {\n  const result: {[attributeName: string]: DracoAttribute} = {};\n  for (const key in loaderData) {\n    const dracoAttribute = loaderData[key];\n    result[dracoAttribute.name || 'undefined'] = dracoAttribute;\n  }\n  return result;\n}\n\nfunction getArrowFieldFromAttribute(\n  attributeName: string,\n  attribute: MeshAttribute,\n  loaderData?: DracoAttribute\n): Field {\n  const metadataMap = loaderData ? makeMetadata(loaderData.metadata) : undefined;\n  const field = deduceMeshField(attributeName, attribute, metadataMap);\n  return field;\n}\n\nfunction makeMetadata(metadata: {[key: string]: DracoMetadataEntry}): Map<string, string> {\n  const metadataMap = new Map();\n  for (const key in metadata) {\n    metadataMap.set(`${key}.string`, JSON.stringify(metadata[key]));\n  }\n  return metadataMap;\n}\n","/* eslint-disable camelcase */\n\nimport type {TypedArray, MeshAttribute, MeshGeometry} from '@loaders.gl/schema';\n\n// Draco types (input)\nimport type {\n  Draco3D,\n  Decoder,\n  Mesh,\n  PointCloud,\n  PointAttribute,\n  Metadata,\n  MetadataQuerier,\n  DracoInt32Array,\n  draco_DataType\n} from '../draco3d/draco3d-types';\n\n// Parsed data types (output)\nimport type {\n  DracoMesh,\n  DracoLoaderData,\n  DracoAttribute,\n  DracoMetadataEntry,\n  DracoQuantizationTransform,\n  DracoOctahedronTransform\n} from './draco-types';\n\nimport {getMeshBoundingBox} from '@loaders.gl/schema';\nimport {getDracoSchema} from './utils/get-draco-schema';\n\n/**\n * @param topology - How triangle indices should be generated (mesh only)\n * @param attributeNameEntry\n * @param extraAttributes\n * @param quantizedAttributes\n * @param octahedronAttributes\n */\nexport type DracoParseOptions = {\n  topology?: 'triangle-list' | 'triangle-strip';\n  attributeNameEntry?: string;\n  extraAttributes?: {[uniqueId: string]: number};\n  quantizedAttributes?: ('POSITION' | 'NORMAL' | 'COLOR' | 'TEX_COORD' | 'GENERIC')[];\n  octahedronAttributes?: ('POSITION' | 'NORMAL' | 'COLOR' | 'TEX_COORD' | 'GENERIC')[];\n};\n\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst GEOMETRY_TYPE = {\n  TRIANGULAR_MESH: 0,\n  POINT_CLOUD: 1\n};\n\n// Native Draco attribute names to GLTF attribute names.\nconst DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP = {\n  POSITION: 'POSITION',\n  NORMAL: 'NORMAL',\n  COLOR: 'COLOR_0',\n  TEX_COORD: 'TEXCOORD_0'\n};\n\nconst DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP = {\n  1: Int8Array,\n  2: Uint8Array,\n  3: Int16Array,\n  4: Uint16Array,\n  5: Int32Array,\n  6: Uint32Array,\n  9: Float32Array\n};\n\nconst INDEX_ITEM_SIZE = 4;\n\nexport default class DracoParser {\n  draco: Draco3D;\n  decoder: Decoder;\n  metadataQuerier: MetadataQuerier;\n\n  // draco - the draco decoder, either import `draco3d` or load dynamically\n  constructor(draco: Draco3D) {\n    this.draco = draco;\n    this.decoder = new this.draco.Decoder();\n    this.metadataQuerier = new this.draco.MetadataQuerier();\n  }\n\n  /**\n   * Destroy draco resources\n   */\n  destroy(): void {\n    this.draco.destroy(this.decoder);\n    this.draco.destroy(this.metadataQuerier);\n  }\n\n  /**\n   * NOTE: caller must call `destroyGeometry` on the return value after using it\n   * @param arrayBuffer\n   * @param options\n   */\n  parseSync(arrayBuffer: ArrayBuffer, options: DracoParseOptions = {}): DracoMesh {\n    const buffer = new this.draco.DecoderBuffer();\n    buffer.Init(new Int8Array(arrayBuffer), arrayBuffer.byteLength);\n\n    this._disableAttributeTransforms(options);\n\n    const geometry_type = this.decoder.GetEncodedGeometryType(buffer);\n    const dracoGeometry =\n      geometry_type === this.draco.TRIANGULAR_MESH\n        ? new this.draco.Mesh()\n        : new this.draco.PointCloud();\n\n    try {\n      let dracoStatus;\n      switch (geometry_type) {\n        case this.draco.TRIANGULAR_MESH:\n          dracoStatus = this.decoder.DecodeBufferToMesh(buffer, dracoGeometry as Mesh);\n          break;\n\n        case this.draco.POINT_CLOUD:\n          dracoStatus = this.decoder.DecodeBufferToPointCloud(buffer, dracoGeometry);\n          break;\n\n        default:\n          throw new Error('DRACO: Unknown geometry type.');\n      }\n\n      if (!dracoStatus.ok() || !dracoGeometry.ptr) {\n        const message = `DRACO decompression failed: ${dracoStatus.error_msg()}`;\n        // console.error(message);\n        throw new Error(message);\n      }\n\n      const loaderData = this._getDracoLoaderData(dracoGeometry, geometry_type, options);\n\n      const geometry = this._getMeshData(dracoGeometry, loaderData, options);\n\n      const boundingBox = getMeshBoundingBox(geometry.attributes);\n\n      const schema = getDracoSchema(geometry.attributes, loaderData, geometry.indices);\n\n      const data: DracoMesh = {\n        loader: 'draco',\n        loaderData,\n        header: {\n          vertexCount: dracoGeometry.num_points(),\n          boundingBox\n        },\n        ...geometry,\n        schema\n      };\n      return data;\n    } finally {\n      this.draco.destroy(buffer);\n      if (dracoGeometry) {\n        this.draco.destroy(dracoGeometry);\n      }\n    }\n  }\n\n  // Draco specific \"loader data\"\n\n  /**\n   * Extract\n   * @param dracoGeometry\n   * @param geometry_type\n   * @param options\n   * @returns\n   */\n  _getDracoLoaderData(\n    dracoGeometry: Mesh | PointCloud,\n    geometry_type,\n    options: DracoParseOptions\n  ): DracoLoaderData {\n    const metadata = this._getTopLevelMetadata(dracoGeometry);\n    const attributes = this._getDracoAttributes(dracoGeometry, options);\n\n    return {\n      geometry_type,\n      num_attributes: dracoGeometry.num_attributes(),\n      num_points: dracoGeometry.num_points(),\n      num_faces: dracoGeometry instanceof this.draco.Mesh ? dracoGeometry.num_faces() : 0,\n      metadata,\n      attributes\n    };\n  }\n\n  /**\n   * Extract all draco provided information and metadata for each attribute\n   * @param dracoGeometry\n   * @param options\n   * @returns\n   */\n  _getDracoAttributes(\n    dracoGeometry: Mesh | PointCloud,\n    options: DracoParseOptions\n  ): {[unique_id: number]: DracoAttribute} {\n    const dracoAttributes: {[unique_id: number]: DracoAttribute} = {};\n\n    for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {\n      // Note: Draco docs do not seem clear on `GetAttribute` ids just being a zero-based index,\n      // but it does seems to work this way\n      const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);\n\n      const metadata = this._getAttributeMetadata(dracoGeometry, attributeId);\n\n      dracoAttributes[dracoAttribute.unique_id()] = {\n        unique_id: dracoAttribute.unique_id(),\n        attribute_type: dracoAttribute.attribute_type(),\n        data_type: dracoAttribute.data_type(),\n        num_components: dracoAttribute.num_components(),\n\n        byte_offset: dracoAttribute.byte_offset(),\n        byte_stride: dracoAttribute.byte_stride(),\n        normalized: dracoAttribute.normalized(),\n        attribute_index: attributeId,\n\n        metadata\n      };\n\n      // Add transformation parameters for any attributes app wants untransformed\n      const quantization = this._getQuantizationTransform(dracoAttribute, options);\n      if (quantization) {\n        dracoAttributes[dracoAttribute.unique_id()].quantization_transform = quantization;\n      }\n\n      const octahedron = this._getOctahedronTransform(dracoAttribute, options);\n      if (octahedron) {\n        dracoAttributes[dracoAttribute.unique_id()].octahedron_transform = octahedron;\n      }\n    }\n\n    return dracoAttributes;\n  }\n\n  /**\n   * Get standard loaders.gl mesh category data\n   * Extracts the geometry from draco\n   * @param dracoGeometry\n   * @param options\n   */\n  _getMeshData(\n    dracoGeometry: Mesh | PointCloud,\n    loaderData: DracoLoaderData,\n    options: DracoParseOptions\n  ): MeshGeometry {\n    const attributes = this._getMeshAttributes(loaderData, dracoGeometry, options);\n\n    const positionAttribute = attributes.POSITION;\n    if (!positionAttribute) {\n      throw new Error('DRACO: No position attribute found.');\n    }\n\n    // For meshes, we need indices to define the faces.\n    if (dracoGeometry instanceof this.draco.Mesh) {\n      switch (options.topology) {\n        case 'triangle-strip':\n          return {\n            topology: 'triangle-strip',\n            mode: 4, // GL.TRIANGLES\n            attributes,\n            indices: {\n              value: this._getTriangleStripIndices(dracoGeometry),\n              size: 1\n            }\n          };\n        case 'triangle-list':\n        default:\n          return {\n            topology: 'triangle-list',\n            mode: 5, // GL.TRIANGLE_STRIP\n            attributes,\n            indices: {\n              value: this._getTriangleListIndices(dracoGeometry),\n              size: 1\n            }\n          };\n      }\n    }\n\n    // PointCloud - must come last as Mesh inherits from PointCloud\n    return {\n      topology: 'point-list',\n      mode: 0, // GL.POINTS\n      attributes\n    };\n  }\n\n  _getMeshAttributes(\n    loaderData: DracoLoaderData,\n    dracoGeometry: Mesh | PointCloud,\n    options: DracoParseOptions\n  ): {[attributeName: string]: MeshAttribute} {\n    const attributes: {[key: string]: MeshAttribute} = {};\n\n    for (const loaderAttribute of Object.values(loaderData.attributes)) {\n      const attributeName = this._deduceAttributeName(loaderAttribute, options);\n      loaderAttribute.name = attributeName;\n      const {value, size} = this._getAttributeValues(dracoGeometry, loaderAttribute);\n      attributes[attributeName] = {\n        value,\n        size,\n        byteOffset: loaderAttribute.byte_offset,\n        byteStride: loaderAttribute.byte_stride,\n        normalized: loaderAttribute.normalized\n      };\n    }\n\n    return attributes;\n  }\n\n  // MESH INDICES EXTRACTION\n\n  /**\n   * For meshes, we need indices to define the faces.\n   * @param dracoGeometry\n   */\n  _getTriangleListIndices(dracoGeometry: Mesh) {\n    // Example on how to retrieve mesh and attributes.\n    const numFaces = dracoGeometry.num_faces();\n    const numIndices = numFaces * 3;\n    const byteLength = numIndices * INDEX_ITEM_SIZE;\n\n    const ptr = this.draco._malloc(byteLength);\n    try {\n      this.decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);\n      return new Uint32Array(this.draco.HEAPF32.buffer, ptr, numIndices).slice();\n    } finally {\n      this.draco._free(ptr);\n    }\n  }\n\n  /**\n   * For meshes, we need indices to define the faces.\n   * @param dracoGeometry\n   */\n  _getTriangleStripIndices(dracoGeometry: Mesh) {\n    const dracoArray = new this.draco.DracoInt32Array();\n    try {\n      /* const numStrips = */ this.decoder.GetTriangleStripsFromMesh(dracoGeometry, dracoArray);\n      return getUint32Array(dracoArray);\n    } finally {\n      this.draco.destroy(dracoArray);\n    }\n  }\n\n  /**\n   *\n   * @param dracoGeometry\n   * @param dracoAttribute\n   * @param attributeName\n   */\n  _getAttributeValues(\n    dracoGeometry: Mesh | PointCloud,\n    attribute: DracoAttribute\n  ): {value: TypedArray; size: number} {\n    const TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];\n    const numComponents = attribute.num_components;\n    const numPoints = dracoGeometry.num_points();\n    const numValues = numPoints * numComponents;\n\n    const byteLength = numValues * TypedArrayCtor.BYTES_PER_ELEMENT;\n    const dataType = getDracoDataType(this.draco, TypedArrayCtor);\n\n    let value: TypedArray;\n\n    const ptr = this.draco._malloc(byteLength);\n    try {\n      const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attribute.attribute_index);\n      this.decoder.GetAttributeDataArrayForAllPoints(\n        dracoGeometry,\n        dracoAttribute,\n        dataType,\n        byteLength,\n        ptr\n      );\n      value = new TypedArrayCtor(this.draco.HEAPF32.buffer, ptr, numValues).slice();\n    } finally {\n      this.draco._free(ptr);\n    }\n\n    return {value, size: numComponents};\n  }\n\n  // Attribute names\n\n  /** \n   * DRACO does not store attribute names - We need to deduce an attribute name\n   * for each attribute\n  _getAttributeNames(\n    dracoGeometry: Mesh | PointCloud,\n    options: DracoParseOptions\n  ): {[unique_id: number]: string} {\n    const attributeNames: {[unique_id: number]: string} = {};\n    for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {\n      const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);\n      const attributeName = this._deduceAttributeName(dracoAttribute, options);\n      attributeNames[attributeName] = attributeName;\n    }\n    return attributeNames;\n  }\n   */\n\n  /**\n   * Deduce an attribute name.\n   * @note DRACO does not save attribute names, just general type (POSITION, COLOR)\n   * to help optimize compression. We generate GLTF compatible names for the Draco-recognized\n   * types\n   * @param attributeData\n   */\n  _deduceAttributeName(attribute: DracoAttribute, options: DracoParseOptions): string {\n    // Deduce name based on application provided map\n    const uniqueId = attribute.unique_id;\n    for (const [attributeName, attributeUniqueId] of Object.entries(\n      options.extraAttributes || {}\n    )) {\n      if (attributeUniqueId === uniqueId) {\n        return attributeName;\n      }\n    }\n\n    // Deduce name based on attribute type\n    const thisAttributeType = attribute.attribute_type;\n    for (const dracoAttributeConstant in DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP) {\n      const attributeType = this.draco[dracoAttributeConstant];\n      if (attributeType === thisAttributeType) {\n        // TODO - Return unique names if there multiple attributes per type\n        // (e.g. multiple TEX_COORDS or COLORS)\n        return DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP[dracoAttributeConstant];\n      }\n    }\n\n    // Look up in metadata\n    // TODO - shouldn't this have priority?\n    const entryName = options.attributeNameEntry || 'name';\n    if (attribute.metadata[entryName]) {\n      return attribute.metadata[entryName].string;\n    }\n\n    // Attribute of \"GENERIC\" type, we need to assign some name\n    return `CUSTOM_ATTRIBUTE_${uniqueId}`;\n  }\n\n  // METADATA EXTRACTION\n\n  /** Get top level metadata */\n  _getTopLevelMetadata(dracoGeometry: Mesh | PointCloud) {\n    const dracoMetadata = this.decoder.GetMetadata(dracoGeometry);\n    return this._getDracoMetadata(dracoMetadata);\n  }\n\n  /** Get per attribute metadata */\n  _getAttributeMetadata(dracoGeometry: Mesh | PointCloud, attributeId: number) {\n    const dracoMetadata = this.decoder.GetAttributeMetadata(dracoGeometry, attributeId);\n    return this._getDracoMetadata(dracoMetadata);\n  }\n\n  /**\n   * Extract metadata field values\n   * @param dracoMetadata\n   * @returns\n   */\n  _getDracoMetadata(dracoMetadata: Metadata): {[entry: string]: DracoMetadataEntry} {\n    // The not so wonderful world of undocumented Draco APIs :(\n    if (!dracoMetadata || !dracoMetadata.ptr) {\n      return {};\n    }\n    const result = {};\n    const numEntries = this.metadataQuerier.NumEntries(dracoMetadata);\n    for (let entryIndex = 0; entryIndex < numEntries; entryIndex++) {\n      const entryName = this.metadataQuerier.GetEntryName(dracoMetadata, entryIndex);\n      result[entryName] = this._getDracoMetadataField(dracoMetadata, entryName);\n    }\n    return result;\n  }\n\n  /**\n   * Extracts possible values for one metadata entry by name\n   * @param dracoMetadata\n   * @param entryName\n   */\n  _getDracoMetadataField(dracoMetadata: Metadata, entryName: string): DracoMetadataEntry {\n    const dracoArray = new this.draco.DracoInt32Array();\n    try {\n      // Draco metadata fields can hold int32 arrays\n      this.metadataQuerier.GetIntEntryArray(dracoMetadata, entryName, dracoArray);\n      const intArray = getInt32Array(dracoArray);\n      return {\n        int: this.metadataQuerier.GetIntEntry(dracoMetadata, entryName),\n        string: this.metadataQuerier.GetStringEntry(dracoMetadata, entryName),\n        double: this.metadataQuerier.GetDoubleEntry(dracoMetadata, entryName),\n        intArray\n      };\n    } finally {\n      this.draco.destroy(dracoArray);\n    }\n  }\n\n  // QUANTIZED ATTRIBUTE SUPPORT (NO DECOMPRESSION)\n\n  /** Skip transforms for specific attribute types */\n  _disableAttributeTransforms(options: DracoParseOptions) {\n    const {quantizedAttributes = [], octahedronAttributes = []} = options;\n    const skipAttributes = [...quantizedAttributes, ...octahedronAttributes];\n    for (const dracoAttributeName of skipAttributes) {\n      this.decoder.SkipAttributeTransform(this.draco[dracoAttributeName]);\n    }\n  }\n\n  /**\n   * Extract (and apply?) Position Transform\n   * @todo not used\n   */\n  _getQuantizationTransform(\n    dracoAttribute: PointAttribute,\n    options: DracoParseOptions\n  ): DracoQuantizationTransform | null {\n    const {quantizedAttributes = []} = options;\n    const attribute_type = dracoAttribute.attribute_type();\n    const skip = quantizedAttributes.map((type) => this.decoder[type]).includes(attribute_type);\n    if (skip) {\n      const transform = new this.draco.AttributeQuantizationTransform();\n      try {\n        if (transform.InitFromAttribute(dracoAttribute)) {\n          return {\n            quantization_bits: transform.quantization_bits(),\n            range: transform.range(),\n            min_values: new Float32Array([1, 2, 3]).map((i) => transform.min_value(i))\n          };\n        }\n      } finally {\n        this.draco.destroy(transform);\n      }\n    }\n    return null;\n  }\n\n  _getOctahedronTransform(\n    dracoAttribute: PointAttribute,\n    options: DracoParseOptions\n  ): DracoOctahedronTransform | null {\n    const {octahedronAttributes = []} = options;\n    const attribute_type = dracoAttribute.attribute_type();\n    const octahedron = octahedronAttributes\n      .map((type) => this.decoder[type])\n      .includes(attribute_type);\n    if (octahedron) {\n      const transform = new this.draco.AttributeQuantizationTransform();\n      try {\n        if (transform.InitFromAttribute(dracoAttribute)) {\n          return {\n            quantization_bits: transform.quantization_bits()\n          };\n        }\n      } finally {\n        this.draco.destroy(transform);\n      }\n    }\n    return null;\n  }\n\n  // HELPERS\n}\n\n/**\n * Get draco specific data type by TypedArray constructor type\n * @param attributeType\n * @returns draco specific data type\n */\nfunction getDracoDataType(draco: Draco3D, attributeType: any): draco_DataType {\n  switch (attributeType) {\n    case Float32Array:\n      return draco.DT_FLOAT32;\n    case Int8Array:\n      return draco.DT_INT8;\n    case Int16Array:\n      return draco.DT_INT16;\n    case Int32Array:\n      return draco.DT_INT32;\n    case Uint8Array:\n      return draco.DT_UINT8;\n    case Uint16Array:\n      return draco.DT_UINT16;\n    case Uint32Array:\n      return draco.DT_UINT32;\n    default:\n      return draco.DT_INVALID;\n  }\n}\n\n/**\n * Copy a Draco int32 array into a JS typed array\n */\nfunction getInt32Array(dracoArray: DracoInt32Array): Int32Array {\n  const numValues = dracoArray.size();\n  const intArray = new Int32Array(numValues);\n  for (let i = 0; i < numValues; i++) {\n    intArray[i] = dracoArray.GetValue(i);\n  }\n  return intArray;\n}\n\n/**\n * Copy a Draco int32 array into a JS typed array\n */\nfunction getUint32Array(dracoArray: DracoInt32Array): Int32Array {\n  const numValues = dracoArray.size();\n  const intArray = new Int32Array(numValues);\n  for (let i = 0; i < numValues; i++) {\n    intArray[i] = dracoArray.GetValue(i);\n  }\n  return intArray;\n}\n","/* global importScripts */\nimport {global, isBrowser, isWorker} from '../env-utils/globals';\nimport * as node from '../node/require-utils.node';\nimport {assert} from '../env-utils/assert';\nimport {VERSION as __VERSION__} from '../env-utils/version';\n\n// TODO - unpkg.com doesn't seem to have a `latest` specifier for alpha releases...\nconst LATEST = 'beta';\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : LATEST;\n\nconst loadLibraryPromises = {}; // promises\n\n/**\n * Dynamically loads a library (\"module\")\n *\n * - wasm library: Array buffer is returned\n * - js library: Parse JS is returned\n *\n * Method depends on environment\n * - browser - script element is created and installed on document\n * - worker - eval is called on global context\n * - node - file is required\n *\n * @param libraryUrl\n * @param moduleName\n * @param options\n */\nexport async function loadLibrary(\n  libraryUrl: string,\n  moduleName: string | null = null,\n  options: object = {}\n): Promise<any> {\n  if (moduleName) {\n    libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);\n  }\n\n  // Ensure libraries are only loaded once\n  loadLibraryPromises[libraryUrl] =\n    loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);\n  return await loadLibraryPromises[libraryUrl];\n}\n\n// TODO - sort out how to resolve paths for main/worker and dev/prod\nexport function getLibraryUrl(library, moduleName?: string, options?): string {\n  // Check if already a URL\n  if (library.startsWith('http')) {\n    return library;\n  }\n\n  // Allow application to import and supply libraries through `options.modules`\n  const modules = options.modules || {};\n  if (modules[library]) {\n    return modules[library];\n  }\n\n  // Load from local files, not from CDN scripts in Node.js\n  // TODO - needs to locate the modules directory when installed!\n  if (!isBrowser) {\n    return `modules/${moduleName}/dist/libs/${library}`;\n  }\n\n  // In browser, load from external scripts\n  if (options.CDN) {\n    assert(options.CDN.startsWith('http'));\n    return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${library}`;\n  }\n\n  // TODO - loading inside workers requires paths relative to worker script location...\n  if (isWorker) {\n    return `../src/libs/${library}`;\n  }\n\n  return `modules/${moduleName}/src/libs/${library}`;\n}\n\nasync function loadLibraryFromFile(libraryUrl) {\n  if (libraryUrl.endsWith('wasm')) {\n    const response = await fetch(libraryUrl);\n    return await response.arrayBuffer();\n  }\n\n  if (!isBrowser) {\n    return node.requireFromFile && (await node.requireFromFile(libraryUrl));\n  }\n  if (isWorker) {\n    return importScripts(libraryUrl);\n  }\n  // TODO - fix - should be more secure than string parsing since observes CORS\n  // if (isBrowser) {\n  //   return await loadScriptFromFile(libraryUrl);\n  // }\n\n  const response = await fetch(libraryUrl);\n  const scriptSource = await response.text();\n  return loadLibraryFromString(scriptSource, libraryUrl);\n}\n\n/*\nasync function loadScriptFromFile(libraryUrl) {\n  const script = document.createElement('script');\n  script.src = libraryUrl;\n  return await new Promise((resolve, reject) => {\n    script.onload = data => {\n      resolve(data);\n    };\n    script.onerror = reject;\n  });\n}\n*/\n\n// TODO - Needs security audit...\n//  - Raw eval call\n//  - Potentially bypasses CORS\n// Upside is that this separates fetching and parsing\n// we could create a`LibraryLoader` or`ModuleLoader`\nfunction loadLibraryFromString(scriptSource, id) {\n  if (!isBrowser) {\n    return node.requireFromString && node.requireFromString(scriptSource, id);\n  }\n\n  if (isWorker) {\n    // Use lvalue trick to make eval run in global scope\n    eval.call(global, scriptSource); // eslint-disable-line no-eval\n    // https://stackoverflow.com/questions/9107240/1-evalthis-vs-evalthis-in-javascript\n    // http://perfectionkills.com/global-eval-what-are-the-options/\n    return null;\n  }\n\n  const script = document.createElement('script');\n  script.id = id;\n  // most browsers like a separate text node but some throw an error. The second method covers those.\n  try {\n    script.appendChild(document.createTextNode(scriptSource));\n  } catch (e) {\n    script.text = scriptSource;\n  }\n  document.body.appendChild(script);\n  return null;\n}\n\n// TODO - technique for module injection into worker, from THREE.DracoLoader...\n/*\nfunction combineWorkerWithLibrary(worker, jsContent) {\n  var fn = wWorker.toString();\n  var body = [\n    '// injected',\n    jsContent,\n    '',\n    '// worker',\n    fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}'))\n  ].join('\\n');\n  this.workerSourceURL = URL.createObjectURL(new Blob([body]));\n}\n*/\n","// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\n\n/** Throws an `Error` with the optional `message` if `condition` is falsy */\nexport function assert(condition: any, message?: string): void {\n  if (!condition) {\n    throw new Error(message || 'loaders.gl assertion failed.');\n  }\n}\n","// Dynamic DRACO module loading inspired by THREE.DRACOLoader\n// https://github.com/mrdoob/three.js/blob/398c4f39ebdb8b23eefd4a7a5ec49ec0c96c7462/examples/jsm/loaders/DRACOLoader.js\n// by Don McCurdy / https://www.donmccurdy.com / MIT license\n\nimport {loadLibrary} from '@loaders.gl/worker-utils';\n\nconst DRACO_VERSION = '1.4.1';\nconst DRACO_JS_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_decoder.js`;\nconst DRACO_WASM_WRAPPER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_wasm_wrapper.js`;\nconst DRACO_WASM_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_decoder.wasm`;\n\nconst DRACO_ENCODER_URL = `https://raw.githubusercontent.com/google/draco/${DRACO_VERSION}/javascript/draco_encoder.js`;\n\nlet loadDecoderPromise;\nlet loadEncoderPromise;\n\nexport async function loadDracoDecoderModule(options) {\n  const modules = options.modules || {};\n\n  // Check if a bundled draco3d library has been supplied by application\n  if (modules.draco3d) {\n    loadDecoderPromise =\n      loadDecoderPromise ||\n      modules.draco3d.createDecoderModule({}).then((draco) => {\n        return {draco};\n      });\n  } else {\n    // If not, dynamically load the WASM script from our CDN\n    loadDecoderPromise = loadDecoderPromise || loadDracoDecoder(options);\n  }\n  return await loadDecoderPromise;\n}\n\nexport async function loadDracoEncoderModule(options) {\n  const modules = options.modules || {};\n\n  // Check if a bundled draco3d library has been supplied by application\n  if (modules.draco3d) {\n    loadEncoderPromise =\n      loadEncoderPromise ||\n      modules.draco3d.createEncoderModule({}).then((draco) => {\n        return {draco};\n      });\n  } else {\n    // If not, dynamically load the WASM script from our CDN\n    loadEncoderPromise = loadEncoderPromise || loadDracoEncoder(options);\n  }\n  return await loadEncoderPromise;\n}\n\n// DRACO DECODER LOADING\n\nasync function loadDracoDecoder(options) {\n  let DracoDecoderModule;\n  let wasmBinary;\n  switch (options.draco && options.draco.decoderType) {\n    case 'js':\n      DracoDecoderModule = await loadLibrary(DRACO_JS_DECODER_URL, 'draco', options);\n      break;\n\n    case 'wasm':\n    default:\n      [DracoDecoderModule, wasmBinary] = await Promise.all([\n        await loadLibrary(DRACO_WASM_WRAPPER_URL, 'draco', options),\n        await loadLibrary(DRACO_WASM_DECODER_URL, 'draco', options)\n      ]);\n  }\n  // Depends on how import happened...\n  // @ts-ignore\n  DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;\n  return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);\n}\n\nfunction initializeDracoDecoder(DracoDecoderModule, wasmBinary) {\n  const options: {wasmBinary?: any} = {};\n  if (wasmBinary) {\n    options.wasmBinary = wasmBinary;\n  }\n\n  return new Promise((resolve) => {\n    DracoDecoderModule({\n      ...options,\n      onModuleLoaded: (draco) => resolve({draco}) // Module is Promise-like. Wrap in object to avoid loop.\n    });\n  });\n}\n\n// ENCODER\n\nasync function loadDracoEncoder(options) {\n  let DracoEncoderModule = await loadLibrary(DRACO_ENCODER_URL, 'draco', options);\n  // @ts-ignore\n  DracoEncoderModule = DracoEncoderModule || globalThis.DracoEncoderModule;\n\n  return new Promise((resolve) => {\n    DracoEncoderModule({\n      onModuleLoaded: (draco) => resolve({draco}) // Module is Promise-like. Wrap in object to avoid loop.\n    });\n  });\n}\n","import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {DracoMesh, DracoLoaderData} from './lib/draco-types';\nimport type {DracoLoaderOptions} from './draco-loader';\nimport {DracoLoader as DracoWorkerLoader} from './draco-loader';\nimport DracoParser from './lib/draco-parser';\nimport {loadDracoDecoderModule} from './lib/draco-module-loader';\n\n// Draco data types\n\nexport type {DracoMesh, DracoLoaderData};\n\n// Draco Writer\n\nexport type {DracoWriterOptions} from './draco-writer';\nexport {DracoWriter} from './draco-writer';\n\n// Draco Loader\n\nexport type {DracoLoaderOptions};\nexport {DracoWorkerLoader};\n\n/**\n * Loader for Draco3D compressed geometries\n */\nexport const DracoLoader = {\n  ...DracoWorkerLoader,\n  parse\n};\n\nasync function parse(arrayBuffer: ArrayBuffer, options?: DracoLoaderOptions): Promise<DracoMesh> {\n  const {draco} = await loadDracoDecoderModule(options);\n  const dracoParser = new DracoParser(draco);\n  try {\n    return dracoParser.parseSync(arrayBuffer, options?.draco);\n  } finally {\n    dracoParser.destroy();\n  }\n}\n\n// TYPE TESTS - TODO find a better way than exporting junk\nexport const _TypecheckDracoLoader: LoaderWithParser = DracoLoader;\n","import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {DracoLoader} from '../index';\n\ncreateLoaderWorker(DracoLoader);\n"],"sourceRoot":""}