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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (15) hide show
  1. package/dist/bundle.js +2 -4
  2. package/dist/bundle.js.map +1 -1
  3. package/dist/tileset/helpers/transform-utils.js +4 -1
  4. package/dist/tileset/helpers/transform-utils.js.map +1 -1
  5. package/dist/tileset/tile-3d.js +1 -1
  6. package/dist/tileset/tile-3d.js.map +1 -1
  7. package/dist/tileset/tileset-3d.js +5 -5
  8. package/dist/tileset/tileset-3d.js.map +1 -1
  9. package/dist/tileset/traversers/i3s-tileset-traverser.js +2 -2
  10. package/dist/tileset/traversers/i3s-tileset-traverser.js.map +1 -1
  11. package/package.json +8 -6
  12. package/src/bundle.ts +2 -3
  13. package/src/tileset/helpers/transform-utils.ts +3 -1
  14. package/dist/dist.min.js +0 -2
  15. package/dist/dist.min.js.map +0 -1
package/dist/dist.min.js.map DELETED
@@ -1 +0,0 @@
1
- {"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap","webpack:///../loader-utils/src/lib/env-utils/globals.ts","webpack:////home/user/apps/loaders.gl/node_modules/probe.gl/dist/esm/env/globals.js","webpack:////home/user/apps/loaders.gl/node_modules/process/browser.js","webpack:////home/user/apps/loaders.gl/node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js","webpack:///(webpack)/buildin/global.js","webpack:////home/user/apps/loaders.gl/node_modules/probe.gl/dist/esm/env/is-browser.js","webpack:////home/user/apps/loaders.gl/node_modules/probe.gl/dist/esm/env/is-electron.js","webpack:///../worker-utils/src/lib/env-utils/globals.ts","webpack:///./src/bundle.ts","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/lib/assert.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/lib/common.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/lib/validators.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/base/math-array.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/base/matrix.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/lib/gl-matrix-extras.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/common.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/mat4.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/vec2.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/vec3.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/vec4.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/matrix4.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/base/vector.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/vector3.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/lib/math-utils.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/geospatial/dist/esm/constants.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/geospatial/dist/esm/type-utils.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/geospatial/dist/esm/ellipsoid/helpers/scale-to-geodetic-surface.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/geospatial/dist/esm/ellipsoid/helpers/ellipsoid-transform.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/geospatial/dist/esm/ellipsoid/ellipsoid.js","webpack:////home/user/apps/loaders.gl/node_modules/@probe.gl/stats/dist/esm/lib/stat.js","webpack:////home/user/apps/loaders.gl/node_modules/@probe.gl/stats/dist/esm/lib/stats.js","webpack:///../loader-utils/src/lib/env-utils/assert.ts","webpack:///../loader-utils/src/lib/path-utils/path.ts","webpack:///../loader-utils/src/lib/request-utils/request-scheduler.ts","webpack:///./src/utils/doubly-linked-list-node.js","webpack:///./src/utils/doubly-linked-list.js","webpack:///./src/tileset/tileset-cache.ts","webpack:///./src/tileset/helpers/transform-utils.ts","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/culling/dist/esm/constants.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/axis-aligned-bounding-box.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/bounding-sphere.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/mat3.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/matrix3.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/quat.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/quaternion.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/oriented-bounding-box.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/culling/dist/esm/lib/plane.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/culling/dist/esm/lib/culling-volume.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/culling/dist/esm/lib/perspective-off-center-frustum.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/culling/dist/esm/lib/algorithms/bounding-sphere-from-points.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/culling/dist/esm/lib/algorithms/compute-eigen-decomposition.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/culling/dist/esm/lib/algorithms/bounding-box-from-points.js","webpack:///./src/tileset/helpers/frame-state.ts","webpack:///./src/tileset/helpers/zoom.ts","webpack:///../core/src/javascript-utils/is-type.ts","webpack:///../core/src/lib/loader-utils/normalize-loader.ts","webpack:///../loader-utils/src/lib/path-utils/file-aliases.ts","webpack:///../core/src/lib/utils/mime-type-utils.ts","webpack:///../core/src/lib/utils/resource-utils.ts","webpack:///../core/src/lib/utils/response-utils.ts","webpack:///../core/src/lib/fetch/fetch-file.ts","webpack:////home/user/apps/loaders.gl/node_modules/probe.gl/dist/esm/utils/globals.js","webpack:////home/user/apps/loaders.gl/node_modules/probe.gl/dist/esm/utils/local-storage.js","webpack:////home/user/apps/loaders.gl/node_modules/probe.gl/dist/esm/utils/formatters.js","webpack:////home/user/apps/loaders.gl/node_modules/probe.gl/dist/esm/utils/color.js","webpack:////home/user/apps/loaders.gl/node_modules/probe.gl/dist/esm/utils/assert.js","webpack:////home/user/apps/loaders.gl/node_modules/probe.gl/dist/esm/utils/hi-res-timestamp.js","webpack:////home/user/apps/loaders.gl/node_modules/probe.gl/dist/esm/lib/log.js","webpack:////home/user/apps/loaders.gl/node_modules/probe.gl/dist/esm/utils/autobind.js","webpack:///../core/src/lib/loader-utils/loggers.ts","webpack:///../core/src/lib/loader-utils/option-defaults.ts","webpack:///../core/src/lib/loader-utils/option-utils.ts","webpack:///../worker-utils/src/lib/env-utils/assert.ts","webpack:///../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts","webpack:///../worker-utils/src/lib/worker-utils/get-transfer-list.ts","webpack:///../worker-utils/src/lib/worker-farm/worker-thread.ts","webpack:///../worker-utils/src/lib/worker-farm/worker-job.ts","webpack:///../worker-utils/src/lib/worker-farm/worker-pool.ts","webpack:///../worker-utils/src/lib/worker-farm/worker-farm.ts","webpack:///../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts","webpack:///../worker-utils/src/lib/worker-api/get-worker-url.ts","webpack:///../loader-utils/src/lib/binary-utils/buffer-utils.ts","webpack:///../loader-utils/src/lib/binary-utils/array-buffer-utils.ts","webpack:///../loader-utils/src/lib/iterators/async-iteration.ts","webpack:///../core/src/iterators/make-iterator/make-array-buffer-iterator.ts","webpack:///../core/src/iterators/make-iterator/make-stream-iterator.ts","webpack:///../core/src/iterators/make-iterator/make-iterator.ts","webpack:///../core/src/iterators/make-iterator/make-string-iterator.ts","webpack:///../core/src/iterators/make-iterator/make-blob-iterator.ts","webpack:///../core/src/lib/loader-utils/get-data.ts","webpack:///../core/src/lib/api/register-loaders.ts","webpack:///../core/src/lib/api/select-loader.ts","webpack:///../core/src/lib/api/parse.ts","webpack:///../core/src/lib/loader-utils/loader-context.ts","webpack:///../worker-utils/src/lib/worker-api/validate-worker-version.ts","webpack:///../worker-utils/src/lib/env-utils/version.ts","webpack:///../core/src/lib/api/load.ts","webpack:///./src/constants.ts","webpack:///./src/tileset/helpers/bounding-volume.ts","webpack:///./src/tileset/helpers/tiles-3d-lod.ts","webpack:///./src/tileset/helpers/i3s-lod.ts","webpack:///./src/utils/managed-array.js","webpack:///./src/tileset/traversers/tileset-traverser.ts","webpack:///./src/tileset/tile-3d.ts","webpack:///./src/tileset/helpers/3d-tiles-options.ts","webpack:///./src/tileset/traversers/tileset-3d-traverser.ts","webpack:///./src/tileset/traversers/i3s-tile-manager.ts","webpack:///./src/tileset/traversers/i3s-tileset-traverser.ts","webpack:///./src/tileset/tileset-3d.ts"],"names":["root","factory","exports","module","define","amd","a","i","window","installedModules","__webpack_require__","moduleId","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","globals","self","global","document","global_","isBrowser","process","String","browser","matches","version","exec","parseFloat","window_","process_","console","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","Error","defaultClearTimeout","runTimeout","fun","setTimeout","e","this","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","length","concat","drainQueue","timeout","len","run","marker","runClearTimeout","Item","array","noop","nextTick","args","Array","arguments","push","apply","title","env","argv","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","getHiResTimestamp","timestamp","performance","now","hrtime","timeParts","Date","g","Function","isElectron","mockUserAgent","type","Boolean","electron","realUserAgent","navigator","userAgent","indexOf","isMobile","orientation","moduleExports","require","_global","loaders","assign","assert","condition","message","RADIANS_TO_DEGREES","Math","PI","DEGREES_TO_RADIANS","config","formatValue","precision","round","EPSILON","toPrecision","isArray","ArrayBuffer","isView","DataView","func","result","clone","toRadians","degrees","toDegrees","radians","equals","b","epsilon","oldEpsilon","Number","isFinite","abs","max","checkNumber","checkVector","v","callerName","debug","validateVector","printTypes","printDegrees","printRowMajor","deprecated","method","warn","cls","ExtendableBuiltin","instance","Reflect","construct","from","setPrototypeOf","getPrototypeOf","constructor","writable","configurable","__proto__","_extendableBuiltin","copy","arrayOrObject","fromObject","offset","ELEMENTS","check","toArray","toObject","target","to","Float32Array","formatString","opts","string","undefined","ai","vector","min","minVector","maxVector","vectors","scale","multiply","subtract","addScalar","scalar","validate","valid","row","RANK","col","columnIndex","fill","firstIndex","columnVector","vec3_transformMat4AsVector","out","x","y","z","w","ARRAY_TYPE","random","a00","a01","a02","a03","a10","a11","a12","a13","a20","a21","a22","a23","a30","a31","a32","a33","b0","b1","b2","b3","getScaling","mat","m11","m12","m13","m21","m22","m23","m31","m32","m33","hypot","sqrt","vec","ax","ay","az","bx","by","bz","IDENTITY","freeze","ZERO","INDICES","COL0ROW0","COL0ROW1","COL0ROW2","COL0ROW3","COL1ROW0","COL1ROW1","COL1ROW2","COL1ROW3","COL2ROW0","COL2ROW1","COL2ROW2","COL2ROW3","COL3ROW0","COL3ROW1","COL3ROW2","COL3ROW3","constants","super","identity","m00","m10","m20","m30","m01","m02","m03","q","x2","y2","z2","xx","yx","yy","zx","zy","zz","wx","wy","wz","left","right","bottom","top","near","far","Infinity","_computeInfinitePerspectiveOffCenter","rl","tb","nf","column0Row0","column1Row1","column2Row0","column2Row1","column3Row2","eye","center","up","x0","x1","y0","y1","z0","z1","eyex","eyey","eyez","upx","upy","upz","centerx","centery","centerz","lr","bt","fovy","aspect","focalDistance","halfY","tan","ortho","fov","f","scaleResult","getScale","inverseScale0","inverseScale1","inverseScale2","b00","b01","b02","b03","b04","b05","b06","b07","b08","b09","b10","b11","det","rad","sin","cos","rx","ry","rz","rotateX","rotateY","rotateZ","axis","b12","b20","b21","b22","factor","transformAsPoint","vec2_transformMat4AsVector","translate","transformAsVector","lengthSquared","mathArray","distanceSquared","dist","product","magnitude","distance","add","multiplyScalar","ORIGIN","mag","cosine","acos","origin","matrix4","matrix3","matrix2","vec3_transformMat2","quaternion","qx","qy","qz","qw","uvx","uvy","uvz","uuvx","uuvy","uuvz","w2","scratchVector","fromCartographic","cartographic","map","longitude","latitude","height","toCartographic","scaleToGeodeticSurfaceIntersection","scaleToGeodeticSurfaceGradient","scratchOrigin","VECTOR_PRODUCT_LOCAL_FRAME","south","north","west","east","down","degeneratePositionLocalFrame","scratchAxisVectors","scratchVector1","scratchVector2","scratchVector3","localFrameToFixedFrame","ellipsoid","firstAxis","secondAxis","thirdAxis","cartesianOrigin","thirdAxisInferred","firstAxisVector","secondAxisVector","thirdAxisVector","sign","fromArray","set","normalize","geodeticSurfaceNormal","cross","scratchNormal","scratchK","scratchPosition","scratchHeight","scratchCartesian","wgs84","radii","radiiSquared","radiiToTheFourth","oneOverRadii","oneOverRadiiSquared","minimumRadius","maximumRadius","centerToleranceSquared","squaredXOverSquaredZ","toString","normal","k","geodeticSurfaceNormalCartographic","gamma","dot","cartesian","point","scaleToGeodeticSurface","h","atan2","asin","_cartographicRadians","cartographicVectorRadians","fromCartographicToRadians","cosLatitude","positionX","positionY","positionZ","oneOverRadiiX","oneOverRadiiY","oneOverRadiiZ","squaredNorm","ratio","intersection","oneOverRadiiSquaredX","oneOverRadiiSquaredY","oneOverRadiiSquaredZ","gradient","xMultiplier","yMultiplier","zMultiplier","lambda","correction","xMultiplier2","yMultiplier2","zMultiplier2","beta","position","buffer","sampleSize","reset","samples","addCount","subtractCount","_count","_samples","_checkSampling","time","_time","lastTiming","_startTime","_timerPending","addTime","lastSampleCount","lastSampleTime","count","id","stats","_initializeStats","seal","_getOrCreate","keys","fn","table","forEach","stat","average","getAverageTime","hz","getHz","dirname","url","slashIndex","lastIndexOf","substr","join","parts","part","index","replace","RegExp","DEFAULT_PROPS","throttleRequests","maxRequests","RequestScheduler","props","Map","Stats","scheduleRequest","handle","getPriority","Promise","resolve","done","requestMap","has","request","priority","promise","requestQueue","_issueNewRequests","_issueRequest","isDone","delete","activeRequestCount","deferredUpdate","_issueNewRequestsAsync","freeSlots","_updateAllRequests","shift","_updateRequest","splice","sort","DoublyLinkedListNode","item","previous","next","DoublyLinkedList","head","tail","_length","node","remove","nextNode","_insert","oldNodeNext","defined","TilesetCache","_list","_sentinel","_trimTiles","touch","tile","_cacheNode","tileset","addCallback","unloadTile","unloadCallback","unloadTiles","trimTiles","list","maximumMemoryUsageInBytes","maximumMemoryUsage","sentinel","gpuMemoryUsageInBytes","trim","calculateTransformProps","tileHeader","rtcCenter","gltfUpAxis","computedTransform","boundingVolume","modelMatrix","Matrix4","rotationY","multiplyRight","rotationX","isQuantized","quantizedVolumeOffset","quantizedVolumeScale","Vector3","cartesianModelMatrix","cartographicOrigin","Ellipsoid","WGS84","cartesianToCartographic","toFixedFrameMatrix","eastNorthUpToFixedFrame","invert","cartographicModelMatrix","INTERSECTION","OUTSIDE","INTERSECTING","INSIDE","radius","fromCenterRadius","corner","oppositeCorner","boundingSphere","leftCenter","leftRadius","rightCenter","rightRadius","toRightCenter","centerSeparation","halfDistanceBetweenTangentPoints","transform","distanceSquaredTo","plane","distanceToPlane","vec4_transformMat3","setAxisAngle","aw","bw","slerp","omega","cosom","sinom","scale0","scale1","fromMat3","fRoot","fTrace","j","tmpvec3","xUnitVec3","yUnitVec3","temp1","temp2","matr","rotationTo","IDENTITY_QUATERNION","fromAxisRotation","vectorA","vectorB","a0","a1","a2","a3","invDot","start","ix","iy","iz","iw","multiplyLeft","scratchOffset","scratchVectorU","scratchVectorV","scratchVectorW","scratchCorner","scratchToCenter","MATRIX3","halfAxes","xAxis","getColumn","yAxis","zAxis","normXAxis","normYAxis","normZAxis","fromMatrix3","halfSize","quaternionObject","directionsMatrix","fromQuaternion","u","cornerVector","normalX","normalY","normalZ","radEffective","uHalf","vHalf","wHalf","direction","minDist","POSITIVE_INFINITY","maxDist","NEGATIVE_INFINITY","toCenter","transformation","fromNormalDistance","fromPointNormal","pointDistance","getPointDistance","scaledNormal","faces","scratchPlaneCenter","scratchPlaneNormal","planes","every","planeIndex","faceNormal","plane0","plane1","plane0Center","plane1Center","negatedFaceNormal","negate","intersect","intersectPlane","parentPlaneMask","MASK_OUTSIDE","MASK_INSIDE","mask","flag","cullingVolume","CullingVolume","Plane","getFrameState","viewport","frameNumber","cameraDirection","cameraUp","metersPerUnit","distanceScales","viewportCenterCartographic","viewportCenterCartesian","cartographicToCartesian","enuToFixedTransform","cameraPositionCartographic","unprojectPosition","cameraPosition","cameraPositionCartesian","cameraDirectionCartesian","cameraUpCartesian","frustumPlanes","getFrustumPlanes","distanceToCenter","cartographicPos","cartesianPos","commonSpacePlanesToWGS84","camera","sseDenominator","getZoomFromBoundingVolume","width","obbSize","axeY","axeZ","farthestVertex","getObbSize","log2","isBoolean","isFunction","isObject","isPureObject","isIterable","iterator","isAsyncIterable","asyncIterator","isResponse","Response","arrayBuffer","text","json","isBlob","Blob","isReadableStream","ReadableStream","tee","cancel","getReader","isReadableDOMStream","read","pipe","readable","isReadableNodeStream","isLoaderObject","loader","extensions","normalizeLoader","options","parseTextSync","parseText","binary","pathPrefix","fileAliases","DATA_URL_PATTERN","MIME_TYPE_PATTERN","parseMIMEType","mimeString","parseMIMETypeFromURL","QUERY_STRING_PATTERN","getResourceUrlAndType","resource","stripQueryString","headers","async","makeResponse","contentLength","size","byteLength","getResourceContentLength","initialDataUrl","slice","blobSlice","reader","FileReader","onload","event","readAsDataURL","bytes","Uint8Array","fromCharCode","btoa","arrayBufferToBase64","getInitialDataUrl","TextEncoder","encode","response","checkResponse","ok","status","contentType","statusText","includes","error","getResponseError","fetchFile","filename","alias","startsWith","replacement","resolvePath","fetchOptions","fetch","LocalStorage","defaultSettings","storage","setItem","removeItem","getStorage","_loadConfiguration","configuration","updateConfiguration","serialized","JSON","stringify","serializedConfiguration","getItem","parse","formatImage","image","maxWidth","imageUrl","src","style","floor","COLOR","BLACK","RED","GREEN","YELLOW","BLUE","MAGENTA","CYAN","WHITE","BRIGHT_BLACK","BRIGHT_RED","BRIGHT_GREEN","BRIGHT_YELLOW","BRIGHT_BLUE","BRIGHT_MAGENTA","BRIGHT_CYAN","BRIGHT_WHITE","getColor","color","toUpperCase","originalConsole","log","info","DEFAULT_SETTINGS","enabled","level","cache","ONCE","getTableHeader","VERSION","_startTs","_deltaTs","LOG_THROTTLE_TIMEOUT","_storage","userData","timeStamp","obj","predefined","proto","propNames","getOwnPropertyNames","find","autobind","newLevel","setLevel","getLevel","newPriority","_getLogFunction","oldUsage","newUsage","logLevel","columns","tag","_shouldLog","img","Image","element","nodeName","toLowerCase","toDataURL","logImageInBrowser","asciify","fit","then","data","logImageInNode","setting","timeEnd","collapsed","normalizeArguments","groupCollapsed","group","groupEnd","trace","isEnabled","normalizeLogLevel","total","getTotal","delta","getDelta","padLength","repeat","leftPad","ms","formatted","toFixed","formatTime","background","decorateMessage","resolvedLevel","unshift","messageType","probeLog","Log","NullLog","DEFAULT_LOADER_OPTIONS","mimeType","nothrow","CDN","worker","maxConcurrency","maxMobileConcurrency","reuseWorkers","_workerType","limit","_limitMB","batchSize","batchDebounceMs","metadata","transforms","REMOVED_LOADER_OPTIONS","throws","dataType","uri","body","credentials","redirect","referrer","referrerPolicy","integrity","keepalive","signal","getGlobalLoaderState","_state","getGlobalLoaderOptions","state","globalOptions","normalizeOptions","validateOptionsObject","idOptions","loaderOptions","deprecatedOptions","validateOptions","normalizeOptionsInternal","getFetchFunction","context","defaultOptions","loaderName","prefix","isSubOptions","isBaseUriOption","isWorkerUrlOption","suggestion","findSimilarOption","optionKey","lowerCaseOptionKey","bestSuggestion","lowerCaseKey","mergedOptions","baseUri","addUrlOptions","mergeNestedFields","workerURLCache","getLoadableWorkerURL","source","workerURL","getLoadableWorkerURLFromSource","workerUrl","getLoadableWorkerURLFromURL","workerSource","blob","URL","createObjectURL","isTransferable","MessagePort","ImageBitmap","OffscreenCanvas","NOOP","WorkerThread","Worker","onMessage","onError","_createBrowserWorker","destroy","terminate","terminated","postMessage","transferList","getTransferList","recursive","transfers","transfersSet","Set","_getErrorFromErrorEvent","lineno","colno","_loadableURL","onmessage","onerror","onmessageerror","WorkerJob","jobName","workerThread","isRunning","_resolve","_reject","reject","payload","WorkerPool","setProps","idleQueue","isDestroyed","onDebug","job","startPromise","onStart","jobQueue","_startQueuedJob","_getAvailableWorker","queuedJob","backlog","returnWorkerToQueue","_getMaxConcurrency","WorkerFarm","isSupported","_workerFarm","workerPools","workerPool","values","_getWorkerPoolProps","getWorkerPool","parseWithWorker","parseOnMainThread","workerOptions","workerFile","versionTag","getWorkerURL","getWorkerFarm","startJob","input","isBuffer","toArrayBuffer","byteOffset","bufferToArrayBuffer","_toArrayBuffer","concatenateArrayBuffersAsync","arrayBuffers","chunk","sources","sourceArrays","source2","reduce","typedArray","sourceArray","concatenateArrayBuffers","DEFAULT_CHUNK_SIZE","makeStreamIterator","stream","nextBatchPromise","currentBatchPromise","_streamReadAhead","releaseLock","makeBrowserStreamIterator","makeNodeStreamIterator","makeIterator","chunkSize","textEncoder","chunkLength","makeStringIterator","chunkByteLength","makeArrayBufferIterator","end","makeBlobIterator","ERR_DATA","getArrayBufferOrStringFromData","isArrayBuffer","TextDecoder","decode","getArrayBufferOrStringFromDataSync","getGlobalLoaderRegistry","loaderRegistry","EXT_PATTERN","selectLoaderSync","validHTTPResponse","candidateLoaders","ignoreRegisteredLoaders","normalizeLoaders","testUrl","findLoaderByMIMEType","match","extension","loaderExtension","findLoaderByExtension","findLoaderByUrl","testDataAgainstText","testDataAgainstBinary","findLoaderByInitialBytes","fallbackMimeType","selectLoaderInternal","getNoValidLoaderMessage","getMagicString","getFirstCharacters","mimeTypes","testText","tests","some","test","arrayBuffer1","arrayBuffer2","array1","array2","compareArrayBuffers","magic","testBinary","dataView","getUint8","contextLoaders","getLoadersFromContext","selectLoader","previousContext","resolvedContext","getLoaderContext","coreVersion","workerVersion","validateWorkerVersion","canParseWithWorker","parseSync","parseWithLoader","load","TILE_CONTENT_STATE","UNLOADED","LOADING","PROCESSING","READY","EXPIRED","FAILED","TILE_REFINEMENT","ADD","REPLACE","TILE_TYPE","EMPTY","SCENEGRAPH","POINTCLOUD","MESH","TILESET_TYPE","I3S","TILES3D","LOD_METRIC_TYPE","GEOMETRIC_ERROR","MAX_SCREEN_THRESHOLD","TILE3D_OPTIMIZATION_HINT","scratchScale","scratchNorthWest","scratchSouthEast","createBoundingVolume","boundingVolumeHeader","box","Quaternion","transformByQuaternion","Matrix3","OrientedBoundingBox","createBox","region","minHeight","maxHeight","northWest","southEast","centerInCartesian","addVectors","subVectors","createSphere","sphere","uniformScale","BoundingSphere","getDynamicScreenSpaceError","distanceToCamera","dynamicScreenSpaceError","dynamicScreenSpaceErrorComputedDensity","density","dynamicScreenSpaceErrorFactor","exp","fog","qualityFactor","projectVertexToSphere","azim","incl","radCosInc","getDistanceFromLatLon","observer","observerLon","observerLat","observerZ","centerLon","centerLat","centerZ","projectedCenter","projectedObserver","dx","dy","dz","getI3ScreenSize","frameState","mbsLat","header","mbs","mbsCenter","mbsRNormalized","projectionMatrix","getTanOfHalfVFAngle","ManagedArray","_array","_map","peek","pop","reserve","resize","loadSiblings","skipLevelOfDetail","maximumScreenSpaceError","updateTransforms","onTraversalEnd","viewportTraversersMap","basePath","TilesetTraverser","_traversalStack","_emptyTraversalStack","_frameNumber","selectedTiles","requestedTiles","emptyTiles","traverse","updateTile","executeTraversal","stack","_selectionDepth","shouldRefine","canTraverse","updateChildTiles","updateAndPushChildren","hasRenderContent","parent","parentRefines","_shouldRefine","stoppedRefining","refine","loadTile","selectTile","touchTile","children","child","depth","compareDistanceToCamera","checkRefines","hasVisibleChild","refines","isVisibleAndInRequestVolume","childRefines","_inRequestVolume","contentAvailable","executeEmptyTraversal","updateTileVisibility","shouldSelectTile","_selectedFrame","shouldLoadTile","_requestedFrame","_priority","_getPriority","_cache","_touchedFrame","useParentMetric","ignoreVisibility","hasChildren","hasTilesetContent","contentExpired","hasUnloadedContent","screenSpaceError","_screenSpaceError","getScreenSpaceError","viewportIds","updateVisibility","_distanceToCamera","anyChildrenVisible","anyVisible","allDescendantsLoaded","TileHeader","parentHeader","extendedId","_getRefine","contentUrl","lodMetricType","lodMetricValue","content","contentState","hasEmptyContent","_visitedFrame","traverser","_centerZDepth","_visible","_stackLength","_initialTransform","_initializeLodMetric","_initializeTransforms","_initializeBoundingVolumes","_initializeContent","_initializeRenderingState","_lodJudge","_expireDate","_expiredContent","contentReady","contentFailed","contentUnloaded","useParentLodMetric","parentLodMetricValue","viewDistanceScale","getTiles3DScreenSpaceError","_traverser","maySkipTile","isVisible","rootScreenSpaceError","requestToken","_requestScheduler","getTileUrl","loadOptions","isTileset","_getLoaderSpecificOptions","contentLoader","_isTileset","_initializeTileHeaders","_onContentLoaded","unloadContent","parentVisibilityPlaneMask","_visibilityPlaneMask","MASK_INDETERMINATE","parentTransform","_updateTransform","distanceToTile","visibility","insideViewerRequestVolume","computeVisibilityWithPlaneMask","contentVisibility","cameraSpaceZDepth","viewerRequestVolume","_viewerRequestVolume","updateExpiration","lessThan","extras","parentInitialTransform","_contentBoundingVolume","_updateBoundingVolume","_tileset","_tile","disableSkipLevelOfDetail","loaderId","i3s","isTileHeader","assetGltfUpAxis","asset","Tileset3DTraverser","firstChild","meetsScreenSpaceErrorEarly","useOptimization","_optimChildrenWithinParent","STATUS","I3STileManager","_statusMap","callback","catch","update","I3STilesetTraverser","_tileManager","metersPerPixel","mbsLon","mbsZ","mbsR","viewportCenter","mbsLatProjected","mbsLonProjected","diagonalInMeters","visibleHeight","visibleWidth","screenSize","lodJudge","childTiles","childTile","_loadTile","nodePages","nodePagesTile","formTileFromNodePages","_onTileLoad","nodeId","nodeUrl","loadContent","description","onTileLoad","onTileUnload","onTileError","onTraversalComplete","loadTiles","attributions","Tileset3D","path","roots","cartographicCenter","cartesianCenter","zoom","traverseCounter","geometricError","_initializeTraverser","_pendingCount","_tiles","_emptyTiles","_requestedTiles","frameStateData","lastUpdatedVieports","_queryParams","_queryParamsString","_extensionsUsed","credits","_initializeTileSet","_destroy","isLoaded","queryParams","queryParamStrings","getQueryParamString","setOptions","tilePath","hasExtension","extensionName","viewports","viewportsToTraverse","_needTraverse","viewportId","traverserId","_onTraversalEnd","currentFrameStateData","_updateTiles","frameStateKey","frameStateDataValue","_loadTiles","_unloadTiles","_updateStats","_tilesChanged","oldSelectedTiles","set1","set2","changed","filter","_unloadTile","tilesRenderable","pointsRenderable","pointCount","tilesetJson","_initializeCesiumTileset","_initializeI3STileset","_calculateViewProps","parentTileHeader","rootTile","Tile3D","incrementCount","childHeader","TraverserClass","I3SetTraverser","_destroyTileHeaders","parentTile","_destroySubtree","loaded","_onStartTileLoading","_onTileLoadError","_onEndTileLoading","_addTileToCache","decrementCount","_updateCacheStats","_destroyTile","tilesetVersion","properties","extensionsUsed","token"],"mappings":"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","file":"dist.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse {\n\t\tvar a = factory();\n\t\tfor(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n\t}\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 20);\n","// Purpose: include this in your module to avoid\n// dependencies on 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\ntype obj = {[key: string]: any};\nconst self_: obj = globals.self || globals.window || globals.global || {};\nconst window_: obj = globals.window || globals.self || globals.global || {};\nconst global_: obj = globals.global || globals.self || globals.window || {};\nconst document_: obj = globals.document || {};\n\nexport {self_ as self, window_ as window, global_ as global, document_ as document};\n\n/** true if running in a browser */\nexport const isBrowser: boolean =\n // @ts-ignore process does not exist on browser\n typeof process !== 'object' || String(process) !== '[object process]' || process.browser;\n\n/** true if running in a worker thread */\nexport const isWorker: boolean = typeof importScripts === 'function';\n\n// Extract node major version\nconst matches =\n typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);\n/** Major Node version (as a number) */\nexport const nodeVersion: number = (matches && parseFloat(matches[1])) || 0;\n","const 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 process: typeof process === 'object' && process\n};\nconst self_ = globals.self || globals.window || globals.global;\nconst window_ = globals.window || globals.self || globals.global;\nconst global_ = globals.global || globals.self || globals.window;\nconst document_ = globals.document || {};\nconst process_ = globals.process || {};\nconst console_ = console;\nexport { self_ as self, window_ as window, global_ as global, document_ as document, process_ as process, console_ as console };\n//# sourceMappingURL=globals.js.map","// 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","export default function getHiResTimestamp() {\n let timestamp;\n\n if (typeof window !== 'undefined' && window.performance) {\n timestamp = window.performance.now();\n } else if (typeof process !== 'undefined' && process.hrtime) {\n const timeParts = process.hrtime();\n timestamp = timeParts[0] * 1000 + timeParts[1] / 1e6;\n } else {\n timestamp = Date.now();\n }\n\n return timestamp;\n}\n//# sourceMappingURL=hi-res-timestamp.js.map","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","import isElectron from './is-electron';\nexport default function isBrowser() {\n const isNode = typeof process === 'object' && String(process) === '[object process]' && !process.browser;\n return !isNode || isElectron();\n}\nexport function isBrowserMainThread() {\n return isBrowser() && typeof document !== 'undefined';\n}\n//# sourceMappingURL=is-browser.js.map","export default function isElectron(mockUserAgent) {\n if (typeof window !== 'undefined' && typeof window.process === 'object' && window.process.type === 'renderer') {\n return true;\n }\n\n if (typeof process !== 'undefined' && typeof process.versions === 'object' && Boolean(process.versions.electron)) {\n return true;\n }\n\n const realUserAgent = typeof navigator === 'object' && typeof navigator.userAgent === 'string' && navigator.userAgent;\n const userAgent = mockUserAgent || realUserAgent;\n\n if (userAgent && userAgent.indexOf('Electron') >= 0) {\n return true;\n }\n\n return false;\n}\n//# sourceMappingURL=is-electron.js.map","// 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","// @ts-nocheck\nconst moduleExports = require('./index');\nconst _global = typeof window === 'undefined' ? global : window;\n_global.loaders = _global.loaders || {};\nmodule.exports = Object.assign(_global.loaders, moduleExports);\n","export default function assert(condition, message) {\n if (!condition) {\n throw new Error(\"math.gl assertion \".concat(message));\n }\n}\n//# sourceMappingURL=assert.js.map","import assert from './assert';\nconst RADIANS_TO_DEGREES = 1 / Math.PI * 180;\nconst DEGREES_TO_RADIANS = 1 / 180 * Math.PI;\nconst config = {};\nconfig.EPSILON = 1e-12;\nconfig.debug = false;\nconfig.precision = 4;\nconfig.printTypes = false;\nconfig.printDegrees = false;\nconfig.printRowMajor = true;\nexport { config };\nexport function configure(options = {}) {\n for (const key in options) {\n assert(key in config);\n config[key] = options[key];\n }\n\n return config;\n}\n\nfunction round(value) {\n return Math.round(value / config.EPSILON) * config.EPSILON;\n}\n\nexport function formatValue(value, {\n precision = config.precision || 4\n} = {}) {\n value = round(value);\n return \"\".concat(parseFloat(value.toPrecision(precision)));\n}\nexport function isArray(value) {\n return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);\n}\n\nfunction duplicateArray(array) {\n return array.clone ? array.clone() : new Array(array.length);\n}\n\nexport function clone(array) {\n return array.clone ? array.clone() : new Array(...array);\n}\n\nfunction map(value, func, result) {\n if (isArray(value)) {\n result = result || duplicateArray(value);\n\n for (let i = 0; i < result.length && i < value.length; ++i) {\n result[i] = func(value[i], i, result);\n }\n\n return result;\n }\n\n return func(value);\n}\n\nexport function toRadians(degrees) {\n return radians(degrees);\n}\nexport function toDegrees(radians) {\n return degrees(radians);\n}\nexport function radians(degrees, result) {\n return map(degrees, degrees => degrees * DEGREES_TO_RADIANS, result);\n}\nexport function degrees(radians, result) {\n return map(radians, radians => radians * RADIANS_TO_DEGREES, result);\n}\nexport function sin(radians) {\n return map(radians, angle => Math.sin(angle));\n}\nexport function cos(radians) {\n return map(radians, angle => Math.cos(angle));\n}\nexport function tan(radians) {\n return map(radians, angle => Math.tan(angle));\n}\nexport function asin(radians) {\n return map(radians, angle => Math.asin(angle));\n}\nexport function acos(radians) {\n return map(radians, angle => Math.acos(angle));\n}\nexport function atan(radians) {\n return map(radians, angle => Math.atan(angle));\n}\nexport function clamp(value, min, max) {\n return map(value, value => Math.max(min, Math.min(max, value)));\n}\nexport function lerp(a, b, t) {\n if (isArray(a)) {\n return a.map((ai, i) => lerp(ai, b[i], t));\n }\n\n return t * b + (1 - t) * a;\n}\nexport function equals(a, b, epsilon) {\n const oldEpsilon = config.EPSILON;\n\n if (epsilon) {\n config.EPSILON = epsilon;\n }\n\n try {\n if (a === b) {\n return true;\n }\n\n if (isArray(a) && isArray(b)) {\n if (a.length !== b.length) {\n return false;\n }\n\n for (let i = 0; i < a.length; ++i) {\n if (!equals(a[i], b[i])) {\n return false;\n }\n }\n\n return true;\n }\n\n if (a && a.equals) {\n return a.equals(b);\n }\n\n if (b && b.equals) {\n return b.equals(a);\n }\n\n if (Number.isFinite(a) && Number.isFinite(b)) {\n return Math.abs(a - b) <= config.EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));\n }\n\n return false;\n } finally {\n config.EPSILON = oldEpsilon;\n }\n}\nexport function exactEquals(a, b) {\n if (a === b) {\n return true;\n }\n\n if (a && typeof a === 'object' && b && typeof b === 'object') {\n if (a.constructor !== b.constructor) {\n return false;\n }\n\n if (a.exactEquals) {\n return a.exactEquals(b);\n }\n }\n\n if (isArray(a) && isArray(b)) {\n if (a.length !== b.length) {\n return false;\n }\n\n for (let i = 0; i < a.length; ++i) {\n if (!exactEquals(a[i], b[i])) {\n return false;\n }\n }\n\n return true;\n }\n\n return false;\n}\nexport function withEpsilon(EPSILON, func) {\n const oldPrecision = config.EPSILON;\n config.EPSILON = EPSILON;\n let value;\n\n try {\n value = func();\n } finally {\n config.EPSILON = oldPrecision;\n }\n\n return value;\n}\n//# sourceMappingURL=common.js.map","import { config } from './common';\nexport function validateVector(v, length) {\n if (v.length !== length) {\n return false;\n }\n\n for (let i = 0; i < v.length; ++i) {\n if (!Number.isFinite(v[i])) {\n return false;\n }\n }\n\n return true;\n}\nexport function checkNumber(value) {\n if (!Number.isFinite(value)) {\n throw new Error(\"Invalid number \".concat(value));\n }\n\n return value;\n}\nexport function checkVector(v, length, callerName = '') {\n if (config.debug && !validateVector(v, length)) {\n throw new Error(\"math.gl: \".concat(callerName, \" some fields set to invalid numbers'\"));\n }\n\n return v;\n}\nconst map = {};\nexport function deprecated(method, version) {\n if (!map[method]) {\n map[method] = true;\n console.warn(\"\".concat(method, \" has been removed in version \").concat(version, \", see upgrade guide for more information\"));\n }\n}\n//# sourceMappingURL=validators.js.map","function _extendableBuiltin(cls) {\n function ExtendableBuiltin() {\n var instance = Reflect.construct(cls, Array.from(arguments));\n Object.setPrototypeOf(instance, Object.getPrototypeOf(this));\n return instance;\n }\n\n ExtendableBuiltin.prototype = Object.create(cls.prototype, {\n constructor: {\n value: cls,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(ExtendableBuiltin, cls);\n } else {\n ExtendableBuiltin.__proto__ = cls;\n }\n\n return ExtendableBuiltin;\n}\n\nimport { config, formatValue, equals, isArray } from '../../lib/common';\nimport assert from '../../lib/assert';\nexport default class MathArray extends _extendableBuiltin(Array) {\n get ELEMENTS() {\n assert(false);\n return 0;\n }\n\n clone() {\n return new this.constructor().copy(this);\n }\n\n from(arrayOrObject) {\n return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);\n }\n\n fromArray(array, offset = 0) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = array[i + offset];\n }\n\n return this.check();\n }\n\n to(arrayOrObject) {\n if (arrayOrObject === this) {\n return this;\n }\n\n return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);\n }\n\n toTarget(target) {\n return target ? this.to(target) : this;\n }\n\n toArray(array = [], offset = 0) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n array[offset + i] = this[i];\n }\n\n return array;\n }\n\n toFloat32Array() {\n return new Float32Array(this);\n }\n\n toString() {\n return this.formatString(config);\n }\n\n formatString(opts) {\n let string = '';\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n string += (i > 0 ? ', ' : '') + formatValue(this[i], opts);\n }\n\n return \"\".concat(opts.printTypes ? this.constructor.name : '', \"[\").concat(string, \"]\");\n }\n\n equals(array) {\n if (!array || this.length !== array.length) {\n return false;\n }\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n if (!equals(this[i], array[i])) {\n return false;\n }\n }\n\n return true;\n }\n\n exactEquals(array) {\n if (!array || this.length !== array.length) {\n return false;\n }\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n if (this[i] !== array[i]) {\n return false;\n }\n }\n\n return true;\n }\n\n negate() {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = -this[i];\n }\n\n return this.check();\n }\n\n lerp(a, b, t) {\n if (t === undefined) {\n t = b;\n b = a;\n a = this;\n }\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n const ai = a[i];\n this[i] = ai + t * (b[i] - ai);\n }\n\n return this.check();\n }\n\n min(vector) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = Math.min(vector[i], this[i]);\n }\n\n return this.check();\n }\n\n max(vector) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = Math.max(vector[i], this[i]);\n }\n\n return this.check();\n }\n\n clamp(minVector, maxVector) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);\n }\n\n return this.check();\n }\n\n add(...vectors) {\n for (const vector of vectors) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] += vector[i];\n }\n }\n\n return this.check();\n }\n\n subtract(...vectors) {\n for (const vector of vectors) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] -= vector[i];\n }\n }\n\n return this.check();\n }\n\n scale(scale) {\n if (Array.isArray(scale)) {\n return this.multiply(scale);\n }\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] *= scale;\n }\n\n return this.check();\n }\n\n sub(a) {\n return this.subtract(a);\n }\n\n setScalar(a) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = a;\n }\n\n return this.check();\n }\n\n addScalar(a) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] += a;\n }\n\n return this.check();\n }\n\n subScalar(a) {\n return this.addScalar(-a);\n }\n\n multiplyScalar(scalar) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] *= scalar;\n }\n\n return this.check();\n }\n\n divideScalar(a) {\n return this.scale(1 / a);\n }\n\n clampScalar(min, max) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = Math.min(Math.max(this[i], min), max);\n }\n\n return this.check();\n }\n\n multiplyByScalar(scalar) {\n return this.scale(scalar);\n }\n\n get elements() {\n return this;\n }\n\n check() {\n if (config.debug && !this.validate()) {\n throw new Error(\"math.gl: \".concat(this.constructor.name, \" some fields set to invalid numbers'\"));\n }\n\n return this;\n }\n\n validate() {\n let valid = this.length === this.ELEMENTS;\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n valid = valid && Number.isFinite(this[i]);\n }\n\n return valid;\n }\n\n}\n//# sourceMappingURL=math-array.js.map","import MathArray from './math-array';\nimport { checkNumber } from '../../lib/validators';\nimport { config } from '../../lib/common';\nimport assert from '../../lib/assert';\nexport default class Matrix extends MathArray {\n get ELEMENTS() {\n assert(false);\n return 0;\n }\n\n get RANK() {\n assert(false);\n return 0;\n }\n\n toString() {\n let string = '[';\n\n if (config.printRowMajor) {\n string += 'row-major:';\n\n for (let row = 0; row < this.RANK; ++row) {\n for (let col = 0; col < this.RANK; ++col) {\n string += \" \".concat(this[col * this.RANK + row]);\n }\n }\n } else {\n string += 'column-major:';\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n string += \" \".concat(this[i]);\n }\n }\n\n string += ']';\n return string;\n }\n\n getElementIndex(row, col) {\n return col * this.RANK + row;\n }\n\n getElement(row, col) {\n return this[col * this.RANK + row];\n }\n\n setElement(row, col, value) {\n this[col * this.RANK + row] = checkNumber(value);\n return this;\n }\n\n getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) {\n const firstIndex = columnIndex * this.RANK;\n\n for (let i = 0; i < this.RANK; ++i) {\n result[i] = this[firstIndex + i];\n }\n\n return result;\n }\n\n setColumn(columnIndex, columnVector) {\n const firstIndex = columnIndex * this.RANK;\n\n for (let i = 0; i < this.RANK; ++i) {\n this[firstIndex + i] = columnVector[i];\n }\n\n return this;\n }\n\n}\n//# sourceMappingURL=matrix.js.map","export function vec2_transformMat4AsVector(out, a, m) {\n const x = a[0];\n const y = a[1];\n const w = m[3] * x + m[7] * y || 1.0;\n out[0] = (m[0] * x + m[4] * y) / w;\n out[1] = (m[1] * x + m[5] * y) / w;\n return out;\n}\nexport function vec3_transformMat4AsVector(out, a, m) {\n const x = a[0];\n const y = a[1];\n const z = a[2];\n const w = m[3] * x + m[7] * y + m[11] * z || 1.0;\n out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;\n out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;\n out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;\n return out;\n}\nexport function vec3_transformMat2(out, a, m) {\n const x = a[0];\n const y = a[1];\n out[0] = m[0] * x + m[2] * y;\n out[1] = m[1] * x + m[3] * y;\n out[2] = a[2];\n return out;\n}\nexport function vec4_transformMat2(out, a, m) {\n const x = a[0];\n const y = a[1];\n out[0] = m[0] * x + m[2] * y;\n out[1] = m[1] * x + m[3] * y;\n out[2] = a[2];\n out[3] = a[3];\n return out;\n}\nexport function vec4_transformMat3(out, a, m) {\n const x = a[0];\n const y = a[1];\n const z = a[2];\n out[0] = m[0] * x + m[3] * y + m[6] * z;\n out[1] = m[1] * x + m[4] * y + m[7] * z;\n out[2] = m[2] * x + m[5] * y + m[8] * z;\n out[3] = a[3];\n return out;\n}\n//# sourceMappingURL=gl-matrix-extras.js.map","/**\r\n * Common utilities\r\n * @module glMatrix\r\n */\n// Configuration Constants\nexport var EPSILON = 0.000001;\nexport var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;\nexport var RANDOM = Math.random;\n/**\r\n * Sets the type of array used when creating new vectors and matrices\r\n *\r\n * @param {Float32ArrayConstructor | ArrayConstructor} type Array type, such as Float32Array or Array\r\n */\n\nexport function setMatrixArrayType(type) {\n ARRAY_TYPE = type;\n}\nvar degree = Math.PI / 180;\n/**\r\n * Convert Degree To Radian\r\n *\r\n * @param {Number} a Angle in Degrees\r\n */\n\nexport function toRadian(a) {\n return a * degree;\n}\n/**\r\n * Tests whether or not the arguments have approximately the same value, within an absolute\r\n * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less\r\n * than or equal to 1.0, and a relative tolerance is used for larger values)\r\n *\r\n * @param {Number} a The first number to test.\r\n * @param {Number} b The second number to test.\r\n * @returns {Boolean} True if the numbers are approximately equal, false otherwise.\r\n */\n\nexport function equals(a, b) {\n return Math.abs(a - b) <= EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));\n}\nif (!Math.hypot) Math.hypot = function () {\n var y = 0,\n i = arguments.length;\n\n while (i--) {\n y += arguments[i] * arguments[i];\n }\n\n return Math.sqrt(y);\n};","import * as glMatrix from \"./common.js\";\n/**\r\n * 4x4 Matrix<br>Format: column-major, when typed out it looks like row-major<br>The matrices are being post multiplied.\r\n * @module mat4\r\n */\n\n/**\r\n * Creates a new identity mat4\r\n *\r\n * @returns {mat4} a new 4x4 matrix\r\n */\n\nexport function create() {\n var out = new glMatrix.ARRAY_TYPE(16);\n\n if (glMatrix.ARRAY_TYPE != Float32Array) {\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n }\n\n out[0] = 1;\n out[5] = 1;\n out[10] = 1;\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a new mat4 initialized with values from an existing matrix\r\n *\r\n * @param {ReadonlyMat4} a matrix to clone\r\n * @returns {mat4} a new 4x4 matrix\r\n */\n\nexport function clone(a) {\n var out = new glMatrix.ARRAY_TYPE(16);\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n out[4] = a[4];\n out[5] = a[5];\n out[6] = a[6];\n out[7] = a[7];\n out[8] = a[8];\n out[9] = a[9];\n out[10] = a[10];\n out[11] = a[11];\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n return out;\n}\n/**\r\n * Copy the values from one mat4 to another\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the source matrix\r\n * @returns {mat4} out\r\n */\n\nexport function copy(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n out[4] = a[4];\n out[5] = a[5];\n out[6] = a[6];\n out[7] = a[7];\n out[8] = a[8];\n out[9] = a[9];\n out[10] = a[10];\n out[11] = a[11];\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n return out;\n}\n/**\r\n * Create a new mat4 with the given values\r\n *\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\r\n * @param {Number} m03 Component in column 0, row 3 position (index 3)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 4)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 5)\r\n * @param {Number} m12 Component in column 1, row 2 position (index 6)\r\n * @param {Number} m13 Component in column 1, row 3 position (index 7)\r\n * @param {Number} m20 Component in column 2, row 0 position (index 8)\r\n * @param {Number} m21 Component in column 2, row 1 position (index 9)\r\n * @param {Number} m22 Component in column 2, row 2 position (index 10)\r\n * @param {Number} m23 Component in column 2, row 3 position (index 11)\r\n * @param {Number} m30 Component in column 3, row 0 position (index 12)\r\n * @param {Number} m31 Component in column 3, row 1 position (index 13)\r\n * @param {Number} m32 Component in column 3, row 2 position (index 14)\r\n * @param {Number} m33 Component in column 3, row 3 position (index 15)\r\n * @returns {mat4} A new mat4\r\n */\n\nexport function fromValues(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {\n var out = new glMatrix.ARRAY_TYPE(16);\n out[0] = m00;\n out[1] = m01;\n out[2] = m02;\n out[3] = m03;\n out[4] = m10;\n out[5] = m11;\n out[6] = m12;\n out[7] = m13;\n out[8] = m20;\n out[9] = m21;\n out[10] = m22;\n out[11] = m23;\n out[12] = m30;\n out[13] = m31;\n out[14] = m32;\n out[15] = m33;\n return out;\n}\n/**\r\n * Set the components of a mat4 to the given values\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\r\n * @param {Number} m03 Component in column 0, row 3 position (index 3)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 4)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 5)\r\n * @param {Number} m12 Component in column 1, row 2 position (index 6)\r\n * @param {Number} m13 Component in column 1, row 3 position (index 7)\r\n * @param {Number} m20 Component in column 2, row 0 position (index 8)\r\n * @param {Number} m21 Component in column 2, row 1 position (index 9)\r\n * @param {Number} m22 Component in column 2, row 2 position (index 10)\r\n * @param {Number} m23 Component in column 2, row 3 position (index 11)\r\n * @param {Number} m30 Component in column 3, row 0 position (index 12)\r\n * @param {Number} m31 Component in column 3, row 1 position (index 13)\r\n * @param {Number} m32 Component in column 3, row 2 position (index 14)\r\n * @param {Number} m33 Component in column 3, row 3 position (index 15)\r\n * @returns {mat4} out\r\n */\n\nexport function set(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {\n out[0] = m00;\n out[1] = m01;\n out[2] = m02;\n out[3] = m03;\n out[4] = m10;\n out[5] = m11;\n out[6] = m12;\n out[7] = m13;\n out[8] = m20;\n out[9] = m21;\n out[10] = m22;\n out[11] = m23;\n out[12] = m30;\n out[13] = m31;\n out[14] = m32;\n out[15] = m33;\n return out;\n}\n/**\r\n * Set a mat4 to the identity matrix\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @returns {mat4} out\r\n */\n\nexport function identity(out) {\n out[0] = 1;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = 1;\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[10] = 1;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Transpose the values of a mat4\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the source matrix\r\n * @returns {mat4} out\r\n */\n\nexport function transpose(out, a) {\n // If we are transposing ourselves we can skip a few steps but have to cache some values\n if (out === a) {\n var a01 = a[1],\n a02 = a[2],\n a03 = a[3];\n var a12 = a[6],\n a13 = a[7];\n var a23 = a[11];\n out[1] = a[4];\n out[2] = a[8];\n out[3] = a[12];\n out[4] = a01;\n out[6] = a[9];\n out[7] = a[13];\n out[8] = a02;\n out[9] = a12;\n out[11] = a[14];\n out[12] = a03;\n out[13] = a13;\n out[14] = a23;\n } else {\n out[0] = a[0];\n out[1] = a[4];\n out[2] = a[8];\n out[3] = a[12];\n out[4] = a[1];\n out[5] = a[5];\n out[6] = a[9];\n out[7] = a[13];\n out[8] = a[2];\n out[9] = a[6];\n out[10] = a[10];\n out[11] = a[14];\n out[12] = a[3];\n out[13] = a[7];\n out[14] = a[11];\n out[15] = a[15];\n }\n\n return out;\n}\n/**\r\n * Inverts a mat4\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the source matrix\r\n * @returns {mat4} out\r\n */\n\nexport function invert(out, a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a03 = a[3];\n var a10 = a[4],\n a11 = a[5],\n a12 = a[6],\n a13 = a[7];\n var a20 = a[8],\n a21 = a[9],\n a22 = a[10],\n a23 = a[11];\n var a30 = a[12],\n a31 = a[13],\n a32 = a[14],\n a33 = a[15];\n var b00 = a00 * a11 - a01 * a10;\n var b01 = a00 * a12 - a02 * a10;\n var b02 = a00 * a13 - a03 * a10;\n var b03 = a01 * a12 - a02 * a11;\n var b04 = a01 * a13 - a03 * a11;\n var b05 = a02 * a13 - a03 * a12;\n var b06 = a20 * a31 - a21 * a30;\n var b07 = a20 * a32 - a22 * a30;\n var b08 = a20 * a33 - a23 * a30;\n var b09 = a21 * a32 - a22 * a31;\n var b10 = a21 * a33 - a23 * a31;\n var b11 = a22 * a33 - a23 * a32; // Calculate the determinant\n\n var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\n if (!det) {\n return null;\n }\n\n det = 1.0 / det;\n out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;\n out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;\n out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;\n out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;\n out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;\n out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;\n out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;\n out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;\n out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;\n out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;\n out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;\n out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;\n out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;\n out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;\n out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;\n out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;\n return out;\n}\n/**\r\n * Calculates the adjugate of a mat4\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the source matrix\r\n * @returns {mat4} out\r\n */\n\nexport function adjoint(out, a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a03 = a[3];\n var a10 = a[4],\n a11 = a[5],\n a12 = a[6],\n a13 = a[7];\n var a20 = a[8],\n a21 = a[9],\n a22 = a[10],\n a23 = a[11];\n var a30 = a[12],\n a31 = a[13],\n a32 = a[14],\n a33 = a[15];\n out[0] = a11 * (a22 * a33 - a23 * a32) - a21 * (a12 * a33 - a13 * a32) + a31 * (a12 * a23 - a13 * a22);\n out[1] = -(a01 * (a22 * a33 - a23 * a32) - a21 * (a02 * a33 - a03 * a32) + a31 * (a02 * a23 - a03 * a22));\n out[2] = a01 * (a12 * a33 - a13 * a32) - a11 * (a02 * a33 - a03 * a32) + a31 * (a02 * a13 - a03 * a12);\n out[3] = -(a01 * (a12 * a23 - a13 * a22) - a11 * (a02 * a23 - a03 * a22) + a21 * (a02 * a13 - a03 * a12));\n out[4] = -(a10 * (a22 * a33 - a23 * a32) - a20 * (a12 * a33 - a13 * a32) + a30 * (a12 * a23 - a13 * a22));\n out[5] = a00 * (a22 * a33 - a23 * a32) - a20 * (a02 * a33 - a03 * a32) + a30 * (a02 * a23 - a03 * a22);\n out[6] = -(a00 * (a12 * a33 - a13 * a32) - a10 * (a02 * a33 - a03 * a32) + a30 * (a02 * a13 - a03 * a12));\n out[7] = a00 * (a12 * a23 - a13 * a22) - a10 * (a02 * a23 - a03 * a22) + a20 * (a02 * a13 - a03 * a12);\n out[8] = a10 * (a21 * a33 - a23 * a31) - a20 * (a11 * a33 - a13 * a31) + a30 * (a11 * a23 - a13 * a21);\n out[9] = -(a00 * (a21 * a33 - a23 * a31) - a20 * (a01 * a33 - a03 * a31) + a30 * (a01 * a23 - a03 * a21));\n out[10] = a00 * (a11 * a33 - a13 * a31) - a10 * (a01 * a33 - a03 * a31) + a30 * (a01 * a13 - a03 * a11);\n out[11] = -(a00 * (a11 * a23 - a13 * a21) - a10 * (a01 * a23 - a03 * a21) + a20 * (a01 * a13 - a03 * a11));\n out[12] = -(a10 * (a21 * a32 - a22 * a31) - a20 * (a11 * a32 - a12 * a31) + a30 * (a11 * a22 - a12 * a21));\n out[13] = a00 * (a21 * a32 - a22 * a31) - a20 * (a01 * a32 - a02 * a31) + a30 * (a01 * a22 - a02 * a21);\n out[14] = -(a00 * (a11 * a32 - a12 * a31) - a10 * (a01 * a32 - a02 * a31) + a30 * (a01 * a12 - a02 * a11));\n out[15] = a00 * (a11 * a22 - a12 * a21) - a10 * (a01 * a22 - a02 * a21) + a20 * (a01 * a12 - a02 * a11);\n return out;\n}\n/**\r\n * Calculates the determinant of a mat4\r\n *\r\n * @param {ReadonlyMat4} a the source matrix\r\n * @returns {Number} determinant of a\r\n */\n\nexport function determinant(a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a03 = a[3];\n var a10 = a[4],\n a11 = a[5],\n a12 = a[6],\n a13 = a[7];\n var a20 = a[8],\n a21 = a[9],\n a22 = a[10],\n a23 = a[11];\n var a30 = a[12],\n a31 = a[13],\n a32 = a[14],\n a33 = a[15];\n var b00 = a00 * a11 - a01 * a10;\n var b01 = a00 * a12 - a02 * a10;\n var b02 = a00 * a13 - a03 * a10;\n var b03 = a01 * a12 - a02 * a11;\n var b04 = a01 * a13 - a03 * a11;\n var b05 = a02 * a13 - a03 * a12;\n var b06 = a20 * a31 - a21 * a30;\n var b07 = a20 * a32 - a22 * a30;\n var b08 = a20 * a33 - a23 * a30;\n var b09 = a21 * a32 - a22 * a31;\n var b10 = a21 * a33 - a23 * a31;\n var b11 = a22 * a33 - a23 * a32; // Calculate the determinant\n\n return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n}\n/**\r\n * Multiplies two mat4s\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the first operand\r\n * @param {ReadonlyMat4} b the second operand\r\n * @returns {mat4} out\r\n */\n\nexport function multiply(out, a, b) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a03 = a[3];\n var a10 = a[4],\n a11 = a[5],\n a12 = a[6],\n a13 = a[7];\n var a20 = a[8],\n a21 = a[9],\n a22 = a[10],\n a23 = a[11];\n var a30 = a[12],\n a31 = a[13],\n a32 = a[14],\n a33 = a[15]; // Cache only the current line of the second matrix\n\n var b0 = b[0],\n b1 = b[1],\n b2 = b[2],\n b3 = b[3];\n out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\n out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\n out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\n out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\n b0 = b[4];\n b1 = b[5];\n b2 = b[6];\n b3 = b[7];\n out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\n out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\n out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\n out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\n b0 = b[8];\n b1 = b[9];\n b2 = b[10];\n b3 = b[11];\n out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\n out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\n out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\n out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\n b0 = b[12];\n b1 = b[13];\n b2 = b[14];\n b3 = b[15];\n out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\n out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\n out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\n out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\n return out;\n}\n/**\r\n * Translate a mat4 by the given vector\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to translate\r\n * @param {ReadonlyVec3} v vector to translate by\r\n * @returns {mat4} out\r\n */\n\nexport function translate(out, a, v) {\n var x = v[0],\n y = v[1],\n z = v[2];\n var a00, a01, a02, a03;\n var a10, a11, a12, a13;\n var a20, a21, a22, a23;\n\n if (a === out) {\n out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];\n out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];\n out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];\n out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];\n } else {\n a00 = a[0];\n a01 = a[1];\n a02 = a[2];\n a03 = a[3];\n a10 = a[4];\n a11 = a[5];\n a12 = a[6];\n a13 = a[7];\n a20 = a[8];\n a21 = a[9];\n a22 = a[10];\n a23 = a[11];\n out[0] = a00;\n out[1] = a01;\n out[2] = a02;\n out[3] = a03;\n out[4] = a10;\n out[5] = a11;\n out[6] = a12;\n out[7] = a13;\n out[8] = a20;\n out[9] = a21;\n out[10] = a22;\n out[11] = a23;\n out[12] = a00 * x + a10 * y + a20 * z + a[12];\n out[13] = a01 * x + a11 * y + a21 * z + a[13];\n out[14] = a02 * x + a12 * y + a22 * z + a[14];\n out[15] = a03 * x + a13 * y + a23 * z + a[15];\n }\n\n return out;\n}\n/**\r\n * Scales the mat4 by the dimensions in the given vec3 not using vectorization\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to scale\r\n * @param {ReadonlyVec3} v the vec3 to scale the matrix by\r\n * @returns {mat4} out\r\n **/\n\nexport function scale(out, a, v) {\n var x = v[0],\n y = v[1],\n z = v[2];\n out[0] = a[0] * x;\n out[1] = a[1] * x;\n out[2] = a[2] * x;\n out[3] = a[3] * x;\n out[4] = a[4] * y;\n out[5] = a[5] * y;\n out[6] = a[6] * y;\n out[7] = a[7] * y;\n out[8] = a[8] * z;\n out[9] = a[9] * z;\n out[10] = a[10] * z;\n out[11] = a[11] * z;\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n return out;\n}\n/**\r\n * Rotates a mat4 by the given angle around the given axis\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @param {ReadonlyVec3} axis the axis to rotate around\r\n * @returns {mat4} out\r\n */\n\nexport function rotate(out, a, rad, axis) {\n var x = axis[0],\n y = axis[1],\n z = axis[2];\n var len = Math.hypot(x, y, z);\n var s, c, t;\n var a00, a01, a02, a03;\n var a10, a11, a12, a13;\n var a20, a21, a22, a23;\n var b00, b01, b02;\n var b10, b11, b12;\n var b20, b21, b22;\n\n if (len < glMatrix.EPSILON) {\n return null;\n }\n\n len = 1 / len;\n x *= len;\n y *= len;\n z *= len;\n s = Math.sin(rad);\n c = Math.cos(rad);\n t = 1 - c;\n a00 = a[0];\n a01 = a[1];\n a02 = a[2];\n a03 = a[3];\n a10 = a[4];\n a11 = a[5];\n a12 = a[6];\n a13 = a[7];\n a20 = a[8];\n a21 = a[9];\n a22 = a[10];\n a23 = a[11]; // Construct the elements of the rotation matrix\n\n b00 = x * x * t + c;\n b01 = y * x * t + z * s;\n b02 = z * x * t - y * s;\n b10 = x * y * t - z * s;\n b11 = y * y * t + c;\n b12 = z * y * t + x * s;\n b20 = x * z * t + y * s;\n b21 = y * z * t - x * s;\n b22 = z * z * t + c; // Perform rotation-specific matrix multiplication\n\n out[0] = a00 * b00 + a10 * b01 + a20 * b02;\n out[1] = a01 * b00 + a11 * b01 + a21 * b02;\n out[2] = a02 * b00 + a12 * b01 + a22 * b02;\n out[3] = a03 * b00 + a13 * b01 + a23 * b02;\n out[4] = a00 * b10 + a10 * b11 + a20 * b12;\n out[5] = a01 * b10 + a11 * b11 + a21 * b12;\n out[6] = a02 * b10 + a12 * b11 + a22 * b12;\n out[7] = a03 * b10 + a13 * b11 + a23 * b12;\n out[8] = a00 * b20 + a10 * b21 + a20 * b22;\n out[9] = a01 * b20 + a11 * b21 + a21 * b22;\n out[10] = a02 * b20 + a12 * b21 + a22 * b22;\n out[11] = a03 * b20 + a13 * b21 + a23 * b22;\n\n if (a !== out) {\n // If the source and destination differ, copy the unchanged last row\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n }\n\n return out;\n}\n/**\r\n * Rotates a matrix by the given angle around the X axis\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\n\nexport function rotateX(out, a, rad) {\n var s = Math.sin(rad);\n var c = Math.cos(rad);\n var a10 = a[4];\n var a11 = a[5];\n var a12 = a[6];\n var a13 = a[7];\n var a20 = a[8];\n var a21 = a[9];\n var a22 = a[10];\n var a23 = a[11];\n\n if (a !== out) {\n // If the source and destination differ, copy the unchanged rows\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n } // Perform axis-specific matrix multiplication\n\n\n out[4] = a10 * c + a20 * s;\n out[5] = a11 * c + a21 * s;\n out[6] = a12 * c + a22 * s;\n out[7] = a13 * c + a23 * s;\n out[8] = a20 * c - a10 * s;\n out[9] = a21 * c - a11 * s;\n out[10] = a22 * c - a12 * s;\n out[11] = a23 * c - a13 * s;\n return out;\n}\n/**\r\n * Rotates a matrix by the given angle around the Y axis\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\n\nexport function rotateY(out, a, rad) {\n var s = Math.sin(rad);\n var c = Math.cos(rad);\n var a00 = a[0];\n var a01 = a[1];\n var a02 = a[2];\n var a03 = a[3];\n var a20 = a[8];\n var a21 = a[9];\n var a22 = a[10];\n var a23 = a[11];\n\n if (a !== out) {\n // If the source and destination differ, copy the unchanged rows\n out[4] = a[4];\n out[5] = a[5];\n out[6] = a[6];\n out[7] = a[7];\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n } // Perform axis-specific matrix multiplication\n\n\n out[0] = a00 * c - a20 * s;\n out[1] = a01 * c - a21 * s;\n out[2] = a02 * c - a22 * s;\n out[3] = a03 * c - a23 * s;\n out[8] = a00 * s + a20 * c;\n out[9] = a01 * s + a21 * c;\n out[10] = a02 * s + a22 * c;\n out[11] = a03 * s + a23 * c;\n return out;\n}\n/**\r\n * Rotates a matrix by the given angle around the Z axis\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\n\nexport function rotateZ(out, a, rad) {\n var s = Math.sin(rad);\n var c = Math.cos(rad);\n var a00 = a[0];\n var a01 = a[1];\n var a02 = a[2];\n var a03 = a[3];\n var a10 = a[4];\n var a11 = a[5];\n var a12 = a[6];\n var a13 = a[7];\n\n if (a !== out) {\n // If the source and destination differ, copy the unchanged last row\n out[8] = a[8];\n out[9] = a[9];\n out[10] = a[10];\n out[11] = a[11];\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n } // Perform axis-specific matrix multiplication\n\n\n out[0] = a00 * c + a10 * s;\n out[1] = a01 * c + a11 * s;\n out[2] = a02 * c + a12 * s;\n out[3] = a03 * c + a13 * s;\n out[4] = a10 * c - a00 * s;\n out[5] = a11 * c - a01 * s;\n out[6] = a12 * c - a02 * s;\n out[7] = a13 * c - a03 * s;\n return out;\n}\n/**\r\n * Creates a matrix from a vector translation\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.translate(dest, dest, vec);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {ReadonlyVec3} v Translation vector\r\n * @returns {mat4} out\r\n */\n\nexport function fromTranslation(out, v) {\n out[0] = 1;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = 1;\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[10] = 1;\n out[11] = 0;\n out[12] = v[0];\n out[13] = v[1];\n out[14] = v[2];\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from a vector scaling\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.scale(dest, dest, vec);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {ReadonlyVec3} v Scaling vector\r\n * @returns {mat4} out\r\n */\n\nexport function fromScaling(out, v) {\n out[0] = v[0];\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = v[1];\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[10] = v[2];\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from a given angle around a given axis\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.rotate(dest, dest, rad, axis);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @param {ReadonlyVec3} axis the axis to rotate around\r\n * @returns {mat4} out\r\n */\n\nexport function fromRotation(out, rad, axis) {\n var x = axis[0],\n y = axis[1],\n z = axis[2];\n var len = Math.hypot(x, y, z);\n var s, c, t;\n\n if (len < glMatrix.EPSILON) {\n return null;\n }\n\n len = 1 / len;\n x *= len;\n y *= len;\n z *= len;\n s = Math.sin(rad);\n c = Math.cos(rad);\n t = 1 - c; // Perform rotation-specific matrix multiplication\n\n out[0] = x * x * t + c;\n out[1] = y * x * t + z * s;\n out[2] = z * x * t - y * s;\n out[3] = 0;\n out[4] = x * y * t - z * s;\n out[5] = y * y * t + c;\n out[6] = z * y * t + x * s;\n out[7] = 0;\n out[8] = x * z * t + y * s;\n out[9] = y * z * t - x * s;\n out[10] = z * z * t + c;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from the given angle around the X axis\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.rotateX(dest, dest, rad);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\n\nexport function fromXRotation(out, rad) {\n var s = Math.sin(rad);\n var c = Math.cos(rad); // Perform axis-specific matrix multiplication\n\n out[0] = 1;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = c;\n out[6] = s;\n out[7] = 0;\n out[8] = 0;\n out[9] = -s;\n out[10] = c;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from the given angle around the Y axis\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.rotateY(dest, dest, rad);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\n\nexport function fromYRotation(out, rad) {\n var s = Math.sin(rad);\n var c = Math.cos(rad); // Perform axis-specific matrix multiplication\n\n out[0] = c;\n out[1] = 0;\n out[2] = -s;\n out[3] = 0;\n out[4] = 0;\n out[5] = 1;\n out[6] = 0;\n out[7] = 0;\n out[8] = s;\n out[9] = 0;\n out[10] = c;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from the given angle around the Z axis\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.rotateZ(dest, dest, rad);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\n\nexport function fromZRotation(out, rad) {\n var s = Math.sin(rad);\n var c = Math.cos(rad); // Perform axis-specific matrix multiplication\n\n out[0] = c;\n out[1] = s;\n out[2] = 0;\n out[3] = 0;\n out[4] = -s;\n out[5] = c;\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[10] = 1;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from a quaternion rotation and vector translation\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.translate(dest, vec);\r\n * let quatMat = mat4.create();\r\n * quat4.toMat4(quat, quatMat);\r\n * mat4.multiply(dest, quatMat);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {quat4} q Rotation quaternion\r\n * @param {ReadonlyVec3} v Translation vector\r\n * @returns {mat4} out\r\n */\n\nexport function fromRotationTranslation(out, q, v) {\n // Quaternion math\n var x = q[0],\n y = q[1],\n z = q[2],\n w = q[3];\n var x2 = x + x;\n var y2 = y + y;\n var z2 = z + z;\n var xx = x * x2;\n var xy = x * y2;\n var xz = x * z2;\n var yy = y * y2;\n var yz = y * z2;\n var zz = z * z2;\n var wx = w * x2;\n var wy = w * y2;\n var wz = w * z2;\n out[0] = 1 - (yy + zz);\n out[1] = xy + wz;\n out[2] = xz - wy;\n out[3] = 0;\n out[4] = xy - wz;\n out[5] = 1 - (xx + zz);\n out[6] = yz + wx;\n out[7] = 0;\n out[8] = xz + wy;\n out[9] = yz - wx;\n out[10] = 1 - (xx + yy);\n out[11] = 0;\n out[12] = v[0];\n out[13] = v[1];\n out[14] = v[2];\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a new mat4 from a dual quat.\r\n *\r\n * @param {mat4} out Matrix\r\n * @param {ReadonlyQuat2} a Dual Quaternion\r\n * @returns {mat4} mat4 receiving operation result\r\n */\n\nexport function fromQuat2(out, a) {\n var translation = new glMatrix.ARRAY_TYPE(3);\n var bx = -a[0],\n by = -a[1],\n bz = -a[2],\n bw = a[3],\n ax = a[4],\n ay = a[5],\n az = a[6],\n aw = a[7];\n var magnitude = bx * bx + by * by + bz * bz + bw * bw; //Only scale if it makes sense\n\n if (magnitude > 0) {\n translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude;\n translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude;\n translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude;\n } else {\n translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;\n translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;\n translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;\n }\n\n fromRotationTranslation(out, a, translation);\n return out;\n}\n/**\r\n * Returns the translation vector component of a transformation\r\n * matrix. If a matrix is built with fromRotationTranslation,\r\n * the returned vector will be the same as the translation vector\r\n * originally supplied.\r\n * @param {vec3} out Vector to receive translation component\r\n * @param {ReadonlyMat4} mat Matrix to be decomposed (input)\r\n * @return {vec3} out\r\n */\n\nexport function getTranslation(out, mat) {\n out[0] = mat[12];\n out[1] = mat[13];\n out[2] = mat[14];\n return out;\n}\n/**\r\n * Returns the scaling factor component of a transformation\r\n * matrix. If a matrix is built with fromRotationTranslationScale\r\n * with a normalized Quaternion paramter, the returned vector will be\r\n * the same as the scaling vector\r\n * originally supplied.\r\n * @param {vec3} out Vector to receive scaling factor component\r\n * @param {ReadonlyMat4} mat Matrix to be decomposed (input)\r\n * @return {vec3} out\r\n */\n\nexport function getScaling(out, mat) {\n var m11 = mat[0];\n var m12 = mat[1];\n var m13 = mat[2];\n var m21 = mat[4];\n var m22 = mat[5];\n var m23 = mat[6];\n var m31 = mat[8];\n var m32 = mat[9];\n var m33 = mat[10];\n out[0] = Math.hypot(m11, m12, m13);\n out[1] = Math.hypot(m21, m22, m23);\n out[2] = Math.hypot(m31, m32, m33);\n return out;\n}\n/**\r\n * Returns a quaternion representing the rotational component\r\n * of a transformation matrix. If a matrix is built with\r\n * fromRotationTranslation, the returned quaternion will be the\r\n * same as the quaternion originally supplied.\r\n * @param {quat} out Quaternion to receive the rotation component\r\n * @param {ReadonlyMat4} mat Matrix to be decomposed (input)\r\n * @return {quat} out\r\n */\n\nexport function getRotation(out, mat) {\n var scaling = new glMatrix.ARRAY_TYPE(3);\n getScaling(scaling, mat);\n var is1 = 1 / scaling[0];\n var is2 = 1 / scaling[1];\n var is3 = 1 / scaling[2];\n var sm11 = mat[0] * is1;\n var sm12 = mat[1] * is2;\n var sm13 = mat[2] * is3;\n var sm21 = mat[4] * is1;\n var sm22 = mat[5] * is2;\n var sm23 = mat[6] * is3;\n var sm31 = mat[8] * is1;\n var sm32 = mat[9] * is2;\n var sm33 = mat[10] * is3;\n var trace = sm11 + sm22 + sm33;\n var S = 0;\n\n if (trace > 0) {\n S = Math.sqrt(trace + 1.0) * 2;\n out[3] = 0.25 * S;\n out[0] = (sm23 - sm32) / S;\n out[1] = (sm31 - sm13) / S;\n out[2] = (sm12 - sm21) / S;\n } else if (sm11 > sm22 && sm11 > sm33) {\n S = Math.sqrt(1.0 + sm11 - sm22 - sm33) * 2;\n out[3] = (sm23 - sm32) / S;\n out[0] = 0.25 * S;\n out[1] = (sm12 + sm21) / S;\n out[2] = (sm31 + sm13) / S;\n } else if (sm22 > sm33) {\n S = Math.sqrt(1.0 + sm22 - sm11 - sm33) * 2;\n out[3] = (sm31 - sm13) / S;\n out[0] = (sm12 + sm21) / S;\n out[1] = 0.25 * S;\n out[2] = (sm23 + sm32) / S;\n } else {\n S = Math.sqrt(1.0 + sm33 - sm11 - sm22) * 2;\n out[3] = (sm12 - sm21) / S;\n out[0] = (sm31 + sm13) / S;\n out[1] = (sm23 + sm32) / S;\n out[2] = 0.25 * S;\n }\n\n return out;\n}\n/**\r\n * Creates a matrix from a quaternion rotation, vector translation and vector scale\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.translate(dest, vec);\r\n * let quatMat = mat4.create();\r\n * quat4.toMat4(quat, quatMat);\r\n * mat4.multiply(dest, quatMat);\r\n * mat4.scale(dest, scale)\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {quat4} q Rotation quaternion\r\n * @param {ReadonlyVec3} v Translation vector\r\n * @param {ReadonlyVec3} s Scaling vector\r\n * @returns {mat4} out\r\n */\n\nexport function fromRotationTranslationScale(out, q, v, s) {\n // Quaternion math\n var x = q[0],\n y = q[1],\n z = q[2],\n w = q[3];\n var x2 = x + x;\n var y2 = y + y;\n var z2 = z + z;\n var xx = x * x2;\n var xy = x * y2;\n var xz = x * z2;\n var yy = y * y2;\n var yz = y * z2;\n var zz = z * z2;\n var wx = w * x2;\n var wy = w * y2;\n var wz = w * z2;\n var sx = s[0];\n var sy = s[1];\n var sz = s[2];\n out[0] = (1 - (yy + zz)) * sx;\n out[1] = (xy + wz) * sx;\n out[2] = (xz - wy) * sx;\n out[3] = 0;\n out[4] = (xy - wz) * sy;\n out[5] = (1 - (xx + zz)) * sy;\n out[6] = (yz + wx) * sy;\n out[7] = 0;\n out[8] = (xz + wy) * sz;\n out[9] = (yz - wx) * sz;\n out[10] = (1 - (xx + yy)) * sz;\n out[11] = 0;\n out[12] = v[0];\n out[13] = v[1];\n out[14] = v[2];\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from a quaternion rotation, vector translation and vector scale, rotating and scaling around the given origin\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.translate(dest, vec);\r\n * mat4.translate(dest, origin);\r\n * let quatMat = mat4.create();\r\n * quat4.toMat4(quat, quatMat);\r\n * mat4.multiply(dest, quatMat);\r\n * mat4.scale(dest, scale)\r\n * mat4.translate(dest, negativeOrigin);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {quat4} q Rotation quaternion\r\n * @param {ReadonlyVec3} v Translation vector\r\n * @param {ReadonlyVec3} s Scaling vector\r\n * @param {ReadonlyVec3} o The origin vector around which to scale and rotate\r\n * @returns {mat4} out\r\n */\n\nexport function fromRotationTranslationScaleOrigin(out, q, v, s, o) {\n // Quaternion math\n var x = q[0],\n y = q[1],\n z = q[2],\n w = q[3];\n var x2 = x + x;\n var y2 = y + y;\n var z2 = z + z;\n var xx = x * x2;\n var xy = x * y2;\n var xz = x * z2;\n var yy = y * y2;\n var yz = y * z2;\n var zz = z * z2;\n var wx = w * x2;\n var wy = w * y2;\n var wz = w * z2;\n var sx = s[0];\n var sy = s[1];\n var sz = s[2];\n var ox = o[0];\n var oy = o[1];\n var oz = o[2];\n var out0 = (1 - (yy + zz)) * sx;\n var out1 = (xy + wz) * sx;\n var out2 = (xz - wy) * sx;\n var out4 = (xy - wz) * sy;\n var out5 = (1 - (xx + zz)) * sy;\n var out6 = (yz + wx) * sy;\n var out8 = (xz + wy) * sz;\n var out9 = (yz - wx) * sz;\n var out10 = (1 - (xx + yy)) * sz;\n out[0] = out0;\n out[1] = out1;\n out[2] = out2;\n out[3] = 0;\n out[4] = out4;\n out[5] = out5;\n out[6] = out6;\n out[7] = 0;\n out[8] = out8;\n out[9] = out9;\n out[10] = out10;\n out[11] = 0;\n out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz);\n out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz);\n out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz);\n out[15] = 1;\n return out;\n}\n/**\r\n * Calculates a 4x4 matrix from the given quaternion\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {ReadonlyQuat} q Quaternion to create matrix from\r\n *\r\n * @returns {mat4} out\r\n */\n\nexport function fromQuat(out, q) {\n var x = q[0],\n y = q[1],\n z = q[2],\n w = q[3];\n var x2 = x + x;\n var y2 = y + y;\n var z2 = z + z;\n var xx = x * x2;\n var yx = y * x2;\n var yy = y * y2;\n var zx = z * x2;\n var zy = z * y2;\n var zz = z * z2;\n var wx = w * x2;\n var wy = w * y2;\n var wz = w * z2;\n out[0] = 1 - yy - zz;\n out[1] = yx + wz;\n out[2] = zx - wy;\n out[3] = 0;\n out[4] = yx - wz;\n out[5] = 1 - xx - zz;\n out[6] = zy + wx;\n out[7] = 0;\n out[8] = zx + wy;\n out[9] = zy - wx;\n out[10] = 1 - xx - yy;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Generates a frustum matrix with the given bounds\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {Number} left Left bound of the frustum\r\n * @param {Number} right Right bound of the frustum\r\n * @param {Number} bottom Bottom bound of the frustum\r\n * @param {Number} top Top bound of the frustum\r\n * @param {Number} near Near bound of the frustum\r\n * @param {Number} far Far bound of the frustum\r\n * @returns {mat4} out\r\n */\n\nexport function frustum(out, left, right, bottom, top, near, far) {\n var rl = 1 / (right - left);\n var tb = 1 / (top - bottom);\n var nf = 1 / (near - far);\n out[0] = near * 2 * rl;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = near * 2 * tb;\n out[6] = 0;\n out[7] = 0;\n out[8] = (right + left) * rl;\n out[9] = (top + bottom) * tb;\n out[10] = (far + near) * nf;\n out[11] = -1;\n out[12] = 0;\n out[13] = 0;\n out[14] = far * near * 2 * nf;\n out[15] = 0;\n return out;\n}\n/**\r\n * Generates a perspective projection matrix with the given bounds.\r\n * Passing null/undefined/no value for far will generate infinite projection matrix.\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {number} fovy Vertical field of view in radians\r\n * @param {number} aspect Aspect ratio. typically viewport width/height\r\n * @param {number} near Near bound of the frustum\r\n * @param {number} far Far bound of the frustum, can be null or Infinity\r\n * @returns {mat4} out\r\n */\n\nexport function perspective(out, fovy, aspect, near, far) {\n var f = 1.0 / Math.tan(fovy / 2),\n nf;\n out[0] = f / aspect;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = f;\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[11] = -1;\n out[12] = 0;\n out[13] = 0;\n out[15] = 0;\n\n if (far != null && far !== Infinity) {\n nf = 1 / (near - far);\n out[10] = (far + near) * nf;\n out[14] = 2 * far * near * nf;\n } else {\n out[10] = -1;\n out[14] = -2 * near;\n }\n\n return out;\n}\n/**\r\n * Generates a perspective projection matrix with the given field of view.\r\n * This is primarily useful for generating projection matrices to be used\r\n * with the still experiemental WebVR API.\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {Object} fov Object containing the following values: upDegrees, downDegrees, leftDegrees, rightDegrees\r\n * @param {number} near Near bound of the frustum\r\n * @param {number} far Far bound of the frustum\r\n * @returns {mat4} out\r\n */\n\nexport function perspectiveFromFieldOfView(out, fov, near, far) {\n var upTan = Math.tan(fov.upDegrees * Math.PI / 180.0);\n var downTan = Math.tan(fov.downDegrees * Math.PI / 180.0);\n var leftTan = Math.tan(fov.leftDegrees * Math.PI / 180.0);\n var rightTan = Math.tan(fov.rightDegrees * Math.PI / 180.0);\n var xScale = 2.0 / (leftTan + rightTan);\n var yScale = 2.0 / (upTan + downTan);\n out[0] = xScale;\n out[1] = 0.0;\n out[2] = 0.0;\n out[3] = 0.0;\n out[4] = 0.0;\n out[5] = yScale;\n out[6] = 0.0;\n out[7] = 0.0;\n out[8] = -((leftTan - rightTan) * xScale * 0.5);\n out[9] = (upTan - downTan) * yScale * 0.5;\n out[10] = far / (near - far);\n out[11] = -1.0;\n out[12] = 0.0;\n out[13] = 0.0;\n out[14] = far * near / (near - far);\n out[15] = 0.0;\n return out;\n}\n/**\r\n * Generates a orthogonal projection matrix with the given bounds\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {number} left Left bound of the frustum\r\n * @param {number} right Right bound of the frustum\r\n * @param {number} bottom Bottom bound of the frustum\r\n * @param {number} top Top bound of the frustum\r\n * @param {number} near Near bound of the frustum\r\n * @param {number} far Far bound of the frustum\r\n * @returns {mat4} out\r\n */\n\nexport function ortho(out, left, right, bottom, top, near, far) {\n var lr = 1 / (left - right);\n var bt = 1 / (bottom - top);\n var nf = 1 / (near - far);\n out[0] = -2 * lr;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = -2 * bt;\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[10] = 2 * nf;\n out[11] = 0;\n out[12] = (left + right) * lr;\n out[13] = (top + bottom) * bt;\n out[14] = (far + near) * nf;\n out[15] = 1;\n return out;\n}\n/**\r\n * Generates a look-at matrix with the given eye position, focal point, and up axis.\r\n * If you want a matrix that actually makes an object look at another object, you should use targetTo instead.\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {ReadonlyVec3} eye Position of the viewer\r\n * @param {ReadonlyVec3} center Point the viewer is looking at\r\n * @param {ReadonlyVec3} up vec3 pointing up\r\n * @returns {mat4} out\r\n */\n\nexport function lookAt(out, eye, center, up) {\n var x0, x1, x2, y0, y1, y2, z0, z1, z2, len;\n var eyex = eye[0];\n var eyey = eye[1];\n var eyez = eye[2];\n var upx = up[0];\n var upy = up[1];\n var upz = up[2];\n var centerx = center[0];\n var centery = center[1];\n var centerz = center[2];\n\n if (Math.abs(eyex - centerx) < glMatrix.EPSILON && Math.abs(eyey - centery) < glMatrix.EPSILON && Math.abs(eyez - centerz) < glMatrix.EPSILON) {\n return identity(out);\n }\n\n z0 = eyex - centerx;\n z1 = eyey - centery;\n z2 = eyez - centerz;\n len = 1 / Math.hypot(z0, z1, z2);\n z0 *= len;\n z1 *= len;\n z2 *= len;\n x0 = upy * z2 - upz * z1;\n x1 = upz * z0 - upx * z2;\n x2 = upx * z1 - upy * z0;\n len = Math.hypot(x0, x1, x2);\n\n if (!len) {\n x0 = 0;\n x1 = 0;\n x2 = 0;\n } else {\n len = 1 / len;\n x0 *= len;\n x1 *= len;\n x2 *= len;\n }\n\n y0 = z1 * x2 - z2 * x1;\n y1 = z2 * x0 - z0 * x2;\n y2 = z0 * x1 - z1 * x0;\n len = Math.hypot(y0, y1, y2);\n\n if (!len) {\n y0 = 0;\n y1 = 0;\n y2 = 0;\n } else {\n len = 1 / len;\n y0 *= len;\n y1 *= len;\n y2 *= len;\n }\n\n out[0] = x0;\n out[1] = y0;\n out[2] = z0;\n out[3] = 0;\n out[4] = x1;\n out[5] = y1;\n out[6] = z1;\n out[7] = 0;\n out[8] = x2;\n out[9] = y2;\n out[10] = z2;\n out[11] = 0;\n out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);\n out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);\n out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);\n out[15] = 1;\n return out;\n}\n/**\r\n * Generates a matrix that makes something look at something else.\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {ReadonlyVec3} eye Position of the viewer\r\n * @param {ReadonlyVec3} center Point the viewer is looking at\r\n * @param {ReadonlyVec3} up vec3 pointing up\r\n * @returns {mat4} out\r\n */\n\nexport function targetTo(out, eye, target, up) {\n var eyex = eye[0],\n eyey = eye[1],\n eyez = eye[2],\n upx = up[0],\n upy = up[1],\n upz = up[2];\n var z0 = eyex - target[0],\n z1 = eyey - target[1],\n z2 = eyez - target[2];\n var len = z0 * z0 + z1 * z1 + z2 * z2;\n\n if (len > 0) {\n len = 1 / Math.sqrt(len);\n z0 *= len;\n z1 *= len;\n z2 *= len;\n }\n\n var x0 = upy * z2 - upz * z1,\n x1 = upz * z0 - upx * z2,\n x2 = upx * z1 - upy * z0;\n len = x0 * x0 + x1 * x1 + x2 * x2;\n\n if (len > 0) {\n len = 1 / Math.sqrt(len);\n x0 *= len;\n x1 *= len;\n x2 *= len;\n }\n\n out[0] = x0;\n out[1] = x1;\n out[2] = x2;\n out[3] = 0;\n out[4] = z1 * x2 - z2 * x1;\n out[5] = z2 * x0 - z0 * x2;\n out[6] = z0 * x1 - z1 * x0;\n out[7] = 0;\n out[8] = z0;\n out[9] = z1;\n out[10] = z2;\n out[11] = 0;\n out[12] = eyex;\n out[13] = eyey;\n out[14] = eyez;\n out[15] = 1;\n return out;\n}\n/**\r\n * Returns a string representation of a mat4\r\n *\r\n * @param {ReadonlyMat4} a matrix to represent as a string\r\n * @returns {String} string representation of the matrix\r\n */\n\nexport function str(a) {\n return \"mat4(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \", \" + a[3] + \", \" + a[4] + \", \" + a[5] + \", \" + a[6] + \", \" + a[7] + \", \" + a[8] + \", \" + a[9] + \", \" + a[10] + \", \" + a[11] + \", \" + a[12] + \", \" + a[13] + \", \" + a[14] + \", \" + a[15] + \")\";\n}\n/**\r\n * Returns Frobenius norm of a mat4\r\n *\r\n * @param {ReadonlyMat4} a the matrix to calculate Frobenius norm of\r\n * @returns {Number} Frobenius norm\r\n */\n\nexport function frob(a) {\n return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]);\n}\n/**\r\n * Adds two mat4's\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the first operand\r\n * @param {ReadonlyMat4} b the second operand\r\n * @returns {mat4} out\r\n */\n\nexport function add(out, a, b) {\n out[0] = a[0] + b[0];\n out[1] = a[1] + b[1];\n out[2] = a[2] + b[2];\n out[3] = a[3] + b[3];\n out[4] = a[4] + b[4];\n out[5] = a[5] + b[5];\n out[6] = a[6] + b[6];\n out[7] = a[7] + b[7];\n out[8] = a[8] + b[8];\n out[9] = a[9] + b[9];\n out[10] = a[10] + b[10];\n out[11] = a[11] + b[11];\n out[12] = a[12] + b[12];\n out[13] = a[13] + b[13];\n out[14] = a[14] + b[14];\n out[15] = a[15] + b[15];\n return out;\n}\n/**\r\n * Subtracts matrix b from matrix a\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the first operand\r\n * @param {ReadonlyMat4} b the second operand\r\n * @returns {mat4} out\r\n */\n\nexport function subtract(out, a, b) {\n out[0] = a[0] - b[0];\n out[1] = a[1] - b[1];\n out[2] = a[2] - b[2];\n out[3] = a[3] - b[3];\n out[4] = a[4] - b[4];\n out[5] = a[5] - b[5];\n out[6] = a[6] - b[6];\n out[7] = a[7] - b[7];\n out[8] = a[8] - b[8];\n out[9] = a[9] - b[9];\n out[10] = a[10] - b[10];\n out[11] = a[11] - b[11];\n out[12] = a[12] - b[12];\n out[13] = a[13] - b[13];\n out[14] = a[14] - b[14];\n out[15] = a[15] - b[15];\n return out;\n}\n/**\r\n * Multiply each element of the matrix by a scalar.\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to scale\r\n * @param {Number} b amount to scale the matrix's elements by\r\n * @returns {mat4} out\r\n */\n\nexport function multiplyScalar(out, a, b) {\n out[0] = a[0] * b;\n out[1] = a[1] * b;\n out[2] = a[2] * b;\n out[3] = a[3] * b;\n out[4] = a[4] * b;\n out[5] = a[5] * b;\n out[6] = a[6] * b;\n out[7] = a[7] * b;\n out[8] = a[8] * b;\n out[9] = a[9] * b;\n out[10] = a[10] * b;\n out[11] = a[11] * b;\n out[12] = a[12] * b;\n out[13] = a[13] * b;\n out[14] = a[14] * b;\n out[15] = a[15] * b;\n return out;\n}\n/**\r\n * Adds two mat4's after multiplying each element of the second operand by a scalar value.\r\n *\r\n * @param {mat4} out the receiving vector\r\n * @param {ReadonlyMat4} a the first operand\r\n * @param {ReadonlyMat4} b the second operand\r\n * @param {Number} scale the amount to scale b's elements by before adding\r\n * @returns {mat4} out\r\n */\n\nexport function multiplyScalarAndAdd(out, a, b, scale) {\n out[0] = a[0] + b[0] * scale;\n out[1] = a[1] + b[1] * scale;\n out[2] = a[2] + b[2] * scale;\n out[3] = a[3] + b[3] * scale;\n out[4] = a[4] + b[4] * scale;\n out[5] = a[5] + b[5] * scale;\n out[6] = a[6] + b[6] * scale;\n out[7] = a[7] + b[7] * scale;\n out[8] = a[8] + b[8] * scale;\n out[9] = a[9] + b[9] * scale;\n out[10] = a[10] + b[10] * scale;\n out[11] = a[11] + b[11] * scale;\n out[12] = a[12] + b[12] * scale;\n out[13] = a[13] + b[13] * scale;\n out[14] = a[14] + b[14] * scale;\n out[15] = a[15] + b[15] * scale;\n return out;\n}\n/**\r\n * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {ReadonlyMat4} a The first matrix.\r\n * @param {ReadonlyMat4} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\n\nexport function exactEquals(a, b) {\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15];\n}\n/**\r\n * Returns whether or not the matrices have approximately the same elements in the same position.\r\n *\r\n * @param {ReadonlyMat4} a The first matrix.\r\n * @param {ReadonlyMat4} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\n\nexport function equals(a, b) {\n var a0 = a[0],\n a1 = a[1],\n a2 = a[2],\n a3 = a[3];\n var a4 = a[4],\n a5 = a[5],\n a6 = a[6],\n a7 = a[7];\n var a8 = a[8],\n a9 = a[9],\n a10 = a[10],\n a11 = a[11];\n var a12 = a[12],\n a13 = a[13],\n a14 = a[14],\n a15 = a[15];\n var b0 = b[0],\n b1 = b[1],\n b2 = b[2],\n b3 = b[3];\n var b4 = b[4],\n b5 = b[5],\n b6 = b[6],\n b7 = b[7];\n var b8 = b[8],\n b9 = b[9],\n b10 = b[10],\n b11 = b[11];\n var b12 = b[12],\n b13 = b[13],\n b14 = b[14],\n b15 = b[15];\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a15), Math.abs(b15));\n}\n/**\r\n * Alias for {@link mat4.multiply}\r\n * @function\r\n */\n\nexport var mul = multiply;\n/**\r\n * Alias for {@link mat4.subtract}\r\n * @function\r\n */\n\nexport var sub = subtract;","import * as glMatrix from \"./common.js\";\n/**\r\n * 2 Dimensional Vector\r\n * @module vec2\r\n */\n\n/**\r\n * Creates a new, empty vec2\r\n *\r\n * @returns {vec2} a new 2D vector\r\n */\n\nexport function create() {\n var out = new glMatrix.ARRAY_TYPE(2);\n\n if (glMatrix.ARRAY_TYPE != Float32Array) {\n out[0] = 0;\n out[1] = 0;\n }\n\n return out;\n}\n/**\r\n * Creates a new vec2 initialized with values from an existing vector\r\n *\r\n * @param {ReadonlyVec2} a vector to clone\r\n * @returns {vec2} a new 2D vector\r\n */\n\nexport function clone(a) {\n var out = new glMatrix.ARRAY_TYPE(2);\n out[0] = a[0];\n out[1] = a[1];\n return out;\n}\n/**\r\n * Creates a new vec2 initialized with the given values\r\n *\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @returns {vec2} a new 2D vector\r\n */\n\nexport function fromValues(x, y) {\n var out = new glMatrix.ARRAY_TYPE(2);\n out[0] = x;\n out[1] = y;\n return out;\n}\n/**\r\n * Copy the values from one vec2 to another\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the source vector\r\n * @returns {vec2} out\r\n */\n\nexport function copy(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n return out;\n}\n/**\r\n * Set the components of a vec2 to the given values\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @returns {vec2} out\r\n */\n\nexport function set(out, x, y) {\n out[0] = x;\n out[1] = y;\n return out;\n}\n/**\r\n * Adds two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec2} out\r\n */\n\nexport function add(out, a, b) {\n out[0] = a[0] + b[0];\n out[1] = a[1] + b[1];\n return out;\n}\n/**\r\n * Subtracts vector b from vector a\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec2} out\r\n */\n\nexport function subtract(out, a, b) {\n out[0] = a[0] - b[0];\n out[1] = a[1] - b[1];\n return out;\n}\n/**\r\n * Multiplies two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec2} out\r\n */\n\nexport function multiply(out, a, b) {\n out[0] = a[0] * b[0];\n out[1] = a[1] * b[1];\n return out;\n}\n/**\r\n * Divides two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec2} out\r\n */\n\nexport function divide(out, a, b) {\n out[0] = a[0] / b[0];\n out[1] = a[1] / b[1];\n return out;\n}\n/**\r\n * Math.ceil the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a vector to ceil\r\n * @returns {vec2} out\r\n */\n\nexport function ceil(out, a) {\n out[0] = Math.ceil(a[0]);\n out[1] = Math.ceil(a[1]);\n return out;\n}\n/**\r\n * Math.floor the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a vector to floor\r\n * @returns {vec2} out\r\n */\n\nexport function floor(out, a) {\n out[0] = Math.floor(a[0]);\n out[1] = Math.floor(a[1]);\n return out;\n}\n/**\r\n * Returns the minimum of two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec2} out\r\n */\n\nexport function min(out, a, b) {\n out[0] = Math.min(a[0], b[0]);\n out[1] = Math.min(a[1], b[1]);\n return out;\n}\n/**\r\n * Returns the maximum of two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec2} out\r\n */\n\nexport function max(out, a, b) {\n out[0] = Math.max(a[0], b[0]);\n out[1] = Math.max(a[1], b[1]);\n return out;\n}\n/**\r\n * Math.round the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a vector to round\r\n * @returns {vec2} out\r\n */\n\nexport function round(out, a) {\n out[0] = Math.round(a[0]);\n out[1] = Math.round(a[1]);\n return out;\n}\n/**\r\n * Scales a vec2 by a scalar number\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the vector to scale\r\n * @param {Number} b amount to scale the vector by\r\n * @returns {vec2} out\r\n */\n\nexport function scale(out, a, b) {\n out[0] = a[0] * b;\n out[1] = a[1] * b;\n return out;\n}\n/**\r\n * Adds two vec2's after scaling the second operand by a scalar value\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @param {Number} scale the amount to scale b by before adding\r\n * @returns {vec2} out\r\n */\n\nexport function scaleAndAdd(out, a, b, scale) {\n out[0] = a[0] + b[0] * scale;\n out[1] = a[1] + b[1] * scale;\n return out;\n}\n/**\r\n * Calculates the euclidian distance between two vec2's\r\n *\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {Number} distance between a and b\r\n */\n\nexport function distance(a, b) {\n var x = b[0] - a[0],\n y = b[1] - a[1];\n return Math.hypot(x, y);\n}\n/**\r\n * Calculates the squared euclidian distance between two vec2's\r\n *\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {Number} squared distance between a and b\r\n */\n\nexport function squaredDistance(a, b) {\n var x = b[0] - a[0],\n y = b[1] - a[1];\n return x * x + y * y;\n}\n/**\r\n * Calculates the length of a vec2\r\n *\r\n * @param {ReadonlyVec2} a vector to calculate length of\r\n * @returns {Number} length of a\r\n */\n\nexport function length(a) {\n var x = a[0],\n y = a[1];\n return Math.hypot(x, y);\n}\n/**\r\n * Calculates the squared length of a vec2\r\n *\r\n * @param {ReadonlyVec2} a vector to calculate squared length of\r\n * @returns {Number} squared length of a\r\n */\n\nexport function squaredLength(a) {\n var x = a[0],\n y = a[1];\n return x * x + y * y;\n}\n/**\r\n * Negates the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a vector to negate\r\n * @returns {vec2} out\r\n */\n\nexport function negate(out, a) {\n out[0] = -a[0];\n out[1] = -a[1];\n return out;\n}\n/**\r\n * Returns the inverse of the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a vector to invert\r\n * @returns {vec2} out\r\n */\n\nexport function inverse(out, a) {\n out[0] = 1.0 / a[0];\n out[1] = 1.0 / a[1];\n return out;\n}\n/**\r\n * Normalize a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a vector to normalize\r\n * @returns {vec2} out\r\n */\n\nexport function normalize(out, a) {\n var x = a[0],\n y = a[1];\n var len = x * x + y * y;\n\n if (len > 0) {\n //TODO: evaluate use of glm_invsqrt here?\n len = 1 / Math.sqrt(len);\n }\n\n out[0] = a[0] * len;\n out[1] = a[1] * len;\n return out;\n}\n/**\r\n * Calculates the dot product of two vec2's\r\n *\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {Number} dot product of a and b\r\n */\n\nexport function dot(a, b) {\n return a[0] * b[0] + a[1] * b[1];\n}\n/**\r\n * Computes the cross product of two vec2's\r\n * Note that the cross product must by definition produce a 3D vector\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function cross(out, a, b) {\n var z = a[0] * b[1] - a[1] * b[0];\n out[0] = out[1] = 0;\n out[2] = z;\n return out;\n}\n/**\r\n * Performs a linear interpolation between two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec2} out\r\n */\n\nexport function lerp(out, a, b, t) {\n var ax = a[0],\n ay = a[1];\n out[0] = ax + t * (b[0] - ax);\n out[1] = ay + t * (b[1] - ay);\n return out;\n}\n/**\r\n * Generates a random vector with the given scale\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned\r\n * @returns {vec2} out\r\n */\n\nexport function random(out, scale) {\n scale = scale || 1.0;\n var r = glMatrix.RANDOM() * 2.0 * Math.PI;\n out[0] = Math.cos(r) * scale;\n out[1] = Math.sin(r) * scale;\n return out;\n}\n/**\r\n * Transforms the vec2 with a mat2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the vector to transform\r\n * @param {ReadonlyMat2} m matrix to transform with\r\n * @returns {vec2} out\r\n */\n\nexport function transformMat2(out, a, m) {\n var x = a[0],\n y = a[1];\n out[0] = m[0] * x + m[2] * y;\n out[1] = m[1] * x + m[3] * y;\n return out;\n}\n/**\r\n * Transforms the vec2 with a mat2d\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the vector to transform\r\n * @param {ReadonlyMat2d} m matrix to transform with\r\n * @returns {vec2} out\r\n */\n\nexport function transformMat2d(out, a, m) {\n var x = a[0],\n y = a[1];\n out[0] = m[0] * x + m[2] * y + m[4];\n out[1] = m[1] * x + m[3] * y + m[5];\n return out;\n}\n/**\r\n * Transforms the vec2 with a mat3\r\n * 3rd vector component is implicitly '1'\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the vector to transform\r\n * @param {ReadonlyMat3} m matrix to transform with\r\n * @returns {vec2} out\r\n */\n\nexport function transformMat3(out, a, m) {\n var x = a[0],\n y = a[1];\n out[0] = m[0] * x + m[3] * y + m[6];\n out[1] = m[1] * x + m[4] * y + m[7];\n return out;\n}\n/**\r\n * Transforms the vec2 with a mat4\r\n * 3rd vector component is implicitly '0'\r\n * 4th vector component is implicitly '1'\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the vector to transform\r\n * @param {ReadonlyMat4} m matrix to transform with\r\n * @returns {vec2} out\r\n */\n\nexport function transformMat4(out, a, m) {\n var x = a[0];\n var y = a[1];\n out[0] = m[0] * x + m[4] * y + m[12];\n out[1] = m[1] * x + m[5] * y + m[13];\n return out;\n}\n/**\r\n * Rotate a 2D vector\r\n * @param {vec2} out The receiving vec2\r\n * @param {ReadonlyVec2} a The vec2 point to rotate\r\n * @param {ReadonlyVec2} b The origin of the rotation\r\n * @param {Number} rad The angle of rotation in radians\r\n * @returns {vec2} out\r\n */\n\nexport function rotate(out, a, b, rad) {\n //Translate point to the origin\n var p0 = a[0] - b[0],\n p1 = a[1] - b[1],\n sinC = Math.sin(rad),\n cosC = Math.cos(rad); //perform rotation and translate to correct position\n\n out[0] = p0 * cosC - p1 * sinC + b[0];\n out[1] = p0 * sinC + p1 * cosC + b[1];\n return out;\n}\n/**\r\n * Get the angle between two 2D vectors\r\n * @param {ReadonlyVec2} a The first operand\r\n * @param {ReadonlyVec2} b The second operand\r\n * @returns {Number} The angle in radians\r\n */\n\nexport function angle(a, b) {\n var x1 = a[0],\n y1 = a[1],\n x2 = b[0],\n y2 = b[1],\n // mag is the product of the magnitudes of a and b\n mag = Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2),\n // mag &&.. short circuits if mag == 0\n cosine = mag && (x1 * x2 + y1 * y2) / mag; // Math.min(Math.max(cosine, -1), 1) clamps the cosine between -1 and 1\n\n return Math.acos(Math.min(Math.max(cosine, -1), 1));\n}\n/**\r\n * Set the components of a vec2 to zero\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @returns {vec2} out\r\n */\n\nexport function zero(out) {\n out[0] = 0.0;\n out[1] = 0.0;\n return out;\n}\n/**\r\n * Returns a string representation of a vector\r\n *\r\n * @param {ReadonlyVec2} a vector to represent as a string\r\n * @returns {String} string representation of the vector\r\n */\n\nexport function str(a) {\n return \"vec2(\" + a[0] + \", \" + a[1] + \")\";\n}\n/**\r\n * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)\r\n *\r\n * @param {ReadonlyVec2} a The first vector.\r\n * @param {ReadonlyVec2} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport function exactEquals(a, b) {\n return a[0] === b[0] && a[1] === b[1];\n}\n/**\r\n * Returns whether or not the vectors have approximately the same elements in the same position.\r\n *\r\n * @param {ReadonlyVec2} a The first vector.\r\n * @param {ReadonlyVec2} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport function equals(a, b) {\n var a0 = a[0],\n a1 = a[1];\n var b0 = b[0],\n b1 = b[1];\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1));\n}\n/**\r\n * Alias for {@link vec2.length}\r\n * @function\r\n */\n\nexport var len = length;\n/**\r\n * Alias for {@link vec2.subtract}\r\n * @function\r\n */\n\nexport var sub = subtract;\n/**\r\n * Alias for {@link vec2.multiply}\r\n * @function\r\n */\n\nexport var mul = multiply;\n/**\r\n * Alias for {@link vec2.divide}\r\n * @function\r\n */\n\nexport var div = divide;\n/**\r\n * Alias for {@link vec2.distance}\r\n * @function\r\n */\n\nexport var dist = distance;\n/**\r\n * Alias for {@link vec2.squaredDistance}\r\n * @function\r\n */\n\nexport var sqrDist = squaredDistance;\n/**\r\n * Alias for {@link vec2.squaredLength}\r\n * @function\r\n */\n\nexport var sqrLen = squaredLength;\n/**\r\n * Perform some operation over an array of vec2s.\r\n *\r\n * @param {Array} a the array of vectors to iterate over\r\n * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed\r\n * @param {Number} offset Number of elements to skip at the beginning of the array\r\n * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array\r\n * @param {Function} fn Function to call for each vector in the array\r\n * @param {Object} [arg] additional argument to pass to fn\r\n * @returns {Array} a\r\n * @function\r\n */\n\nexport var forEach = function () {\n var vec = create();\n return function (a, stride, offset, count, fn, arg) {\n var i, l;\n\n if (!stride) {\n stride = 2;\n }\n\n if (!offset) {\n offset = 0;\n }\n\n if (count) {\n l = Math.min(count * stride + offset, a.length);\n } else {\n l = a.length;\n }\n\n for (i = offset; i < l; i += stride) {\n vec[0] = a[i];\n vec[1] = a[i + 1];\n fn(vec, vec, arg);\n a[i] = vec[0];\n a[i + 1] = vec[1];\n }\n\n return a;\n };\n}();","import * as glMatrix from \"./common.js\";\n/**\r\n * 3 Dimensional Vector\r\n * @module vec3\r\n */\n\n/**\r\n * Creates a new, empty vec3\r\n *\r\n * @returns {vec3} a new 3D vector\r\n */\n\nexport function create() {\n var out = new glMatrix.ARRAY_TYPE(3);\n\n if (glMatrix.ARRAY_TYPE != Float32Array) {\n out[0] = 0;\n out[1] = 0;\n out[2] = 0;\n }\n\n return out;\n}\n/**\r\n * Creates a new vec3 initialized with values from an existing vector\r\n *\r\n * @param {ReadonlyVec3} a vector to clone\r\n * @returns {vec3} a new 3D vector\r\n */\n\nexport function clone(a) {\n var out = new glMatrix.ARRAY_TYPE(3);\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n return out;\n}\n/**\r\n * Calculates the length of a vec3\r\n *\r\n * @param {ReadonlyVec3} a vector to calculate length of\r\n * @returns {Number} length of a\r\n */\n\nexport function length(a) {\n var x = a[0];\n var y = a[1];\n var z = a[2];\n return Math.hypot(x, y, z);\n}\n/**\r\n * Creates a new vec3 initialized with the given values\r\n *\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @returns {vec3} a new 3D vector\r\n */\n\nexport function fromValues(x, y, z) {\n var out = new glMatrix.ARRAY_TYPE(3);\n out[0] = x;\n out[1] = y;\n out[2] = z;\n return out;\n}\n/**\r\n * Copy the values from one vec3 to another\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the source vector\r\n * @returns {vec3} out\r\n */\n\nexport function copy(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n return out;\n}\n/**\r\n * Set the components of a vec3 to the given values\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @returns {vec3} out\r\n */\n\nexport function set(out, x, y, z) {\n out[0] = x;\n out[1] = y;\n out[2] = z;\n return out;\n}\n/**\r\n * Adds two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function add(out, a, b) {\n out[0] = a[0] + b[0];\n out[1] = a[1] + b[1];\n out[2] = a[2] + b[2];\n return out;\n}\n/**\r\n * Subtracts vector b from vector a\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function subtract(out, a, b) {\n out[0] = a[0] - b[0];\n out[1] = a[1] - b[1];\n out[2] = a[2] - b[2];\n return out;\n}\n/**\r\n * Multiplies two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function multiply(out, a, b) {\n out[0] = a[0] * b[0];\n out[1] = a[1] * b[1];\n out[2] = a[2] * b[2];\n return out;\n}\n/**\r\n * Divides two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function divide(out, a, b) {\n out[0] = a[0] / b[0];\n out[1] = a[1] / b[1];\n out[2] = a[2] / b[2];\n return out;\n}\n/**\r\n * Math.ceil the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a vector to ceil\r\n * @returns {vec3} out\r\n */\n\nexport function ceil(out, a) {\n out[0] = Math.ceil(a[0]);\n out[1] = Math.ceil(a[1]);\n out[2] = Math.ceil(a[2]);\n return out;\n}\n/**\r\n * Math.floor the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a vector to floor\r\n * @returns {vec3} out\r\n */\n\nexport function floor(out, a) {\n out[0] = Math.floor(a[0]);\n out[1] = Math.floor(a[1]);\n out[2] = Math.floor(a[2]);\n return out;\n}\n/**\r\n * Returns the minimum of two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function min(out, a, b) {\n out[0] = Math.min(a[0], b[0]);\n out[1] = Math.min(a[1], b[1]);\n out[2] = Math.min(a[2], b[2]);\n return out;\n}\n/**\r\n * Returns the maximum of two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function max(out, a, b) {\n out[0] = Math.max(a[0], b[0]);\n out[1] = Math.max(a[1], b[1]);\n out[2] = Math.max(a[2], b[2]);\n return out;\n}\n/**\r\n * Math.round the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a vector to round\r\n * @returns {vec3} out\r\n */\n\nexport function round(out, a) {\n out[0] = Math.round(a[0]);\n out[1] = Math.round(a[1]);\n out[2] = Math.round(a[2]);\n return out;\n}\n/**\r\n * Scales a vec3 by a scalar number\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the vector to scale\r\n * @param {Number} b amount to scale the vector by\r\n * @returns {vec3} out\r\n */\n\nexport function scale(out, a, b) {\n out[0] = a[0] * b;\n out[1] = a[1] * b;\n out[2] = a[2] * b;\n return out;\n}\n/**\r\n * Adds two vec3's after scaling the second operand by a scalar value\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @param {Number} scale the amount to scale b by before adding\r\n * @returns {vec3} out\r\n */\n\nexport function scaleAndAdd(out, a, b, scale) {\n out[0] = a[0] + b[0] * scale;\n out[1] = a[1] + b[1] * scale;\n out[2] = a[2] + b[2] * scale;\n return out;\n}\n/**\r\n * Calculates the euclidian distance between two vec3's\r\n *\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {Number} distance between a and b\r\n */\n\nexport function distance(a, b) {\n var x = b[0] - a[0];\n var y = b[1] - a[1];\n var z = b[2] - a[2];\n return Math.hypot(x, y, z);\n}\n/**\r\n * Calculates the squared euclidian distance between two vec3's\r\n *\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {Number} squared distance between a and b\r\n */\n\nexport function squaredDistance(a, b) {\n var x = b[0] - a[0];\n var y = b[1] - a[1];\n var z = b[2] - a[2];\n return x * x + y * y + z * z;\n}\n/**\r\n * Calculates the squared length of a vec3\r\n *\r\n * @param {ReadonlyVec3} a vector to calculate squared length of\r\n * @returns {Number} squared length of a\r\n */\n\nexport function squaredLength(a) {\n var x = a[0];\n var y = a[1];\n var z = a[2];\n return x * x + y * y + z * z;\n}\n/**\r\n * Negates the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a vector to negate\r\n * @returns {vec3} out\r\n */\n\nexport function negate(out, a) {\n out[0] = -a[0];\n out[1] = -a[1];\n out[2] = -a[2];\n return out;\n}\n/**\r\n * Returns the inverse of the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a vector to invert\r\n * @returns {vec3} out\r\n */\n\nexport function inverse(out, a) {\n out[0] = 1.0 / a[0];\n out[1] = 1.0 / a[1];\n out[2] = 1.0 / a[2];\n return out;\n}\n/**\r\n * Normalize a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a vector to normalize\r\n * @returns {vec3} out\r\n */\n\nexport function normalize(out, a) {\n var x = a[0];\n var y = a[1];\n var z = a[2];\n var len = x * x + y * y + z * z;\n\n if (len > 0) {\n //TODO: evaluate use of glm_invsqrt here?\n len = 1 / Math.sqrt(len);\n }\n\n out[0] = a[0] * len;\n out[1] = a[1] * len;\n out[2] = a[2] * len;\n return out;\n}\n/**\r\n * Calculates the dot product of two vec3's\r\n *\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {Number} dot product of a and b\r\n */\n\nexport function dot(a, b) {\n return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\n}\n/**\r\n * Computes the cross product of two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function cross(out, a, b) {\n var ax = a[0],\n ay = a[1],\n az = a[2];\n var bx = b[0],\n by = b[1],\n bz = b[2];\n out[0] = ay * bz - az * by;\n out[1] = az * bx - ax * bz;\n out[2] = ax * by - ay * bx;\n return out;\n}\n/**\r\n * Performs a linear interpolation between two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec3} out\r\n */\n\nexport function lerp(out, a, b, t) {\n var ax = a[0];\n var ay = a[1];\n var az = a[2];\n out[0] = ax + t * (b[0] - ax);\n out[1] = ay + t * (b[1] - ay);\n out[2] = az + t * (b[2] - az);\n return out;\n}\n/**\r\n * Performs a hermite interpolation with two control points\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @param {ReadonlyVec3} c the third operand\r\n * @param {ReadonlyVec3} d the fourth operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec3} out\r\n */\n\nexport function hermite(out, a, b, c, d, t) {\n var factorTimes2 = t * t;\n var factor1 = factorTimes2 * (2 * t - 3) + 1;\n var factor2 = factorTimes2 * (t - 2) + t;\n var factor3 = factorTimes2 * (t - 1);\n var factor4 = factorTimes2 * (3 - 2 * t);\n out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;\n out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;\n out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;\n return out;\n}\n/**\r\n * Performs a bezier interpolation with two control points\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @param {ReadonlyVec3} c the third operand\r\n * @param {ReadonlyVec3} d the fourth operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec3} out\r\n */\n\nexport function bezier(out, a, b, c, d, t) {\n var inverseFactor = 1 - t;\n var inverseFactorTimesTwo = inverseFactor * inverseFactor;\n var factorTimes2 = t * t;\n var factor1 = inverseFactorTimesTwo * inverseFactor;\n var factor2 = 3 * t * inverseFactorTimesTwo;\n var factor3 = 3 * factorTimes2 * inverseFactor;\n var factor4 = factorTimes2 * t;\n out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;\n out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;\n out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;\n return out;\n}\n/**\r\n * Generates a random vector with the given scale\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned\r\n * @returns {vec3} out\r\n */\n\nexport function random(out, scale) {\n scale = scale || 1.0;\n var r = glMatrix.RANDOM() * 2.0 * Math.PI;\n var z = glMatrix.RANDOM() * 2.0 - 1.0;\n var zScale = Math.sqrt(1.0 - z * z) * scale;\n out[0] = Math.cos(r) * zScale;\n out[1] = Math.sin(r) * zScale;\n out[2] = z * scale;\n return out;\n}\n/**\r\n * Transforms the vec3 with a mat4.\r\n * 4th vector component is implicitly '1'\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the vector to transform\r\n * @param {ReadonlyMat4} m matrix to transform with\r\n * @returns {vec3} out\r\n */\n\nexport function transformMat4(out, a, m) {\n var x = a[0],\n y = a[1],\n z = a[2];\n var w = m[3] * x + m[7] * y + m[11] * z + m[15];\n w = w || 1.0;\n out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;\n out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;\n out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;\n return out;\n}\n/**\r\n * Transforms the vec3 with a mat3.\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the vector to transform\r\n * @param {ReadonlyMat3} m the 3x3 matrix to transform with\r\n * @returns {vec3} out\r\n */\n\nexport function transformMat3(out, a, m) {\n var x = a[0],\n y = a[1],\n z = a[2];\n out[0] = x * m[0] + y * m[3] + z * m[6];\n out[1] = x * m[1] + y * m[4] + z * m[7];\n out[2] = x * m[2] + y * m[5] + z * m[8];\n return out;\n}\n/**\r\n * Transforms the vec3 with a quat\r\n * Can also be used for dual quaternions. (Multiply it with the real part)\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the vector to transform\r\n * @param {ReadonlyQuat} q quaternion to transform with\r\n * @returns {vec3} out\r\n */\n\nexport function transformQuat(out, a, q) {\n // benchmarks: https://jsperf.com/quaternion-transform-vec3-implementations-fixed\n var qx = q[0],\n qy = q[1],\n qz = q[2],\n qw = q[3];\n var x = a[0],\n y = a[1],\n z = a[2]; // var qvec = [qx, qy, qz];\n // var uv = vec3.cross([], qvec, a);\n\n var uvx = qy * z - qz * y,\n uvy = qz * x - qx * z,\n uvz = qx * y - qy * x; // var uuv = vec3.cross([], qvec, uv);\n\n var uuvx = qy * uvz - qz * uvy,\n uuvy = qz * uvx - qx * uvz,\n uuvz = qx * uvy - qy * uvx; // vec3.scale(uv, uv, 2 * w);\n\n var w2 = qw * 2;\n uvx *= w2;\n uvy *= w2;\n uvz *= w2; // vec3.scale(uuv, uuv, 2);\n\n uuvx *= 2;\n uuvy *= 2;\n uuvz *= 2; // return vec3.add(out, a, vec3.add(out, uv, uuv));\n\n out[0] = x + uvx + uuvx;\n out[1] = y + uvy + uuvy;\n out[2] = z + uvz + uuvz;\n return out;\n}\n/**\r\n * Rotate a 3D vector around the x-axis\r\n * @param {vec3} out The receiving vec3\r\n * @param {ReadonlyVec3} a The vec3 point to rotate\r\n * @param {ReadonlyVec3} b The origin of the rotation\r\n * @param {Number} rad The angle of rotation in radians\r\n * @returns {vec3} out\r\n */\n\nexport function rotateX(out, a, b, rad) {\n var p = [],\n r = []; //Translate point to the origin\n\n p[0] = a[0] - b[0];\n p[1] = a[1] - b[1];\n p[2] = a[2] - b[2]; //perform rotation\n\n r[0] = p[0];\n r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);\n r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad); //translate to correct position\n\n out[0] = r[0] + b[0];\n out[1] = r[1] + b[1];\n out[2] = r[2] + b[2];\n return out;\n}\n/**\r\n * Rotate a 3D vector around the y-axis\r\n * @param {vec3} out The receiving vec3\r\n * @param {ReadonlyVec3} a The vec3 point to rotate\r\n * @param {ReadonlyVec3} b The origin of the rotation\r\n * @param {Number} rad The angle of rotation in radians\r\n * @returns {vec3} out\r\n */\n\nexport function rotateY(out, a, b, rad) {\n var p = [],\n r = []; //Translate point to the origin\n\n p[0] = a[0] - b[0];\n p[1] = a[1] - b[1];\n p[2] = a[2] - b[2]; //perform rotation\n\n r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);\n r[1] = p[1];\n r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad); //translate to correct position\n\n out[0] = r[0] + b[0];\n out[1] = r[1] + b[1];\n out[2] = r[2] + b[2];\n return out;\n}\n/**\r\n * Rotate a 3D vector around the z-axis\r\n * @param {vec3} out The receiving vec3\r\n * @param {ReadonlyVec3} a The vec3 point to rotate\r\n * @param {ReadonlyVec3} b The origin of the rotation\r\n * @param {Number} rad The angle of rotation in radians\r\n * @returns {vec3} out\r\n */\n\nexport function rotateZ(out, a, b, rad) {\n var p = [],\n r = []; //Translate point to the origin\n\n p[0] = a[0] - b[0];\n p[1] = a[1] - b[1];\n p[2] = a[2] - b[2]; //perform rotation\n\n r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);\n r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);\n r[2] = p[2]; //translate to correct position\n\n out[0] = r[0] + b[0];\n out[1] = r[1] + b[1];\n out[2] = r[2] + b[2];\n return out;\n}\n/**\r\n * Get the angle between two 3D vectors\r\n * @param {ReadonlyVec3} a The first operand\r\n * @param {ReadonlyVec3} b The second operand\r\n * @returns {Number} The angle in radians\r\n */\n\nexport function angle(a, b) {\n var ax = a[0],\n ay = a[1],\n az = a[2],\n bx = b[0],\n by = b[1],\n bz = b[2],\n mag1 = Math.sqrt(ax * ax + ay * ay + az * az),\n mag2 = Math.sqrt(bx * bx + by * by + bz * bz),\n mag = mag1 * mag2,\n cosine = mag && dot(a, b) / mag;\n return Math.acos(Math.min(Math.max(cosine, -1), 1));\n}\n/**\r\n * Set the components of a vec3 to zero\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @returns {vec3} out\r\n */\n\nexport function zero(out) {\n out[0] = 0.0;\n out[1] = 0.0;\n out[2] = 0.0;\n return out;\n}\n/**\r\n * Returns a string representation of a vector\r\n *\r\n * @param {ReadonlyVec3} a vector to represent as a string\r\n * @returns {String} string representation of the vector\r\n */\n\nexport function str(a) {\n return \"vec3(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \")\";\n}\n/**\r\n * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {ReadonlyVec3} a The first vector.\r\n * @param {ReadonlyVec3} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport function exactEquals(a, b) {\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];\n}\n/**\r\n * Returns whether or not the vectors have approximately the same elements in the same position.\r\n *\r\n * @param {ReadonlyVec3} a The first vector.\r\n * @param {ReadonlyVec3} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport function equals(a, b) {\n var a0 = a[0],\n a1 = a[1],\n a2 = a[2];\n var b0 = b[0],\n b1 = b[1],\n b2 = b[2];\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2));\n}\n/**\r\n * Alias for {@link vec3.subtract}\r\n * @function\r\n */\n\nexport var sub = subtract;\n/**\r\n * Alias for {@link vec3.multiply}\r\n * @function\r\n */\n\nexport var mul = multiply;\n/**\r\n * Alias for {@link vec3.divide}\r\n * @function\r\n */\n\nexport var div = divide;\n/**\r\n * Alias for {@link vec3.distance}\r\n * @function\r\n */\n\nexport var dist = distance;\n/**\r\n * Alias for {@link vec3.squaredDistance}\r\n * @function\r\n */\n\nexport var sqrDist = squaredDistance;\n/**\r\n * Alias for {@link vec3.length}\r\n * @function\r\n */\n\nexport var len = length;\n/**\r\n * Alias for {@link vec3.squaredLength}\r\n * @function\r\n */\n\nexport var sqrLen = squaredLength;\n/**\r\n * Perform some operation over an array of vec3s.\r\n *\r\n * @param {Array} a the array of vectors to iterate over\r\n * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed\r\n * @param {Number} offset Number of elements to skip at the beginning of the array\r\n * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array\r\n * @param {Function} fn Function to call for each vector in the array\r\n * @param {Object} [arg] additional argument to pass to fn\r\n * @returns {Array} a\r\n * @function\r\n */\n\nexport var forEach = function () {\n var vec = create();\n return function (a, stride, offset, count, fn, arg) {\n var i, l;\n\n if (!stride) {\n stride = 3;\n }\n\n if (!offset) {\n offset = 0;\n }\n\n if (count) {\n l = Math.min(count * stride + offset, a.length);\n } else {\n l = a.length;\n }\n\n for (i = offset; i < l; i += stride) {\n vec[0] = a[i];\n vec[1] = a[i + 1];\n vec[2] = a[i + 2];\n fn(vec, vec, arg);\n a[i] = vec[0];\n a[i + 1] = vec[1];\n a[i + 2] = vec[2];\n }\n\n return a;\n };\n}();","import * as glMatrix from \"./common.js\";\n/**\r\n * 4 Dimensional Vector\r\n * @module vec4\r\n */\n\n/**\r\n * Creates a new, empty vec4\r\n *\r\n * @returns {vec4} a new 4D vector\r\n */\n\nexport function create() {\n var out = new glMatrix.ARRAY_TYPE(4);\n\n if (glMatrix.ARRAY_TYPE != Float32Array) {\n out[0] = 0;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n }\n\n return out;\n}\n/**\r\n * Creates a new vec4 initialized with values from an existing vector\r\n *\r\n * @param {ReadonlyVec4} a vector to clone\r\n * @returns {vec4} a new 4D vector\r\n */\n\nexport function clone(a) {\n var out = new glMatrix.ARRAY_TYPE(4);\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n return out;\n}\n/**\r\n * Creates a new vec4 initialized with the given values\r\n *\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @param {Number} w W component\r\n * @returns {vec4} a new 4D vector\r\n */\n\nexport function fromValues(x, y, z, w) {\n var out = new glMatrix.ARRAY_TYPE(4);\n out[0] = x;\n out[1] = y;\n out[2] = z;\n out[3] = w;\n return out;\n}\n/**\r\n * Copy the values from one vec4 to another\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the source vector\r\n * @returns {vec4} out\r\n */\n\nexport function copy(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n return out;\n}\n/**\r\n * Set the components of a vec4 to the given values\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @param {Number} w W component\r\n * @returns {vec4} out\r\n */\n\nexport function set(out, x, y, z, w) {\n out[0] = x;\n out[1] = y;\n out[2] = z;\n out[3] = w;\n return out;\n}\n/**\r\n * Adds two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {vec4} out\r\n */\n\nexport function add(out, a, b) {\n out[0] = a[0] + b[0];\n out[1] = a[1] + b[1];\n out[2] = a[2] + b[2];\n out[3] = a[3] + b[3];\n return out;\n}\n/**\r\n * Subtracts vector b from vector a\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {vec4} out\r\n */\n\nexport function subtract(out, a, b) {\n out[0] = a[0] - b[0];\n out[1] = a[1] - b[1];\n out[2] = a[2] - b[2];\n out[3] = a[3] - b[3];\n return out;\n}\n/**\r\n * Multiplies two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {vec4} out\r\n */\n\nexport function multiply(out, a, b) {\n out[0] = a[0] * b[0];\n out[1] = a[1] * b[1];\n out[2] = a[2] * b[2];\n out[3] = a[3] * b[3];\n return out;\n}\n/**\r\n * Divides two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {vec4} out\r\n */\n\nexport function divide(out, a, b) {\n out[0] = a[0] / b[0];\n out[1] = a[1] / b[1];\n out[2] = a[2] / b[2];\n out[3] = a[3] / b[3];\n return out;\n}\n/**\r\n * Math.ceil the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a vector to ceil\r\n * @returns {vec4} out\r\n */\n\nexport function ceil(out, a) {\n out[0] = Math.ceil(a[0]);\n out[1] = Math.ceil(a[1]);\n out[2] = Math.ceil(a[2]);\n out[3] = Math.ceil(a[3]);\n return out;\n}\n/**\r\n * Math.floor the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a vector to floor\r\n * @returns {vec4} out\r\n */\n\nexport function floor(out, a) {\n out[0] = Math.floor(a[0]);\n out[1] = Math.floor(a[1]);\n out[2] = Math.floor(a[2]);\n out[3] = Math.floor(a[3]);\n return out;\n}\n/**\r\n * Returns the minimum of two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {vec4} out\r\n */\n\nexport function min(out, a, b) {\n out[0] = Math.min(a[0], b[0]);\n out[1] = Math.min(a[1], b[1]);\n out[2] = Math.min(a[2], b[2]);\n out[3] = Math.min(a[3], b[3]);\n return out;\n}\n/**\r\n * Returns the maximum of two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {vec4} out\r\n */\n\nexport function max(out, a, b) {\n out[0] = Math.max(a[0], b[0]);\n out[1] = Math.max(a[1], b[1]);\n out[2] = Math.max(a[2], b[2]);\n out[3] = Math.max(a[3], b[3]);\n return out;\n}\n/**\r\n * Math.round the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a vector to round\r\n * @returns {vec4} out\r\n */\n\nexport function round(out, a) {\n out[0] = Math.round(a[0]);\n out[1] = Math.round(a[1]);\n out[2] = Math.round(a[2]);\n out[3] = Math.round(a[3]);\n return out;\n}\n/**\r\n * Scales a vec4 by a scalar number\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the vector to scale\r\n * @param {Number} b amount to scale the vector by\r\n * @returns {vec4} out\r\n */\n\nexport function scale(out, a, b) {\n out[0] = a[0] * b;\n out[1] = a[1] * b;\n out[2] = a[2] * b;\n out[3] = a[3] * b;\n return out;\n}\n/**\r\n * Adds two vec4's after scaling the second operand by a scalar value\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @param {Number} scale the amount to scale b by before adding\r\n * @returns {vec4} out\r\n */\n\nexport function scaleAndAdd(out, a, b, scale) {\n out[0] = a[0] + b[0] * scale;\n out[1] = a[1] + b[1] * scale;\n out[2] = a[2] + b[2] * scale;\n out[3] = a[3] + b[3] * scale;\n return out;\n}\n/**\r\n * Calculates the euclidian distance between two vec4's\r\n *\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {Number} distance between a and b\r\n */\n\nexport function distance(a, b) {\n var x = b[0] - a[0];\n var y = b[1] - a[1];\n var z = b[2] - a[2];\n var w = b[3] - a[3];\n return Math.hypot(x, y, z, w);\n}\n/**\r\n * Calculates the squared euclidian distance between two vec4's\r\n *\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {Number} squared distance between a and b\r\n */\n\nexport function squaredDistance(a, b) {\n var x = b[0] - a[0];\n var y = b[1] - a[1];\n var z = b[2] - a[2];\n var w = b[3] - a[3];\n return x * x + y * y + z * z + w * w;\n}\n/**\r\n * Calculates the length of a vec4\r\n *\r\n * @param {ReadonlyVec4} a vector to calculate length of\r\n * @returns {Number} length of a\r\n */\n\nexport function length(a) {\n var x = a[0];\n var y = a[1];\n var z = a[2];\n var w = a[3];\n return Math.hypot(x, y, z, w);\n}\n/**\r\n * Calculates the squared length of a vec4\r\n *\r\n * @param {ReadonlyVec4} a vector to calculate squared length of\r\n * @returns {Number} squared length of a\r\n */\n\nexport function squaredLength(a) {\n var x = a[0];\n var y = a[1];\n var z = a[2];\n var w = a[3];\n return x * x + y * y + z * z + w * w;\n}\n/**\r\n * Negates the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a vector to negate\r\n * @returns {vec4} out\r\n */\n\nexport function negate(out, a) {\n out[0] = -a[0];\n out[1] = -a[1];\n out[2] = -a[2];\n out[3] = -a[3];\n return out;\n}\n/**\r\n * Returns the inverse of the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a vector to invert\r\n * @returns {vec4} out\r\n */\n\nexport function inverse(out, a) {\n out[0] = 1.0 / a[0];\n out[1] = 1.0 / a[1];\n out[2] = 1.0 / a[2];\n out[3] = 1.0 / a[3];\n return out;\n}\n/**\r\n * Normalize a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a vector to normalize\r\n * @returns {vec4} out\r\n */\n\nexport function normalize(out, a) {\n var x = a[0];\n var y = a[1];\n var z = a[2];\n var w = a[3];\n var len = x * x + y * y + z * z + w * w;\n\n if (len > 0) {\n len = 1 / Math.sqrt(len);\n }\n\n out[0] = x * len;\n out[1] = y * len;\n out[2] = z * len;\n out[3] = w * len;\n return out;\n}\n/**\r\n * Calculates the dot product of two vec4's\r\n *\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {Number} dot product of a and b\r\n */\n\nexport function dot(a, b) {\n return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];\n}\n/**\r\n * Returns the cross-product of three vectors in a 4-dimensional space\r\n *\r\n * @param {ReadonlyVec4} result the receiving vector\r\n * @param {ReadonlyVec4} U the first vector\r\n * @param {ReadonlyVec4} V the second vector\r\n * @param {ReadonlyVec4} W the third vector\r\n * @returns {vec4} result\r\n */\n\nexport function cross(out, u, v, w) {\n var A = v[0] * w[1] - v[1] * w[0],\n B = v[0] * w[2] - v[2] * w[0],\n C = v[0] * w[3] - v[3] * w[0],\n D = v[1] * w[2] - v[2] * w[1],\n E = v[1] * w[3] - v[3] * w[1],\n F = v[2] * w[3] - v[3] * w[2];\n var G = u[0];\n var H = u[1];\n var I = u[2];\n var J = u[3];\n out[0] = H * F - I * E + J * D;\n out[1] = -(G * F) + I * C - J * B;\n out[2] = G * E - H * C + J * A;\n out[3] = -(G * D) + H * B - I * A;\n return out;\n}\n/**\r\n * Performs a linear interpolation between two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec4} out\r\n */\n\nexport function lerp(out, a, b, t) {\n var ax = a[0];\n var ay = a[1];\n var az = a[2];\n var aw = a[3];\n out[0] = ax + t * (b[0] - ax);\n out[1] = ay + t * (b[1] - ay);\n out[2] = az + t * (b[2] - az);\n out[3] = aw + t * (b[3] - aw);\n return out;\n}\n/**\r\n * Generates a random vector with the given scale\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned\r\n * @returns {vec4} out\r\n */\n\nexport function random(out, scale) {\n scale = scale || 1.0; // Marsaglia, George. Choosing a Point from the Surface of a\n // Sphere. Ann. Math. Statist. 43 (1972), no. 2, 645--646.\n // http://projecteuclid.org/euclid.aoms/1177692644;\n\n var v1, v2, v3, v4;\n var s1, s2;\n\n do {\n v1 = glMatrix.RANDOM() * 2 - 1;\n v2 = glMatrix.RANDOM() * 2 - 1;\n s1 = v1 * v1 + v2 * v2;\n } while (s1 >= 1);\n\n do {\n v3 = glMatrix.RANDOM() * 2 - 1;\n v4 = glMatrix.RANDOM() * 2 - 1;\n s2 = v3 * v3 + v4 * v4;\n } while (s2 >= 1);\n\n var d = Math.sqrt((1 - s1) / s2);\n out[0] = scale * v1;\n out[1] = scale * v2;\n out[2] = scale * v3 * d;\n out[3] = scale * v4 * d;\n return out;\n}\n/**\r\n * Transforms the vec4 with a mat4.\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the vector to transform\r\n * @param {ReadonlyMat4} m matrix to transform with\r\n * @returns {vec4} out\r\n */\n\nexport function transformMat4(out, a, m) {\n var x = a[0],\n y = a[1],\n z = a[2],\n w = a[3];\n out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;\n out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;\n out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;\n out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;\n return out;\n}\n/**\r\n * Transforms the vec4 with a quat\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the vector to transform\r\n * @param {ReadonlyQuat} q quaternion to transform with\r\n * @returns {vec4} out\r\n */\n\nexport function transformQuat(out, a, q) {\n var x = a[0],\n y = a[1],\n z = a[2];\n var qx = q[0],\n qy = q[1],\n qz = q[2],\n qw = q[3]; // calculate quat * vec\n\n var ix = qw * x + qy * z - qz * y;\n var iy = qw * y + qz * x - qx * z;\n var iz = qw * z + qx * y - qy * x;\n var iw = -qx * x - qy * y - qz * z; // calculate result * inverse quat\n\n out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;\n out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;\n out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;\n out[3] = a[3];\n return out;\n}\n/**\r\n * Set the components of a vec4 to zero\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @returns {vec4} out\r\n */\n\nexport function zero(out) {\n out[0] = 0.0;\n out[1] = 0.0;\n out[2] = 0.0;\n out[3] = 0.0;\n return out;\n}\n/**\r\n * Returns a string representation of a vector\r\n *\r\n * @param {ReadonlyVec4} a vector to represent as a string\r\n * @returns {String} string representation of the vector\r\n */\n\nexport function str(a) {\n return \"vec4(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \", \" + a[3] + \")\";\n}\n/**\r\n * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {ReadonlyVec4} a The first vector.\r\n * @param {ReadonlyVec4} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport function exactEquals(a, b) {\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];\n}\n/**\r\n * Returns whether or not the vectors have approximately the same elements in the same position.\r\n *\r\n * @param {ReadonlyVec4} a The first vector.\r\n * @param {ReadonlyVec4} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport function equals(a, b) {\n var a0 = a[0],\n a1 = a[1],\n a2 = a[2],\n a3 = a[3];\n var b0 = b[0],\n b1 = b[1],\n b2 = b[2],\n b3 = b[3];\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3));\n}\n/**\r\n * Alias for {@link vec4.subtract}\r\n * @function\r\n */\n\nexport var sub = subtract;\n/**\r\n * Alias for {@link vec4.multiply}\r\n * @function\r\n */\n\nexport var mul = multiply;\n/**\r\n * Alias for {@link vec4.divide}\r\n * @function\r\n */\n\nexport var div = divide;\n/**\r\n * Alias for {@link vec4.distance}\r\n * @function\r\n */\n\nexport var dist = distance;\n/**\r\n * Alias for {@link vec4.squaredDistance}\r\n * @function\r\n */\n\nexport var sqrDist = squaredDistance;\n/**\r\n * Alias for {@link vec4.length}\r\n * @function\r\n */\n\nexport var len = length;\n/**\r\n * Alias for {@link vec4.squaredLength}\r\n * @function\r\n */\n\nexport var sqrLen = squaredLength;\n/**\r\n * Perform some operation over an array of vec4s.\r\n *\r\n * @param {Array} a the array of vectors to iterate over\r\n * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed\r\n * @param {Number} offset Number of elements to skip at the beginning of the array\r\n * @param {Number} count Number of vec4s to iterate over. If 0 iterates over entire array\r\n * @param {Function} fn Function to call for each vector in the array\r\n * @param {Object} [arg] additional argument to pass to fn\r\n * @returns {Array} a\r\n * @function\r\n */\n\nexport var forEach = function () {\n var vec = create();\n return function (a, stride, offset, count, fn, arg) {\n var i, l;\n\n if (!stride) {\n stride = 4;\n }\n\n if (!offset) {\n offset = 0;\n }\n\n if (count) {\n l = Math.min(count * stride + offset, a.length);\n } else {\n l = a.length;\n }\n\n for (i = offset; i < l; i += stride) {\n vec[0] = a[i];\n vec[1] = a[i + 1];\n vec[2] = a[i + 2];\n vec[3] = a[i + 3];\n fn(vec, vec, arg);\n a[i] = vec[0];\n a[i + 1] = vec[1];\n a[i + 2] = vec[2];\n a[i + 3] = vec[3];\n }\n\n return a;\n };\n}();","import { checkVector, deprecated } from '../lib/validators';\nimport Matrix from './base/matrix';\nimport { vec2_transformMat4AsVector, vec3_transformMat4AsVector } from '../lib/gl-matrix-extras';\nimport * as mat4 from 'gl-matrix/mat4';\nimport * as vec2 from 'gl-matrix/vec2';\nimport * as vec3 from 'gl-matrix/vec3';\nimport * as vec4 from 'gl-matrix/vec4';\nconst IDENTITY = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);\nconst ZERO = Object.freeze([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);\nconst INDICES = Object.freeze({\n COL0ROW0: 0,\n COL0ROW1: 1,\n COL0ROW2: 2,\n COL0ROW3: 3,\n COL1ROW0: 4,\n COL1ROW1: 5,\n COL1ROW2: 6,\n COL1ROW3: 7,\n COL2ROW0: 8,\n COL2ROW1: 9,\n COL2ROW2: 10,\n COL2ROW3: 11,\n COL3ROW0: 12,\n COL3ROW1: 13,\n COL3ROW2: 14,\n COL3ROW3: 15\n});\nconst constants = {};\nexport default class Matrix4 extends Matrix {\n static get IDENTITY() {\n constants.IDENTITY = constants.IDENTITY || Object.freeze(new Matrix4(IDENTITY));\n return constants.IDENTITY;\n }\n\n static get ZERO() {\n constants.ZERO = constants.ZERO || Object.freeze(new Matrix4(ZERO));\n return constants.ZERO;\n }\n\n get INDICES() {\n return INDICES;\n }\n\n get ELEMENTS() {\n return 16;\n }\n\n get RANK() {\n return 4;\n }\n\n constructor(array) {\n super(-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0);\n\n if (arguments.length === 1 && Array.isArray(array)) {\n this.copy(array);\n } else {\n this.identity();\n }\n }\n\n copy(array) {\n this[0] = array[0];\n this[1] = array[1];\n this[2] = array[2];\n this[3] = array[3];\n this[4] = array[4];\n this[5] = array[5];\n this[6] = array[6];\n this[7] = array[7];\n this[8] = array[8];\n this[9] = array[9];\n this[10] = array[10];\n this[11] = array[11];\n this[12] = array[12];\n this[13] = array[13];\n this[14] = array[14];\n this[15] = array[15];\n return this.check();\n }\n\n set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) {\n this[0] = m00;\n this[1] = m10;\n this[2] = m20;\n this[3] = m30;\n this[4] = m01;\n this[5] = m11;\n this[6] = m21;\n this[7] = m31;\n this[8] = m02;\n this[9] = m12;\n this[10] = m22;\n this[11] = m32;\n this[12] = m03;\n this[13] = m13;\n this[14] = m23;\n this[15] = m33;\n return this.check();\n }\n\n setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {\n this[0] = m00;\n this[1] = m10;\n this[2] = m20;\n this[3] = m30;\n this[4] = m01;\n this[5] = m11;\n this[6] = m21;\n this[7] = m31;\n this[8] = m02;\n this[9] = m12;\n this[10] = m22;\n this[11] = m32;\n this[12] = m03;\n this[13] = m13;\n this[14] = m23;\n this[15] = m33;\n return this.check();\n }\n\n toRowMajor(result) {\n result[0] = this[0];\n result[1] = this[4];\n result[2] = this[8];\n result[3] = this[12];\n result[4] = this[1];\n result[5] = this[5];\n result[6] = this[9];\n result[7] = this[13];\n result[8] = this[2];\n result[9] = this[6];\n result[10] = this[10];\n result[11] = this[14];\n result[12] = this[3];\n result[13] = this[7];\n result[14] = this[11];\n result[15] = this[15];\n return result;\n }\n\n identity() {\n return this.copy(IDENTITY);\n }\n\n fromQuaternion(q) {\n mat4.fromQuat(this, q);\n return this.check();\n }\n\n frustum({\n left,\n right,\n bottom,\n top,\n near,\n far\n }) {\n if (far === Infinity) {\n Matrix4._computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);\n } else {\n mat4.frustum(this, left, right, bottom, top, near, far);\n }\n\n return this.check();\n }\n\n static _computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) {\n const column0Row0 = 2.0 * near / (right - left);\n const column1Row1 = 2.0 * near / (top - bottom);\n const column2Row0 = (right + left) / (right - left);\n const column2Row1 = (top + bottom) / (top - bottom);\n const column2Row2 = -1.0;\n const column2Row3 = -1.0;\n const column3Row2 = -2.0 * near;\n result[0] = column0Row0;\n result[1] = 0.0;\n result[2] = 0.0;\n result[3] = 0.0;\n result[4] = 0.0;\n result[5] = column1Row1;\n result[6] = 0.0;\n result[7] = 0.0;\n result[8] = column2Row0;\n result[9] = column2Row1;\n result[10] = column2Row2;\n result[11] = column2Row3;\n result[12] = 0.0;\n result[13] = 0.0;\n result[14] = column3Row2;\n result[15] = 0.0;\n return result;\n }\n\n lookAt(eye, center, up) {\n if (arguments.length === 1) {\n ({\n eye,\n center,\n up\n } = eye);\n }\n\n center = center || [0, 0, 0];\n up = up || [0, 1, 0];\n mat4.lookAt(this, eye, center, up);\n return this.check();\n }\n\n ortho({\n left,\n right,\n bottom,\n top,\n near = 0.1,\n far = 500\n }) {\n mat4.ortho(this, left, right, bottom, top, near, far);\n return this.check();\n }\n\n orthographic({\n fovy = 45 * Math.PI / 180,\n aspect = 1,\n focalDistance = 1,\n near = 0.1,\n far = 500\n }) {\n if (fovy > Math.PI * 2) {\n throw Error('radians');\n }\n\n const halfY = fovy / 2;\n const top = focalDistance * Math.tan(halfY);\n const right = top * aspect;\n return new Matrix4().ortho({\n left: -right,\n right,\n bottom: -top,\n top,\n near,\n far\n });\n }\n\n perspective({\n fovy = undefined,\n fov = 45 * Math.PI / 180,\n aspect = 1,\n near = 0.1,\n far = 500\n } = {}) {\n fovy = fovy || fov;\n\n if (fovy > Math.PI * 2) {\n throw Error('radians');\n }\n\n mat4.perspective(this, fovy, aspect, near, far);\n return this.check();\n }\n\n determinant() {\n return mat4.determinant(this);\n }\n\n getScale(result = [-0, -0, -0]) {\n result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]);\n result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]);\n result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]);\n return result;\n }\n\n getTranslation(result = [-0, -0, -0]) {\n result[0] = this[12];\n result[1] = this[13];\n result[2] = this[14];\n return result;\n }\n\n getRotation(result = [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0], scaleResult = null) {\n const scale = this.getScale(scaleResult || [-0, -0, -0]);\n const inverseScale0 = 1 / scale[0];\n const inverseScale1 = 1 / scale[1];\n const inverseScale2 = 1 / scale[2];\n result[0] = this[0] * inverseScale0;\n result[1] = this[1] * inverseScale1;\n result[2] = this[2] * inverseScale2;\n result[3] = 0;\n result[4] = this[4] * inverseScale0;\n result[5] = this[5] * inverseScale1;\n result[6] = this[6] * inverseScale2;\n result[7] = 0;\n result[8] = this[8] * inverseScale0;\n result[9] = this[9] * inverseScale1;\n result[10] = this[10] * inverseScale2;\n result[11] = 0;\n result[12] = 0;\n result[13] = 0;\n result[14] = 0;\n result[15] = 1;\n return result;\n }\n\n getRotationMatrix3(result = [-0, -0, -0, -0, -0, -0, -0, -0, -0], scaleResult = null) {\n const scale = this.getScale(scaleResult || [-0, -0, -0]);\n const inverseScale0 = 1 / scale[0];\n const inverseScale1 = 1 / scale[1];\n const inverseScale2 = 1 / scale[2];\n result[0] = this[0] * inverseScale0;\n result[1] = this[1] * inverseScale1;\n result[2] = this[2] * inverseScale2;\n result[3] = this[4] * inverseScale0;\n result[4] = this[5] * inverseScale1;\n result[5] = this[6] * inverseScale2;\n result[6] = this[8] * inverseScale0;\n result[7] = this[9] * inverseScale1;\n result[8] = this[10] * inverseScale2;\n return result;\n }\n\n transpose() {\n mat4.transpose(this, this);\n return this.check();\n }\n\n invert() {\n mat4.invert(this, this);\n return this.check();\n }\n\n multiplyLeft(a) {\n mat4.multiply(this, a, this);\n return this.check();\n }\n\n multiplyRight(a) {\n mat4.multiply(this, this, a);\n return this.check();\n }\n\n rotateX(radians) {\n mat4.rotateX(this, this, radians);\n return this.check();\n }\n\n rotateY(radians) {\n mat4.rotateY(this, this, radians);\n return this.check();\n }\n\n rotateZ(radians) {\n mat4.rotateZ(this, this, radians);\n return this.check();\n }\n\n rotateXYZ([rx, ry, rz]) {\n return this.rotateX(rx).rotateY(ry).rotateZ(rz);\n }\n\n rotateAxis(radians, axis) {\n mat4.rotate(this, this, radians, axis);\n return this.check();\n }\n\n scale(factor) {\n if (Array.isArray(factor)) {\n mat4.scale(this, this, factor);\n } else {\n mat4.scale(this, this, [factor, factor, factor]);\n }\n\n return this.check();\n }\n\n translate(vec) {\n mat4.translate(this, this, vec);\n return this.check();\n }\n\n transform(vector, result) {\n if (vector.length === 4) {\n result = vec4.transformMat4(result || [-0, -0, -0, -0], vector, this);\n checkVector(result, 4);\n return result;\n }\n\n return this.transformAsPoint(vector, result);\n }\n\n transformAsPoint(vector, result) {\n const {\n length\n } = vector;\n\n switch (length) {\n case 2:\n result = vec2.transformMat4(result || [-0, -0], vector, this);\n break;\n\n case 3:\n result = vec3.transformMat4(result || [-0, -0, -0], vector, this);\n break;\n\n default:\n throw new Error('Illegal vector');\n }\n\n checkVector(result, vector.length);\n return result;\n }\n\n transformAsVector(vector, result) {\n switch (vector.length) {\n case 2:\n result = vec2_transformMat4AsVector(result || [-0, -0], vector, this);\n break;\n\n case 3:\n result = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this);\n break;\n\n default:\n throw new Error('Illegal vector');\n }\n\n checkVector(result, vector.length);\n return result;\n }\n\n makeRotationX(radians) {\n return this.identity().rotateX(radians);\n }\n\n makeTranslation(x, y, z) {\n return this.identity().translate([x, y, z]);\n }\n\n transformPoint(vector, result) {\n deprecated('Matrix4.transformPoint', '3.0');\n return this.transformAsPoint(vector, result);\n }\n\n transformVector(vector, result) {\n deprecated('Matrix4.transformVector', '3.0');\n return this.transformAsPoint(vector, result);\n }\n\n transformDirection(vector, result) {\n deprecated('Matrix4.transformDirection', '3.0');\n return this.transformAsVector(vector, result);\n }\n\n}\n//# sourceMappingURL=matrix4.js.map","import MathArray from './math-array';\nimport { checkNumber } from '../../lib/validators';\nimport assert from '../../lib/assert';\nexport default class Vector extends MathArray {\n get ELEMENTS() {\n assert(false);\n return 0;\n }\n\n copy(vector) {\n assert(false);\n return this;\n }\n\n get x() {\n return this[0];\n }\n\n set x(value) {\n this[0] = checkNumber(value);\n }\n\n get y() {\n return this[1];\n }\n\n set y(value) {\n this[1] = checkNumber(value);\n }\n\n len() {\n return Math.sqrt(this.lengthSquared());\n }\n\n magnitude() {\n return this.len();\n }\n\n lengthSquared() {\n let length = 0;\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n length += this[i] * this[i];\n }\n\n return length;\n }\n\n magnitudeSquared() {\n return this.lengthSquared();\n }\n\n distance(mathArray) {\n return Math.sqrt(this.distanceSquared(mathArray));\n }\n\n distanceSquared(mathArray) {\n let length = 0;\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n const dist = this[i] - mathArray[i];\n length += dist * dist;\n }\n\n return checkNumber(length);\n }\n\n dot(mathArray) {\n let product = 0;\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n product += this[i] * mathArray[i];\n }\n\n return checkNumber(product);\n }\n\n normalize() {\n const length = this.magnitude();\n\n if (length !== 0) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] /= length;\n }\n }\n\n return this.check();\n }\n\n multiply(...vectors) {\n for (const vector of vectors) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] *= vector[i];\n }\n }\n\n return this.check();\n }\n\n divide(...vectors) {\n for (const vector of vectors) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] /= vector[i];\n }\n }\n\n return this.check();\n }\n\n lengthSq() {\n return this.lengthSquared();\n }\n\n distanceTo(vector) {\n return this.distance(vector);\n }\n\n distanceToSquared(vector) {\n return this.distanceSquared(vector);\n }\n\n getComponent(i) {\n assert(i >= 0 && i < this.ELEMENTS, 'index is out of range');\n return checkNumber(this[i]);\n }\n\n setComponent(i, value) {\n assert(i >= 0 && i < this.ELEMENTS, 'index is out of range');\n this[i] = value;\n return this.check();\n }\n\n addVectors(a, b) {\n return this.copy(a).add(b);\n }\n\n subVectors(a, b) {\n return this.copy(a).subtract(b);\n }\n\n multiplyVectors(a, b) {\n return this.copy(a).multiply(b);\n }\n\n addScaledVector(a, b) {\n return this.add(new this.constructor(a).multiplyScalar(b));\n }\n\n}\n//# sourceMappingURL=vector.js.map","import Vector from './base/vector';\nimport { config, isArray } from '../lib/common';\nimport { checkNumber } from '../lib/validators';\nimport * as vec3 from 'gl-matrix/vec3';\nimport { vec3_transformMat2, vec3_transformMat4AsVector } from '../lib/gl-matrix-extras';\nconst ORIGIN = [0, 0, 0];\nconst constants = {};\nexport default class Vector3 extends Vector {\n static get ZERO() {\n return constants.ZERO = constants.ZERO || Object.freeze(new Vector3(0, 0, 0, 0));\n }\n\n constructor(x = 0, y = 0, z = 0) {\n super(-0, -0, -0);\n\n if (arguments.length === 1 && isArray(x)) {\n this.copy(x);\n } else {\n if (config.debug) {\n checkNumber(x);\n checkNumber(y);\n checkNumber(z);\n }\n\n this[0] = x;\n this[1] = y;\n this[2] = z;\n }\n }\n\n set(x, y, z) {\n this[0] = x;\n this[1] = y;\n this[2] = z;\n return this.check();\n }\n\n copy(array) {\n this[0] = array[0];\n this[1] = array[1];\n this[2] = array[2];\n return this.check();\n }\n\n fromObject(object) {\n if (config.debug) {\n checkNumber(object.x);\n checkNumber(object.y);\n checkNumber(object.z);\n }\n\n this[0] = object.x;\n this[1] = object.y;\n this[2] = object.z;\n return this.check();\n }\n\n toObject(object) {\n object.x = this[0];\n object.y = this[1];\n object.z = this[2];\n return object;\n }\n\n get ELEMENTS() {\n return 3;\n }\n\n get z() {\n return this[2];\n }\n\n set z(value) {\n this[2] = checkNumber(value);\n }\n\n angle(vector) {\n return vec3.angle(this, vector);\n }\n\n cross(vector) {\n vec3.cross(this, this, vector);\n return this.check();\n }\n\n rotateX({\n radians,\n origin = ORIGIN\n }) {\n vec3.rotateX(this, this, origin, radians);\n return this.check();\n }\n\n rotateY({\n radians,\n origin = ORIGIN\n }) {\n vec3.rotateY(this, this, origin, radians);\n return this.check();\n }\n\n rotateZ({\n radians,\n origin = ORIGIN\n }) {\n vec3.rotateZ(this, this, origin, radians);\n return this.check();\n }\n\n transform(matrix4) {\n return this.transformAsPoint(matrix4);\n }\n\n transformAsPoint(matrix4) {\n vec3.transformMat4(this, this, matrix4);\n return this.check();\n }\n\n transformAsVector(matrix4) {\n vec3_transformMat4AsVector(this, this, matrix4);\n return this.check();\n }\n\n transformByMatrix3(matrix3) {\n vec3.transformMat3(this, this, matrix3);\n return this.check();\n }\n\n transformByMatrix2(matrix2) {\n vec3_transformMat2(this, this, matrix2);\n return this.check();\n }\n\n transformByQuaternion(quaternion) {\n vec3.transformQuat(this, this, quaternion);\n return this.check();\n }\n\n}\n//# sourceMappingURL=vector3.js.map","export default {\n EPSILON1: 1e-1,\n EPSILON2: 1e-2,\n EPSILON3: 1e-3,\n EPSILON4: 1e-4,\n EPSILON5: 1e-5,\n EPSILON6: 1e-6,\n EPSILON7: 1e-7,\n EPSILON8: 1e-8,\n EPSILON9: 1e-9,\n EPSILON10: 1e-10,\n EPSILON11: 1e-11,\n EPSILON12: 1e-12,\n EPSILON13: 1e-13,\n EPSILON14: 1e-14,\n EPSILON15: 1e-15,\n EPSILON16: 1e-16,\n EPSILON17: 1e-17,\n EPSILON18: 1e-18,\n EPSILON19: 1e-19,\n EPSILON20: 1e-20,\n PI_OVER_TWO: Math.PI / 2,\n PI_OVER_FOUR: Math.PI / 4,\n PI_OVER_SIX: Math.PI / 6,\n TWO_PI: Math.PI * 2\n};\n//# sourceMappingURL=math-utils.js.map","export const WGS84_RADIUS_X = 6378137.0;\nexport const WGS84_RADIUS_Y = 6378137.0;\nexport const WGS84_RADIUS_Z = 6356752.3142451793;\nexport const WGS84_CONSTANTS = {\n radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],\n radiiSquared: [WGS84_RADIUS_X * WGS84_RADIUS_X, WGS84_RADIUS_Y * WGS84_RADIUS_Y, WGS84_RADIUS_Z * WGS84_RADIUS_Z],\n oneOverRadii: [1.0 / WGS84_RADIUS_X, 1.0 / WGS84_RADIUS_Y, 1.0 / WGS84_RADIUS_Z],\n oneOverRadiiSquared: [1.0 / (WGS84_RADIUS_X * WGS84_RADIUS_X), 1.0 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y), 1.0 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)],\n maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),\n centerToleranceSquared: 1e-1\n};\n//# sourceMappingURL=constants.js.map","import { Vector3, isArray, toRadians, toDegrees, config } from '@math.gl/core';\nimport { WGS84_CONSTANTS } from './constants';\n\nconst noop = x => x;\n\nconst scratchVector = new Vector3();\nexport function fromCartographic(cartographic, result, map = noop) {\n if (isArray(cartographic)) {\n result[0] = map(cartographic[0]);\n result[1] = map(cartographic[1]);\n result[2] = cartographic[2];\n } else if ('longitude' in cartographic) {\n result[0] = map(cartographic.longitude);\n result[1] = map(cartographic.latitude);\n result[2] = cartographic.height;\n } else {\n result[0] = map(cartographic.x);\n result[1] = map(cartographic.y);\n result[2] = cartographic.z;\n }\n\n return result;\n}\nexport function fromCartographicToRadians(cartographic, vector = scratchVector) {\n return fromCartographic(cartographic, vector, config._cartographicRadians ? noop : toRadians);\n}\nexport function fromCartographicToDegrees(cartographic, vector = scratchVector) {\n return fromCartographic(cartographic, vector, config._cartographicRadians ? toDegrees : noop);\n}\nexport function toCartographic(vector, cartographic, map = noop) {\n if (isArray(cartographic)) {\n cartographic[0] = map(vector[0]);\n cartographic[1] = map(vector[1]);\n cartographic[2] = vector[2];\n } else if ('longitude' in cartographic) {\n cartographic.longitude = map(vector[0]);\n cartographic.latitude = map(vector[1]);\n cartographic.height = vector[2];\n } else {\n cartographic.x = map(vector[0]);\n cartographic.y = map(vector[1]);\n cartographic.z = vector[2];\n }\n\n return cartographic;\n}\nexport function toCartographicFromRadians(vector, cartographic) {\n return toCartographic(vector, cartographic, config._cartographicRadians ? noop : toDegrees);\n}\nexport function toCartographicFromDegrees(vector, cartographic) {\n return toCartographic(vector, cartographic, config._cartographicRadians ? toRadians : noop);\n}\nexport function isWGS84(vector) {\n if (!vector) {\n return false;\n }\n\n scratchVector.from(vector);\n const {\n oneOverRadiiSquared,\n centerToleranceSquared\n } = WGS84_CONSTANTS;\n const x2 = vector[0] * vector[0] * oneOverRadiiSquared[0];\n const y2 = vector[1] * vector[1] * oneOverRadiiSquared[1];\n const z2 = vector[2] * vector[2] * oneOverRadiiSquared[2];\n return Math.abs(x2 + y2 + z2 - 1) < centerToleranceSquared;\n}\n//# sourceMappingURL=type-utils.js.map","import { Vector3, assert, _MathUtils } from '@math.gl/core';\nimport * as vec3 from 'gl-matrix/vec3';\nconst scratchVector = new Vector3();\nconst scaleToGeodeticSurfaceIntersection = new Vector3();\nconst scaleToGeodeticSurfaceGradient = new Vector3();\nexport default function scaleToGeodeticSurface(cartesian, ellipsoid, result = new Vector3()) {\n const {\n oneOverRadii,\n oneOverRadiiSquared,\n centerToleranceSquared\n } = ellipsoid;\n scratchVector.from(cartesian);\n const positionX = cartesian.x;\n const positionY = cartesian.y;\n const positionZ = cartesian.z;\n const oneOverRadiiX = oneOverRadii.x;\n const oneOverRadiiY = oneOverRadii.y;\n const oneOverRadiiZ = oneOverRadii.z;\n const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;\n const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;\n const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;\n const squaredNorm = x2 + y2 + z2;\n const ratio = Math.sqrt(1.0 / squaredNorm);\n\n if (!Number.isFinite(ratio)) {\n return undefined;\n }\n\n const intersection = scaleToGeodeticSurfaceIntersection;\n intersection.copy(cartesian).scale(ratio);\n\n if (squaredNorm < centerToleranceSquared) {\n return intersection.to(result);\n }\n\n const oneOverRadiiSquaredX = oneOverRadiiSquared.x;\n const oneOverRadiiSquaredY = oneOverRadiiSquared.y;\n const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;\n const gradient = scaleToGeodeticSurfaceGradient;\n gradient.set(intersection.x * oneOverRadiiSquaredX * 2.0, intersection.y * oneOverRadiiSquaredY * 2.0, intersection.z * oneOverRadiiSquaredZ * 2.0);\n let lambda = (1.0 - ratio) * cartesian.len() / (0.5 * gradient.len());\n let correction = 0.0;\n let xMultiplier;\n let yMultiplier;\n let zMultiplier;\n let func;\n\n do {\n lambda -= correction;\n xMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredX);\n yMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredY);\n zMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredZ);\n const xMultiplier2 = xMultiplier * xMultiplier;\n const yMultiplier2 = yMultiplier * yMultiplier;\n const zMultiplier2 = zMultiplier * zMultiplier;\n const xMultiplier3 = xMultiplier2 * xMultiplier;\n const yMultiplier3 = yMultiplier2 * yMultiplier;\n const zMultiplier3 = zMultiplier2 * zMultiplier;\n func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1.0;\n const denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;\n const derivative = -2.0 * denominator;\n correction = func / derivative;\n } while (Math.abs(func) > _MathUtils.EPSILON12);\n\n return scratchVector.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);\n}\n//# sourceMappingURL=scale-to-geodetic-surface.js.map","import { Vector3, assert, equals as equalsEpsilon } from '@math.gl/core';\nconst EPSILON14 = 1e-14;\nconst scratchOrigin = new Vector3();\nconst VECTOR_PRODUCT_LOCAL_FRAME = {\n up: {\n south: 'east',\n north: 'west',\n west: 'south',\n east: 'north'\n },\n down: {\n south: 'west',\n north: 'east',\n west: 'north',\n east: 'south'\n },\n south: {\n up: 'west',\n down: 'east',\n west: 'down',\n east: 'up'\n },\n north: {\n up: 'east',\n down: 'west',\n west: 'up',\n east: 'down'\n },\n west: {\n up: 'north',\n down: 'south',\n north: 'down',\n south: 'up'\n },\n east: {\n up: 'south',\n down: 'north',\n north: 'up',\n south: 'down'\n }\n};\nconst degeneratePositionLocalFrame = {\n north: [-1, 0, 0],\n east: [0, 1, 0],\n up: [0, 0, 1],\n south: [1, 0, 0],\n west: [0, -1, 0],\n down: [0, 0, -1]\n};\nconst scratchAxisVectors = {\n east: new Vector3(),\n north: new Vector3(),\n up: new Vector3(),\n west: new Vector3(),\n south: new Vector3(),\n down: new Vector3()\n};\nconst scratchVector1 = new Vector3();\nconst scratchVector2 = new Vector3();\nconst scratchVector3 = new Vector3();\nexport default function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {\n const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];\n assert(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));\n let firstAxisVector;\n let secondAxisVector;\n let thirdAxisVector;\n const origin = scratchOrigin.copy(cartesianOrigin);\n const atPole = equalsEpsilon(origin.x, 0.0, EPSILON14) && equalsEpsilon(origin.y, 0.0, EPSILON14);\n\n if (atPole) {\n const sign = Math.sign(origin.z);\n firstAxisVector = scratchVector1.fromArray(degeneratePositionLocalFrame[firstAxis]);\n\n if (firstAxis !== 'east' && firstAxis !== 'west') {\n firstAxisVector.scale(sign);\n }\n\n secondAxisVector = scratchVector2.fromArray(degeneratePositionLocalFrame[secondAxis]);\n\n if (secondAxis !== 'east' && secondAxis !== 'west') {\n secondAxisVector.scale(sign);\n }\n\n thirdAxisVector = scratchVector3.fromArray(degeneratePositionLocalFrame[thirdAxis]);\n\n if (thirdAxis !== 'east' && thirdAxis !== 'west') {\n thirdAxisVector.scale(sign);\n }\n } else {\n const {\n up,\n east,\n north\n } = scratchAxisVectors;\n east.set(-origin.y, origin.x, 0.0).normalize();\n ellipsoid.geodeticSurfaceNormal(origin, up);\n north.copy(up).cross(east);\n const {\n down,\n west,\n south\n } = scratchAxisVectors;\n down.copy(up).scale(-1);\n west.copy(east).scale(-1);\n south.copy(north).scale(-1);\n firstAxisVector = scratchAxisVectors[firstAxis];\n secondAxisVector = scratchAxisVectors[secondAxis];\n thirdAxisVector = scratchAxisVectors[thirdAxis];\n }\n\n result[0] = firstAxisVector.x;\n result[1] = firstAxisVector.y;\n result[2] = firstAxisVector.z;\n result[3] = 0.0;\n result[4] = secondAxisVector.x;\n result[5] = secondAxisVector.y;\n result[6] = secondAxisVector.z;\n result[7] = 0.0;\n result[8] = thirdAxisVector.x;\n result[9] = thirdAxisVector.y;\n result[10] = thirdAxisVector.z;\n result[11] = 0.0;\n result[12] = origin.x;\n result[13] = origin.y;\n result[14] = origin.z;\n result[15] = 1.0;\n return result;\n}\n//# sourceMappingURL=ellipsoid-transform.js.map","import { Vector3, Matrix4, toRadians, toDegrees, assert, equals, _MathUtils } from '@math.gl/core';\nimport * as vec3 from 'gl-matrix/vec3';\nimport { WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z } from '../constants';\nimport { fromCartographicToRadians, toCartographicFromRadians } from '../type-utils';\nimport scaleToGeodeticSurface from './helpers/scale-to-geodetic-surface';\nimport localFrameToFixedFrame from './helpers/ellipsoid-transform';\nconst scratchVector = new Vector3();\nconst scratchNormal = new Vector3();\nconst scratchK = new Vector3();\nconst scratchPosition = new Vector3();\nconst scratchHeight = new Vector3();\nconst scratchCartesian = new Vector3();\nlet wgs84;\nexport default class Ellipsoid {\n static get WGS84() {\n wgs84 = wgs84 || new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);\n return wgs84;\n }\n\n constructor(x = 0.0, y = 0.0, z = 0.0) {\n assert(x >= 0.0);\n assert(y >= 0.0);\n assert(z >= 0.0);\n this.radii = new Vector3(x, y, z);\n this.radiiSquared = new Vector3(x * x, y * y, z * z);\n this.radiiToTheFourth = new Vector3(x * x * x * x, y * y * y * y, z * z * z * z);\n this.oneOverRadii = new Vector3(x === 0.0 ? 0.0 : 1.0 / x, y === 0.0 ? 0.0 : 1.0 / y, z === 0.0 ? 0.0 : 1.0 / z);\n this.oneOverRadiiSquared = new Vector3(x === 0.0 ? 0.0 : 1.0 / (x * x), y === 0.0 ? 0.0 : 1.0 / (y * y), z === 0.0 ? 0.0 : 1.0 / (z * z));\n this.minimumRadius = Math.min(x, y, z);\n this.maximumRadius = Math.max(x, y, z);\n this.centerToleranceSquared = _MathUtils.EPSILON1;\n\n if (this.radiiSquared.z !== 0) {\n this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;\n }\n\n Object.freeze(this);\n }\n\n equals(right) {\n return this === right || Boolean(right && this.radii.equals(right.radii));\n }\n\n toString() {\n return this.radii.toString();\n }\n\n cartographicToCartesian(cartographic, result = [0, 0, 0]) {\n const normal = scratchNormal;\n const k = scratchK;\n const [,, height] = cartographic;\n this.geodeticSurfaceNormalCartographic(cartographic, normal);\n k.copy(this.radiiSquared).scale(normal);\n const gamma = Math.sqrt(normal.dot(k));\n k.scale(1 / gamma);\n normal.scale(height);\n k.add(normal);\n return k.to(result);\n }\n\n cartesianToCartographic(cartesian, result = [0, 0, 0]) {\n scratchCartesian.from(cartesian);\n const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);\n\n if (!point) {\n return undefined;\n }\n\n const normal = this.geodeticSurfaceNormal(point, scratchNormal);\n const h = scratchHeight;\n h.copy(scratchCartesian).subtract(point);\n const longitude = Math.atan2(normal.y, normal.x);\n const latitude = Math.asin(normal.z);\n const height = Math.sign(vec3.dot(h, scratchCartesian)) * vec3.length(h);\n return toCartographicFromRadians([longitude, latitude, height], result);\n }\n\n eastNorthUpToFixedFrame(origin, result = new Matrix4()) {\n return localFrameToFixedFrame(this, 'east', 'north', 'up', origin, result);\n }\n\n localFrameToFixedFrame(firstAxis, secondAxis, thirdAxis, origin, result = new Matrix4()) {\n return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);\n }\n\n geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {\n return scratchVector.from(cartesian).normalize().to(result);\n }\n\n geodeticSurfaceNormalCartographic(cartographic, result = [0, 0, 0]) {\n const cartographicVectorRadians = fromCartographicToRadians(cartographic);\n const longitude = cartographicVectorRadians[0];\n const latitude = cartographicVectorRadians[1];\n const cosLatitude = Math.cos(latitude);\n scratchVector.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude)).normalize();\n return scratchVector.to(result);\n }\n\n geodeticSurfaceNormal(cartesian, result = [0, 0, 0]) {\n return scratchVector.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);\n }\n\n scaleToGeodeticSurface(cartesian, result) {\n return scaleToGeodeticSurface(cartesian, this, result);\n }\n\n scaleToGeocentricSurface(cartesian, result = [0, 0, 0]) {\n scratchPosition.from(cartesian);\n const positionX = scratchPosition.x;\n const positionY = scratchPosition.y;\n const positionZ = scratchPosition.z;\n const oneOverRadiiSquared = this.oneOverRadiiSquared;\n const beta = 1.0 / Math.sqrt(positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z);\n return scratchPosition.multiplyScalar(beta).to(result);\n }\n\n transformPositionToScaledSpace(position, result = [0, 0, 0]) {\n return scratchPosition.from(position).scale(this.oneOverRadii).to(result);\n }\n\n transformPositionFromScaledSpace(position, result = [0, 0, 0]) {\n return scratchPosition.from(position).scale(this.radii).to(result);\n }\n\n getSurfaceNormalIntersectionWithZAxis(position, buffer = 0.0, result = [0, 0, 0]) {\n assert(equals(this.radii.x, this.radii.y, _MathUtils.EPSILON15));\n assert(this.radii.z > 0);\n scratchPosition.from(position);\n const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);\n\n if (Math.abs(z) >= this.radii.z - buffer) {\n return undefined;\n }\n\n return scratchPosition.set(0.0, 0.0, z).to(result);\n }\n\n}\n//# sourceMappingURL=ellipsoid.js.map","import getHiResTimestamp from '../utils/hi-res-timestamp';\nexport default class Stat {\n constructor(name, type) {\n this.name = name;\n this.type = type;\n this.sampleSize = 1;\n this.reset();\n }\n\n setSampleSize(samples) {\n this.sampleSize = samples;\n return this;\n }\n\n incrementCount() {\n this.addCount(1);\n return this;\n }\n\n decrementCount() {\n this.subtractCount(1);\n return this;\n }\n\n addCount(value) {\n this._count += value;\n this._samples++;\n\n this._checkSampling();\n\n return this;\n }\n\n subtractCount(value) {\n this._count -= value;\n this._samples++;\n\n this._checkSampling();\n\n return this;\n }\n\n addTime(time) {\n this._time += time;\n this.lastTiming = time;\n this._samples++;\n\n this._checkSampling();\n\n return this;\n }\n\n timeStart() {\n this._startTime = getHiResTimestamp();\n this._timerPending = true;\n return this;\n }\n\n timeEnd() {\n if (!this._timerPending) {\n return this;\n }\n\n this.addTime(getHiResTimestamp() - this._startTime);\n this._timerPending = false;\n\n this._checkSampling();\n\n return this;\n }\n\n getSampleAverageCount() {\n return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;\n }\n\n getSampleAverageTime() {\n return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;\n }\n\n getSampleHz() {\n return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1000) : 0;\n }\n\n getAverageCount() {\n return this.samples > 0 ? this.count / this.samples : 0;\n }\n\n getAverageTime() {\n return this.samples > 0 ? this.time / this.samples : 0;\n }\n\n getHz() {\n return this.time > 0 ? this.samples / (this.time / 1000) : 0;\n }\n\n reset() {\n this.time = 0;\n this.count = 0;\n this.samples = 0;\n this.lastTiming = 0;\n this.lastSampleTime = 0;\n this.lastSampleCount = 0;\n this._count = 0;\n this._time = 0;\n this._samples = 0;\n this._startTime = 0;\n this._timerPending = false;\n return this;\n }\n\n _checkSampling() {\n if (this._samples === this.sampleSize) {\n this.lastSampleTime = this._time;\n this.lastSampleCount = this._count;\n this.count += this._count;\n this.time += this._time;\n this.samples += this._samples;\n this._time = 0;\n this._count = 0;\n this._samples = 0;\n }\n }\n\n}\n//# sourceMappingURL=stat.js.map","import Stat from './stat';\nexport default class Stats {\n constructor({\n id,\n stats\n }) {\n this.id = id;\n this.stats = {};\n\n this._initializeStats(stats);\n\n Object.seal(this);\n }\n\n get(name, type = 'count') {\n return this._getOrCreate({\n name,\n type\n });\n }\n\n get size() {\n return Object.keys(this.stats).length;\n }\n\n reset() {\n for (const key in this.stats) {\n this.stats[key].reset();\n }\n\n return this;\n }\n\n forEach(fn) {\n for (const key in this.stats) {\n fn(this.stats[key]);\n }\n }\n\n getTable() {\n const table = {};\n this.forEach(stat => {\n table[stat.name] = {\n time: stat.time || 0,\n count: stat.count || 0,\n average: stat.getAverageTime() || 0,\n hz: stat.getHz() || 0\n };\n });\n return table;\n }\n\n _initializeStats(stats = []) {\n stats.forEach(stat => this._getOrCreate(stat));\n }\n\n _getOrCreate(stat) {\n if (!stat || !stat.name) {\n return null;\n }\n\n const {\n name,\n type\n } = stat;\n\n if (!this.stats[name]) {\n if (stat instanceof Stat) {\n this.stats[name] = stat;\n } else {\n this.stats[name] = new Stat(name, type);\n }\n }\n\n return this.stats[name];\n }\n\n}\n//# sourceMappingURL=stats.js.map","/**\n * Throws an `Error` with the optional `message` if `condition` is falsy\n * @note Replacement for the external assert method to reduce bundle size\n */\nexport function assert(condition: any, message?: string): void {\n if (!condition) {\n throw new Error(message || 'loader assertion failed.');\n }\n}\n","// Beginning of a minimal implementation of the Node.js path API, that doesn't pull in big polyfills.\n\n/**\n * Replacement for Node.js path.dirname\n * @param url\n */\nexport function dirname(url: string): string {\n const slashIndex = url && url.lastIndexOf('/');\n return slashIndex >= 0 ? url.substr(0, slashIndex as number) : '';\n}\n\n/**\n * Replacement for Node.js path.join\n * @param parts\n */\nexport function join(...parts: string[]): string {\n const separator = '/';\n parts = parts.map((part, index) => {\n if (index) {\n part = part.replace(new RegExp(`^${separator}`), '');\n }\n if (index !== parts.length - 1) {\n part = part.replace(new RegExp(`${separator}$`), '');\n }\n return part;\n });\n return parts.join(separator);\n}\n","import {Stats} from '@probe.gl/stats';\n\ntype Handle = any;\ntype DoneFunction = () => any;\ntype GetPriorityFunction = () => number;\ntype RequestResult = {\n done: DoneFunction;\n} | null;\n\n/** RequestScheduler Options */\nexport type RequestSchedulerProps = {\n id?: string;\n throttleRequests?: boolean;\n maxRequests?: number;\n};\n\nconst STAT_QUEUED_REQUESTS = 'Queued Requests';\nconst STAT_ACTIVE_REQUESTS = 'Active Requests';\nconst STAT_CANCELLED_REQUESTS = 'Cancelled Requests';\nconst STAT_QUEUED_REQUESTS_EVER = 'Queued Requests Ever';\nconst STAT_ACTIVE_REQUESTS_EVER = 'Active Requests Ever';\n\nconst DEFAULT_PROPS: Required<RequestSchedulerProps> = {\n id: 'request-scheduler',\n // Specifies if the request scheduler should throttle incoming requests, mainly for comparative testing\n throttleRequests: true,\n // The maximum number of simultaneous active requests. Un-throttled requests do not observe this limit.\n maxRequests: 6\n};\n\n/** Tracks one request */\ntype Request = {\n handle: Handle;\n priority: number;\n getPriority: GetPriorityFunction;\n resolve?: (value: any) => any;\n};\n\n/**\n * Used to issue a request, without having them \"deeply queued\" by the browser.\n * @todo - Track requests globally, across multiple servers\n */\nexport default class RequestScheduler {\n readonly props: Required<RequestSchedulerProps>;\n readonly stats: Stats;\n activeRequestCount: number = 0;\n\n /** Tracks the number of active requests and prioritizes/cancels queued requests. */\n private requestQueue: Request[] = [];\n private requestMap: Map<Handle, Promise<RequestResult>> = new Map();\n private deferredUpdate: any = null;\n\n constructor(props: RequestSchedulerProps = {}) {\n this.props = {...DEFAULT_PROPS, ...props};\n\n // Returns the statistics used by the request scheduler.\n this.stats = new Stats({id: this.props.id});\n this.stats.get(STAT_QUEUED_REQUESTS);\n this.stats.get(STAT_ACTIVE_REQUESTS);\n this.stats.get(STAT_CANCELLED_REQUESTS);\n this.stats.get(STAT_QUEUED_REQUESTS_EVER);\n this.stats.get(STAT_ACTIVE_REQUESTS_EVER);\n }\n\n /**\n * Called by an application that wants to issue a request, without having it deeply queued by the browser\n *\n * When the returned promise resolved, it is OK for the application to issue a request.\n * The promise resolves to an object that contains a `done` method.\n * When the application's request has completed (or failed), the application must call the `done` function\n *\n * @param handle\n * @param getPriority will be called when request \"slots\" open up,\n * allowing the caller to update priority or cancel the request\n * Highest priority executes first, priority < 0 cancels the request\n * @returns a promise\n * - resolves to a object (with a `done` field) when the request can be issued without queueing,\n * - resolves to `null` if the request has been cancelled (by the callback return < 0).\n * In this case the application should not issue the request\n */\n scheduleRequest(\n handle: Handle,\n getPriority: GetPriorityFunction = () => 0\n ): Promise<RequestResult> {\n // Allows throttling to be disabled\n if (!this.props.throttleRequests) {\n return Promise.resolve({done: () => {}});\n }\n\n // dedupe\n if (this.requestMap.has(handle)) {\n return this.requestMap.get(handle) as Promise<any>;\n }\n\n const request: Request = {handle, priority: 0, getPriority};\n const promise = new Promise<RequestResult>((resolve) => {\n // @ts-ignore\n request.resolve = resolve;\n return request;\n });\n\n this.requestQueue.push(request);\n this.requestMap.set(handle, promise);\n this._issueNewRequests();\n return promise;\n }\n\n // PRIVATE\n\n _issueRequest(request: Request): Promise<any> {\n const {handle, resolve} = request;\n let isDone = false;\n\n const done = () => {\n // can only be called once\n if (!isDone) {\n isDone = true;\n\n // Stop tracking a request - it has completed, failed, cancelled etc\n this.requestMap.delete(handle);\n this.activeRequestCount--;\n // A slot just freed up, see if any queued requests are waiting\n this._issueNewRequests();\n }\n };\n\n // Track this request\n this.activeRequestCount++;\n\n return resolve ? resolve({done}) : Promise.resolve({done});\n }\n\n /** We check requests asynchronously, to prevent multiple updates */\n _issueNewRequests(): void {\n if (!this.deferredUpdate) {\n this.deferredUpdate = setTimeout(() => this._issueNewRequestsAsync(), 0);\n }\n }\n\n /** Refresh all requests */\n _issueNewRequestsAsync() {\n // TODO - shouldn't we clear the timeout?\n this.deferredUpdate = null;\n\n const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0);\n\n if (freeSlots === 0) {\n return;\n }\n\n this._updateAllRequests();\n\n // Resolve pending promises for the top-priority requests\n for (let i = 0; i < freeSlots; ++i) {\n const request = this.requestQueue.shift();\n if (request) {\n this._issueRequest(request); // eslint-disable-line @typescript-eslint/no-floating-promises\n }\n }\n\n // Uncomment to debug\n // console.log(`${freeSlots} free slots, ${this.requestQueue.length} queued requests`);\n }\n\n /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */\n _updateAllRequests() {\n const requestQueue = this.requestQueue;\n for (let i = 0; i < requestQueue.length; ++i) {\n const request = requestQueue[i];\n if (!this._updateRequest(request)) {\n // Remove the element and make sure to adjust the counter to account for shortened array\n requestQueue.splice(i, 1);\n this.requestMap.delete(request.handle);\n i--;\n }\n }\n\n // Sort the remaining requests based on priority\n requestQueue.sort((a, b) => a.priority - b.priority);\n }\n\n /** Update a single request by calling the callback */\n _updateRequest(request) {\n request.priority = request.getPriority(request.handle); // eslint-disable-line callback-return\n\n // by returning a negative priority, the callback cancels the request\n if (request.priority < 0) {\n request.resolve(null);\n return false;\n }\n return true;\n }\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\n/**\n * Doubly linked list node\n *\n * @private\n */\nexport default class DoublyLinkedListNode {\n constructor(item, previous, next) {\n this.item = item;\n this.previous = previous;\n this.next = next;\n }\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport DoublyLinkedListNode from '../utils/doubly-linked-list-node';\n\n/**\n * Doubly linked list\n *\n * @private\n */\nexport default class DoublyLinkedList {\n constructor() {\n this.head = null;\n this.tail = null;\n this._length = 0;\n }\n\n get length() {\n return this._length;\n }\n\n /**\n * Adds the item to the end of the list\n * @param {*} [item]\n * @return {DoublyLinkedListNode}\n */\n add(item) {\n const node = new DoublyLinkedListNode(item, this.tail, null);\n\n if (this.tail) {\n this.tail.next = node;\n this.tail = node;\n } else {\n this.head = node;\n this.tail = node;\n }\n\n ++this._length;\n\n return node;\n }\n\n /**\n * Removes the given node from the list\n * @param {DoublyLinkedListNode} node\n */\n remove(node) {\n if (!node) {\n return;\n }\n\n if (node.previous && node.next) {\n node.previous.next = node.next;\n node.next.previous = node.previous;\n } else if (node.previous) {\n // Remove last node\n node.previous.next = null;\n this.tail = node.previous;\n } else if (node.next) {\n // Remove first node\n node.next.previous = null;\n this.head = node.next;\n } else {\n // Remove last node in the linked list\n this.head = null;\n this.tail = null;\n }\n\n node.next = null;\n node.previous = null;\n\n --this._length;\n }\n\n /**\n * Moves nextNode after node\n * @param {DoublyLinkedListNode} node\n * @param {DoublyLinkedListNode} nextNode\n */\n splice(node, nextNode) {\n if (node === nextNode) {\n return;\n }\n\n // Remove nextNode, then insert after node\n this.remove(nextNode);\n this._insert(node, nextNode);\n }\n\n _insert(node, nextNode) {\n const oldNodeNext = node.next;\n node.next = nextNode;\n\n // nextNode is the new tail\n if (this.tail === node) {\n this.tail = nextNode;\n } else {\n oldNodeNext.previous = nextNode;\n }\n\n nextNode.next = oldNodeNext;\n nextNode.previous = node;\n\n ++this._length;\n }\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport DoublyLinkedList from '../utils/doubly-linked-list';\n\nfunction defined(x) {\n return x !== undefined && x !== null;\n}\n\n/**\n * Stores tiles with content loaded.\n *\n * @private\n */\nexport default class TilesetCache {\n private _list: DoublyLinkedList;\n private _sentinel: any;\n private _trimTiles: boolean;\n\n constructor() {\n // [head, sentinel) -> tiles that weren't selected this frame and may be removed from the cache\n // (sentinel, tail] -> tiles that were selected this frame\n this._list = new DoublyLinkedList();\n this._sentinel = this._list.add('sentinel');\n this._trimTiles = false;\n }\n\n reset() {\n // Move sentinel node to the tail so, at the start of the frame, all tiles\n // may be potentially replaced. Tiles are moved to the right of the sentinel\n // when they are selected so they will not be replaced.\n this._list.splice(this._list.tail, this._sentinel);\n }\n\n touch(tile) {\n const node = tile._cacheNode;\n if (defined(node)) {\n this._list.splice(this._sentinel, node);\n }\n }\n\n add(tileset, tile, addCallback) {\n if (!defined(tile._cacheNode)) {\n tile._cacheNode = this._list.add(tile);\n\n if (addCallback) {\n addCallback(tileset, tile);\n }\n }\n }\n\n unloadTile(tileset, tile, unloadCallback?) {\n const node = tile._cacheNode;\n if (!defined(node)) {\n return;\n }\n\n this._list.remove(node);\n tile._cacheNode = undefined;\n if (unloadCallback) {\n unloadCallback(tileset, tile);\n }\n }\n\n unloadTiles(tileset, unloadCallback) {\n const trimTiles = this._trimTiles;\n this._trimTiles = false;\n\n const list = this._list;\n\n const maximumMemoryUsageInBytes = tileset.maximumMemoryUsage * 1024 * 1024;\n\n // Traverse the list only to the sentinel since tiles/nodes to the\n // right of the sentinel were used this frame.\n // The sub-list to the left of the sentinel is ordered from LRU to MRU.\n const sentinel = this._sentinel;\n let node = list.head;\n\n while (\n node !== sentinel &&\n (tileset.gpuMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)\n ) {\n const tile = node.item;\n node = node.next;\n this.unloadTile(tileset, tile, unloadCallback);\n }\n }\n\n trim() {\n this._trimTiles = true;\n }\n}\n","import {Ellipsoid} from '@math.gl/geospatial';\nimport {Matrix4, Vector3} from '@math.gl/core';\nimport {assert} from '@loaders.gl/loader-utils';\n\nexport function calculateTransformProps(tileHeader, tile) {\n assert(tileHeader);\n assert(tile);\n\n const {rtcCenter, gltfUpAxis} = tile;\n const {\n computedTransform,\n boundingVolume: {center}\n } = tileHeader;\n\n let modelMatrix = new Matrix4(computedTransform);\n\n // Translate if appropriate\n if (rtcCenter) {\n modelMatrix.translate(rtcCenter);\n }\n\n // glTF models need to be rotated from Y to Z up\n // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up\n switch (gltfUpAxis) {\n case 'Z':\n break;\n case 'Y':\n const rotationY = new Matrix4().rotateX(Math.PI / 2);\n modelMatrix = modelMatrix.multiplyRight(rotationY);\n break;\n case 'X':\n const rotationX = new Matrix4().rotateY(-Math.PI / 2);\n modelMatrix = modelMatrix.multiplyRight(rotationX);\n break;\n default:\n break;\n }\n\n // Scale/offset positions if normalized integers\n if (tile.isQuantized) {\n modelMatrix.translate(tile.quantizedVolumeOffset).scale(tile.quantizedVolumeScale);\n }\n\n // Option 1: Cartesian matrix and origin\n const cartesianOrigin = new Vector3(center);\n\n tile.cartesianModelMatrix = modelMatrix;\n tile.cartesianOrigin = cartesianOrigin;\n\n // Option 2: Cartographic matrix and origin\n const cartographicOrigin = Ellipsoid.WGS84.cartesianToCartographic(\n cartesianOrigin,\n new Vector3()\n );\n const fromFixedFrameMatrix = Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin);\n const toFixedFrameMatrix = fromFixedFrameMatrix.invert();\n\n tile.cartographicModelMatrix = toFixedFrameMatrix.multiplyRight(modelMatrix);\n tile.cartographicOrigin = cartographicOrigin;\n\n // Deprecated, drop\n tile.modelMatrix = tile.cartographicModelMatrix;\n}\n","export const INTERSECTION = Object.freeze({\n OUTSIDE: -1,\n INTERSECTING: 0,\n INSIDE: 1\n});\n//# sourceMappingURL=constants.js.map","import { Vector3 } from '@math.gl/core';\nimport { INTERSECTION } from '../../constants';\nconst scratchVector = new Vector3();\nconst scratchNormal = new Vector3();\nexport default class AxisAlignedBoundingBox {\n constructor(minimum = [0, 0, 0], maximum = [0, 0, 0], center = null) {\n center = center || scratchVector.copy(minimum).add(maximum).scale(0.5);\n this.center = new Vector3(center);\n this.halfDiagonal = new Vector3(maximum).subtract(this.center);\n this.minimum = new Vector3(minimum);\n this.maximum = new Vector3(maximum);\n }\n\n clone() {\n return new AxisAlignedBoundingBox(this.minimum, this.maximum, this.center);\n }\n\n equals(right) {\n return this === right || Boolean(right) && this.minimum.equals(right.minimum) && this.maximum.equals(right.maximum);\n }\n\n transform(transformation) {\n this.center.transformAsPoint(transformation);\n this.halfDiagonal.transform(transformation);\n this.minimum.transform(transformation);\n this.maximum.transform(transformation);\n return this;\n }\n\n intersectPlane(plane) {\n const {\n halfDiagonal\n } = this;\n const normal = scratchNormal.from(plane.normal);\n const e = halfDiagonal.x * Math.abs(normal.x) + halfDiagonal.y * Math.abs(normal.y) + halfDiagonal.z * Math.abs(normal.z);\n const s = this.center.dot(normal) + plane.distance;\n\n if (s - e > 0) {\n return INTERSECTION.INSIDE;\n }\n\n if (s + e < 0) {\n return INTERSECTION.OUTSIDE;\n }\n\n return INTERSECTION.INTERSECTING;\n }\n\n distanceTo(point) {\n return Math.sqrt(this.distanceSquaredTo(point));\n }\n\n distanceSquaredTo(point) {\n const offset = scratchVector.from(point).subtract(this.center);\n const {\n halfDiagonal\n } = this;\n let distanceSquared = 0.0;\n let d;\n d = Math.abs(offset.x) - halfDiagonal.x;\n\n if (d > 0) {\n distanceSquared += d * d;\n }\n\n d = Math.abs(offset.y) - halfDiagonal.y;\n\n if (d > 0) {\n distanceSquared += d * d;\n }\n\n d = Math.abs(offset.z) - halfDiagonal.z;\n\n if (d > 0) {\n distanceSquared += d * d;\n }\n\n return distanceSquared;\n }\n\n}\n//# sourceMappingURL=axis-aligned-bounding-box.js.map","import { Vector3 } from '@math.gl/core';\nimport * as mat4 from 'gl-matrix/mat4';\nimport { INTERSECTION } from '../../constants';\nconst scratchVector = new Vector3();\nconst scratchVector2 = new Vector3();\nexport default class BoundingSphere {\n constructor(center = [0, 0, 0], radius = 0.0) {\n this.radius = -0;\n this.center = new Vector3();\n this.fromCenterRadius(center, radius);\n }\n\n fromCenterRadius(center, radius) {\n this.center.from(center);\n this.radius = radius;\n return this;\n }\n\n fromCornerPoints(corner, oppositeCorner) {\n oppositeCorner = scratchVector.from(oppositeCorner);\n this.center = new Vector3().from(corner).add(oppositeCorner).scale(0.5);\n this.radius = this.center.distance(oppositeCorner);\n return this;\n }\n\n equals(right) {\n return this === right || Boolean(right) && this.center.equals(right.center) && this.radius === right.radius;\n }\n\n clone() {\n return new BoundingSphere(this.center, this.radius);\n }\n\n union(boundingSphere) {\n const leftCenter = this.center;\n const leftRadius = this.radius;\n const rightCenter = boundingSphere.center;\n const rightRadius = boundingSphere.radius;\n const toRightCenter = scratchVector.copy(rightCenter).subtract(leftCenter);\n const centerSeparation = toRightCenter.magnitude();\n\n if (leftRadius >= centerSeparation + rightRadius) {\n return this.clone();\n }\n\n if (rightRadius >= centerSeparation + leftRadius) {\n return boundingSphere.clone();\n }\n\n const halfDistanceBetweenTangentPoints = (leftRadius + centerSeparation + rightRadius) * 0.5;\n scratchVector2.copy(toRightCenter).scale((-leftRadius + halfDistanceBetweenTangentPoints) / centerSeparation).add(leftCenter);\n this.center.copy(scratchVector2);\n this.radius = halfDistanceBetweenTangentPoints;\n return this;\n }\n\n expand(point) {\n point = scratchVector.from(point);\n const radius = point.subtract(this.center).magnitude();\n\n if (radius > this.radius) {\n this.radius = radius;\n }\n\n return this;\n }\n\n transform(transform) {\n this.center.transform(transform);\n const scale = mat4.getScaling(scratchVector, transform);\n this.radius = Math.max(scale[0], Math.max(scale[1], scale[2])) * this.radius;\n return this;\n }\n\n distanceSquaredTo(point) {\n point = scratchVector.from(point);\n const delta = point.subtract(this.center);\n return delta.lengthSquared() - this.radius * this.radius;\n }\n\n distanceTo(point) {\n return Math.sqrt(this.distanceSquaredTo(point));\n }\n\n intersectPlane(plane) {\n const center = this.center;\n const radius = this.radius;\n const normal = plane.normal;\n const distanceToPlane = normal.dot(center) + plane.distance;\n\n if (distanceToPlane < -radius) {\n return INTERSECTION.OUTSIDE;\n }\n\n if (distanceToPlane < radius) {\n return INTERSECTION.INTERSECTING;\n }\n\n return INTERSECTION.INSIDE;\n }\n\n}\n//# sourceMappingURL=bounding-sphere.js.map","import * as glMatrix from \"./common.js\";\n/**\r\n * 3x3 Matrix\r\n * @module mat3\r\n */\n\n/**\r\n * Creates a new identity mat3\r\n *\r\n * @returns {mat3} a new 3x3 matrix\r\n */\n\nexport function create() {\n var out = new glMatrix.ARRAY_TYPE(9);\n\n if (glMatrix.ARRAY_TYPE != Float32Array) {\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[5] = 0;\n out[6] = 0;\n out[7] = 0;\n }\n\n out[0] = 1;\n out[4] = 1;\n out[8] = 1;\n return out;\n}\n/**\r\n * Copies the upper-left 3x3 values into the given mat3.\r\n *\r\n * @param {mat3} out the receiving 3x3 matrix\r\n * @param {ReadonlyMat4} a the source 4x4 matrix\r\n * @returns {mat3} out\r\n */\n\nexport function fromMat4(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[4];\n out[4] = a[5];\n out[5] = a[6];\n out[6] = a[8];\n out[7] = a[9];\n out[8] = a[10];\n return out;\n}\n/**\r\n * Creates a new mat3 initialized with values from an existing matrix\r\n *\r\n * @param {ReadonlyMat3} a matrix to clone\r\n * @returns {mat3} a new 3x3 matrix\r\n */\n\nexport function clone(a) {\n var out = new glMatrix.ARRAY_TYPE(9);\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n out[4] = a[4];\n out[5] = a[5];\n out[6] = a[6];\n out[7] = a[7];\n out[8] = a[8];\n return out;\n}\n/**\r\n * Copy the values from one mat3 to another\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the source matrix\r\n * @returns {mat3} out\r\n */\n\nexport function copy(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n out[4] = a[4];\n out[5] = a[5];\n out[6] = a[6];\n out[7] = a[7];\n out[8] = a[8];\n return out;\n}\n/**\r\n * Create a new mat3 with the given values\r\n *\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 3)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 4)\r\n * @param {Number} m12 Component in column 1, row 2 position (index 5)\r\n * @param {Number} m20 Component in column 2, row 0 position (index 6)\r\n * @param {Number} m21 Component in column 2, row 1 position (index 7)\r\n * @param {Number} m22 Component in column 2, row 2 position (index 8)\r\n * @returns {mat3} A new mat3\r\n */\n\nexport function fromValues(m00, m01, m02, m10, m11, m12, m20, m21, m22) {\n var out = new glMatrix.ARRAY_TYPE(9);\n out[0] = m00;\n out[1] = m01;\n out[2] = m02;\n out[3] = m10;\n out[4] = m11;\n out[5] = m12;\n out[6] = m20;\n out[7] = m21;\n out[8] = m22;\n return out;\n}\n/**\r\n * Set the components of a mat3 to the given values\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 3)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 4)\r\n * @param {Number} m12 Component in column 1, row 2 position (index 5)\r\n * @param {Number} m20 Component in column 2, row 0 position (index 6)\r\n * @param {Number} m21 Component in column 2, row 1 position (index 7)\r\n * @param {Number} m22 Component in column 2, row 2 position (index 8)\r\n * @returns {mat3} out\r\n */\n\nexport function set(out, m00, m01, m02, m10, m11, m12, m20, m21, m22) {\n out[0] = m00;\n out[1] = m01;\n out[2] = m02;\n out[3] = m10;\n out[4] = m11;\n out[5] = m12;\n out[6] = m20;\n out[7] = m21;\n out[8] = m22;\n return out;\n}\n/**\r\n * Set a mat3 to the identity matrix\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @returns {mat3} out\r\n */\n\nexport function identity(out) {\n out[0] = 1;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 1;\n out[5] = 0;\n out[6] = 0;\n out[7] = 0;\n out[8] = 1;\n return out;\n}\n/**\r\n * Transpose the values of a mat3\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the source matrix\r\n * @returns {mat3} out\r\n */\n\nexport function transpose(out, a) {\n // If we are transposing ourselves we can skip a few steps but have to cache some values\n if (out === a) {\n var a01 = a[1],\n a02 = a[2],\n a12 = a[5];\n out[1] = a[3];\n out[2] = a[6];\n out[3] = a01;\n out[5] = a[7];\n out[6] = a02;\n out[7] = a12;\n } else {\n out[0] = a[0];\n out[1] = a[3];\n out[2] = a[6];\n out[3] = a[1];\n out[4] = a[4];\n out[5] = a[7];\n out[6] = a[2];\n out[7] = a[5];\n out[8] = a[8];\n }\n\n return out;\n}\n/**\r\n * Inverts a mat3\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the source matrix\r\n * @returns {mat3} out\r\n */\n\nexport function invert(out, a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2];\n var a10 = a[3],\n a11 = a[4],\n a12 = a[5];\n var a20 = a[6],\n a21 = a[7],\n a22 = a[8];\n var b01 = a22 * a11 - a12 * a21;\n var b11 = -a22 * a10 + a12 * a20;\n var b21 = a21 * a10 - a11 * a20; // Calculate the determinant\n\n var det = a00 * b01 + a01 * b11 + a02 * b21;\n\n if (!det) {\n return null;\n }\n\n det = 1.0 / det;\n out[0] = b01 * det;\n out[1] = (-a22 * a01 + a02 * a21) * det;\n out[2] = (a12 * a01 - a02 * a11) * det;\n out[3] = b11 * det;\n out[4] = (a22 * a00 - a02 * a20) * det;\n out[5] = (-a12 * a00 + a02 * a10) * det;\n out[6] = b21 * det;\n out[7] = (-a21 * a00 + a01 * a20) * det;\n out[8] = (a11 * a00 - a01 * a10) * det;\n return out;\n}\n/**\r\n * Calculates the adjugate of a mat3\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the source matrix\r\n * @returns {mat3} out\r\n */\n\nexport function adjoint(out, a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2];\n var a10 = a[3],\n a11 = a[4],\n a12 = a[5];\n var a20 = a[6],\n a21 = a[7],\n a22 = a[8];\n out[0] = a11 * a22 - a12 * a21;\n out[1] = a02 * a21 - a01 * a22;\n out[2] = a01 * a12 - a02 * a11;\n out[3] = a12 * a20 - a10 * a22;\n out[4] = a00 * a22 - a02 * a20;\n out[5] = a02 * a10 - a00 * a12;\n out[6] = a10 * a21 - a11 * a20;\n out[7] = a01 * a20 - a00 * a21;\n out[8] = a00 * a11 - a01 * a10;\n return out;\n}\n/**\r\n * Calculates the determinant of a mat3\r\n *\r\n * @param {ReadonlyMat3} a the source matrix\r\n * @returns {Number} determinant of a\r\n */\n\nexport function determinant(a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2];\n var a10 = a[3],\n a11 = a[4],\n a12 = a[5];\n var a20 = a[6],\n a21 = a[7],\n a22 = a[8];\n return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);\n}\n/**\r\n * Multiplies two mat3's\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the first operand\r\n * @param {ReadonlyMat3} b the second operand\r\n * @returns {mat3} out\r\n */\n\nexport function multiply(out, a, b) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2];\n var a10 = a[3],\n a11 = a[4],\n a12 = a[5];\n var a20 = a[6],\n a21 = a[7],\n a22 = a[8];\n var b00 = b[0],\n b01 = b[1],\n b02 = b[2];\n var b10 = b[3],\n b11 = b[4],\n b12 = b[5];\n var b20 = b[6],\n b21 = b[7],\n b22 = b[8];\n out[0] = b00 * a00 + b01 * a10 + b02 * a20;\n out[1] = b00 * a01 + b01 * a11 + b02 * a21;\n out[2] = b00 * a02 + b01 * a12 + b02 * a22;\n out[3] = b10 * a00 + b11 * a10 + b12 * a20;\n out[4] = b10 * a01 + b11 * a11 + b12 * a21;\n out[5] = b10 * a02 + b11 * a12 + b12 * a22;\n out[6] = b20 * a00 + b21 * a10 + b22 * a20;\n out[7] = b20 * a01 + b21 * a11 + b22 * a21;\n out[8] = b20 * a02 + b21 * a12 + b22 * a22;\n return out;\n}\n/**\r\n * Translate a mat3 by the given vector\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the matrix to translate\r\n * @param {ReadonlyVec2} v vector to translate by\r\n * @returns {mat3} out\r\n */\n\nexport function translate(out, a, v) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a10 = a[3],\n a11 = a[4],\n a12 = a[5],\n a20 = a[6],\n a21 = a[7],\n a22 = a[8],\n x = v[0],\n y = v[1];\n out[0] = a00;\n out[1] = a01;\n out[2] = a02;\n out[3] = a10;\n out[4] = a11;\n out[5] = a12;\n out[6] = x * a00 + y * a10 + a20;\n out[7] = x * a01 + y * a11 + a21;\n out[8] = x * a02 + y * a12 + a22;\n return out;\n}\n/**\r\n * Rotates a mat3 by the given angle\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat3} out\r\n */\n\nexport function rotate(out, a, rad) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a10 = a[3],\n a11 = a[4],\n a12 = a[5],\n a20 = a[6],\n a21 = a[7],\n a22 = a[8],\n s = Math.sin(rad),\n c = Math.cos(rad);\n out[0] = c * a00 + s * a10;\n out[1] = c * a01 + s * a11;\n out[2] = c * a02 + s * a12;\n out[3] = c * a10 - s * a00;\n out[4] = c * a11 - s * a01;\n out[5] = c * a12 - s * a02;\n out[6] = a20;\n out[7] = a21;\n out[8] = a22;\n return out;\n}\n/**\r\n * Scales the mat3 by the dimensions in the given vec2\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the matrix to rotate\r\n * @param {ReadonlyVec2} v the vec2 to scale the matrix by\r\n * @returns {mat3} out\r\n **/\n\nexport function scale(out, a, v) {\n var x = v[0],\n y = v[1];\n out[0] = x * a[0];\n out[1] = x * a[1];\n out[2] = x * a[2];\n out[3] = y * a[3];\n out[4] = y * a[4];\n out[5] = y * a[5];\n out[6] = a[6];\n out[7] = a[7];\n out[8] = a[8];\n return out;\n}\n/**\r\n * Creates a matrix from a vector translation\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat3.identity(dest);\r\n * mat3.translate(dest, dest, vec);\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {ReadonlyVec2} v Translation vector\r\n * @returns {mat3} out\r\n */\n\nexport function fromTranslation(out, v) {\n out[0] = 1;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 1;\n out[5] = 0;\n out[6] = v[0];\n out[7] = v[1];\n out[8] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from a given angle\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat3.identity(dest);\r\n * mat3.rotate(dest, dest, rad);\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat3} out\r\n */\n\nexport function fromRotation(out, rad) {\n var s = Math.sin(rad),\n c = Math.cos(rad);\n out[0] = c;\n out[1] = s;\n out[2] = 0;\n out[3] = -s;\n out[4] = c;\n out[5] = 0;\n out[6] = 0;\n out[7] = 0;\n out[8] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from a vector scaling\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat3.identity(dest);\r\n * mat3.scale(dest, dest, vec);\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {ReadonlyVec2} v Scaling vector\r\n * @returns {mat3} out\r\n */\n\nexport function fromScaling(out, v) {\n out[0] = v[0];\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = v[1];\n out[5] = 0;\n out[6] = 0;\n out[7] = 0;\n out[8] = 1;\n return out;\n}\n/**\r\n * Copies the values from a mat2d into a mat3\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat2d} a the matrix to copy\r\n * @returns {mat3} out\r\n **/\n\nexport function fromMat2d(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n out[2] = 0;\n out[3] = a[2];\n out[4] = a[3];\n out[5] = 0;\n out[6] = a[4];\n out[7] = a[5];\n out[8] = 1;\n return out;\n}\n/**\r\n * Calculates a 3x3 matrix from the given quaternion\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {ReadonlyQuat} q Quaternion to create matrix from\r\n *\r\n * @returns {mat3} out\r\n */\n\nexport function fromQuat(out, q) {\n var x = q[0],\n y = q[1],\n z = q[2],\n w = q[3];\n var x2 = x + x;\n var y2 = y + y;\n var z2 = z + z;\n var xx = x * x2;\n var yx = y * x2;\n var yy = y * y2;\n var zx = z * x2;\n var zy = z * y2;\n var zz = z * z2;\n var wx = w * x2;\n var wy = w * y2;\n var wz = w * z2;\n out[0] = 1 - yy - zz;\n out[3] = yx - wz;\n out[6] = zx + wy;\n out[1] = yx + wz;\n out[4] = 1 - xx - zz;\n out[7] = zy - wx;\n out[2] = zx - wy;\n out[5] = zy + wx;\n out[8] = 1 - xx - yy;\n return out;\n}\n/**\r\n * Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {ReadonlyMat4} a Mat4 to derive the normal matrix from\r\n *\r\n * @returns {mat3} out\r\n */\n\nexport function normalFromMat4(out, a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a03 = a[3];\n var a10 = a[4],\n a11 = a[5],\n a12 = a[6],\n a13 = a[7];\n var a20 = a[8],\n a21 = a[9],\n a22 = a[10],\n a23 = a[11];\n var a30 = a[12],\n a31 = a[13],\n a32 = a[14],\n a33 = a[15];\n var b00 = a00 * a11 - a01 * a10;\n var b01 = a00 * a12 - a02 * a10;\n var b02 = a00 * a13 - a03 * a10;\n var b03 = a01 * a12 - a02 * a11;\n var b04 = a01 * a13 - a03 * a11;\n var b05 = a02 * a13 - a03 * a12;\n var b06 = a20 * a31 - a21 * a30;\n var b07 = a20 * a32 - a22 * a30;\n var b08 = a20 * a33 - a23 * a30;\n var b09 = a21 * a32 - a22 * a31;\n var b10 = a21 * a33 - a23 * a31;\n var b11 = a22 * a33 - a23 * a32; // Calculate the determinant\n\n var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\n if (!det) {\n return null;\n }\n\n det = 1.0 / det;\n out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;\n out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;\n out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;\n out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;\n out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;\n out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;\n out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;\n out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;\n out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;\n return out;\n}\n/**\r\n * Generates a 2D projection matrix with the given bounds\r\n *\r\n * @param {mat3} out mat3 frustum matrix will be written into\r\n * @param {number} width Width of your gl context\r\n * @param {number} height Height of gl context\r\n * @returns {mat3} out\r\n */\n\nexport function projection(out, width, height) {\n out[0] = 2 / width;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = -2 / height;\n out[5] = 0;\n out[6] = -1;\n out[7] = 1;\n out[8] = 1;\n return out;\n}\n/**\r\n * Returns a string representation of a mat3\r\n *\r\n * @param {ReadonlyMat3} a matrix to represent as a string\r\n * @returns {String} string representation of the matrix\r\n */\n\nexport function str(a) {\n return \"mat3(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \", \" + a[3] + \", \" + a[4] + \", \" + a[5] + \", \" + a[6] + \", \" + a[7] + \", \" + a[8] + \")\";\n}\n/**\r\n * Returns Frobenius norm of a mat3\r\n *\r\n * @param {ReadonlyMat3} a the matrix to calculate Frobenius norm of\r\n * @returns {Number} Frobenius norm\r\n */\n\nexport function frob(a) {\n return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);\n}\n/**\r\n * Adds two mat3's\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the first operand\r\n * @param {ReadonlyMat3} b the second operand\r\n * @returns {mat3} out\r\n */\n\nexport function add(out, a, b) {\n out[0] = a[0] + b[0];\n out[1] = a[1] + b[1];\n out[2] = a[2] + b[2];\n out[3] = a[3] + b[3];\n out[4] = a[4] + b[4];\n out[5] = a[5] + b[5];\n out[6] = a[6] + b[6];\n out[7] = a[7] + b[7];\n out[8] = a[8] + b[8];\n return out;\n}\n/**\r\n * Subtracts matrix b from matrix a\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the first operand\r\n * @param {ReadonlyMat3} b the second operand\r\n * @returns {mat3} out\r\n */\n\nexport function subtract(out, a, b) {\n out[0] = a[0] - b[0];\n out[1] = a[1] - b[1];\n out[2] = a[2] - b[2];\n out[3] = a[3] - b[3];\n out[4] = a[4] - b[4];\n out[5] = a[5] - b[5];\n out[6] = a[6] - b[6];\n out[7] = a[7] - b[7];\n out[8] = a[8] - b[8];\n return out;\n}\n/**\r\n * Multiply each element of the matrix by a scalar.\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the matrix to scale\r\n * @param {Number} b amount to scale the matrix's elements by\r\n * @returns {mat3} out\r\n */\n\nexport function multiplyScalar(out, a, b) {\n out[0] = a[0] * b;\n out[1] = a[1] * b;\n out[2] = a[2] * b;\n out[3] = a[3] * b;\n out[4] = a[4] * b;\n out[5] = a[5] * b;\n out[6] = a[6] * b;\n out[7] = a[7] * b;\n out[8] = a[8] * b;\n return out;\n}\n/**\r\n * Adds two mat3's after multiplying each element of the second operand by a scalar value.\r\n *\r\n * @param {mat3} out the receiving vector\r\n * @param {ReadonlyMat3} a the first operand\r\n * @param {ReadonlyMat3} b the second operand\r\n * @param {Number} scale the amount to scale b's elements by before adding\r\n * @returns {mat3} out\r\n */\n\nexport function multiplyScalarAndAdd(out, a, b, scale) {\n out[0] = a[0] + b[0] * scale;\n out[1] = a[1] + b[1] * scale;\n out[2] = a[2] + b[2] * scale;\n out[3] = a[3] + b[3] * scale;\n out[4] = a[4] + b[4] * scale;\n out[5] = a[5] + b[5] * scale;\n out[6] = a[6] + b[6] * scale;\n out[7] = a[7] + b[7] * scale;\n out[8] = a[8] + b[8] * scale;\n return out;\n}\n/**\r\n * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {ReadonlyMat3} a The first matrix.\r\n * @param {ReadonlyMat3} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\n\nexport function exactEquals(a, b) {\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8];\n}\n/**\r\n * Returns whether or not the matrices have approximately the same elements in the same position.\r\n *\r\n * @param {ReadonlyMat3} a The first matrix.\r\n * @param {ReadonlyMat3} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\n\nexport function equals(a, b) {\n var a0 = a[0],\n a1 = a[1],\n a2 = a[2],\n a3 = a[3],\n a4 = a[4],\n a5 = a[5],\n a6 = a[6],\n a7 = a[7],\n a8 = a[8];\n var b0 = b[0],\n b1 = b[1],\n b2 = b[2],\n b3 = b[3],\n b4 = b[4],\n b5 = b[5],\n b6 = b[6],\n b7 = b[7],\n b8 = b[8];\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8));\n}\n/**\r\n * Alias for {@link mat3.multiply}\r\n * @function\r\n */\n\nexport var mul = multiply;\n/**\r\n * Alias for {@link mat3.subtract}\r\n * @function\r\n */\n\nexport var sub = subtract;","import Matrix from './base/matrix';\nimport { checkVector, deprecated } from '../lib/validators';\nimport { vec4_transformMat3 } from '../lib/gl-matrix-extras';\nimport * as mat3 from 'gl-matrix/mat3';\nimport * as vec2 from 'gl-matrix/vec2';\nimport * as vec3 from 'gl-matrix/vec3';\nconst IDENTITY = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]);\nconst ZERO = Object.freeze([0, 0, 0, 0, 0, 0, 0, 0, 0]);\nconst INDICES = Object.freeze({\n COL0ROW0: 0,\n COL0ROW1: 1,\n COL0ROW2: 2,\n COL1ROW0: 3,\n COL1ROW1: 4,\n COL1ROW2: 5,\n COL2ROW0: 6,\n COL2ROW1: 7,\n COL2ROW2: 8\n});\nconst constants = {};\nexport default class Matrix3 extends Matrix {\n static get IDENTITY() {\n constants.IDENTITY = constants.IDENTITY || Object.freeze(new Matrix3(IDENTITY));\n return constants.IDENTITY;\n }\n\n static get ZERO() {\n constants.ZERO = constants.ZERO || Object.freeze(new Matrix3(ZERO));\n return constants.ZERO;\n }\n\n get ELEMENTS() {\n return 9;\n }\n\n get RANK() {\n return 3;\n }\n\n get INDICES() {\n return INDICES;\n }\n\n constructor(array) {\n super(-0, -0, -0, -0, -0, -0, -0, -0, -0);\n\n if (arguments.length === 1 && Array.isArray(array)) {\n this.copy(array);\n } else {\n this.identity();\n }\n }\n\n copy(array) {\n this[0] = array[0];\n this[1] = array[1];\n this[2] = array[2];\n this[3] = array[3];\n this[4] = array[4];\n this[5] = array[5];\n this[6] = array[6];\n this[7] = array[7];\n this[8] = array[8];\n return this.check();\n }\n\n set(m00, m10, m20, m01, m11, m21, m02, m12, m22) {\n this[0] = m00;\n this[1] = m10;\n this[2] = m20;\n this[3] = m01;\n this[4] = m11;\n this[5] = m21;\n this[6] = m02;\n this[7] = m12;\n this[8] = m22;\n return this.check();\n }\n\n setRowMajor(m00, m01, m02, m10, m11, m12, m20, m21, m22) {\n this[0] = m00;\n this[1] = m10;\n this[2] = m20;\n this[3] = m01;\n this[4] = m11;\n this[5] = m21;\n this[6] = m02;\n this[7] = m12;\n this[8] = m22;\n return this.check();\n }\n\n determinant() {\n return mat3.determinant(this);\n }\n\n identity() {\n return this.copy(IDENTITY);\n }\n\n fromQuaternion(q) {\n mat3.fromQuat(this, q);\n return this.check();\n }\n\n transpose() {\n mat3.transpose(this, this);\n return this.check();\n }\n\n invert() {\n mat3.invert(this, this);\n return this.check();\n }\n\n multiplyLeft(a) {\n mat3.multiply(this, a, this);\n return this.check();\n }\n\n multiplyRight(a) {\n mat3.multiply(this, this, a);\n return this.check();\n }\n\n rotate(radians) {\n mat3.rotate(this, this, radians);\n return this.check();\n }\n\n scale(factor) {\n if (Array.isArray(factor)) {\n mat3.scale(this, this, factor);\n } else {\n mat3.scale(this, this, [factor, factor, factor]);\n }\n\n return this.check();\n }\n\n translate(vec) {\n mat3.translate(this, this, vec);\n return this.check();\n }\n\n transform(vector, result) {\n switch (vector.length) {\n case 2:\n result = vec2.transformMat3(result || [-0, -0], vector, this);\n break;\n\n case 3:\n result = vec3.transformMat3(result || [-0, -0, -0], vector, this);\n break;\n\n case 4:\n result = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this);\n break;\n\n default:\n throw new Error('Illegal vector');\n }\n\n checkVector(result, vector.length);\n return result;\n }\n\n transformVector(vector, result) {\n deprecated('Matrix3.transformVector');\n return this.transform(vector, result);\n }\n\n transformVector2(vector, result) {\n deprecated('Matrix3.transformVector');\n return this.transform(vector, result);\n }\n\n transformVector3(vector, result) {\n deprecated('Matrix3.transformVector');\n return this.transform(vector, result);\n }\n\n}\n//# sourceMappingURL=matrix3.js.map","import * as glMatrix from \"./common.js\";\nimport * as mat3 from \"./mat3.js\";\nimport * as vec3 from \"./vec3.js\";\nimport * as vec4 from \"./vec4.js\";\n/**\r\n * Quaternion\r\n * @module quat\r\n */\n\n/**\r\n * Creates a new identity quat\r\n *\r\n * @returns {quat} a new quaternion\r\n */\n\nexport function create() {\n var out = new glMatrix.ARRAY_TYPE(4);\n\n if (glMatrix.ARRAY_TYPE != Float32Array) {\n out[0] = 0;\n out[1] = 0;\n out[2] = 0;\n }\n\n out[3] = 1;\n return out;\n}\n/**\r\n * Set a quat to the identity quaternion\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @returns {quat} out\r\n */\n\nexport function identity(out) {\n out[0] = 0;\n out[1] = 0;\n out[2] = 0;\n out[3] = 1;\n return out;\n}\n/**\r\n * Sets a quat from the given angle and rotation axis,\r\n * then returns it.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyVec3} axis the axis around which to rotate\r\n * @param {Number} rad the angle in radians\r\n * @returns {quat} out\r\n **/\n\nexport function setAxisAngle(out, axis, rad) {\n rad = rad * 0.5;\n var s = Math.sin(rad);\n out[0] = s * axis[0];\n out[1] = s * axis[1];\n out[2] = s * axis[2];\n out[3] = Math.cos(rad);\n return out;\n}\n/**\r\n * Gets the rotation axis and angle for a given\r\n * quaternion. If a quaternion is created with\r\n * setAxisAngle, this method will return the same\r\n * values as providied in the original parameter list\r\n * OR functionally equivalent values.\r\n * Example: The quaternion formed by axis [0, 0, 1] and\r\n * angle -90 is the same as the quaternion formed by\r\n * [0, 0, 1] and 270. This method favors the latter.\r\n * @param {vec3} out_axis Vector receiving the axis of rotation\r\n * @param {ReadonlyQuat} q Quaternion to be decomposed\r\n * @return {Number} Angle, in radians, of the rotation\r\n */\n\nexport function getAxisAngle(out_axis, q) {\n var rad = Math.acos(q[3]) * 2.0;\n var s = Math.sin(rad / 2.0);\n\n if (s > glMatrix.EPSILON) {\n out_axis[0] = q[0] / s;\n out_axis[1] = q[1] / s;\n out_axis[2] = q[2] / s;\n } else {\n // If s is zero, return any axis (no rotation - axis does not matter)\n out_axis[0] = 1;\n out_axis[1] = 0;\n out_axis[2] = 0;\n }\n\n return rad;\n}\n/**\r\n * Gets the angular distance between two unit quaternions\r\n *\r\n * @param {ReadonlyQuat} a Origin unit quaternion\r\n * @param {ReadonlyQuat} b Destination unit quaternion\r\n * @return {Number} Angle, in radians, between the two quaternions\r\n */\n\nexport function getAngle(a, b) {\n var dotproduct = dot(a, b);\n return Math.acos(2 * dotproduct * dotproduct - 1);\n}\n/**\r\n * Multiplies two quat's\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a the first operand\r\n * @param {ReadonlyQuat} b the second operand\r\n * @returns {quat} out\r\n */\n\nexport function multiply(out, a, b) {\n var ax = a[0],\n ay = a[1],\n az = a[2],\n aw = a[3];\n var bx = b[0],\n by = b[1],\n bz = b[2],\n bw = b[3];\n out[0] = ax * bw + aw * bx + ay * bz - az * by;\n out[1] = ay * bw + aw * by + az * bx - ax * bz;\n out[2] = az * bw + aw * bz + ax * by - ay * bx;\n out[3] = aw * bw - ax * bx - ay * by - az * bz;\n return out;\n}\n/**\r\n * Rotates a quaternion by the given angle about the X axis\r\n *\r\n * @param {quat} out quat receiving operation result\r\n * @param {ReadonlyQuat} a quat to rotate\r\n * @param {number} rad angle (in radians) to rotate\r\n * @returns {quat} out\r\n */\n\nexport function rotateX(out, a, rad) {\n rad *= 0.5;\n var ax = a[0],\n ay = a[1],\n az = a[2],\n aw = a[3];\n var bx = Math.sin(rad),\n bw = Math.cos(rad);\n out[0] = ax * bw + aw * bx;\n out[1] = ay * bw + az * bx;\n out[2] = az * bw - ay * bx;\n out[3] = aw * bw - ax * bx;\n return out;\n}\n/**\r\n * Rotates a quaternion by the given angle about the Y axis\r\n *\r\n * @param {quat} out quat receiving operation result\r\n * @param {ReadonlyQuat} a quat to rotate\r\n * @param {number} rad angle (in radians) to rotate\r\n * @returns {quat} out\r\n */\n\nexport function rotateY(out, a, rad) {\n rad *= 0.5;\n var ax = a[0],\n ay = a[1],\n az = a[2],\n aw = a[3];\n var by = Math.sin(rad),\n bw = Math.cos(rad);\n out[0] = ax * bw - az * by;\n out[1] = ay * bw + aw * by;\n out[2] = az * bw + ax * by;\n out[3] = aw * bw - ay * by;\n return out;\n}\n/**\r\n * Rotates a quaternion by the given angle about the Z axis\r\n *\r\n * @param {quat} out quat receiving operation result\r\n * @param {ReadonlyQuat} a quat to rotate\r\n * @param {number} rad angle (in radians) to rotate\r\n * @returns {quat} out\r\n */\n\nexport function rotateZ(out, a, rad) {\n rad *= 0.5;\n var ax = a[0],\n ay = a[1],\n az = a[2],\n aw = a[3];\n var bz = Math.sin(rad),\n bw = Math.cos(rad);\n out[0] = ax * bw + ay * bz;\n out[1] = ay * bw - ax * bz;\n out[2] = az * bw + aw * bz;\n out[3] = aw * bw - az * bz;\n return out;\n}\n/**\r\n * Calculates the W component of a quat from the X, Y, and Z components.\r\n * Assumes that quaternion is 1 unit in length.\r\n * Any existing W component will be ignored.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quat to calculate W component of\r\n * @returns {quat} out\r\n */\n\nexport function calculateW(out, a) {\n var x = a[0],\n y = a[1],\n z = a[2];\n out[0] = x;\n out[1] = y;\n out[2] = z;\n out[3] = Math.sqrt(Math.abs(1.0 - x * x - y * y - z * z));\n return out;\n}\n/**\r\n * Calculate the exponential of a unit quaternion.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quat to calculate the exponential of\r\n * @returns {quat} out\r\n */\n\nexport function exp(out, a) {\n var x = a[0],\n y = a[1],\n z = a[2],\n w = a[3];\n var r = Math.sqrt(x * x + y * y + z * z);\n var et = Math.exp(w);\n var s = r > 0 ? et * Math.sin(r) / r : 0;\n out[0] = x * s;\n out[1] = y * s;\n out[2] = z * s;\n out[3] = et * Math.cos(r);\n return out;\n}\n/**\r\n * Calculate the natural logarithm of a unit quaternion.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quat to calculate the exponential of\r\n * @returns {quat} out\r\n */\n\nexport function ln(out, a) {\n var x = a[0],\n y = a[1],\n z = a[2],\n w = a[3];\n var r = Math.sqrt(x * x + y * y + z * z);\n var t = r > 0 ? Math.atan2(r, w) / r : 0;\n out[0] = x * t;\n out[1] = y * t;\n out[2] = z * t;\n out[3] = 0.5 * Math.log(x * x + y * y + z * z + w * w);\n return out;\n}\n/**\r\n * Calculate the scalar power of a unit quaternion.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quat to calculate the exponential of\r\n * @param {Number} b amount to scale the quaternion by\r\n * @returns {quat} out\r\n */\n\nexport function pow(out, a, b) {\n ln(out, a);\n scale(out, out, b);\n exp(out, out);\n return out;\n}\n/**\r\n * Performs a spherical linear interpolation between two quat\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a the first operand\r\n * @param {ReadonlyQuat} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {quat} out\r\n */\n\nexport function slerp(out, a, b, t) {\n // benchmarks:\n // http://jsperf.com/quaternion-slerp-implementations\n var ax = a[0],\n ay = a[1],\n az = a[2],\n aw = a[3];\n var bx = b[0],\n by = b[1],\n bz = b[2],\n bw = b[3];\n var omega, cosom, sinom, scale0, scale1; // calc cosine\n\n cosom = ax * bx + ay * by + az * bz + aw * bw; // adjust signs (if necessary)\n\n if (cosom < 0.0) {\n cosom = -cosom;\n bx = -bx;\n by = -by;\n bz = -bz;\n bw = -bw;\n } // calculate coefficients\n\n\n if (1.0 - cosom > glMatrix.EPSILON) {\n // standard case (slerp)\n omega = Math.acos(cosom);\n sinom = Math.sin(omega);\n scale0 = Math.sin((1.0 - t) * omega) / sinom;\n scale1 = Math.sin(t * omega) / sinom;\n } else {\n // \"from\" and \"to\" quaternions are very close\n // ... so we can do a linear interpolation\n scale0 = 1.0 - t;\n scale1 = t;\n } // calculate final values\n\n\n out[0] = scale0 * ax + scale1 * bx;\n out[1] = scale0 * ay + scale1 * by;\n out[2] = scale0 * az + scale1 * bz;\n out[3] = scale0 * aw + scale1 * bw;\n return out;\n}\n/**\r\n * Generates a random unit quaternion\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @returns {quat} out\r\n */\n\nexport function random(out) {\n // Implementation of http://planning.cs.uiuc.edu/node198.html\n // TODO: Calling random 3 times is probably not the fastest solution\n var u1 = glMatrix.RANDOM();\n var u2 = glMatrix.RANDOM();\n var u3 = glMatrix.RANDOM();\n var sqrt1MinusU1 = Math.sqrt(1 - u1);\n var sqrtU1 = Math.sqrt(u1);\n out[0] = sqrt1MinusU1 * Math.sin(2.0 * Math.PI * u2);\n out[1] = sqrt1MinusU1 * Math.cos(2.0 * Math.PI * u2);\n out[2] = sqrtU1 * Math.sin(2.0 * Math.PI * u3);\n out[3] = sqrtU1 * Math.cos(2.0 * Math.PI * u3);\n return out;\n}\n/**\r\n * Calculates the inverse of a quat\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quat to calculate inverse of\r\n * @returns {quat} out\r\n */\n\nexport function invert(out, a) {\n var a0 = a[0],\n a1 = a[1],\n a2 = a[2],\n a3 = a[3];\n var dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;\n var invDot = dot ? 1.0 / dot : 0; // TODO: Would be faster to return [0,0,0,0] immediately if dot == 0\n\n out[0] = -a0 * invDot;\n out[1] = -a1 * invDot;\n out[2] = -a2 * invDot;\n out[3] = a3 * invDot;\n return out;\n}\n/**\r\n * Calculates the conjugate of a quat\r\n * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quat to calculate conjugate of\r\n * @returns {quat} out\r\n */\n\nexport function conjugate(out, a) {\n out[0] = -a[0];\n out[1] = -a[1];\n out[2] = -a[2];\n out[3] = a[3];\n return out;\n}\n/**\r\n * Creates a quaternion from the given 3x3 rotation matrix.\r\n *\r\n * NOTE: The resultant quaternion is not normalized, so you should be sure\r\n * to renormalize the quaternion yourself where necessary.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyMat3} m rotation matrix\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport function fromMat3(out, m) {\n // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes\n // article \"Quaternion Calculus and Fast Animation\".\n var fTrace = m[0] + m[4] + m[8];\n var fRoot;\n\n if (fTrace > 0.0) {\n // |w| > 1/2, may as well choose w > 1/2\n fRoot = Math.sqrt(fTrace + 1.0); // 2w\n\n out[3] = 0.5 * fRoot;\n fRoot = 0.5 / fRoot; // 1/(4w)\n\n out[0] = (m[5] - m[7]) * fRoot;\n out[1] = (m[6] - m[2]) * fRoot;\n out[2] = (m[1] - m[3]) * fRoot;\n } else {\n // |w| <= 1/2\n var i = 0;\n if (m[4] > m[0]) i = 1;\n if (m[8] > m[i * 3 + i]) i = 2;\n var j = (i + 1) % 3;\n var k = (i + 2) % 3;\n fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0);\n out[i] = 0.5 * fRoot;\n fRoot = 0.5 / fRoot;\n out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;\n out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;\n out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;\n }\n\n return out;\n}\n/**\r\n * Creates a quaternion from the given euler angle x, y, z.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {x} Angle to rotate around X axis in degrees.\r\n * @param {y} Angle to rotate around Y axis in degrees.\r\n * @param {z} Angle to rotate around Z axis in degrees.\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport function fromEuler(out, x, y, z) {\n var halfToRad = 0.5 * Math.PI / 180.0;\n x *= halfToRad;\n y *= halfToRad;\n z *= halfToRad;\n var sx = Math.sin(x);\n var cx = Math.cos(x);\n var sy = Math.sin(y);\n var cy = Math.cos(y);\n var sz = Math.sin(z);\n var cz = Math.cos(z);\n out[0] = sx * cy * cz - cx * sy * sz;\n out[1] = cx * sy * cz + sx * cy * sz;\n out[2] = cx * cy * sz - sx * sy * cz;\n out[3] = cx * cy * cz + sx * sy * sz;\n return out;\n}\n/**\r\n * Returns a string representation of a quatenion\r\n *\r\n * @param {ReadonlyQuat} a vector to represent as a string\r\n * @returns {String} string representation of the vector\r\n */\n\nexport function str(a) {\n return \"quat(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \", \" + a[3] + \")\";\n}\n/**\r\n * Creates a new quat initialized with values from an existing quaternion\r\n *\r\n * @param {ReadonlyQuat} a quaternion to clone\r\n * @returns {quat} a new quaternion\r\n * @function\r\n */\n\nexport var clone = vec4.clone;\n/**\r\n * Creates a new quat initialized with the given values\r\n *\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @param {Number} w W component\r\n * @returns {quat} a new quaternion\r\n * @function\r\n */\n\nexport var fromValues = vec4.fromValues;\n/**\r\n * Copy the values from one quat to another\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a the source quaternion\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport var copy = vec4.copy;\n/**\r\n * Set the components of a quat to the given values\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @param {Number} w W component\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport var set = vec4.set;\n/**\r\n * Adds two quat's\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a the first operand\r\n * @param {ReadonlyQuat} b the second operand\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport var add = vec4.add;\n/**\r\n * Alias for {@link quat.multiply}\r\n * @function\r\n */\n\nexport var mul = multiply;\n/**\r\n * Scales a quat by a scalar number\r\n *\r\n * @param {quat} out the receiving vector\r\n * @param {ReadonlyQuat} a the vector to scale\r\n * @param {Number} b amount to scale the vector by\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport var scale = vec4.scale;\n/**\r\n * Calculates the dot product of two quat's\r\n *\r\n * @param {ReadonlyQuat} a the first operand\r\n * @param {ReadonlyQuat} b the second operand\r\n * @returns {Number} dot product of a and b\r\n * @function\r\n */\n\nexport var dot = vec4.dot;\n/**\r\n * Performs a linear interpolation between two quat's\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a the first operand\r\n * @param {ReadonlyQuat} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport var lerp = vec4.lerp;\n/**\r\n * Calculates the length of a quat\r\n *\r\n * @param {ReadonlyQuat} a vector to calculate length of\r\n * @returns {Number} length of a\r\n */\n\nexport var length = vec4.length;\n/**\r\n * Alias for {@link quat.length}\r\n * @function\r\n */\n\nexport var len = length;\n/**\r\n * Calculates the squared length of a quat\r\n *\r\n * @param {ReadonlyQuat} a vector to calculate squared length of\r\n * @returns {Number} squared length of a\r\n * @function\r\n */\n\nexport var squaredLength = vec4.squaredLength;\n/**\r\n * Alias for {@link quat.squaredLength}\r\n * @function\r\n */\n\nexport var sqrLen = squaredLength;\n/**\r\n * Normalize a quat\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quaternion to normalize\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport var normalize = vec4.normalize;\n/**\r\n * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {ReadonlyQuat} a The first quaternion.\r\n * @param {ReadonlyQuat} b The second quaternion.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport var exactEquals = vec4.exactEquals;\n/**\r\n * Returns whether or not the quaternions have approximately the same elements in the same position.\r\n *\r\n * @param {ReadonlyQuat} a The first vector.\r\n * @param {ReadonlyQuat} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport var equals = vec4.equals;\n/**\r\n * Sets a quaternion to represent the shortest rotation from one\r\n * vector to another.\r\n *\r\n * Both vectors are assumed to be unit length.\r\n *\r\n * @param {quat} out the receiving quaternion.\r\n * @param {ReadonlyVec3} a the initial vector\r\n * @param {ReadonlyVec3} b the destination vector\r\n * @returns {quat} out\r\n */\n\nexport var rotationTo = function () {\n var tmpvec3 = vec3.create();\n var xUnitVec3 = vec3.fromValues(1, 0, 0);\n var yUnitVec3 = vec3.fromValues(0, 1, 0);\n return function (out, a, b) {\n var dot = vec3.dot(a, b);\n\n if (dot < -0.999999) {\n vec3.cross(tmpvec3, xUnitVec3, a);\n if (vec3.len(tmpvec3) < 0.000001) vec3.cross(tmpvec3, yUnitVec3, a);\n vec3.normalize(tmpvec3, tmpvec3);\n setAxisAngle(out, tmpvec3, Math.PI);\n return out;\n } else if (dot > 0.999999) {\n out[0] = 0;\n out[1] = 0;\n out[2] = 0;\n out[3] = 1;\n return out;\n } else {\n vec3.cross(tmpvec3, a, b);\n out[0] = tmpvec3[0];\n out[1] = tmpvec3[1];\n out[2] = tmpvec3[2];\n out[3] = 1 + dot;\n return normalize(out, out);\n }\n };\n}();\n/**\r\n * Performs a spherical linear interpolation with two control points\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a the first operand\r\n * @param {ReadonlyQuat} b the second operand\r\n * @param {ReadonlyQuat} c the third operand\r\n * @param {ReadonlyQuat} d the fourth operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {quat} out\r\n */\n\nexport var sqlerp = function () {\n var temp1 = create();\n var temp2 = create();\n return function (out, a, b, c, d, t) {\n slerp(temp1, a, d, t);\n slerp(temp2, b, c, t);\n slerp(out, temp1, temp2, 2 * t * (1 - t));\n return out;\n };\n}();\n/**\r\n * Sets the specified quaternion with values corresponding to the given\r\n * axes. Each axis is a vec3 and is expected to be unit length and\r\n * perpendicular to all other specified axes.\r\n *\r\n * @param {ReadonlyVec3} view the vector representing the viewing direction\r\n * @param {ReadonlyVec3} right the vector representing the local \"right\" direction\r\n * @param {ReadonlyVec3} up the vector representing the local \"up\" direction\r\n * @returns {quat} out\r\n */\n\nexport var setAxes = function () {\n var matr = mat3.create();\n return function (out, view, right, up) {\n matr[0] = right[0];\n matr[3] = right[1];\n matr[6] = right[2];\n matr[1] = up[0];\n matr[4] = up[1];\n matr[7] = up[2];\n matr[2] = -view[0];\n matr[5] = -view[1];\n matr[8] = -view[2];\n return normalize(out, fromMat3(out, matr));\n };\n}();","import MathArray from './base/math-array';\nimport { checkNumber, checkVector } from '../lib/validators';\nimport assert from '../lib/assert';\nimport * as quat from 'gl-matrix/quat';\nimport * as vec4 from 'gl-matrix/vec4';\nconst IDENTITY_QUATERNION = [0, 0, 0, 1];\nexport default class Quaternion extends MathArray {\n constructor(x = 0, y = 0, z = 0, w = 1) {\n super(-0, -0, -0, -0);\n\n if (Array.isArray(x) && arguments.length === 1) {\n this.copy(x);\n } else {\n this.set(x, y, z, w);\n }\n }\n\n copy(array) {\n this[0] = array[0];\n this[1] = array[1];\n this[2] = array[2];\n this[3] = array[3];\n return this.check();\n }\n\n set(x, y, z, w) {\n this[0] = x;\n this[1] = y;\n this[2] = z;\n this[3] = w;\n return this.check();\n }\n\n fromMatrix3(m) {\n quat.fromMat3(this, m);\n return this.check();\n }\n\n identity() {\n quat.identity(this);\n return this.check();\n }\n\n fromAxisRotation(axis, rad) {\n quat.setAxisAngle(this, axis, rad);\n return this.check();\n }\n\n setAxisAngle(axis, rad) {\n return this.fromAxisRotation(axis, rad);\n }\n\n get ELEMENTS() {\n return 4;\n }\n\n get x() {\n return this[0];\n }\n\n set x(value) {\n this[0] = checkNumber(value);\n }\n\n get y() {\n return this[1];\n }\n\n set y(value) {\n this[1] = checkNumber(value);\n }\n\n get z() {\n return this[2];\n }\n\n set z(value) {\n this[2] = checkNumber(value);\n }\n\n get w() {\n return this[3];\n }\n\n set w(value) {\n this[3] = checkNumber(value);\n }\n\n len() {\n return quat.length(this);\n }\n\n lengthSquared() {\n return quat.squaredLength(this);\n }\n\n dot(a, b) {\n if (b !== undefined) {\n throw new Error('Quaternion.dot only takes one argument');\n }\n\n return quat.dot(this, a);\n }\n\n rotationTo(vectorA, vectorB) {\n quat.rotationTo(this, vectorA, vectorB);\n return this.check();\n }\n\n add(a, b) {\n if (b !== undefined) {\n throw new Error('Quaternion.add only takes one argument');\n }\n\n quat.add(this, this, a);\n return this.check();\n }\n\n calculateW() {\n quat.calculateW(this, this);\n return this.check();\n }\n\n conjugate() {\n quat.conjugate(this, this);\n return this.check();\n }\n\n invert() {\n quat.invert(this, this);\n return this.check();\n }\n\n lerp(a, b, t) {\n quat.lerp(this, a, b, t);\n return this.check();\n }\n\n multiplyRight(a, b) {\n assert(!b);\n quat.multiply(this, this, a);\n return this.check();\n }\n\n multiplyLeft(a, b) {\n assert(!b);\n quat.multiply(this, a, this);\n return this.check();\n }\n\n normalize() {\n const length = this.len();\n const l = length > 0 ? 1 / length : 0;\n this[0] = this[0] * l;\n this[1] = this[1] * l;\n this[2] = this[2] * l;\n this[3] = this[3] * l;\n\n if (length === 0) {\n this[3] = 1;\n }\n\n return this.check();\n }\n\n rotateX(rad) {\n quat.rotateX(this, this, rad);\n return this.check();\n }\n\n rotateY(rad) {\n quat.rotateY(this, this, rad);\n return this.check();\n }\n\n rotateZ(rad) {\n quat.rotateZ(this, this, rad);\n return this.check();\n }\n\n scale(b) {\n quat.scale(this, this, b);\n return this.check();\n }\n\n slerp(start, target, ratio) {\n switch (arguments.length) {\n case 1:\n ({\n start = IDENTITY_QUATERNION,\n target,\n ratio\n } = arguments[0]);\n break;\n\n case 2:\n [target, ratio] = arguments;\n start = this;\n break;\n\n default:\n }\n\n quat.slerp(this, start, target, ratio);\n return this.check();\n }\n\n transformVector4(vector, result = vector) {\n vec4.transformQuat(result, vector, this);\n return checkVector(result, 4);\n }\n\n lengthSq() {\n return this.lengthSquared();\n }\n\n setFromAxisAngle(axis, rad) {\n return this.setAxisAngle(axis, rad);\n }\n\n premultiply(a, b) {\n return this.multiplyLeft(a, b);\n }\n\n multiply(a, b) {\n return this.multiplyRight(a, b);\n }\n\n}\n//# sourceMappingURL=quaternion.js.map","import { Vector3, Matrix3, Quaternion } from '@math.gl/core';\nimport BoundingSphere from './bounding-sphere';\nimport { INTERSECTION } from '../../constants';\nconst scratchVector3 = new Vector3();\nconst scratchOffset = new Vector3();\nconst scratchVectorU = new Vector3();\nconst scratchVectorV = new Vector3();\nconst scratchVectorW = new Vector3();\nconst scratchCorner = new Vector3();\nconst scratchToCenter = new Vector3();\nconst MATRIX3 = {\n COLUMN0ROW0: 0,\n COLUMN0ROW1: 1,\n COLUMN0ROW2: 2,\n COLUMN1ROW0: 3,\n COLUMN1ROW1: 4,\n COLUMN1ROW2: 5,\n COLUMN2ROW0: 6,\n COLUMN2ROW1: 7,\n COLUMN2ROW2: 8\n};\nexport default class OrientedBoundingBox {\n constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {\n this.center = new Vector3().from(center);\n this.halfAxes = new Matrix3(halfAxes);\n }\n\n get halfSize() {\n const xAxis = this.halfAxes.getColumn(0);\n const yAxis = this.halfAxes.getColumn(1);\n const zAxis = this.halfAxes.getColumn(2);\n return [new Vector3(xAxis).len(), new Vector3(yAxis).len(), new Vector3(zAxis).len()];\n }\n\n get quaternion() {\n const xAxis = this.halfAxes.getColumn(0);\n const yAxis = this.halfAxes.getColumn(1);\n const zAxis = this.halfAxes.getColumn(2);\n const normXAxis = new Vector3(xAxis).normalize();\n const normYAxis = new Vector3(yAxis).normalize();\n const normZAxis = new Vector3(zAxis).normalize();\n return new Quaternion().fromMatrix3(new Matrix3([...normXAxis, ...normYAxis, ...normZAxis]));\n }\n\n fromCenterHalfSizeQuaternion(center, halfSize, quaternion) {\n const quaternionObject = new Quaternion(quaternion);\n const directionsMatrix = new Matrix3().fromQuaternion(quaternionObject);\n directionsMatrix[0] = directionsMatrix[0] * halfSize[0];\n directionsMatrix[1] = directionsMatrix[1] * halfSize[0];\n directionsMatrix[2] = directionsMatrix[2] * halfSize[0];\n directionsMatrix[3] = directionsMatrix[3] * halfSize[1];\n directionsMatrix[4] = directionsMatrix[4] * halfSize[1];\n directionsMatrix[5] = directionsMatrix[5] * halfSize[1];\n directionsMatrix[6] = directionsMatrix[6] * halfSize[2];\n directionsMatrix[7] = directionsMatrix[7] * halfSize[2];\n directionsMatrix[8] = directionsMatrix[8] * halfSize[2];\n this.center = new Vector3().from(center);\n this.halfAxes = directionsMatrix;\n return this;\n }\n\n clone() {\n return new OrientedBoundingBox(this.center, this.halfAxes);\n }\n\n equals(right) {\n return this === right || Boolean(right) && this.center.equals(right.center) && this.halfAxes.equals(right.halfAxes);\n }\n\n getBoundingSphere(result = new BoundingSphere()) {\n const halfAxes = this.halfAxes;\n const u = halfAxes.getColumn(0, scratchVectorU);\n const v = halfAxes.getColumn(1, scratchVectorV);\n const w = halfAxes.getColumn(2, scratchVectorW);\n const cornerVector = scratchVector3.copy(u).add(v).add(w);\n result.center.copy(this.center);\n result.radius = cornerVector.magnitude();\n return result;\n }\n\n intersectPlane(plane) {\n const center = this.center;\n const normal = plane.normal;\n const halfAxes = this.halfAxes;\n const normalX = normal.x;\n const normalY = normal.y;\n const normalZ = normal.z;\n const radEffective = Math.abs(normalX * halfAxes[MATRIX3.COLUMN0ROW0] + normalY * halfAxes[MATRIX3.COLUMN0ROW1] + normalZ * halfAxes[MATRIX3.COLUMN0ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN1ROW0] + normalY * halfAxes[MATRIX3.COLUMN1ROW1] + normalZ * halfAxes[MATRIX3.COLUMN1ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN2ROW0] + normalY * halfAxes[MATRIX3.COLUMN2ROW1] + normalZ * halfAxes[MATRIX3.COLUMN2ROW2]);\n const distanceToPlane = normal.dot(center) + plane.distance;\n\n if (distanceToPlane <= -radEffective) {\n return INTERSECTION.OUTSIDE;\n } else if (distanceToPlane >= radEffective) {\n return INTERSECTION.INSIDE;\n }\n\n return INTERSECTION.INTERSECTING;\n }\n\n distanceTo(point) {\n return Math.sqrt(this.distanceSquaredTo(point));\n }\n\n distanceSquaredTo(point) {\n const offset = scratchOffset.from(point).subtract(this.center);\n const halfAxes = this.halfAxes;\n const u = halfAxes.getColumn(0, scratchVectorU);\n const v = halfAxes.getColumn(1, scratchVectorV);\n const w = halfAxes.getColumn(2, scratchVectorW);\n const uHalf = u.magnitude();\n const vHalf = v.magnitude();\n const wHalf = w.magnitude();\n u.normalize();\n v.normalize();\n w.normalize();\n let distanceSquared = 0.0;\n let d;\n d = Math.abs(offset.dot(u)) - uHalf;\n\n if (d > 0) {\n distanceSquared += d * d;\n }\n\n d = Math.abs(offset.dot(v)) - vHalf;\n\n if (d > 0) {\n distanceSquared += d * d;\n }\n\n d = Math.abs(offset.dot(w)) - wHalf;\n\n if (d > 0) {\n distanceSquared += d * d;\n }\n\n return distanceSquared;\n }\n\n computePlaneDistances(position, direction, result = [-0, -0]) {\n let minDist = Number.POSITIVE_INFINITY;\n let maxDist = Number.NEGATIVE_INFINITY;\n const center = this.center;\n const halfAxes = this.halfAxes;\n const u = halfAxes.getColumn(0, scratchVectorU);\n const v = halfAxes.getColumn(1, scratchVectorV);\n const w = halfAxes.getColumn(2, scratchVectorW);\n const corner = scratchCorner.copy(u).add(v).add(w).add(center);\n const toCenter = scratchToCenter.copy(corner).subtract(position);\n let mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n corner.copy(center).add(u).add(v).subtract(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n corner.copy(center).add(u).subtract(v).add(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n corner.copy(center).add(u).subtract(v).subtract(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n center.copy(corner).subtract(u).add(v).add(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n center.copy(corner).subtract(u).add(v).subtract(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n center.copy(corner).subtract(u).subtract(v).add(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n center.copy(corner).subtract(u).subtract(v).subtract(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n result[0] = minDist;\n result[1] = maxDist;\n return result;\n }\n\n transform(transformation) {\n this.center.transformAsPoint(transformation);\n const xAxis = this.halfAxes.getColumn(0, scratchVectorU);\n xAxis.transformAsPoint(transformation);\n const yAxis = this.halfAxes.getColumn(1, scratchVectorV);\n yAxis.transformAsPoint(transformation);\n const zAxis = this.halfAxes.getColumn(2, scratchVectorW);\n zAxis.transformAsPoint(transformation);\n this.halfAxes = new Matrix3([...xAxis, ...yAxis, ...zAxis]);\n return this;\n }\n\n getTransform() {\n throw new Error('not implemented');\n }\n\n}\n//# sourceMappingURL=oriented-bounding-box.js.map","import { Vector3, equals, assert } from '@math.gl/core';\nconst scratchPosition = new Vector3();\nconst scratchNormal = new Vector3();\nexport default class Plane {\n constructor(normal = [0, 0, 1], distance = 0) {\n this.normal = new Vector3();\n this.distance = -0;\n this.fromNormalDistance(normal, distance);\n }\n\n fromNormalDistance(normal, distance) {\n assert(Number.isFinite(distance));\n this.normal.from(normal).normalize();\n this.distance = distance;\n return this;\n }\n\n fromPointNormal(point, normal) {\n point = scratchPosition.from(point);\n this.normal.from(normal).normalize();\n const distance = -this.normal.dot(point);\n this.distance = distance;\n return this;\n }\n\n fromCoefficients(a, b, c, d) {\n this.normal.set(a, b, c);\n assert(equals(this.normal.len(), 1));\n this.distance = d;\n return this;\n }\n\n clone(plane) {\n return new Plane(this.normal, this.distance);\n }\n\n equals(right) {\n return equals(this.distance, right.distance) && equals(this.normal, right.normal);\n }\n\n getPointDistance(point) {\n return this.normal.dot(point) + this.distance;\n }\n\n transform(matrix4) {\n const normal = scratchNormal.copy(this.normal).transformAsVector(matrix4).normalize();\n const point = this.normal.scale(-this.distance).transform(matrix4);\n return this.fromPointNormal(point, normal);\n }\n\n projectPointOntoPlane(point, result = [0, 0, 0]) {\n point = scratchPosition.from(point);\n const pointDistance = this.getPointDistance(point);\n const scaledNormal = scratchNormal.copy(this.normal).scale(pointDistance);\n return point.subtract(scaledNormal).to(result);\n }\n\n}\n//# sourceMappingURL=plane.js.map","import { Vector3, Vector4, assert } from '@math.gl/core';\nimport { INTERSECTION } from '../constants';\nimport Plane from './plane';\nconst faces = [new Vector3([1, 0, 0]), new Vector3([0, 1, 0]), new Vector3([0, 0, 1])];\nconst scratchPlaneCenter = new Vector3();\nconst scratchPlaneNormal = new Vector3();\nconst scratchPlane = new Plane(new Vector3(1.0, 0.0, 0.0), 0.0);\nexport default class CullingVolume {\n static get MASK_OUTSIDE() {\n return 0xffffffff;\n }\n\n static get MASK_INSIDE() {\n return 0x00000000;\n }\n\n static get MASK_INDETERMINATE() {\n return 0x7fffffff;\n }\n\n constructor(planes = []) {\n this.planes = planes;\n assert(this.planes.every(plane => plane instanceof Plane));\n }\n\n fromBoundingSphere(boundingSphere) {\n this.planes.length = 2 * faces.length;\n const center = boundingSphere.center;\n const radius = boundingSphere.radius;\n let planeIndex = 0;\n\n for (const faceNormal of faces) {\n let plane0 = this.planes[planeIndex];\n let plane1 = this.planes[planeIndex + 1];\n\n if (!plane0) {\n plane0 = this.planes[planeIndex] = new Plane();\n }\n\n if (!plane1) {\n plane1 = this.planes[planeIndex + 1] = new Plane();\n }\n\n const plane0Center = scratchPlaneCenter.copy(faceNormal).scale(-radius).add(center);\n const plane0Distance = -faceNormal.dot(plane0Center);\n plane0.fromPointNormal(plane0Center, faceNormal);\n const plane1Center = scratchPlaneCenter.copy(faceNormal).scale(radius).add(center);\n const negatedFaceNormal = scratchPlaneNormal.copy(faceNormal).negate();\n const plane1Distance = -negatedFaceNormal.dot(plane1Center);\n plane1.fromPointNormal(plane1Center, negatedFaceNormal);\n planeIndex += 2;\n }\n\n return this;\n }\n\n computeVisibility(boundingVolume) {\n assert(boundingVolume);\n let intersect = INTERSECTION.INSIDE;\n\n for (const plane of this.planes) {\n const result = boundingVolume.intersectPlane(plane);\n\n switch (result) {\n case INTERSECTION.OUTSIDE:\n return INTERSECTION.OUTSIDE;\n\n case INTERSECTION.INTERSECTING:\n intersect = INTERSECTION.INTERSECTING;\n break;\n\n default:\n }\n }\n\n return intersect;\n }\n\n computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) {\n assert(boundingVolume, 'boundingVolume is required.');\n assert(Number.isFinite(parentPlaneMask), 'parentPlaneMask is required.');\n\n if (parentPlaneMask === CullingVolume.MASK_OUTSIDE || parentPlaneMask === CullingVolume.MASK_INSIDE) {\n return parentPlaneMask;\n }\n\n let mask = CullingVolume.MASK_INSIDE;\n const planes = this.planes;\n\n for (let k = 0; k < this.planes.length; ++k) {\n const flag = k < 31 ? 1 << k : 0;\n\n if (k < 31 && (parentPlaneMask & flag) === 0) {\n continue;\n }\n\n const plane = planes[k];\n const result = boundingVolume.intersectPlane(plane);\n\n if (result === INTERSECTION.OUTSIDE) {\n return CullingVolume.MASK_OUTSIDE;\n } else if (result === INTERSECTION.INTERSECTING) {\n mask |= flag;\n }\n }\n\n return mask;\n }\n\n}\n//# sourceMappingURL=culling-volume.js.map","import { Vector3, Matrix4, assert } from '@math.gl/core';\nimport CullingVolume from './culling-volume';\nimport Plane from './plane';\nconst scratchPlaneUpVector = new Vector3();\nconst scratchPlaneRightVector = new Vector3();\nconst scratchPlaneNearCenter = new Vector3();\nconst scratchPlaneFarCenter = new Vector3();\nconst scratchPlaneNormal = new Vector3();\nexport default class PerspectiveOffCenterFrustum {\n constructor(options = {}) {\n options = {\n near: 1.0,\n far: 500000000.0,\n ...options\n };\n this.left = options.left;\n this._left = undefined;\n this.right = options.right;\n this._right = undefined;\n this.top = options.top;\n this._top = undefined;\n this.bottom = options.bottom;\n this._bottom = undefined;\n this.near = options.near;\n this._near = this.near;\n this.far = options.far;\n this._far = this.far;\n this._cullingVolume = new CullingVolume([new Plane(), new Plane(), new Plane(), new Plane(), new Plane(), new Plane()]);\n this._perspectiveMatrix = new Matrix4();\n this._infinitePerspective = new Matrix4();\n }\n\n clone() {\n return new PerspectiveOffCenterFrustum({\n right: this.right,\n left: this.left,\n top: this.top,\n bottom: this.bottom,\n near: this.near,\n far: this.far\n });\n }\n\n equals(other) {\n return other && other instanceof PerspectiveOffCenterFrustum && this.right === other.right && this.left === other.left && this.top === other.top && this.bottom === other.bottom && this.near === other.near && this.far === other.far;\n }\n\n get projectionMatrix() {\n update(this);\n return this._perspectiveMatrix;\n }\n\n get infiniteProjectionMatrix() {\n update(this);\n return this._infinitePerspective;\n }\n\n computeCullingVolume(position, direction, up) {\n assert(position, 'position is required.');\n assert(direction, 'direction is required.');\n assert(up, 'up is required.');\n const planes = this._cullingVolume.planes;\n up = scratchPlaneUpVector.copy(up).normalize();\n const right = scratchPlaneRightVector.copy(direction).cross(up).normalize();\n const nearCenter = scratchPlaneNearCenter.copy(direction).multiplyByScalar(this.near).add(position);\n const farCenter = scratchPlaneFarCenter.copy(direction).multiplyByScalar(this.far).add(position);\n let normal = scratchPlaneNormal;\n normal.copy(right).multiplyByScalar(this.left).add(nearCenter).subtract(position).cross(up);\n planes[0].fromPointNormal(position, normal);\n normal.copy(right).multiplyByScalar(this.right).add(nearCenter).subtract(position).cross(up).negate();\n planes[1].fromPointNormal(position, normal);\n normal.copy(up).multiplyByScalar(this.bottom).add(nearCenter).subtract(position).cross(right).negate();\n planes[2].fromPointNormal(position, normal);\n normal.copy(up).multiplyByScalar(this.top).add(nearCenter).subtract(position).cross(right);\n planes[3].fromPointNormal(position, normal);\n normal = new Vector3().copy(direction);\n planes[4].fromPointNormal(nearCenter, normal);\n normal.negate();\n planes[5].fromPointNormal(farCenter, normal);\n return this._cullingVolume;\n }\n\n getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result) {\n update(this);\n assert(Number.isFinite(drawingBufferWidth) && Number.isFinite(drawingBufferHeight));\n assert(drawingBufferWidth > 0);\n assert(drawingBufferHeight > 0);\n assert(distance > 0);\n assert(result);\n const inverseNear = 1.0 / this.near;\n let tanTheta = this.top * inverseNear;\n const pixelHeight = 2.0 * distance * tanTheta / drawingBufferHeight;\n tanTheta = this.right * inverseNear;\n const pixelWidth = 2.0 * distance * tanTheta / drawingBufferWidth;\n result.x = pixelWidth;\n result.y = pixelHeight;\n return result;\n }\n\n}\n\nfunction update(frustum) {\n assert(Number.isFinite(frustum.right) && Number.isFinite(frustum.left) && Number.isFinite(frustum.top) && Number.isFinite(frustum.bottom) && Number.isFinite(frustum.near) && Number.isFinite(frustum.far));\n const {\n top,\n bottom,\n right,\n left,\n near,\n far\n } = frustum;\n\n if (top !== frustum._top || bottom !== frustum._bottom || left !== frustum._left || right !== frustum._right || near !== frustum._near || far !== frustum._far) {\n assert(frustum.near > 0 && frustum.near < frustum.far, 'near must be greater than zero and less than far.');\n frustum._left = left;\n frustum._right = right;\n frustum._top = top;\n frustum._bottom = bottom;\n frustum._near = near;\n frustum._far = far;\n frustum._perspectiveMatrix = new Matrix4().frustum({\n left,\n right,\n bottom,\n top,\n near,\n far\n });\n frustum._infinitePerspective = new Matrix4().frustum({\n left,\n right,\n bottom,\n top,\n near,\n far: Infinity\n });\n }\n}\n//# sourceMappingURL=perspective-off-center-frustum.js.map","import { Vector3 } from '@math.gl/core';\nimport BoundingSphere from '../bounding-volumes/bounding-sphere';\nconst fromPointsXMin = new Vector3();\nconst fromPointsYMin = new Vector3();\nconst fromPointsZMin = new Vector3();\nconst fromPointsXMax = new Vector3();\nconst fromPointsYMax = new Vector3();\nconst fromPointsZMax = new Vector3();\nconst fromPointsCurrentPos = new Vector3();\nconst fromPointsScratch = new Vector3();\nconst fromPointsRitterCenter = new Vector3();\nconst fromPointsMinBoxPt = new Vector3();\nconst fromPointsMaxBoxPt = new Vector3();\nconst fromPointsNaiveCenterScratch = new Vector3();\nconst volumeConstant = 4.0 / 3.0 * Math.PI;\nexport default function makeBoundingSphereFromPoints(positions, result = new BoundingSphere()) {\n if (!positions || positions.length === 0) {\n return result.fromCenterRadius([0, 0, 0], 0);\n }\n\n const currentPos = fromPointsCurrentPos.copy(positions[0]);\n const xMin = fromPointsXMin.copy(currentPos);\n const yMin = fromPointsYMin.copy(currentPos);\n const zMin = fromPointsZMin.copy(currentPos);\n const xMax = fromPointsXMax.copy(currentPos);\n const yMax = fromPointsYMax.copy(currentPos);\n const zMax = fromPointsZMax.copy(currentPos);\n\n for (const position of positions) {\n currentPos.copy(position);\n const x = currentPos.x;\n const y = currentPos.y;\n const z = currentPos.z;\n\n if (x < xMin.x) {\n currentPos.copy(xMin);\n }\n\n if (x > xMax.x) {\n currentPos.copy(xMax);\n }\n\n if (y < yMin.y) {\n currentPos.copy(yMin);\n }\n\n if (y > yMax.y) {\n currentPos.copy(yMax);\n }\n\n if (z < zMin.z) {\n currentPos.copy(zMin);\n }\n\n if (z > zMax.z) {\n currentPos.copy(zMax);\n }\n }\n\n const xSpan = fromPointsScratch.copy(xMax).subtract(xMin).magnitudeSquared();\n const ySpan = fromPointsScratch.copy(yMax).subtract(yMin).magnitudeSquared();\n const zSpan = fromPointsScratch.copy(zMax).subtract(zMin).magnitudeSquared();\n let diameter1 = xMin;\n let diameter2 = xMax;\n let maxSpan = xSpan;\n\n if (ySpan > maxSpan) {\n maxSpan = ySpan;\n diameter1 = yMin;\n diameter2 = yMax;\n }\n\n if (zSpan > maxSpan) {\n maxSpan = zSpan;\n diameter1 = zMin;\n diameter2 = zMax;\n }\n\n const ritterCenter = fromPointsRitterCenter;\n ritterCenter.x = (diameter1.x + diameter2.x) * 0.5;\n ritterCenter.y = (diameter1.y + diameter2.y) * 0.5;\n ritterCenter.z = (diameter1.z + diameter2.z) * 0.5;\n let radiusSquared = fromPointsScratch.copy(diameter2).subtract(ritterCenter).magnitudeSquared();\n let ritterRadius = Math.sqrt(radiusSquared);\n const minBoxPt = fromPointsMinBoxPt;\n minBoxPt.x = xMin.x;\n minBoxPt.y = yMin.y;\n minBoxPt.z = zMin.z;\n const maxBoxPt = fromPointsMaxBoxPt;\n maxBoxPt.x = xMax.x;\n maxBoxPt.y = yMax.y;\n maxBoxPt.z = zMax.z;\n const naiveCenter = fromPointsNaiveCenterScratch.copy(minBoxPt).add(maxBoxPt).multiplyByScalar(0.5);\n let naiveRadius = 0;\n\n for (const position of positions) {\n currentPos.copy(position);\n const r = fromPointsScratch.copy(currentPos).subtract(naiveCenter).magnitude();\n\n if (r > naiveRadius) {\n naiveRadius = r;\n }\n\n const oldCenterToPointSquared = fromPointsScratch.copy(currentPos).subtract(ritterCenter).magnitudeSquared();\n\n if (oldCenterToPointSquared > radiusSquared) {\n const oldCenterToPoint = Math.sqrt(oldCenterToPointSquared);\n ritterRadius = (ritterRadius + oldCenterToPoint) * 0.5;\n radiusSquared = ritterRadius * ritterRadius;\n const oldToNew = oldCenterToPoint - ritterRadius;\n ritterCenter.x = (ritterRadius * ritterCenter.x + oldToNew * currentPos.x) / oldCenterToPoint;\n ritterCenter.y = (ritterRadius * ritterCenter.y + oldToNew * currentPos.y) / oldCenterToPoint;\n ritterCenter.z = (ritterRadius * ritterCenter.z + oldToNew * currentPos.z) / oldCenterToPoint;\n }\n }\n\n if (ritterRadius < naiveRadius) {\n ritterCenter.to(result.center);\n result.radius = ritterRadius;\n } else {\n naiveCenter.to(result.center);\n result.radius = naiveRadius;\n }\n\n return result;\n}\n//# sourceMappingURL=bounding-sphere-from-points.js.map","import { Matrix3, _MathUtils } from '@math.gl/core';\nconst scratchMatrix = new Matrix3();\nconst scratchUnitary = new Matrix3();\nconst scratchDiagonal = new Matrix3();\nconst jMatrix = new Matrix3();\nconst jMatrixTranspose = new Matrix3();\nexport default function computeEigenDecomposition(matrix, result = {}) {\n const EIGEN_TOLERANCE = _MathUtils.EPSILON20;\n const EIGEN_MAX_SWEEPS = 10;\n let count = 0;\n let sweep = 0;\n const unitaryMatrix = scratchUnitary;\n const diagonalMatrix = scratchDiagonal;\n unitaryMatrix.identity();\n diagonalMatrix.copy(matrix);\n const epsilon = EIGEN_TOLERANCE * computeFrobeniusNorm(diagonalMatrix);\n\n while (sweep < EIGEN_MAX_SWEEPS && offDiagonalFrobeniusNorm(diagonalMatrix) > epsilon) {\n shurDecomposition(diagonalMatrix, jMatrix);\n jMatrixTranspose.copy(jMatrix).transpose();\n diagonalMatrix.multiplyRight(jMatrix);\n diagonalMatrix.multiplyLeft(jMatrixTranspose);\n unitaryMatrix.multiplyRight(jMatrix);\n\n if (++count > 2) {\n ++sweep;\n count = 0;\n }\n }\n\n result.unitary = unitaryMatrix.toTarget(result.unitary);\n result.diagonal = diagonalMatrix.toTarget(result.diagonal);\n return result;\n}\n\nfunction computeFrobeniusNorm(matrix) {\n let norm = 0.0;\n\n for (let i = 0; i < 9; ++i) {\n const temp = matrix[i];\n norm += temp * temp;\n }\n\n return Math.sqrt(norm);\n}\n\nconst rowVal = [1, 0, 0];\nconst colVal = [2, 2, 1];\n\nfunction offDiagonalFrobeniusNorm(matrix) {\n let norm = 0.0;\n\n for (let i = 0; i < 3; ++i) {\n const temp = matrix[scratchMatrix.getElementIndex(colVal[i], rowVal[i])];\n norm += 2.0 * temp * temp;\n }\n\n return Math.sqrt(norm);\n}\n\nfunction shurDecomposition(matrix, result) {\n const tolerance = _MathUtils.EPSILON15;\n let maxDiagonal = 0.0;\n let rotAxis = 1;\n\n for (let i = 0; i < 3; ++i) {\n const temp = Math.abs(matrix[scratchMatrix.getElementIndex(colVal[i], rowVal[i])]);\n\n if (temp > maxDiagonal) {\n rotAxis = i;\n maxDiagonal = temp;\n }\n }\n\n const p = rowVal[rotAxis];\n const q = colVal[rotAxis];\n let c = 1.0;\n let s = 0.0;\n\n if (Math.abs(matrix[scratchMatrix.getElementIndex(q, p)]) > tolerance) {\n const qq = matrix[scratchMatrix.getElementIndex(q, q)];\n const pp = matrix[scratchMatrix.getElementIndex(p, p)];\n const qp = matrix[scratchMatrix.getElementIndex(q, p)];\n const tau = (qq - pp) / 2.0 / qp;\n let t;\n\n if (tau < 0.0) {\n t = -1.0 / (-tau + Math.sqrt(1.0 + tau * tau));\n } else {\n t = 1.0 / (tau + Math.sqrt(1.0 + tau * tau));\n }\n\n c = 1.0 / Math.sqrt(1.0 + t * t);\n s = t * c;\n }\n\n Matrix3.IDENTITY.to(result);\n result[scratchMatrix.getElementIndex(p, p)] = result[scratchMatrix.getElementIndex(q, q)] = c;\n result[scratchMatrix.getElementIndex(q, p)] = s;\n result[scratchMatrix.getElementIndex(p, q)] = -s;\n return result;\n}\n//# sourceMappingURL=compute-eigen-decomposition.js.map","import { Vector3, Matrix3 } from '@math.gl/core';\nimport computeEigenDecomposition from './compute-eigen-decomposition';\nimport OrientedBoundingBox from '../bounding-volumes/oriented-bounding-box';\nimport AxisAlignedBoundingBox from '../bounding-volumes/axis-aligned-bounding-box';\nconst scratchVector2 = new Vector3();\nconst scratchVector3 = new Vector3();\nconst scratchVector4 = new Vector3();\nconst scratchVector5 = new Vector3();\nconst scratchVector6 = new Vector3();\nconst scratchCovarianceResult = new Matrix3();\nconst scratchEigenResult = {\n diagonal: new Matrix3(),\n unitary: new Matrix3()\n};\nexport function makeOrientedBoundingBoxFromPoints(positions, result = new OrientedBoundingBox()) {\n if (!positions || positions.length === 0) {\n result.halfAxes = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]);\n result.center = new Vector3();\n return result;\n }\n\n const length = positions.length;\n const meanPoint = new Vector3(0, 0, 0);\n\n for (const position of positions) {\n meanPoint.add(position);\n }\n\n const invLength = 1.0 / length;\n meanPoint.multiplyByScalar(invLength);\n let exx = 0.0;\n let exy = 0.0;\n let exz = 0.0;\n let eyy = 0.0;\n let eyz = 0.0;\n let ezz = 0.0;\n\n for (const position of positions) {\n const p = scratchVector2.copy(position).subtract(meanPoint);\n exx += p.x * p.x;\n exy += p.x * p.y;\n exz += p.x * p.z;\n eyy += p.y * p.y;\n eyz += p.y * p.z;\n ezz += p.z * p.z;\n }\n\n exx *= invLength;\n exy *= invLength;\n exz *= invLength;\n eyy *= invLength;\n eyz *= invLength;\n ezz *= invLength;\n const covarianceMatrix = scratchCovarianceResult;\n covarianceMatrix[0] = exx;\n covarianceMatrix[1] = exy;\n covarianceMatrix[2] = exz;\n covarianceMatrix[3] = exy;\n covarianceMatrix[4] = eyy;\n covarianceMatrix[5] = eyz;\n covarianceMatrix[6] = exz;\n covarianceMatrix[7] = eyz;\n covarianceMatrix[8] = ezz;\n const {\n unitary\n } = computeEigenDecomposition(covarianceMatrix, scratchEigenResult);\n const rotation = result.halfAxes.copy(unitary);\n let v1 = rotation.getColumn(0, scratchVector4);\n let v2 = rotation.getColumn(1, scratchVector5);\n let v3 = rotation.getColumn(2, scratchVector6);\n let u1 = -Number.MAX_VALUE;\n let u2 = -Number.MAX_VALUE;\n let u3 = -Number.MAX_VALUE;\n let l1 = Number.MAX_VALUE;\n let l2 = Number.MAX_VALUE;\n let l3 = Number.MAX_VALUE;\n\n for (const position of positions) {\n u1 = Math.max(position.dot(v1), u1);\n u2 = Math.max(position.dot(v2), u2);\n u3 = Math.max(position.dot(v3), u3);\n l1 = Math.min(position.dot(v1), l1);\n l2 = Math.min(position.dot(v2), l2);\n l3 = Math.min(position.dot(v3), l3);\n }\n\n v1 = v1.multiplyByScalar(0.5 * (l1 + u1));\n v2 = v2.multiplyByScalar(0.5 * (l2 + u2));\n v3 = v3.multiplyByScalar(0.5 * (l3 + u3));\n result.center.copy(v1).add(v2).add(v3);\n const scale = scratchVector3.set(u1 - l1, u2 - l2, u3 - l3).multiplyByScalar(0.5);\n const scaleMatrix = new Matrix3([scale[0], 0, 0, 0, scale[1], 0, 0, 0, scale[2]]);\n result.halfAxes.multiplyRight(scaleMatrix);\n return result;\n}\nexport function makeAxisAlignedBoundingBoxFromPoints(positions, result = new AxisAlignedBoundingBox()) {\n if (!positions || positions.length === 0) {\n result.minimum.set(0, 0, 0);\n result.maximum.set(0, 0, 0);\n result.center.set(0, 0, 0);\n result.halfDiagonal.set(0, 0, 0);\n return result;\n }\n\n let minimumX = positions[0][0];\n let minimumY = positions[0][1];\n let minimumZ = positions[0][2];\n let maximumX = positions[0][0];\n let maximumY = positions[0][1];\n let maximumZ = positions[0][2];\n\n for (const p of positions) {\n const x = p[0];\n const y = p[1];\n const z = p[2];\n minimumX = Math.min(x, minimumX);\n maximumX = Math.max(x, maximumX);\n minimumY = Math.min(y, minimumY);\n maximumY = Math.max(y, maximumY);\n minimumZ = Math.min(z, minimumZ);\n maximumZ = Math.max(z, maximumZ);\n }\n\n result.minimum.set(minimumX, minimumY, minimumZ);\n result.maximum.set(maximumX, maximumY, maximumZ);\n result.center.copy(result.minimum).add(result.maximum).scale(0.5);\n result.halfDiagonal.copy(result.maximum).subtract(result.center);\n return result;\n}\n//# sourceMappingURL=bounding-box-from-points.js.map","import {Vector3} from '@math.gl/core';\nimport {CullingVolume, Plane} from '@math.gl/culling';\nimport {Ellipsoid} from '@math.gl/geospatial';\n\nexport type FrameState = {\n camera: {\n position: number[];\n direction: number[];\n up: number[];\n };\n viewport: {[key: string]: any};\n height: number;\n cullingVolume: CullingVolume;\n frameNumber: number; // TODO: This can be the same between updates, what number is unique for between updates?\n sseDenominator: number; // Assumes fovy = 60 degrees\n};\n\nconst scratchVector = new Vector3();\nconst scratchPosition = new Vector3();\nconst cullingVolume = new CullingVolume([\n new Plane(),\n new Plane(),\n new Plane(),\n new Plane(),\n new Plane(),\n new Plane()\n]);\n\n// Extracts a frame state appropriate for tile culling from a deck.gl viewport\n// TODO - this could likely be generalized and merged back into deck.gl for other culling scenarios\nexport function getFrameState(viewport, frameNumber: number): FrameState {\n // Traverse and and request. Update _selectedTiles so that we know what to render.\n const {cameraDirection, cameraUp, height} = viewport;\n const {metersPerUnit} = viewport.distanceScales;\n\n const viewportCenterCartographic = [viewport.longitude, viewport.latitude, 0];\n // TODO - Ellipsoid.eastNorthUpToFixedFrame() breaks on raw array, create a Vector.\n // TODO - Ellipsoid.eastNorthUpToFixedFrame() takes a cartesian, is that intuitive?\n const viewportCenterCartesian = Ellipsoid.WGS84.cartographicToCartesian(\n viewportCenterCartographic,\n new Vector3()\n );\n const enuToFixedTransform = Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);\n\n const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);\n const cameraPositionCartesian = Ellipsoid.WGS84.cartographicToCartesian(\n cameraPositionCartographic,\n new Vector3()\n );\n\n // These should still be normalized as the transform has scale 1 (goes from meters to meters)\n const cameraDirectionCartesian = new Vector3(\n // @ts-ignore\n enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))\n ).normalize();\n const cameraUpCartesian = new Vector3(\n // @ts-ignore\n enuToFixedTransform.transformAsVector(new Vector3(cameraUp).scale(metersPerUnit))\n ).normalize();\n\n commonSpacePlanesToWGS84(viewport, viewportCenterCartesian);\n\n // TODO: make a file/class for frameState and document what needs to be attached to this so that traversal can function\n return {\n camera: {\n position: cameraPositionCartesian,\n direction: cameraDirectionCartesian,\n up: cameraUpCartesian\n },\n viewport,\n height,\n cullingVolume,\n frameNumber, // TODO: This can be the same between updates, what number is unique for between updates?\n sseDenominator: 1.15 // Assumes fovy = 60 degrees\n };\n}\n\nfunction commonSpacePlanesToWGS84(viewport, viewportCenterCartesian) {\n // Extract frustum planes based on current view.\n const frustumPlanes = viewport.getFrustumPlanes();\n let i = 0;\n for (const dir in frustumPlanes) {\n const plane = frustumPlanes[dir];\n const distanceToCenter = plane.normal.dot(viewport.center);\n scratchPosition\n .copy(plane.normal)\n .scale(plane.distance - distanceToCenter)\n .add(viewport.center);\n const cartographicPos = viewport.unprojectPosition(scratchPosition);\n\n const cartesianPos = Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, new Vector3());\n\n cullingVolume.planes[i++].fromPointNormal(\n cartesianPos,\n // Want the normal to point into the frustum since that's what culling expects\n scratchVector.copy(viewportCenterCartesian).subtract(cartesianPos)\n );\n }\n}\n","import {Vector3} from '@math.gl/core';\n\nconst WGS84_RADIUS_X = 6378137.0;\nconst WGS84_RADIUS_Y = 6378137.0;\nconst WGS84_RADIUS_Z = 6356752.3142451793;\n\nconst scratchVector = new Vector3();\n\n/**\n * Calculate appropriate zoom value for a particular boundingVolume\n * @param {BoundingSphere, OrientedBoundingBox} boundingVolume - the instance of bounding volume\n * @returns {number} - zoom value\n */\nexport function getZoomFromBoundingVolume(boundingVolume) {\n const {halfAxes, radius, width, height} = boundingVolume;\n\n if (halfAxes) {\n // OrientedBoundingBox\n const obbSize = getObbSize(halfAxes);\n // Use WGS84_RADIUS_Z to allign with BoundingSphere algorithm\n return Math.log2(WGS84_RADIUS_Z / obbSize);\n } else if (radius) {\n // BoundingSphere\n return Math.log2(WGS84_RADIUS_Z / radius);\n } else if (height && width) {\n // BoundingRectangle\n const zoomX = Math.log2(WGS84_RADIUS_X / width);\n const zoomY = Math.log2(WGS84_RADIUS_Y / height);\n\n return (zoomX + zoomY) / 2;\n }\n\n return 1;\n}\n\nfunction getObbSize(halfAxes) {\n halfAxes.getColumn(0, scratchVector);\n const axeY = halfAxes.getColumn(1);\n const axeZ = halfAxes.getColumn(2);\n const farthestVertex = scratchVector.add(axeY).add(axeZ);\n const size = farthestVertex.len();\n return size;\n}\n","import type {Readable} from 'stream';\n\n/** A DOM or Node readable stream */\nexport type ReadableStreamType = ReadableStream | Readable;\n\nconst isBoolean: (x: any) => boolean = (x) => typeof x === 'boolean';\nconst isFunction: (x: any) => boolean = (x) => typeof x === 'function';\n\nexport const isObject: (x: any) => boolean = (x) => x !== null && typeof x === 'object';\nexport const isPureObject: (x: any) => boolean = (x) =>\n isObject(x) && x.constructor === {}.constructor;\nexport const isPromise: (x: any) => boolean = (x) => isObject(x) && isFunction(x.then);\n\nexport const isIterable: (x: any) => boolean = (x) => x && typeof x[Symbol.iterator] === 'function';\nexport const isAsyncIterable: (x: any) => boolean = (x) =>\n x && typeof x[Symbol.asyncIterator] === 'function';\nexport const isIterator: (x: any) => boolean = (x) => x && isFunction(x.next);\n\nexport const isResponse: (x: any) => boolean = (x) =>\n (typeof Response !== 'undefined' && x instanceof Response) ||\n (x && x.arrayBuffer && x.text && x.json);\n\nexport const isFile: (x: any) => boolean = (x) => typeof File !== 'undefined' && x instanceof File;\nexport const isBlob: (x: any) => boolean = (x) => typeof Blob !== 'undefined' && x instanceof Blob;\n\n/** Check for Node.js `Buffer` without triggering bundler to include buffer polyfill */\nexport const isBuffer: (x: any) => boolean = (x) => x && typeof x === 'object' && x.isBuffer;\n\nexport const isWritableDOMStream: (x: any) => boolean = (x) =>\n isObject(x) && isFunction(x.abort) && isFunction(x.getWriter);\n\nexport const isReadableDOMStream: (x: any) => boolean = (x) =>\n (typeof ReadableStream !== 'undefined' && x instanceof ReadableStream) ||\n (isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader));\n// Not implemented in Firefox: && isFunction(x.pipeTo)\n\nexport const isWritableNodeStream: (x: any) => boolean = (x) =>\n isObject(x) && isFunction(x.end) && isFunction(x.write) && isBoolean(x.writable);\nexport const isReadableNodeStream: (x: any) => boolean = (x) =>\n isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);\nexport const isReadableStream: (x: any) => boolean = (x) =>\n isReadableDOMStream(x) || isReadableNodeStream(x);\nexport const isWritableStream: (x: any) => boolean = (x) =>\n isWritableDOMStream(x) || isWritableNodeStream(x);\n","import type {Loader} from '@loaders.gl/loader-utils';\nimport {assert} from '@loaders.gl/loader-utils';\n\nexport function isLoaderObject(loader?: any): boolean {\n if (!loader) {\n return false;\n }\n\n if (Array.isArray(loader)) {\n loader = loader[0];\n }\n\n const hasExtensions = Array.isArray(loader?.extensions);\n\n /* Now handled by types and worker loaders do not have these\n let hasParser =\n loader.parseTextSync ||\n loader.parseSync ||\n loader.parse ||\n loader.parseStream || // TODO Remove, Replace with parseInBatches\n loader.parseInBatches;\n */\n\n return hasExtensions;\n}\n\nexport function normalizeLoader(loader: Loader): Loader {\n // This error is fairly easy to trigger by mixing up import statements etc\n // So we make an exception and add a developer error message for this case\n // To help new users from getting stuck here\n assert(loader, 'null loader');\n assert(isLoaderObject(loader), 'invalid loader');\n\n // NORMALIZE [LOADER, OPTIONS] => LOADER\n\n // If [loader, options], create a new loaders object with options merged in\n let options;\n if (Array.isArray(loader)) {\n options = loader[1];\n loader = loader[0];\n loader = {\n ...loader,\n options: {...loader.options, ...options}\n };\n }\n\n // NORMALIZE text and binary flags\n // Ensure at least one of text/binary flags are properly set\n\n // @ts-expect-error\n if (loader?.parseTextSync || loader?.parseText) {\n loader.text = true;\n }\n\n if (!loader.text) {\n loader.binary = true;\n }\n\n return loader;\n}\n","// Simple file alias mechanisms for tests.\n\nlet pathPrefix = '';\nconst fileAliases: {[aliasPath: string]: string} = {};\n\n/*\n * Set a relative path prefix\n */\nexport function setPathPrefix(prefix: string): void {\n pathPrefix = prefix;\n}\n\n/*\n * Get the relative path prefix\n */\nexport function getPathPrefix(): string {\n return pathPrefix;\n}\n\n/**\n *\n * @param aliases\n *\n * Note: addAliases are an experimental export, they are only for testing of loaders.gl loaders\n * not intended as a generic aliasing mechanism\n */\nexport function addAliases(aliases: {[aliasPath: string]: string}): void {\n Object.assign(fileAliases, aliases);\n}\n\n/**\n * Resolves aliases and adds path-prefix to paths\n */\nexport function resolvePath(filename: string): string {\n for (const alias in fileAliases) {\n if (filename.startsWith(alias)) {\n const replacement = fileAliases[alias];\n filename = filename.replace(alias, replacement);\n }\n }\n if (!filename.startsWith('http://') && !filename.startsWith('https://')) {\n filename = `${pathPrefix}${filename}`;\n }\n return filename;\n}\n","// TODO - build/integrate proper MIME type parsing\n// https://mimesniff.spec.whatwg.org/\n\nconst DATA_URL_PATTERN = /^data:([-\\w.]+\\/[-\\w.+]+)(;|,)/;\nconst MIME_TYPE_PATTERN = /^([-\\w.]+\\/[-\\w.+]+)/;\n\n/**\n * Remove extra data like `charset` from MIME types\n * @param mimeString\n * @returns A clean MIME type, or an empty string\n *\n * @todo - handle more advanced MIMETYpes, multiple types\n * @todo - extract charset etc\n */\nexport function parseMIMEType(mimeString: string): string {\n // If resource is a data url, extract any embedded mime type\n const matches = MIME_TYPE_PATTERN.exec(mimeString);\n if (matches) {\n return matches[1];\n }\n return mimeString;\n}\n\n/**\n * Extract MIME type from data URL\n *\n * @param mimeString\n * @returns A clean MIME type, or an empty string\n *\n * @todo - handle more advanced MIMETYpes, multiple types\n * @todo - extract charset etc\n */\nexport function parseMIMETypeFromURL(url: string): string {\n // If resource is a data URL, extract any embedded mime type\n const matches = DATA_URL_PATTERN.exec(url);\n if (matches) {\n return matches[1];\n }\n return '';\n}\n","import {isResponse, isBlob} from '../../javascript-utils/is-type';\nimport {parseMIMEType, parseMIMETypeFromURL} from './mime-type-utils';\n\nconst QUERY_STRING_PATTERN = /\\?.*/;\n\n/**\n * Returns an object with `url` and (MIME) `type` fields\n * If it cannot determine url or type, the corresponding value will be an empty string\n *\n * @param resource Any type, but only Responses, string URLs and data URLs are processed\n *\n * @todo string parameters are assumed to be URLs\n */\nexport function getResourceUrlAndType(resource: any): {url: string; type: string} {\n // If resource is a response, it contains the information directly\n if (isResponse(resource)) {\n const url = stripQueryString(resource.url || '');\n const contentTypeHeader = resource.headers.get('content-type') || '';\n return {\n url,\n type: parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(url)\n };\n }\n\n // If the resource is a Blob or a File (subclass of Blob)\n if (isBlob(resource)) {\n return {\n // File objects have a \"name\" property. Blob objects don't have any\n // url (name) information\n url: stripQueryString(resource.name || ''),\n type: resource.type || ''\n };\n }\n\n if (typeof resource === 'string') {\n return {\n // TODO this could mess up data URL but it doesn't matter as it is just used for inference\n url: stripQueryString(resource),\n // If a data url\n type: parseMIMETypeFromURL(resource)\n };\n }\n\n // Unknown\n return {\n url: '',\n type: ''\n };\n}\n\n/**\n * Returns (approximate) content length for a resource if it can be determined.\n * Returns -1 if content length cannot be determined.\n * @param resource\n\n * @note string parameters are NOT assumed to be URLs\n */\nexport function getResourceContentLength(resource: any): number {\n if (isResponse(resource)) {\n return resource.headers['content-length'] || -1;\n }\n if (isBlob(resource)) {\n return resource.size;\n }\n if (typeof resource === 'string') {\n // TODO - handle data URL?\n return resource.length;\n }\n if (resource instanceof ArrayBuffer) {\n return resource.byteLength;\n }\n if (ArrayBuffer.isView(resource)) {\n return resource.byteLength;\n }\n return -1;\n}\n\nfunction stripQueryString(url) {\n return url.replace(QUERY_STRING_PATTERN, '');\n}\n","import {isResponse} from '../../javascript-utils/is-type';\nimport {getResourceContentLength, getResourceUrlAndType} from './resource-utils';\n\n/**\n * Returns a Response object\n * Adds content-length header when possible\n *\n * @param resource\n */\nexport async function makeResponse(resource: any): Promise<Response> {\n if (isResponse(resource)) {\n return resource;\n }\n\n // Add content-length header if possible\n const headers: {[header: string]: string} = {};\n\n const contentLength = getResourceContentLength(resource);\n if (contentLength >= 0) {\n headers['content-length'] = String(contentLength);\n }\n\n // `new Response(File)` does not preserve content-type and URL\n // so we add them here\n const {url, type} = getResourceUrlAndType(resource);\n if (type) {\n headers['content-type'] = type;\n }\n\n // Add a custom header with initial bytes if available\n const initialDataUrl = await getInitialDataUrl(resource);\n if (initialDataUrl) {\n headers['x-first-bytes'] = initialDataUrl;\n }\n\n // TODO - is this the best way of handling strings?\n // Maybe package as data URL instead?\n if (typeof resource === 'string') {\n // Convert to ArrayBuffer to avoid Response treating it as a URL\n resource = new TextEncoder().encode(resource);\n }\n\n // Attempt to create a Response from the resource, adding headers and setting url\n const response = new Response(resource, {headers});\n // We can't control `Response.url` via constructor, use a property override to record URL.\n Object.defineProperty(response, 'url', {value: url});\n return response;\n}\n\n/**\n * Checks response status (async) and throws a helpful error message if status is not OK.\n * @param response\n */\nexport async function checkResponse(response: Response): Promise<void> {\n if (!response.ok) {\n const message = await getResponseError(response);\n throw new Error(message);\n }\n}\n\n/**\n * Checks response status (sync) and throws a helpful error message if status is not OK.\n * @param response\n */\nexport function checkResponseSync(response: Response): void {\n if (!response.ok) {\n let message = `${response.status} ${response.statusText}`;\n message = message.length > 60 ? `${message.slice(60)}...` : message;\n throw new Error(message);\n }\n}\n\n// HELPERS\n\nasync function getResponseError(response): Promise<string> {\n let message = `Failed to fetch resource ${response.url} (${response.status}): `;\n try {\n const contentType = response.headers.get('Content-Type');\n let text = response.statusText;\n if (contentType.includes('application/json')) {\n text += ` ${await response.text()}`;\n }\n message += text;\n message = message.length > 60 ? `${message.slice(60)}...` : message;\n } catch (error) {\n // eslint forbids return in a finally statement, so we just catch here\n }\n return message;\n}\n\nasync function getInitialDataUrl(resource): Promise<string | null> {\n const INITIAL_DATA_LENGTH = 5;\n if (typeof resource === 'string') {\n return `data:,${resource.slice(0, INITIAL_DATA_LENGTH)}`;\n }\n if (resource instanceof Blob) {\n const blobSlice = resource.slice(0, 5);\n return await new Promise((resolve) => {\n const reader = new FileReader();\n reader.onload = (event) => resolve(event?.target?.result as string);\n reader.readAsDataURL(blobSlice);\n });\n }\n if (resource instanceof ArrayBuffer) {\n const slice = resource.slice(0, INITIAL_DATA_LENGTH);\n const base64 = arrayBufferToBase64(slice);\n return `data:base64,${base64}`;\n }\n return null;\n}\n\n// https://stackoverflow.com/questions/9267899/arraybuffer-to-base64-encoded-string\nfunction arrayBufferToBase64(buffer) {\n let binary = '';\n const bytes = new Uint8Array(buffer);\n for (let i = 0; i < bytes.byteLength; i++) {\n binary += String.fromCharCode(bytes[i]);\n }\n return btoa(binary);\n}\n","import {resolvePath} from '@loaders.gl/loader-utils';\nimport {makeResponse} from '../utils/response-utils';\n// import {getErrorMessageFromResponse} from './fetch-error-message';\n\n/**\n * fetch compatible function\n * Reads file data from:\n * - http/http urls\n * - data urls\n * - File/Blob objects\n * Leverages `@loaders.gl/polyfills` for Node.js support\n * Respects pathPrefix and file aliases\n */\nexport async function fetchFile(\n url: string | Blob,\n options?: RequestInit & {fetch?: RequestInit | Function}\n): Promise<Response> {\n if (typeof url === 'string') {\n url = resolvePath(url);\n\n let fetchOptions: RequestInit = options as RequestInit;\n if (options?.fetch && typeof options?.fetch !== 'function') {\n fetchOptions = options.fetch;\n }\n\n return await fetch(url, fetchOptions);\n }\n\n return await makeResponse(url);\n}\n","import checkIfBrowser from '../env/is-browser';\nexport { self, window, global, document, process, console } from '../env/globals';\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'untranspiled source';\nexport const isBrowser = checkIfBrowser();\n//# sourceMappingURL=globals.js.map","function getStorage(type) {\n try {\n const storage = window[type];\n const x = '__storage_test__';\n storage.setItem(x, x);\n storage.removeItem(x);\n return storage;\n } catch (e) {\n return null;\n }\n}\n\nexport default class LocalStorage {\n constructor(id, defaultSettings, type = 'sessionStorage') {\n this.storage = getStorage(type);\n this.id = id;\n this.config = {};\n Object.assign(this.config, defaultSettings);\n\n this._loadConfiguration();\n }\n\n getConfiguration() {\n return this.config;\n }\n\n setConfiguration(configuration) {\n this.config = {};\n return this.updateConfiguration(configuration);\n }\n\n updateConfiguration(configuration) {\n Object.assign(this.config, configuration);\n\n if (this.storage) {\n const serialized = JSON.stringify(this.config);\n this.storage.setItem(this.id, serialized);\n }\n\n return this;\n }\n\n _loadConfiguration() {\n let configuration = {};\n\n if (this.storage) {\n const serializedConfiguration = this.storage.getItem(this.id);\n configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};\n }\n\n Object.assign(this.config, configuration);\n return this;\n }\n\n}\n//# sourceMappingURL=local-storage.js.map","export function formatTime(ms) {\n let formatted;\n\n if (ms < 10) {\n formatted = \"\".concat(ms.toFixed(2), \"ms\");\n } else if (ms < 100) {\n formatted = \"\".concat(ms.toFixed(1), \"ms\");\n } else if (ms < 1000) {\n formatted = \"\".concat(ms.toFixed(0), \"ms\");\n } else {\n formatted = \"\".concat((ms / 1000).toFixed(2), \"s\");\n }\n\n return formatted;\n}\nexport function leftPad(string, length = 8) {\n const padLength = Math.max(length - string.length, 0);\n return \"\".concat(' '.repeat(padLength)).concat(string);\n}\nexport function rightPad(string, length = 8) {\n const padLength = Math.max(length - string.length, 0);\n return \"\".concat(string).concat(' '.repeat(padLength));\n}\nexport function formatValue(v, opts = {}) {\n const EPSILON = 1e-16;\n const {\n isInteger = false\n } = opts;\n\n if (Array.isArray(v) || ArrayBuffer.isView(v)) {\n return formatArrayValue(v, opts);\n }\n\n if (!Number.isFinite(v)) {\n return String(v);\n }\n\n if (Math.abs(v) < EPSILON) {\n return isInteger ? '0' : '0.';\n }\n\n if (isInteger) {\n return v.toFixed(0);\n }\n\n if (Math.abs(v) > 100 && Math.abs(v) < 10000) {\n return v.toFixed(0);\n }\n\n const string = v.toPrecision(2);\n const decimal = string.indexOf('.0');\n return decimal === string.length - 2 ? string.slice(0, -1) : string;\n}\n\nfunction formatArrayValue(v, opts) {\n const {\n maxElts = 16,\n size = 1\n } = opts;\n let string = '[';\n\n for (let i = 0; i < v.length && i < maxElts; ++i) {\n if (i > 0) {\n string += \",\".concat(i % size === 0 ? ' ' : '');\n }\n\n string += formatValue(v[i], opts);\n }\n\n const terminator = v.length > maxElts ? '...' : ']';\n return \"\".concat(string).concat(terminator);\n}\n\nexport function formatImage(image, message, scale, maxWidth = 600) {\n const imageUrl = image.src.replace(/\\(/g, '%28').replace(/\\)/g, '%29');\n\n if (image.width > maxWidth) {\n scale = Math.min(scale, maxWidth / image.width);\n }\n\n const width = image.width * scale;\n const height = image.height * scale;\n const style = ['font-size:1px;', \"padding:\".concat(Math.floor(height / 2), \"px \").concat(Math.floor(width / 2), \"px;\"), \"line-height:\".concat(height, \"px;\"), \"background:url(\".concat(imageUrl, \");\"), \"background-size:\".concat(width, \"px \").concat(height, \"px;\"), 'color:transparent;'].join('');\n return [\"\".concat(message, \" %c+\"), style];\n}\n//# sourceMappingURL=formatters.js.map","import { isBrowser } from './globals';\nexport const COLOR = {\n BLACK: 30,\n RED: 31,\n GREEN: 32,\n YELLOW: 33,\n BLUE: 34,\n MAGENTA: 35,\n CYAN: 36,\n WHITE: 37,\n BRIGHT_BLACK: 90,\n BRIGHT_RED: 91,\n BRIGHT_GREEN: 92,\n BRIGHT_YELLOW: 93,\n BRIGHT_BLUE: 94,\n BRIGHT_MAGENTA: 95,\n BRIGHT_CYAN: 96,\n BRIGHT_WHITE: 97\n};\n\nfunction getColor(color) {\n return typeof color === 'string' ? COLOR[color.toUpperCase()] || COLOR.WHITE : color;\n}\n\nexport function addColor(string, color, background) {\n if (!isBrowser && typeof string === 'string') {\n if (color) {\n color = getColor(color);\n string = \"\\x1B[\".concat(color, \"m\").concat(string, \"\\x1B[39m\");\n }\n\n if (background) {\n color = getColor(background);\n string = \"\\x1B[\".concat(background + 10, \"m\").concat(string, \"\\x1B[49m\");\n }\n }\n\n return string;\n}\n//# sourceMappingURL=color.js.map","export default function assert(condition, message) {\n if (!condition) {\n throw new Error(message || 'Assertion failed');\n }\n}\n//# sourceMappingURL=assert.js.map","import { window, process, isBrowser } from './globals';\nexport default function getHiResTimestamp() {\n let timestamp;\n\n if (isBrowser && window.performance) {\n timestamp = window.performance.now();\n } else if (process.hrtime) {\n const timeParts = process.hrtime();\n timestamp = timeParts[0] * 1000 + timeParts[1] / 1e6;\n } else {\n timestamp = Date.now();\n }\n\n return timestamp;\n}\n//# sourceMappingURL=hi-res-timestamp.js.map","import { VERSION, isBrowser } from '../utils/globals';\nimport LocalStorage from '../utils/local-storage';\nimport { formatImage, formatTime, leftPad } from '../utils/formatters';\nimport { addColor } from '../utils/color';\nimport { autobind } from '../utils/autobind';\nimport assert from '../utils/assert';\nimport getHiResTimestamp from '../utils/hi-res-timestamp';\nconst originalConsole = {\n debug: isBrowser ? console.debug || console.log : console.log,\n log: console.log,\n info: console.info,\n warn: console.warn,\n error: console.error\n};\nconst DEFAULT_SETTINGS = {\n enabled: true,\n level: 0\n};\n\nfunction noop() {}\n\nconst cache = {};\nconst ONCE = {\n once: true\n};\n\nfunction getTableHeader(table) {\n for (const key in table) {\n for (const title in table[key]) {\n return title || 'untitled';\n }\n }\n\n return 'empty';\n}\n\nexport default class Log {\n constructor({\n id\n } = {\n id: ''\n }) {\n this.id = id;\n this.VERSION = VERSION;\n this._startTs = getHiResTimestamp();\n this._deltaTs = getHiResTimestamp();\n this.LOG_THROTTLE_TIMEOUT = 0;\n this._storage = new LocalStorage(\"__probe-\".concat(this.id, \"__\"), DEFAULT_SETTINGS);\n this.userData = {};\n this.timeStamp(\"\".concat(this.id, \" started\"));\n autobind(this);\n Object.seal(this);\n }\n\n set level(newLevel) {\n this.setLevel(newLevel);\n }\n\n get level() {\n return this.getLevel();\n }\n\n isEnabled() {\n return this._storage.config.enabled;\n }\n\n getLevel() {\n return this._storage.config.level;\n }\n\n getTotal() {\n return Number((getHiResTimestamp() - this._startTs).toPrecision(10));\n }\n\n getDelta() {\n return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10));\n }\n\n set priority(newPriority) {\n this.level = newPriority;\n }\n\n get priority() {\n return this.level;\n }\n\n getPriority() {\n return this.level;\n }\n\n enable(enabled = true) {\n this._storage.updateConfiguration({\n enabled\n });\n\n return this;\n }\n\n setLevel(level) {\n this._storage.updateConfiguration({\n level\n });\n\n return this;\n }\n\n assert(condition, message) {\n assert(condition, message);\n }\n\n warn(message) {\n return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE);\n }\n\n error(message) {\n return this._getLogFunction(0, message, originalConsole.error, arguments);\n }\n\n deprecated(oldUsage, newUsage) {\n return this.warn(\"`\".concat(oldUsage, \"` is deprecated and will be removed in a later version. Use `\").concat(newUsage, \"` instead\"));\n }\n\n removed(oldUsage, newUsage) {\n return this.error(\"`\".concat(oldUsage, \"` has been removed. Use `\").concat(newUsage, \"` instead\"));\n }\n\n probe(logLevel, message) {\n return this._getLogFunction(logLevel, message, originalConsole.log, arguments, {\n time: true,\n once: true\n });\n }\n\n log(logLevel, message) {\n return this._getLogFunction(logLevel, message, originalConsole.debug, arguments);\n }\n\n info(logLevel, message) {\n return this._getLogFunction(logLevel, message, console.info, arguments);\n }\n\n once(logLevel, message) {\n return this._getLogFunction(logLevel, message, originalConsole.debug || originalConsole.info, arguments, ONCE);\n }\n\n table(logLevel, table, columns) {\n if (table) {\n return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], {\n tag: getTableHeader(table)\n });\n }\n\n return noop;\n }\n\n image({\n logLevel,\n priority,\n image,\n message = '',\n scale = 1\n }) {\n if (!this._shouldLog(logLevel || priority)) {\n return noop;\n }\n\n return isBrowser ? logImageInBrowser({\n image,\n message,\n scale\n }) : logImageInNode({\n image,\n message,\n scale\n });\n }\n\n settings() {\n if (console.table) {\n console.table(this._storage.config);\n } else {\n console.log(this._storage.config);\n }\n }\n\n get(setting) {\n return this._storage.config[setting];\n }\n\n set(setting, value) {\n this._storage.updateConfiguration({\n [setting]: value\n });\n }\n\n time(logLevel, message) {\n return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);\n }\n\n timeEnd(logLevel, message) {\n return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);\n }\n\n timeStamp(logLevel, message) {\n return this._getLogFunction(logLevel, message, console.timeStamp || noop);\n }\n\n group(logLevel, message, opts = {\n collapsed: false\n }) {\n opts = normalizeArguments({\n logLevel,\n message,\n opts\n });\n const {\n collapsed\n } = opts;\n opts.method = (collapsed ? console.groupCollapsed : console.group) || console.info;\n return this._getLogFunction(opts);\n }\n\n groupCollapsed(logLevel, message, opts = {}) {\n return this.group(logLevel, message, Object.assign({}, opts, {\n collapsed: true\n }));\n }\n\n groupEnd(logLevel) {\n return this._getLogFunction(logLevel, '', console.groupEnd || noop);\n }\n\n withGroup(logLevel, message, func) {\n this.group(logLevel, message)();\n\n try {\n func();\n } finally {\n this.groupEnd(logLevel)();\n }\n }\n\n trace() {\n if (console.trace) {\n console.trace();\n }\n }\n\n _shouldLog(logLevel) {\n return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);\n }\n\n _getLogFunction(logLevel, message, method, args = [], opts) {\n if (this._shouldLog(logLevel)) {\n opts = normalizeArguments({\n logLevel,\n message,\n args,\n opts\n });\n method = method || opts.method;\n assert(method);\n opts.total = this.getTotal();\n opts.delta = this.getDelta();\n this._deltaTs = getHiResTimestamp();\n const tag = opts.tag || opts.message;\n\n if (opts.once) {\n if (!cache[tag]) {\n cache[tag] = getHiResTimestamp();\n } else {\n return noop;\n }\n }\n\n message = decorateMessage(this.id, opts.message, opts);\n return method.bind(console, message, ...opts.args);\n }\n\n return noop;\n }\n\n}\nLog.VERSION = VERSION;\n\nfunction normalizeLogLevel(logLevel) {\n if (!logLevel) {\n return 0;\n }\n\n let resolvedLevel;\n\n switch (typeof logLevel) {\n case 'number':\n resolvedLevel = logLevel;\n break;\n\n case 'object':\n resolvedLevel = logLevel.logLevel || logLevel.priority || 0;\n break;\n\n default:\n return 0;\n }\n\n assert(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);\n return resolvedLevel;\n}\n\nexport function normalizeArguments(opts) {\n const {\n logLevel,\n message\n } = opts;\n opts.logLevel = normalizeLogLevel(logLevel);\n const args = opts.args ? Array.from(opts.args) : [];\n\n while (args.length && args.shift() !== message) {}\n\n opts.args = args;\n\n switch (typeof logLevel) {\n case 'string':\n case 'function':\n if (message !== undefined) {\n args.unshift(message);\n }\n\n opts.message = logLevel;\n break;\n\n case 'object':\n Object.assign(opts, logLevel);\n break;\n\n default:\n }\n\n if (typeof opts.message === 'function') {\n opts.message = opts.message();\n }\n\n const messageType = typeof opts.message;\n assert(messageType === 'string' || messageType === 'object');\n return Object.assign(opts, opts.opts);\n}\n\nfunction decorateMessage(id, message, opts) {\n if (typeof message === 'string') {\n const time = opts.time ? leftPad(formatTime(opts.total)) : '';\n message = opts.time ? \"\".concat(id, \": \").concat(time, \" \").concat(message) : \"\".concat(id, \": \").concat(message);\n message = addColor(message, opts.color, opts.background);\n }\n\n return message;\n}\n\nfunction logImageInNode({\n image,\n message = '',\n scale = 1\n}) {\n let asciify = null;\n\n try {\n asciify = module.require('asciify-image');\n } catch (error) {}\n\n if (asciify) {\n return () => asciify(image, {\n fit: 'box',\n width: \"\".concat(Math.round(80 * scale), \"%\")\n }).then(data => console.log(data));\n }\n\n return noop;\n}\n\nfunction logImageInBrowser({\n image,\n message = '',\n scale = 1\n}) {\n if (typeof image === 'string') {\n const img = new Image();\n\n img.onload = () => {\n const args = formatImage(img, message, scale);\n console.log(...args);\n };\n\n img.src = image;\n return noop;\n }\n\n const element = image.nodeName || '';\n\n if (element.toLowerCase() === 'img') {\n console.log(...formatImage(image, message, scale));\n return noop;\n }\n\n if (element.toLowerCase() === 'canvas') {\n const img = new Image();\n\n img.onload = () => console.log(...formatImage(img, message, scale));\n\n img.src = image.toDataURL();\n return noop;\n }\n\n return noop;\n}\n//# sourceMappingURL=log.js.map","export function autobind(obj, predefined = ['constructor']) {\n const proto = Object.getPrototypeOf(obj);\n const propNames = Object.getOwnPropertyNames(proto);\n\n for (const key of propNames) {\n if (typeof obj[key] === 'function') {\n if (!predefined.find(name => key === name)) {\n obj[key] = obj[key].bind(obj);\n }\n }\n }\n}\n//# sourceMappingURL=autobind.js.map","// probe.gl Log compatible loggers\nimport {Log} from 'probe.gl';\n\nexport const probeLog = new Log({id: 'loaders.gl'});\n\n// Logs nothing\nexport class NullLog {\n log() {\n return () => {};\n }\n info() {\n return () => {};\n }\n warn() {\n return () => {};\n }\n error() {\n return () => {};\n }\n}\n\n// Logs to console\nexport class ConsoleLog {\n console;\n\n constructor() {\n this.console = console; // eslint-disable-line\n }\n log(...args) {\n return this.console.log.bind(this.console, ...args);\n }\n info(...args) {\n return this.console.info.bind(this.console, ...args);\n }\n warn(...args) {\n return this.console.warn.bind(this.console, ...args);\n }\n error(...args) {\n return this.console.error.bind(this.console, ...args);\n }\n}\n","import type {LoaderOptions} from '@loaders.gl/loader-utils';\nimport {ConsoleLog} from './loggers';\n\nexport const DEFAULT_LOADER_OPTIONS: LoaderOptions = {\n // baseUri\n fetch: null,\n mimeType: undefined,\n nothrow: false,\n log: new ConsoleLog(), // A probe.gl compatible (`log.log()()` syntax) that just logs to console\n\n CDN: 'https://unpkg.com/@loaders.gl',\n worker: true, // By default, use worker if provided by loader.\n maxConcurrency: 3, // How many worker instances should be created for each loader.\n maxMobileConcurrency: 1, // How many worker instances should be created for each loader on mobile devices.\n reuseWorkers: true, // By default reuse workers,\n _workerType: '', // 'test' to use locally generated workers\n\n limit: 0,\n _limitMB: 0,\n batchSize: 'auto',\n batchDebounceMs: 0,\n metadata: false, // TODO - currently only implemented for parseInBatches, adds initial metadata batch,\n transforms: []\n};\n\nexport const REMOVED_LOADER_OPTIONS = {\n throws: 'nothrow',\n dataType: '(no longer used)',\n uri: 'baseUri',\n // Warn if fetch options are used on top-level\n method: 'fetch.method',\n headers: 'fetch.headers',\n body: 'fetch.body',\n mode: 'fetch.mode',\n credentials: 'fetch.credentials',\n cache: 'fetch.cache',\n redirect: 'fetch.redirect',\n referrer: 'fetch.referrer',\n referrerPolicy: 'fetch.referrerPolicy',\n integrity: 'fetch.integrity',\n keepalive: 'fetch.keepalive',\n signal: 'fetch.signal'\n};\n","import type {Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {global} from '@loaders.gl/loader-utils';\nimport {isPureObject, isObject} from '../../javascript-utils/is-type';\nimport {fetchFile} from '../fetch/fetch-file';\nimport {probeLog, NullLog} from './loggers';\nimport {DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS} from './option-defaults';\n/**\n * Global state for loaders.gl. Stored on `global.loaders._state`\n */\ntype GlobalLoaderState = {\n loaderRegistry: Loader[];\n globalOptions: {[key: string]: any};\n};\n\n/**\n * Helper for safely accessing global loaders.gl variables\n * Wraps initialization of global variable in function to defeat overly aggressive tree-shakers\n */\nexport function getGlobalLoaderState(): GlobalLoaderState {\n // @ts-ignore\n global.loaders = global.loaders || {};\n // @ts-ignore\n const {loaders} = global;\n\n // Add _state object to keep separate from modules added to global.loaders\n loaders._state = loaders._state || {};\n return loaders._state;\n}\n\n// Store global loader options on the global object to increase chances of cross loaders-version interoperability\n// NOTE: This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks\nconst getGlobalLoaderOptions = () => {\n const state = getGlobalLoaderState();\n // Ensure all default loader options from this library are mentioned\n state.globalOptions = state.globalOptions || {...DEFAULT_LOADER_OPTIONS};\n return state.globalOptions;\n};\n\n/**\n * Set global loader options\n * @param options\n */\nexport function setGlobalOptions(options: object): void {\n const state = getGlobalLoaderState();\n const globalOptions = getGlobalLoaderOptions();\n state.globalOptions = normalizeOptionsInternal(globalOptions, options);\n}\n\n/**\n * Merges options with global opts and loader defaults, also injects baseUri\n * @param options\n * @param loader\n * @param loaders\n * @param url\n */\nexport function normalizeOptions(\n options: object,\n loader: Loader,\n loaders?: Loader[],\n url?: string\n): object {\n loaders = loaders || [];\n loaders = Array.isArray(loaders) ? loaders : [loaders];\n\n validateOptions(options, loaders);\n return normalizeOptionsInternal(loader, options, url);\n}\n\n/**\n * Gets the current fetch function from options and context\n * @param options\n * @param context\n */\nexport function getFetchFunction(\n options?: LoaderOptions,\n context?: Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderContext, 'fetch'>>\n) {\n const globalOptions = getGlobalLoaderOptions();\n\n const fetchOptions = options || globalOptions;\n\n // options.fetch can be a function\n if (typeof fetchOptions.fetch === 'function') {\n return fetchOptions.fetch;\n }\n\n // options.fetch can be an options object\n if (isObject(fetchOptions.fetch)) {\n return (url) => fetchFile(url, fetchOptions);\n }\n\n // else refer to context (from parent loader) if available\n if (context?.fetch) {\n return context?.fetch;\n }\n\n // else return the default fetch function\n return fetchFile;\n}\n\n// VALIDATE OPTIONS\n\n/**\n * Warn for unsupported options\n * @param options\n * @param loaders\n */\nfunction validateOptions(options: LoaderOptions, loaders: Loader[]) {\n // Check top level options\n validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders);\n for (const loader of loaders) {\n // Get the scoped, loader specific options from the user supplied options\n const idOptions = (options && options[loader.id]) || {};\n\n // Get scoped, loader specific default and deprecated options from the selected loader\n const loaderOptions = (loader.options && loader.options[loader.id]) || {};\n const deprecatedOptions =\n (loader.deprecatedOptions && loader.deprecatedOptions[loader.id]) || {};\n\n // Validate loader specific options\n validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders);\n }\n}\n\n// eslint-disable-next-line max-params, complexity\nfunction validateOptionsObject(\n options,\n id: string | null,\n defaultOptions,\n deprecatedOptions,\n loaders: Loader[]\n) {\n const loaderName = id || 'Top level';\n const prefix = id ? `${id}.` : '';\n\n for (const key in options) {\n // If top level option value is an object it could options for a loader, so ignore\n const isSubOptions = !id && isObject(options[key]);\n const isBaseUriOption = key === 'baseUri' && !id;\n const isWorkerUrlOption = key === 'workerUrl' && id;\n // <loader>.workerUrl requires special handling as it is now auto-generated and no longer specified as a default option.\n if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) {\n // Issue deprecation warnings\n if (key in deprecatedOptions) {\n probeLog.warn(\n `${loaderName} loader option \\'${prefix}${key}\\' no longer supported, use \\'${deprecatedOptions[key]}\\'`\n )();\n } else if (!isSubOptions) {\n const suggestion = findSimilarOption(key, loaders);\n probeLog.warn(\n `${loaderName} loader option \\'${prefix}${key}\\' not recognized. ${suggestion}`\n )();\n }\n }\n }\n}\n\nfunction findSimilarOption(optionKey, loaders) {\n const lowerCaseOptionKey = optionKey.toLowerCase();\n let bestSuggestion = '';\n for (const loader of loaders) {\n for (const key in loader.options) {\n if (optionKey === key) {\n return `Did you mean \\'${loader.id}.${key}\\'?`;\n }\n const lowerCaseKey = key.toLowerCase();\n const isPartialMatch =\n lowerCaseOptionKey.startsWith(lowerCaseKey) || lowerCaseKey.startsWith(lowerCaseOptionKey);\n if (isPartialMatch) {\n bestSuggestion = bestSuggestion || `Did you mean \\'${loader.id}.${key}\\'?`;\n }\n }\n }\n return bestSuggestion;\n}\n\nfunction normalizeOptionsInternal(loader, options, url?: string) {\n const loaderDefaultOptions = loader.options || {};\n\n const mergedOptions = {...loaderDefaultOptions};\n\n addUrlOptions(mergedOptions, url);\n\n // LOGGING: options.log can be set to `null` to defeat logging\n if (mergedOptions.log === null) {\n mergedOptions.log = new NullLog();\n }\n\n mergeNestedFields(mergedOptions, getGlobalLoaderOptions());\n mergeNestedFields(mergedOptions, options);\n\n return mergedOptions;\n}\n\n// Merge nested options objects\nfunction mergeNestedFields(mergedOptions, options) {\n for (const key in options) {\n // Check for nested options\n // object in options => either no key in defaultOptions or object in defaultOptions\n if (key in options) {\n const value = options[key];\n if (isPureObject(value) && isPureObject(mergedOptions[key])) {\n mergedOptions[key] = {\n ...mergedOptions[key],\n ...options[key]\n };\n } else {\n mergedOptions[key] = options[key];\n }\n }\n // else: No need to merge nested opts, and the initial merge already copied over the nested options\n }\n}\n\n// Harvest information from the url\n// TODO - baseUri should be a directory, i.e. remove file component from baseUri\n// TODO - extract extension?\n// TODO - extract query parameters?\n// TODO - should these be injected on context instead of options?\nfunction addUrlOptions(options, url?: string) {\n if (url && !('baseUri' in options)) {\n options.baseUri = url;\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","import {assert} from '../env-utils/assert';\n\nconst workerURLCache = new Map();\n\n/**\n * Creates a loadable URL from worker source or URL\n * that can be used to create `Worker` instances.\n * Due to CORS issues it may be necessary to wrap a URL in a small importScripts\n * @param props\n * @param props.source Worker source\n * @param props.url Worker URL\n * @returns loadable url\n */\nexport function getLoadableWorkerURL(props: {source?: string; url?: string}) {\n assert((props.source && !props.url) || (!props.source && props.url)); // Either source or url must be defined\n\n let workerURL = workerURLCache.get(props.source || props.url);\n if (!workerURL) {\n // Differentiate worker urls from worker source code\n if (props.url) {\n workerURL = getLoadableWorkerURLFromURL(props.url);\n workerURLCache.set(props.url, workerURL);\n }\n\n if (props.source) {\n workerURL = getLoadableWorkerURLFromSource(props.source);\n workerURLCache.set(props.source, workerURL);\n }\n }\n\n assert(workerURL);\n return workerURL;\n}\n\n/**\n * Build a loadable worker URL from worker URL\n * @param url\n * @returns loadable URL\n */\nfunction getLoadableWorkerURLFromURL(url: string): string {\n // A local script url, we can use it to initialize a Worker directly\n if (!url.startsWith('http')) {\n return url;\n }\n\n // A remote script, we need to use `importScripts` to load from different origin\n const workerSource = buildScriptSource(url);\n return getLoadableWorkerURLFromSource(workerSource);\n}\n\n/**\n * Build a loadable worker URL from worker source\n * @param workerSource\n * @returns loadable url\n */\nfunction getLoadableWorkerURLFromSource(workerSource: string): string {\n // NOTE: webworkify was previously used\n // const blob = webworkify(workerSource, {bare: true});\n const blob = new Blob([workerSource], {type: 'application/javascript'});\n return URL.createObjectURL(blob);\n}\n\n/**\n * Per spec, worker cannot be initialized with a script from a different origin\n * However a local worker script can still import scripts from other origins,\n * so we simply build a wrapper script.\n *\n * @param workerUrl\n * @returns source\n */\nfunction buildScriptSource(workerUrl: string): string {\n return `\\\ntry {\n importScripts('${workerUrl}');\n} catch (error) {\n console.error(error);\n throw error;\n}`;\n}\n","// NOTE - there is a copy of this function is both in core and loader-utils\n// core does not need all the utils in loader-utils, just this one.\n\n/**\n * Returns an array of Transferrable objects that can be used with postMessage\n * https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage\n * @param object data to be sent via postMessage\n * @param recursive - not for application use\n * @param transfers - not for application use\n * @returns a transfer list that can be passed to postMessage\n */\nexport function getTransferList(\n object: any,\n recursive: boolean = true,\n transfers?: Set<any>\n): Transferable[] {\n // Make sure that items in the transfer list is unique\n const transfersSet = transfers || new Set();\n\n if (!object) {\n // ignore\n } else if (isTransferable(object)) {\n transfersSet.add(object);\n } else if (isTransferable(object.buffer)) {\n // Typed array\n transfersSet.add(object.buffer);\n } else if (ArrayBuffer.isView(object)) {\n // object is a TypeArray viewing into a SharedArrayBuffer (not transferable)\n // Do not iterate through the content in this case\n } else if (recursive && typeof object === 'object') {\n for (const key in object) {\n // Avoid perf hit - only go one level deep\n getTransferList(object[key], recursive, transfersSet);\n }\n }\n\n // If transfers is defined, is internal recursive call\n // Otherwise it's called by the user\n return transfers === undefined ? Array.from(transfersSet) : [];\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/API/Transferable\nfunction isTransferable(object) {\n if (!object) {\n return false;\n }\n if (object instanceof ArrayBuffer) {\n return true;\n }\n if (typeof MessagePort !== 'undefined' && object instanceof MessagePort) {\n return true;\n }\n if (typeof ImageBitmap !== 'undefined' && object instanceof ImageBitmap) {\n return true;\n }\n // @ts-ignore\n if (typeof OffscreenCanvas !== 'undefined' && object instanceof OffscreenCanvas) {\n return true;\n }\n return false;\n}\n","import {assert} from '../env-utils/assert';\nimport {getLoadableWorkerURL} from '../worker-utils/get-loadable-worker-url';\nimport {getTransferList} from '../worker-utils/get-transfer-list';\n\nconst NOOP = () => {};\n\nexport type WorkerThreadProps = {\n name: string;\n source?: string;\n url?: string;\n};\n\n/**\n * Represents one worker thread\n */\nexport default class WorkerThread {\n readonly name: string;\n readonly source: string | undefined;\n readonly url: string | undefined;\n terminated: boolean = false;\n worker: Worker;\n onMessage: (message: any) => void;\n onError: (error: Error) => void;\n\n private _loadableURL: string = '';\n\n static isSupported(): boolean {\n return typeof Worker !== 'undefined';\n }\n\n constructor(props: WorkerThreadProps) {\n const {name, source, url} = props;\n assert(source || url); // Either source or url must be defined\n this.name = name;\n this.source = source;\n this.url = url;\n this.onMessage = NOOP;\n this.onError = (error) => console.log(error); // eslint-disable-line\n\n this.worker = this._createBrowserWorker();\n }\n\n /**\n * Terminate this worker thread\n * @note Can free up significant memory\n */\n destroy(): void {\n this.onMessage = NOOP;\n this.onError = NOOP;\n // @ts-ignore\n this.worker.terminate();\n this.terminated = true;\n }\n\n get isRunning() {\n return Boolean(this.onMessage);\n }\n\n /**\n * Send a message to this worker thread\n * @param data any data structure, ideally consisting mostly of transferrable objects\n * @param transferList If not supplied, calculated automatically by traversing data\n */\n postMessage(data: any, transferList?: any[]): void {\n transferList = transferList || getTransferList(data);\n // @ts-ignore\n this.worker.postMessage(data, transferList);\n }\n\n // PRIVATE\n\n /**\n * Generate a standard Error from an ErrorEvent\n * @param {ErrorEvent} event\n */\n _getErrorFromErrorEvent(event) {\n // Note Error object does not have the expected fields if loading failed completely\n // https://developer.mozilla.org/en-US/docs/Web/API/Worker#Event_handlers\n // https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent\n let message = 'Failed to load ';\n message += `worker ${this.name} from ${this.url}. `;\n if (event.message) {\n message += `${event.message} in `;\n }\n // const hasFilename = event.filename && !event.filename.startsWith('blob:');\n // message += hasFilename ? event.filename : this.source.slice(0, 100);\n if (event.lineno) {\n message += `:${event.lineno}:${event.colno}`;\n }\n return new Error(message);\n }\n\n /**\n * Creates a worker thread on the browser\n */\n _createBrowserWorker() {\n this._loadableURL = getLoadableWorkerURL({source: this.source, url: this.url});\n const worker = new Worker(this._loadableURL, {name: this.name});\n\n worker.onmessage = (event) => {\n if (!event.data) {\n this.onError(new Error('No data received'));\n } else {\n this.onMessage(event.data);\n }\n };\n // This callback represents an uncaught exception in the worker thread\n worker.onerror = (error) => {\n this.onError(this._getErrorFromErrorEvent(error));\n this.terminated = true;\n };\n // TODO - not clear when this would be called, for now just log in case it happens\n worker.onmessageerror = (event) => console.error(event); // eslint-disable-line\n\n return worker;\n }\n}\n","import type {WorkerMessageType, WorkerMessagePayload} from '../../types';\nimport WorkerThread from './worker-thread';\nimport {assert} from '../env-utils/assert';\n\n/**\n * Represents one Job handled by a WorkerPool or WorkerFarm\n */\nexport default class WorkerJob {\n readonly name: string;\n readonly workerThread: WorkerThread;\n isRunning: boolean;\n /** Promise that resolves when Job is done */\n readonly result: Promise<any>;\n\n private _resolve: (value: any) => void;\n private _reject: (reason?: any) => void;\n\n constructor(jobName: string, workerThread: WorkerThread) {\n this.name = jobName;\n this.workerThread = workerThread;\n this.isRunning = true;\n this._resolve = () => {};\n this._reject = () => {};\n this.result = new Promise((resolve, reject) => {\n this._resolve = resolve;\n this._reject = reject;\n });\n }\n\n /**\n * Send a message to the job's worker thread\n * @param data any data structure, ideally consisting mostly of transferrable objects\n */\n postMessage(type: WorkerMessageType, payload: WorkerMessagePayload): void {\n this.workerThread.postMessage({\n source: 'loaders.gl', // Lets worker ignore unrelated messages\n type,\n payload\n });\n }\n\n /**\n * Call to resolve the `result` Promise with the supplied value\n */\n done(value): void {\n assert(this.isRunning);\n this.isRunning = false;\n this._resolve(value);\n }\n\n /**\n * Call to reject the `result` Promise with the supplied error\n */\n error(error): void {\n assert(this.isRunning);\n this.isRunning = false;\n this._reject(error);\n }\n}\n","import type {WorkerMessageType, WorkerMessagePayload} from '../../types';\nimport {isMobile} from '../env-utils/globals';\nimport WorkerThread from './worker-thread';\nimport WorkerJob from './worker-job';\n\n/** WorkerPool onDebug Callback Parameters */\ntype OnDebugParameters = {\n message: string;\n worker: string;\n name: string;\n job: string;\n backlog: number;\n workerThread: WorkerThread;\n};\n\n/** WorkerPool Properties */\nexport type WorkerPoolProps = {\n name?: string;\n source?: string; // | Function;\n url?: string;\n maxConcurrency?: number;\n maxMobileConcurrency?: number;\n onDebug?: (options: OnDebugParameters) => any;\n reuseWorkers?: boolean;\n};\n\n/** Private helper types */\ntype OnMessage = (job: WorkerJob, type: WorkerMessageType, payload: WorkerMessagePayload) => void;\ntype OnError = (job: WorkerJob, error: Error) => void;\n\ntype QueuedJob = {\n name: string;\n onMessage: OnMessage;\n onError: OnError;\n onStart: (value: any) => void; // Resolve job start promise\n};\n\n/**\n * Process multiple data messages with small pool of identical workers\n */\nexport default class WorkerPool {\n name: string = 'unnamed';\n source?: string; // | Function;\n url?: string;\n maxConcurrency: number = 1;\n maxMobileConcurrency: number = 1;\n onDebug: (options: OnDebugParameters) => any = () => {};\n reuseWorkers: boolean = true;\n\n private props: WorkerPoolProps = {};\n private jobQueue: QueuedJob[] = [];\n private idleQueue: WorkerThread[] = [];\n private count = 0;\n private isDestroyed = false;\n\n /**\n * @param processor - worker function\n * @param maxConcurrency - max count of workers\n */\n constructor(props: WorkerPoolProps) {\n this.source = props.source;\n this.url = props.url;\n this.setProps(props);\n }\n\n /**\n * Terminates all workers in the pool\n * @note Can free up significant memory\n */\n destroy(): void {\n // Destroy idle workers, active Workers will be destroyed on completion\n this.idleQueue.forEach((worker) => worker.destroy());\n this.isDestroyed = true;\n }\n\n setProps(props: WorkerPoolProps) {\n this.props = {...this.props, ...props};\n\n if (props.name !== undefined) {\n this.name = props.name;\n }\n if (props.maxConcurrency !== undefined) {\n this.maxConcurrency = props.maxConcurrency;\n }\n if (props.maxMobileConcurrency !== undefined) {\n this.maxMobileConcurrency = props.maxMobileConcurrency;\n }\n if (props.reuseWorkers !== undefined) {\n this.reuseWorkers = props.reuseWorkers;\n }\n if (props.onDebug !== undefined) {\n this.onDebug = props.onDebug;\n }\n }\n\n async startJob(\n name: string,\n onMessage: OnMessage = (job, type, data) => job.done(data),\n onError: OnError = (job, error) => job.error(error)\n ): Promise<WorkerJob> {\n // Promise resolves when thread starts working on this job\n const startPromise = new Promise<WorkerJob>((onStart) => {\n // Promise resolves when thread completes or fails working on this job\n this.jobQueue.push({name, onMessage, onError, onStart});\n return this;\n });\n this._startQueuedJob(); // eslint-disable-line @typescript-eslint/no-floating-promises\n return await startPromise;\n }\n\n // PRIVATE\n\n /**\n * Starts first queued job if worker is available or can be created\n * Called when job is started and whenever a worker returns to the idleQueue\n */\n async _startQueuedJob(): Promise<void> {\n if (!this.jobQueue.length) {\n return;\n }\n\n const workerThread = this._getAvailableWorker();\n if (!workerThread) {\n return;\n }\n\n // We have a worker, dequeue and start the job\n const queuedJob = this.jobQueue.shift();\n if (queuedJob) {\n // Emit a debug event\n // @ts-ignore\n this.onDebug({\n message: 'Starting job',\n name: queuedJob.name,\n workerThread,\n backlog: this.jobQueue.length\n });\n\n // Create a worker job to let the app access thread and manage job completion\n const job = new WorkerJob(queuedJob.name, workerThread);\n\n // Set the worker thread's message handlers\n workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);\n workerThread.onError = (error) => queuedJob.onError(job, error);\n\n // Resolve the start promise so that the app can start sending messages to worker\n queuedJob.onStart(job);\n\n // Wait for the app to signal that the job is complete, then return worker to queue\n try {\n await job.result;\n } finally {\n this.returnWorkerToQueue(workerThread);\n }\n }\n }\n\n /**\n * Returns a worker to the idle queue\n * Destroys the worker if\n * - pool is destroyed\n * - if this pool doesn't reuse workers\n * - if maxConcurrency has been lowered\n * @param worker\n */\n returnWorkerToQueue(worker: WorkerThread) {\n const shouldDestroyWorker =\n this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();\n\n if (shouldDestroyWorker) {\n worker.destroy();\n this.count--;\n } else {\n this.idleQueue.push(worker);\n }\n\n if (!this.isDestroyed) {\n this._startQueuedJob(); // eslint-disable-line @typescript-eslint/no-floating-promises\n }\n }\n\n /**\n * Returns idle worker or creates new worker if maxConcurrency has not been reached\n */\n _getAvailableWorker(): WorkerThread | null {\n // If a worker has completed and returned to the queue, it can be used\n if (this.idleQueue.length > 0) {\n return this.idleQueue.shift() || null;\n }\n\n // Create fresh worker if we haven't yet created the max amount of worker threads for this worker source\n if (this.count < this._getMaxConcurrency()) {\n this.count++;\n const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;\n return new WorkerThread({name, source: this.source, url: this.url});\n }\n\n // No worker available, have to wait\n return null;\n }\n\n _getMaxConcurrency() {\n return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;\n }\n}\n","import WorkerPool from './worker-pool';\nimport WorkerThread from './worker-thread';\n\n/**\n * @param maxConcurrency {number} - max count of workers\n */\nexport type WorkerFarmProps = {\n maxConcurrency?: number;\n maxMobileConcurrency?: number;\n reuseWorkers?: boolean;\n onDebug?: () => void;\n};\n\nconst DEFAULT_PROPS: WorkerFarmProps = {\n maxConcurrency: 3,\n maxMobileConcurrency: 1,\n onDebug: () => {},\n reuseWorkers: true\n};\n\n/**\n * Process multiple jobs with a \"farm\" of different workers in worker pools.\n */\nexport default class WorkerFarm {\n private props: WorkerFarmProps;\n private workerPools = new Map<string, WorkerPool>();\n // singleton\n private static _workerFarm?: WorkerFarm;\n\n /** Check if Workers are supported */\n static isSupported(): boolean {\n return WorkerThread.isSupported();\n }\n\n /** Get the singleton instance of the global worker farm */\n static getWorkerFarm(props: WorkerFarmProps = {}): WorkerFarm {\n WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});\n WorkerFarm._workerFarm.setProps(props);\n return WorkerFarm._workerFarm;\n }\n\n /** get global instance with WorkerFarm.getWorkerFarm() */\n private constructor(props: WorkerFarmProps) {\n this.props = {...DEFAULT_PROPS};\n this.setProps(props);\n /** @type Map<string, WorkerPool>} */\n this.workerPools = new Map();\n }\n\n /**\n * Terminate all workers in the farm\n * @note Can free up significant memory\n */\n destroy(): void {\n for (const workerPool of this.workerPools.values()) {\n workerPool.destroy();\n }\n }\n\n /**\n * Set props used when initializing worker pools\n * @param props\n */\n setProps(props: WorkerFarmProps): void {\n this.props = {...this.props, ...props};\n // Update worker pool props\n for (const workerPool of this.workerPools.values()) {\n workerPool.setProps(this._getWorkerPoolProps());\n }\n }\n\n /**\n * Returns a worker pool for the specified worker\n * @param options - only used first time for a specific worker name\n * @param options.name - the name of the worker - used to identify worker pool\n * @param options.url -\n * @param options.source -\n * @example\n * const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);\n */\n getWorkerPool(options: {name: string; source?: string; url?: string}): WorkerPool {\n const {name, source, url} = options;\n let workerPool = this.workerPools.get(name);\n if (!workerPool) {\n workerPool = new WorkerPool({\n name,\n source,\n url\n });\n workerPool.setProps(this._getWorkerPoolProps());\n this.workerPools.set(name, workerPool);\n }\n return workerPool;\n }\n\n _getWorkerPoolProps() {\n return {\n maxConcurrency: this.props.maxConcurrency,\n maxMobileConcurrency: this.props.maxMobileConcurrency,\n reuseWorkers: this.props.reuseWorkers,\n onDebug: this.props.onDebug\n };\n }\n}\n","import type {WorkerJob, WorkerMessageType, WorkerMessagePayload} from '@loaders.gl/worker-utils';\nimport type {Loader, LoaderOptions, LoaderContext} from '../../types';\nimport {WorkerFarm, getWorkerURL} from '@loaders.gl/worker-utils';\n\n/**\n * Determines if a loader can parse with worker\n * @param loader\n * @param options\n */\nexport function canParseWithWorker(loader: Loader, options?: LoaderOptions) {\n if (!WorkerFarm.isSupported()) {\n return false;\n }\n\n return loader.worker && options?.worker;\n}\n\n/**\n * this function expects that the worker function sends certain messages,\n * this can be automated if the worker is wrapper by a call to createLoaderWorker in @loaders.gl/loader-utils.\n */\nexport async function parseWithWorker(\n loader: Loader,\n data,\n options?: LoaderOptions,\n context?: LoaderContext,\n parseOnMainThread?: (arrayBuffer: ArrayBuffer, options: {[key: string]: any}) => Promise<void>\n) {\n const name = loader.id; // TODO\n const url = getWorkerURL(loader, options);\n\n const workerFarm = WorkerFarm.getWorkerFarm(options);\n const workerPool = workerFarm.getWorkerPool({name, url});\n\n // options.log object contains functions which cannot be transferred\n // TODO - decide how to handle logging on workers\n options = JSON.parse(JSON.stringify(options));\n\n const job = await workerPool.startJob(\n 'process-on-worker',\n // eslint-disable-next-line\n onMessage.bind(null, parseOnMainThread)\n );\n\n job.postMessage('process', {\n // @ts-ignore\n input: data,\n options\n });\n\n const result = await job.result;\n return await result.result;\n}\n\n/**\n * Handle worker's responses to the main thread\n * @param job\n * @param type\n * @param payload\n */\nasync function onMessage(\n parseOnMainThread,\n job: WorkerJob,\n type: WorkerMessageType,\n payload: WorkerMessagePayload\n) {\n switch (type) {\n case 'done':\n job.done(payload);\n break;\n\n case 'error':\n job.error(payload.error);\n break;\n\n case 'process':\n // Worker is asking for main thread to parseO\n const {id, input, options} = payload;\n try {\n const result = await parseOnMainThread(input, options);\n job.postMessage('done', {id, result});\n } catch (error) {\n const message = error instanceof Error ? error.message : 'unknown error';\n job.postMessage('error', {id, error: message});\n }\n break;\n\n default:\n // eslint-disable-next-line\n console.warn(`parse-with-worker unknown message ${type}`);\n }\n}\n","import type {WorkerObject, WorkerOptions} from '../../types';\nimport {assert} from '../env-utils/assert';\nimport {VERSION as __VERSION__} from '../env-utils/version';\n\nconst NPM_TAG = 'beta'; // Change to 'latest' on release-branch\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : NPM_TAG;\n\n/**\n * Gets worker object's name (for debugging in Chrome thread inspector window)\n */\nexport function getWorkerName(worker: WorkerObject): string {\n const warning = worker.version !== VERSION ? ` (worker-utils@${VERSION})` : '';\n return `${worker.name}@${worker.version}${warning}`;\n}\n\n/**\n * Generate a worker URL based on worker object and options\n * @returns A URL to one of the following:\n * - a published worker on unpkg CDN\n * - a local test worker\n * - a URL provided by the user in options\n */\nexport function getWorkerURL(worker: WorkerObject, options: WorkerOptions = {}): string {\n const workerOptions = options[worker.id] || {};\n\n const workerFile = `${worker.id}-worker.js`;\n\n let url = workerOptions.workerUrl;\n\n // If URL is test, generate local loaders.gl url\n // @ts-ignore _workerType\n if (options._workerType === 'test') {\n url = `modules/${worker.module}/dist/${workerFile}`;\n }\n\n // If url override is not provided, generate a URL to published version on npm CDN unpkg.com\n if (!url) {\n // GENERATE\n let version = worker.version;\n // On master we need to load npm alpha releases published with the `beta` tag\n if (version === 'latest') {\n // throw new Error('latest worker version specified');\n version = NPM_TAG;\n }\n const versionTag = version ? `@${version}` : '';\n url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;\n }\n\n assert(url);\n\n // Allow user to override location\n return url;\n}\n","import * as node from '../node/buffer-utils.node';\n\n/**\n * Check for Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)\n */\nexport function isBuffer(value: any): boolean {\n return value && typeof value === 'object' && value.isBuffer;\n}\n\n/**\n * Converts to Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function toBuffer(data: any): Buffer {\n return node.toBuffer ? node.toBuffer(data) : data;\n}\n\n/**\n * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function bufferToArrayBuffer(buffer: any): ArrayBuffer {\n if (isBuffer(buffer)) {\n const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);\n return typedArray.slice().buffer;\n }\n return buffer;\n}\n","import {TypedArray} from '../../types';\nimport {isBuffer, bufferToArrayBuffer} from './buffer-utils';\n\n/**\n * Convert an object to an array buffer\n */\nexport function toArrayBuffer(data: any): ArrayBuffer {\n // Note: Should be called first, Buffers can trigger other detections below\n if (isBuffer(data)) {\n return bufferToArrayBuffer(data);\n }\n\n if (data instanceof ArrayBuffer) {\n return data;\n }\n\n // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)\n if (ArrayBuffer.isView(data)) {\n if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {\n return data.buffer;\n }\n return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);\n }\n\n if (typeof data === 'string') {\n const text = data;\n const uint8Array = new TextEncoder().encode(text);\n return uint8Array.buffer;\n }\n\n // HACK to support Blob polyfill\n if (data && typeof data === 'object' && data._toArrayBuffer) {\n return data._toArrayBuffer();\n }\n\n throw new Error('toArrayBuffer');\n}\n\n/**\n * compare two binary arrays for equality\n * @param {ArrayBuffer} a\n * @param {ArrayBuffer} b\n * @param {number} byteLength\n */\nexport function compareArrayBuffers(\n arrayBuffer1: ArrayBuffer,\n arrayBuffer2: ArrayBuffer,\n byteLength?: number\n): boolean {\n byteLength = byteLength || arrayBuffer1.byteLength;\n if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {\n return false;\n }\n const array1 = new Uint8Array(arrayBuffer1);\n const array2 = new Uint8Array(arrayBuffer2);\n for (let i = 0; i < array1.length; ++i) {\n if (array1[i] !== array2[i]) {\n return false;\n }\n }\n return true;\n}\n\n/**\n * Concatenate a sequence of ArrayBuffers\n * @return A concatenated ArrayBuffer\n */\nexport function concatenateArrayBuffers(...sources: (ArrayBuffer | Uint8Array)[]): ArrayBuffer {\n // Make sure all inputs are wrapped in typed arrays\n const sourceArrays = sources.map((source2) =>\n source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2\n );\n\n // Get length of all inputs\n const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);\n\n // Allocate array with space for all inputs\n const result = new Uint8Array(byteLength);\n\n // Copy the subarrays\n let offset = 0;\n for (const sourceArray of sourceArrays) {\n result.set(sourceArray, offset);\n offset += sourceArray.byteLength;\n }\n\n // We work with ArrayBuffers, discard the typed array wrapper\n return result.buffer;\n}\n\n/**\n * Concatenate arbitrary count of typed arrays\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays\n * @param {...*} arrays - list of arrays. All arrays should be the same type\n * @return A concatenated TypedArray\n */\nexport function concatenateTypedArrays<T>(...typedArrays: T[]): T {\n // @ts-ignore\n const arrays = typedArrays as TypedArray[];\n // @ts-ignore\n const TypedArrayConstructor = (arrays && arrays.length > 1 && arrays[0].constructor) || null;\n if (!TypedArrayConstructor) {\n throw new Error(\n '\"concatenateTypedArrays\" - incorrect quantity of arguments or arguments have incompatible data types'\n );\n }\n\n const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);\n // @ts-ignore typescript does not like dynamic constructors\n const result = new TypedArrayConstructor(sumLength);\n let offset = 0;\n for (const array of arrays) {\n result.set(array, offset);\n offset += array.length;\n }\n return result;\n}\n\n/**\n * Copy a view of an ArrayBuffer into new ArrayBuffer with byteOffset = 0\n * @param arrayBuffer\n * @param byteOffset\n * @param byteLength\n */\nexport function sliceArrayBuffer(\n arrayBuffer: ArrayBuffer,\n byteOffset: number,\n byteLength?: number\n): ArrayBuffer {\n const subArray =\n byteLength !== undefined\n ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength)\n : new Uint8Array(arrayBuffer).subarray(byteOffset);\n const arrayCopy = new Uint8Array(subArray);\n return arrayCopy.buffer;\n}\n","import {concatenateArrayBuffers} from '../binary-utils/array-buffer-utils';\n\n// GENERAL UTILITIES\n\n/**\n * Iterate over async iterator, without resetting iterator if end is not reached\n * - forEach intentionally does not reset iterator if exiting loop prematurely\n * so that iteration can continue in a second loop\n * - It is recommended to use a standard for-await as last loop to ensure\n * iterator gets properly reset\n *\n * TODO - optimize using sync iteration if argument is an Iterable?\n *\n * @param iterator\n * @param visitor\n */\nexport async function forEach(iterator, visitor) {\n // eslint-disable-next-line\n while (true) {\n const {done, value} = await iterator.next();\n if (done) {\n iterator.return();\n return;\n }\n const cancel = visitor(value);\n if (cancel) {\n return;\n }\n }\n}\n\n// Breaking big data into iterable chunks, concatenating iterable chunks into big data objects\n\n/**\n * Concatenates all data chunks yielded by an (async) iterator\n * This function can e.g. be used to enable atomic parsers to work on (async) iterator inputs\n */\n\nexport async function concatenateArrayBuffersAsync(\n asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n): Promise<ArrayBuffer> {\n const arrayBuffers: ArrayBuffer[] = [];\n for await (const chunk of asyncIterator) {\n arrayBuffers.push(chunk);\n }\n return concatenateArrayBuffers(...arrayBuffers);\n}\n\nexport async function concatenateStringsAsync(\n asyncIterator: AsyncIterable<string> | Iterable<string>\n): Promise<string> {\n const strings: string[] = [];\n for await (const chunk of asyncIterator) {\n strings.push(chunk);\n }\n return strings.join('');\n}\n","import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 256 * 1024;\n\n/**\n * Returns an iterator that breaks a big ArrayBuffer into chunks and yields them one-by-one\n * @param blob ArrayBuffer to iterate over\n * @param options\n * @param options.chunkSize\n */\nexport function* makeArrayBufferIterator(\n arrayBuffer: ArrayBuffer,\n options: IteratorOptions = {}\n): Iterable<ArrayBuffer> {\n const {chunkSize = DEFAULT_CHUNK_SIZE} = options;\n\n let byteOffset = 0;\n\n while (byteOffset < arrayBuffer.byteLength) {\n // Create a chunk of the right size\n const chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);\n const chunk = new ArrayBuffer(chunkByteLength);\n\n // Copy data from the big chunk\n const sourceArray = new Uint8Array(arrayBuffer, byteOffset, chunkByteLength);\n const chunkArray = new Uint8Array(chunk);\n chunkArray.set(sourceArray);\n\n // yield the chunk\n byteOffset += chunkByteLength;\n yield chunk;\n }\n}\n","import type {Readable} from 'stream';\nimport {isBrowser, toArrayBuffer} from '@loaders.gl/loader-utils';\n\nexport type StreamIteratorOptions = {\n _streamReadAhead?: boolean;\n};\n\n/**\n * Returns an async iterable that reads from a stream (works in both Node.js and browsers)\n * @param stream stream to iterator over\n */\nexport function makeStreamIterator(\n stream: ReadableStream | Readable,\n options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n return isBrowser\n ? makeBrowserStreamIterator(stream as ReadableStream, options)\n : makeNodeStreamIterator(stream as Readable, options);\n}\n\n/**\n * Returns an async iterable that reads from a DOM (browser) stream\n * @param stream stream to iterate from\n * @see https://jakearchibald.com/2017/async-iterators-and-generators/#making-streams-iterate\n */\nasync function* makeBrowserStreamIterator(\n stream: ReadableStream,\n options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n // WhatWG: stream is supposed to have a `getIterator` method\n // if (typeof stream.getIterator === 'function') {\n // return stream.getIterator();\n // }\n // if (typeof stream[Symbol.asyncIterator] === 'function') {\n // return makeToArrayBufferIterator(stream);\n // }\n\n // In the browser, we first need to get a lock on the stream\n const reader = stream.getReader();\n\n let nextBatchPromise: Promise<{done?: boolean; value?: Uint8Array}> | undefined;\n\n try {\n // eslint-disable-next-line no-constant-condition\n while (true) {\n const currentBatchPromise = nextBatchPromise || reader.read();\n // Issue a read for an additional batch, while we await the next batch\n // Idea is to make fetching happen in parallel with processing / parsing\n if (options?._streamReadAhead) {\n nextBatchPromise = reader.read();\n }\n // Read from the stream\n // value is a Uint8Array\n const {done, value} = await currentBatchPromise;\n // Exit if we're done\n if (done) {\n return;\n }\n // Else yield the chunk\n yield toArrayBuffer(value);\n }\n } catch (error) {\n // TODO - examples makes it look like this should always be called,\n // but that generates exceptions so only call it if we do not reach the end\n reader.releaseLock();\n }\n}\n\n/**\n * Returns an async iterable that reads from a DOM (browser) stream\n * @param stream stream to iterate from\n * @note Requires Node.js >= 10\n */\nasync function* makeNodeStreamIterator(\n stream: Readable,\n options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n // Hacky test for node version to ensure we don't call bad polyfills\n // NODE 10+: stream is an asyncIterator\n for await (const chunk of stream) {\n yield toArrayBuffer(chunk); // Coerce each chunk to ArrayBuffer\n }\n}\n/* TODO - remove NODE < 10\n * @see https://github.com/bustle/streaming-iterables, MIT license\n *\n if (typeof stream[Symbol.asyncIterator] === 'function') {\n return;\n }\n\n // TODO - check if is this ever used in Node 10+?\n // eslint-disable-next-line no-constant-condition\n while (true) {\n const data = stream.read();\n if (data !== null) {\n yield toArrayBuffer(data);\n // eslint-disable-next-line no-continue\n continue;\n }\n if (stream._readableState?.ended) {\n return;\n }\n await onceReadable(stream);\n }\n\nasync function onceReadable(stream: Readable): Promise<any> {\n return new Promise((resolve) => {\n stream.once('readable', resolve);\n });\n}\n */\n","import type {ReadStream} from 'fs';\n\nimport {makeStringIterator} from './make-string-iterator';\nimport {makeArrayBufferIterator} from './make-array-buffer-iterator';\nimport {makeBlobIterator} from './make-blob-iterator';\nimport type {StreamIteratorOptions} from './make-stream-iterator';\nimport {makeStreamIterator} from './make-stream-iterator';\nimport {isBlob, isReadableStream, isResponse} from '../../javascript-utils/is-type';\n\n/**\n * @param [options.chunkSize]\n */\nexport type IteratorOptions = StreamIteratorOptions & {\n chunkSize?: number;\n};\n\n/**\n * Returns an iterator that breaks its input into chunks and yields them one-by-one.\n * @param data\n * @param options\n * @returns\n * This function can e.g. be used to enable data sources that can only be read atomically\n * (such as `Blob` and `File` via `FileReader`) to still be parsed in batches.\n */\nexport function makeIterator(\n data: ArrayBuffer | string | Blob | Response | ReadableStream | ReadStream,\n options?: IteratorOptions\n): AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer> {\n if (typeof data === 'string') {\n // Note: Converts string chunks to binary\n return makeStringIterator(data, options);\n }\n if (data instanceof ArrayBuffer) {\n return makeArrayBufferIterator(data, options);\n }\n if (isBlob(data)) {\n return makeBlobIterator(data as Blob, options);\n }\n if (isReadableStream(data)) {\n return makeStreamIterator(data as ReadableStream, options);\n }\n if (isResponse(data)) {\n const response = data as Response;\n return makeStreamIterator(response.body as ReadableStream, options);\n }\n throw new Error('makeIterator');\n}\n","import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 256 * 1024;\n\n/**\n * Returns an iterator that breaks a big string into chunks and yields them one-by-one as ArrayBuffers\n * @param blob string to iterate over\n * @param options\n * @param options.chunkSize\n */\nexport function* makeStringIterator(\n string: string,\n options?: IteratorOptions\n): Iterable<ArrayBuffer> {\n const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;\n\n let offset = 0;\n const textEncoder = new TextEncoder();\n while (offset < string.length) {\n // Create a chunk of the right size\n const chunkLength = Math.min(string.length - offset, chunkSize);\n const chunk = string.slice(offset, offset + chunkLength);\n offset += chunkLength;\n\n // yield an ArrayBuffer chunk\n yield textEncoder.encode(chunk);\n }\n}\n","import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 1024 * 1024; // 1MB — biggest value that keeps UI responsive\n\n/**\n * Returns an iterator that breaks a big Blob into chunks and yields them one-by-one\n * @param blob Blob or File object\n * @param options\n * @param options.chunkSize\n */\nexport async function* makeBlobIterator(\n blob: Blob,\n options?: IteratorOptions\n): AsyncIterable<ArrayBuffer> {\n const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;\n\n let offset = 0;\n while (offset < blob.size) {\n const end = offset + chunkSize;\n\n const chunk = await blob.slice(offset, end).arrayBuffer();\n\n offset = end;\n yield chunk;\n }\n}\n","import type {\n DataType,\n SyncDataType,\n BatchableDataType,\n Loader,\n LoaderOptions\n} from '@loaders.gl/loader-utils';\nimport {concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\nimport {\n isResponse,\n isReadableStream,\n isAsyncIterable,\n isIterable,\n isIterator,\n isBlob,\n isBuffer\n} from '../../javascript-utils/is-type';\nimport {makeIterator} from '../../iterators/make-iterator/make-iterator';\nimport {checkResponse, makeResponse} from '../utils/response-utils';\n\nconst ERR_DATA = 'Cannot convert supplied data type';\n\n// eslint-disable-next-line complexity\nexport function getArrayBufferOrStringFromDataSync(\n data: SyncDataType,\n loader: Loader,\n options: LoaderOptions\n): ArrayBuffer | string {\n if (loader.text && typeof data === 'string') {\n return data;\n }\n\n if (isBuffer(data)) {\n // @ts-ignore\n data = data.buffer;\n }\n\n if (data instanceof ArrayBuffer) {\n const arrayBuffer = data;\n if (loader.text && !loader.binary) {\n const textDecoder = new TextDecoder('utf8');\n return textDecoder.decode(arrayBuffer);\n }\n return arrayBuffer;\n }\n\n // We may need to handle offsets\n if (ArrayBuffer.isView(data)) {\n // TextDecoder is invoked on typed arrays and will handle offsets\n if (loader.text && !loader.binary) {\n const textDecoder = new TextDecoder('utf8');\n return textDecoder.decode(data);\n }\n\n let arrayBuffer = data.buffer;\n\n // Since we are returning the underlying arrayBuffer, we must create a new copy\n // if this typed array / Buffer is a partial view into the ArryayBuffer\n // TODO - this is a potentially unnecessary copy\n const byteLength = data.byteLength || data.length;\n if (data.byteOffset !== 0 || byteLength !== arrayBuffer.byteLength) {\n // console.warn(`loaders.gl copying arraybuffer of length ${byteLength}`);\n arrayBuffer = arrayBuffer.slice(data.byteOffset, data.byteOffset + byteLength);\n }\n return arrayBuffer;\n }\n\n throw new Error(ERR_DATA);\n}\n\n// Convert async iterator to a promise\nexport async function getArrayBufferOrStringFromData(\n data: DataType,\n loader: Loader,\n options: LoaderOptions\n): Promise<ArrayBuffer | string> {\n const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data);\n if (typeof data === 'string' || isArrayBuffer) {\n return getArrayBufferOrStringFromDataSync(data as string | ArrayBuffer, loader, options);\n }\n\n // Blobs and files are FileReader compatible\n if (isBlob(data)) {\n data = await makeResponse(data);\n }\n\n if (isResponse(data)) {\n const response = data as Response;\n await checkResponse(response);\n return loader.binary ? await response.arrayBuffer() : await response.text();\n }\n\n if (isReadableStream(data)) {\n // @ts-expect-error TS2559 options type\n data = makeIterator(data as ReadableStream, options);\n }\n\n if (isIterable(data) || isAsyncIterable(data)) {\n // Assume arrayBuffer iterator - attempt to concatenate\n return concatenateArrayBuffersAsync(data as AsyncIterable<ArrayBuffer>);\n }\n\n throw new Error(ERR_DATA);\n}\n\nexport async function getAsyncIterableFromData(\n data: BatchableDataType,\n options: LoaderOptions\n): Promise<AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>> {\n if (isIterator(data)) {\n return data as AsyncIterable<ArrayBuffer>;\n }\n\n if (isResponse(data)) {\n const response = data as Response;\n // Note Since this function is not async, we currently can't load error message, just status\n await checkResponse(response);\n // TODO - bug in polyfill, body can be a Promise under Node.js\n // eslint-disable-next-line @typescript-eslint/await-thenable\n const body = await response.body;\n // TODO - body can be null?\n return makeIterator(body as ReadableStream<Uint8Array>, options as any);\n }\n\n if (isBlob(data) || isReadableStream(data)) {\n return makeIterator(data as Blob | ReadableStream, options as any);\n }\n\n if (isAsyncIterable(data)) {\n return data[Symbol.asyncIterator]();\n }\n\n return getIterableFromData(data);\n}\n\nexport async function getReadableStream(data: BatchableDataType): Promise<ReadableStream> {\n if (isReadableStream(data)) {\n return data as ReadableStream;\n }\n if (isResponse(data)) {\n // @ts-ignore\n return data.body;\n }\n const response = await makeResponse(data);\n // @ts-ignore\n return response.body;\n}\n\n// HELPERS\n\nfunction getIterableFromData(data) {\n // generate an iterator that emits a single chunk\n if (ArrayBuffer.isView(data)) {\n return (function* oneChunk() {\n yield data.buffer;\n })();\n }\n\n if (data instanceof ArrayBuffer) {\n return (function* oneChunk() {\n yield data;\n })();\n }\n\n if (isIterator(data)) {\n return data;\n }\n\n if (isIterable(data)) {\n return data[Symbol.iterator]();\n }\n\n throw new Error(ERR_DATA);\n}\n","import {Loader} from '@loaders.gl/loader-utils';\nimport {normalizeLoader} from '../loader-utils/normalize-loader';\nimport {getGlobalLoaderState} from '../loader-utils/option-utils';\n\n// Store global registered loaders on the global object to increase chances of cross loaders-version interoperability\n// This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks\nconst getGlobalLoaderRegistry = () => {\n const state = getGlobalLoaderState();\n state.loaderRegistry = state.loaderRegistry || [];\n return state.loaderRegistry;\n};\n\nexport function registerLoaders(loaders: Loader[]) {\n const loaderRegistry = getGlobalLoaderRegistry();\n\n loaders = Array.isArray(loaders) ? loaders : [loaders];\n\n for (const loader of loaders) {\n const normalizedLoader = normalizeLoader(loader);\n if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) {\n // add to the beginning of the loaderRegistry, so the last registeredLoader get picked\n loaderRegistry.unshift(normalizedLoader);\n }\n }\n}\n\nexport function getRegisteredLoaders(): Loader[] {\n return getGlobalLoaderRegistry();\n}\n\n// For testing\nexport function _unregisterLoaders() {\n const state = getGlobalLoaderState();\n state.loaderRegistry = [];\n}\n","import type {LoaderContext, LoaderOptions, Loader} from '@loaders.gl/loader-utils';\nimport {compareArrayBuffers} from '@loaders.gl/loader-utils';\nimport {normalizeLoader} from '../loader-utils/normalize-loader';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {getRegisteredLoaders} from './register-loaders';\nimport {isBlob} from '../../javascript-utils/is-type';\n\nconst EXT_PATTERN = /\\.([^.]+)$/;\n\n// TODO - Need a variant that peeks at streams for parseInBatches\n// TODO - Detect multiple matching loaders? Use heuristics to grade matches?\n// TODO - Allow apps to pass context to disambiguate between multiple matches (e.g. multiple .json formats)?\n\n/**\n * Find a loader that matches file extension and/or initial file content\n * Search the loaders array argument for a loader that matches url extension or initial data\n * Returns: a normalized loader\n * @param data data to assist\n * @param loaders\n * @param options\n * @param context used internally, applications should not provide this parameter\n */\nexport async function selectLoader(\n data: Response | Blob | ArrayBuffer | string,\n loaders: Loader[] | Loader = [],\n options?: LoaderOptions,\n context?: LoaderContext\n): Promise<Loader | null> {\n if (!validHTTPResponse(data)) {\n return null;\n }\n\n // First make a sync attempt, disabling exceptions\n let loader = selectLoaderSync(data, loaders, {...options, nothrow: true}, context);\n if (loader) {\n return loader;\n }\n\n // For Blobs and Files, try to asynchronously read a small initial slice and test again with that\n // to see if we can detect by initial content\n if (isBlob(data)) {\n data = await (data as Blob).slice(0, 10).arrayBuffer();\n loader = selectLoaderSync(data, loaders, options, context);\n }\n\n // no loader available\n if (!loader && !options?.nothrow) {\n throw new Error(getNoValidLoaderMessage(data));\n }\n\n return loader;\n}\n\n/**\n * Find a loader that matches file extension and/or initial file content\n * Search the loaders array argument for a loader that matches url extension or initial data\n * Returns: a normalized loader\n * @param data data to assist\n * @param loaders\n * @param options\n * @param context used internally, applications should not provide this parameter\n */\nexport function selectLoaderSync(\n data: Response | Blob | ArrayBuffer | string,\n loaders: Loader[] | Loader = [],\n options?: LoaderOptions,\n context?: LoaderContext\n): Loader | null {\n if (!validHTTPResponse(data)) {\n return null;\n }\n\n // eslint-disable-next-line complexity\n // if only a single loader was provided (not as array), force its use\n // TODO - Should this behavior be kept and documented?\n if (loaders && !Array.isArray(loaders)) {\n // TODO - remove support for legacy loaders\n return normalizeLoader(loaders);\n }\n\n // Build list of candidate loaders that will be searched in order for a match\n let candidateLoaders: Loader[] = [];\n // First search supplied loaders\n if (loaders) {\n candidateLoaders = candidateLoaders.concat(loaders);\n }\n // Then fall back to registered loaders\n if (!options?.ignoreRegisteredLoaders) {\n candidateLoaders.push(...getRegisteredLoaders());\n }\n\n // TODO - remove support for legacy loaders\n normalizeLoaders(candidateLoaders);\n\n const loader = selectLoaderInternal(data, candidateLoaders, options, context);\n\n // no loader available\n if (!loader && !options?.nothrow) {\n throw new Error(getNoValidLoaderMessage(data));\n }\n\n return loader;\n}\n\n/** Implements loaders selection logic */\nfunction selectLoaderInternal(\n data: Response | Blob | ArrayBuffer | string,\n loaders: Loader[],\n options?: LoaderOptions,\n context?: LoaderContext\n) {\n const {url, type} = getResourceUrlAndType(data);\n\n const testUrl = url || context?.url;\n\n let loader: Loader | null = null;\n\n // if options.mimeType is supplied, it takes precedence\n if (options?.mimeType) {\n loader = findLoaderByMIMEType(loaders, options?.mimeType);\n }\n // Look up loader by url\n loader = loader || findLoaderByUrl(loaders, testUrl);\n // Look up loader by mime type\n loader = loader || findLoaderByMIMEType(loaders, type);\n // Look for loader via initial bytes (Note: not always accessible (e.g. Response, stream, async iterator)\n loader = loader || findLoaderByInitialBytes(loaders, data);\n // Look up loader by fallback mime type\n loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);\n\n return loader;\n}\n\n/** Check HTTP Response */\nfunction validHTTPResponse(data: any): boolean {\n // HANDLE HTTP status\n if (data instanceof Response) {\n // 204 - NO CONTENT. This handles cases where e.g. a tile server responds with 204 for a missing tile\n if (data.status === 204) {\n return false;\n }\n }\n return true;\n}\n\nfunction getNoValidLoaderMessage(data): string {\n const {url, type} = getResourceUrlAndType(data);\n\n let message = 'No valid loader found';\n if (data) {\n message += ` data: \"${getFirstCharacters(data)}\", contentType: \"${type}\"`;\n }\n if (url) {\n message += ` url: ${url}`;\n }\n return message;\n}\n\nfunction normalizeLoaders(loaders: Loader[]): void {\n for (const loader of loaders) {\n normalizeLoader(loader);\n }\n}\n\n// TODO - Would be nice to support http://example.com/file.glb?parameter=1\n// E.g: x = new URL('http://example.com/file.glb?load=1'; x.pathname\nfunction findLoaderByUrl(loaders: Loader[], url?: string): Loader | null {\n // Get extension\n const match = url && EXT_PATTERN.exec(url);\n const extension = match && match[1];\n return extension ? findLoaderByExtension(loaders, extension) : null;\n}\n\nfunction findLoaderByExtension(loaders: Loader[], extension: string): Loader | null {\n extension = extension.toLowerCase();\n\n for (const loader of loaders) {\n for (const loaderExtension of loader.extensions) {\n if (loaderExtension.toLowerCase() === extension) {\n return loader;\n }\n }\n }\n return null;\n}\n\nfunction findLoaderByMIMEType(loaders, mimeType) {\n for (const loader of loaders) {\n if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {\n return loader;\n }\n\n // Support referring to loaders using the \"unregistered tree\"\n // https://en.wikipedia.org/wiki/Media_type#Unregistered_tree\n if (mimeType === `application/x.${loader.id}`) {\n return loader;\n }\n }\n return null;\n}\n\nfunction findLoaderByInitialBytes(loaders, data) {\n if (!data) {\n return null;\n }\n\n for (const loader of loaders) {\n if (typeof data === 'string') {\n if (testDataAgainstText(data, loader)) {\n return loader;\n }\n } else if (ArrayBuffer.isView(data)) {\n // Typed Arrays can have offsets into underlying buffer\n if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) {\n return loader;\n }\n } else if (data instanceof ArrayBuffer) {\n const byteOffset = 0;\n if (testDataAgainstBinary(data, byteOffset, loader)) {\n return loader;\n }\n }\n // TODO Handle streaming case (requires creating a new AsyncIterator)\n }\n return null;\n}\n\nfunction testDataAgainstText(data, loader) {\n if (loader.testText) {\n return loader.testText(data);\n }\n\n const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];\n return tests.some((test) => data.startsWith(test));\n}\n\nfunction testDataAgainstBinary(data, byteOffset, loader) {\n const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];\n return tests.some((test) => testBinary(data, byteOffset, loader, test));\n}\n\nfunction testBinary(data, byteOffset, loader, test) {\n if (test instanceof ArrayBuffer) {\n return compareArrayBuffers(test, data, test.byteLength);\n }\n switch (typeof test) {\n case 'function':\n return test(data, loader);\n\n case 'string':\n // Magic bytes check: If `test` is a string, check if binary data starts with that strings\n const magic = getMagicString(data, byteOffset, test.length);\n return test === magic;\n\n default:\n return false;\n }\n}\n\nfunction getFirstCharacters(data, length = 5) {\n if (typeof data === 'string') {\n return data.slice(0, length);\n } else if (ArrayBuffer.isView(data)) {\n // Typed Arrays can have offsets into underlying buffer\n return getMagicString(data.buffer, data.byteOffset, length);\n } else if (data instanceof ArrayBuffer) {\n const byteOffset = 0;\n return getMagicString(data, byteOffset, length);\n }\n return '';\n}\n\nfunction getMagicString(arrayBuffer, byteOffset, length) {\n if (arrayBuffer.byteLength < byteOffset + length) {\n return '';\n }\n const dataView = new DataView(arrayBuffer);\n let magic = '';\n for (let i = 0; i < length; i++) {\n magic += String.fromCharCode(dataView.getUint8(byteOffset + i));\n }\n return magic;\n}\n","import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';\nimport {parseWithWorker, canParseWithWorker} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getArrayBufferOrStringFromData} from '../loader-utils/get-data';\nimport {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport async function parse(\n data: DataType | Promise<DataType>,\n loaders?: Loader | Loader[] | LoaderOptions,\n options?: LoaderOptions,\n context?: LoaderContext\n): Promise<any> {\n assert(!context || typeof context === 'object'); // parse no longer accepts final url\n\n // Signature: parse(data, options, context | url)\n // Uses registered loaders\n if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {\n context = undefined; // context not supported in short signature\n options = loaders as LoaderOptions;\n loaders = undefined;\n }\n\n data = await data; // Resolve any promise\n options = options || {};\n\n // Extract a url for auto detection\n const {url} = getResourceUrlAndType(data);\n\n // Chooses a loader (and normalizes it)\n // Also use any loaders in the context, new loaders take priority\n const typedLoaders = loaders as Loader | Loader[] | undefined;\n const candidateLoaders = getLoadersFromContext(typedLoaders, context);\n // todo hacky type cast\n const loader = await selectLoader(data as ArrayBuffer, candidateLoaders, options);\n // Note: if no loader was found, if so just return null\n if (!loader) {\n return null;\n }\n\n // Normalize options\n options = normalizeOptions(options, loader, candidateLoaders, url);\n\n // Get a context (if already present, will be unchanged)\n context = getLoaderContext({url, parse, loaders: candidateLoaders}, options, context);\n\n return await parseWithLoader(loader, data, options, context);\n}\n\n// TODO: support progress and abort\n// TODO - should accept loader.parseAsyncIterator and concatenate.\nasync function parseWithLoader(loader, data, options, context) {\n validateWorkerVersion(loader);\n\n data = await getArrayBufferOrStringFromData(data, loader, options);\n\n // First check for synchronous text parser, wrap results in promises\n if (loader.parseTextSync && typeof data === 'string') {\n options.dataType = 'text';\n return loader.parseTextSync(data, options, context, loader);\n }\n\n // If we have a workerUrl and the loader can parse the given options efficiently in a worker\n if (canParseWithWorker(loader, options)) {\n return await parseWithWorker(loader, data, options, context, parse);\n }\n\n // Check for asynchronous parser\n if (loader.parseText && typeof data === 'string') {\n return await loader.parseText(data, options, context, loader);\n }\n\n if (loader.parse) {\n return await loader.parse(data, options, context, loader);\n }\n\n // This should not happen, all sync loaders should also offer `parse` function\n assert(!loader.parseSync);\n\n // TBD - If asynchronous parser not available, return null\n throw new Error(`${loader.id} loader - no parser found and worker is disabled`);\n}\n","import type {Loader, LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';\nimport {getFetchFunction} from './option-utils';\n\n/**\n * \"sub\" loaders invoked by other loaders get a \"context\" injected on `this`\n * The context will inject core methods like `parse` and contain information\n * about loaders and options passed in to the top-level `parse` call.\n *\n * @param context\n * @param options\n * @param previousContext\n */\nexport function getLoaderContext(\n context: Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderContext, 'fetch'>>,\n options?: LoaderOptions,\n previousContext: LoaderContext | null = null\n): LoaderContext {\n // For recursive calls, we already have a context\n // TODO - add any additional loaders to context?\n if (previousContext) {\n return previousContext;\n }\n\n const resolvedContext: LoaderContext = {\n fetch: getFetchFunction(options, context),\n ...context\n };\n\n // Recursive loading does not use single loader\n if (!Array.isArray(resolvedContext.loaders)) {\n resolvedContext.loaders = null;\n }\n\n return resolvedContext;\n}\n\n// eslint-disable-next-line complexity\nexport function getLoadersFromContext(\n loaders: Loader[] | Loader | undefined,\n context?: LoaderContext\n) {\n // A single non-array loader is force selected, but only on top-level (context === null)\n if (!context && loaders && !Array.isArray(loaders)) {\n return loaders;\n }\n\n // Create a merged list\n let candidateLoaders;\n if (loaders) {\n candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];\n }\n if (context && context.loaders) {\n const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];\n candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;\n }\n // If no loaders, return null to look in globally registered loaders\n return candidateLoaders && candidateLoaders.length ? candidateLoaders : null;\n}\n","import type {WorkerObject} from '../../types';\nimport {assert} from '../env-utils/assert';\nimport {VERSION} from '../env-utils/version';\n\n/**\n * Check if worker is compatible with this library version\n * @param worker\n * @param libVersion\n * @returns `true` if the two versions are compatible\n */\nexport function validateWorkerVersion(\n worker: WorkerObject,\n coreVersion: string = VERSION\n): boolean {\n assert(worker, 'no worker provided');\n\n const workerVersion = worker.version;\n if (!coreVersion || !workerVersion) {\n return false;\n }\n\n // TODO enable when fix the __version__ injection\n // const coreVersions = parseVersion(coreVersion);\n // const workerVersions = parseVersion(workerVersion);\n // assert(\n // coreVersion.major === workerVersion.major && coreVersion.minor <= workerVersion.minor,\n // `worker: ${worker.name} is not compatible. ${coreVersion.major}.${\n // coreVersion.minor\n // }+ is required.`\n // );\n\n return true;\n}\n\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction parseVersion(version) {\n const parts = version.split('.').map(Number);\n return {major: parts[0], minor: parts[1]};\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\n// Change to `latest` on production branches\nconst DEFAULT_VERSION = 'beta';\ndeclare let __VERSION__;\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : DEFAULT_VERSION;\nif (typeof __VERSION__ === 'undefined') {\n // eslint-disable-next-line\n console.error(\n 'loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.'\n );\n}\n","import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {isBlob} from '../../javascript-utils/is-type';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {getFetchFunction} from '../loader-utils/option-utils';\n\nimport {parse} from './parse';\n\n/**\n * Parses `data` using a specified loader\n * Note: Load does duplicate a lot of parse.\n * it can also call fetchFile on string urls, which `parse` won't do.\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\n// implementation signature\nexport async function load(\n url: string | DataType,\n loaders?: Loader | Loader[] | LoaderOptions,\n options?: LoaderOptions,\n context?: LoaderContext\n): Promise<any> {\n // Signature: load(url, options)\n if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n context = undefined; // context not supported in short signature\n options = loaders as LoaderOptions;\n loaders = undefined;\n }\n\n // Select fetch function\n const fetch = getFetchFunction(options);\n\n // at this point, `url` could be already loaded binary data\n let data = url;\n // url is a string, fetch the url\n if (typeof url === 'string') {\n data = await fetch(url);\n // URL is Blob or File, fetchFile handles it (alt: we could generate ObjectURL here)\n }\n\n if (isBlob(url)) {\n // The fetch response object will contain blob.name\n data = await fetch(url);\n }\n\n // Data is loaded (at least we have a `Response` object) so time to hand over to `parse`\n return await parse(data, loaders, options);\n}\n","export const TILE_CONTENT_STATE = {\n UNLOADED: 0, // Has never been requested\n LOADING: 1, // Is waiting on a pending request\n PROCESSING: 2, // Request received. Contents are being processed for rendering. Depending on the content, it might make its own requests for external data.\n READY: 3, // Ready to render.\n EXPIRED: 4, // Is expired and will be unloaded once new content is loaded.\n FAILED: 5 // Request failed.\n};\n\nexport const TILE_REFINEMENT = {\n ADD: 1, // Render tile and, if screen space error exceeded, also refine to its children.\n REPLACE: 2 // Render tile or, if screen space error exceeded, refine to its descendants instead.\n};\n\nexport const TILE_TYPE = {\n EMPTY: 'empty',\n SCENEGRAPH: 'scenegraph',\n POINTCLOUD: 'pointcloud',\n MESH: 'mesh'\n};\n\nexport const TILESET_TYPE = {\n I3S: 'I3S',\n TILES3D: 'TILES3D'\n};\n\nexport const LOD_METRIC_TYPE = {\n GEOMETRIC_ERROR: 'geometricError',\n MAX_SCREEN_THRESHOLD: 'maxScreenThreshold'\n};\n\n// Cesium 3D Tiles Specific\nexport const TILE3D_OPTIMIZATION_HINT = {\n NOT_COMPUTED: -1,\n USE_OPTIMIZATION: 1,\n SKIP_OPTIMIZATION: 0\n};\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\n/* eslint-disable */\nimport {Quaternion, Vector3, Matrix3, Matrix4, degrees} from '@math.gl/core';\nimport {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';\nimport {Ellipsoid} from '@math.gl/geospatial';\nimport {assert} from '@loaders.gl/loader-utils';\n\n// const scratchProjectedBoundingSphere = new BoundingSphere();\n\nfunction defined(x) {\n return x !== undefined && x !== null;\n}\n\n// const scratchMatrix = new Matrix3();\nconst scratchScale = new Vector3();\nconst scratchNorthWest = new Vector3();\nconst scratchSouthEast = new Vector3();\n// const scratchRectangle = new Rectangle();\n// const scratchOrientedBoundingBox = new OrientedBoundingBox();\n// const scratchTransform = new Matrix4();\n\n/**\n * Create a bounding volume from the tile's bounding volume header.\n * @param {Object} boundingVolumeHeader The tile's bounding volume header.\n * @param {Matrix4} transform The transform to apply to the bounding volume.\n * @param [result] The object onto which to store the result.\n * @returns The modified result parameter or a new TileBoundingVolume instance if none was provided.\n */\nexport function createBoundingVolume(boundingVolumeHeader, transform, result) {\n assert(boundingVolumeHeader, '3D Tile: boundingVolume must be defined');\n\n // boundingVolume schema:\n // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/boundingVolume.schema.json\n if (boundingVolumeHeader.box) {\n return createBox(boundingVolumeHeader.box, transform, result);\n }\n if (boundingVolumeHeader.region) {\n // [west, south, east, north, minimum height, maximum height]\n // Latitudes and longitudes are in the WGS 84 datum as defined in EPSG 4979 and are in radians.\n // Heights are in meters above (or below) the WGS 84 ellipsoid.\n const [west, south, east, north, minHeight, maxHeight] = boundingVolumeHeader.region;\n\n const northWest = Ellipsoid.WGS84.cartographicToCartesian(\n [degrees(west), degrees(north), minHeight],\n scratchNorthWest\n );\n const southEast = Ellipsoid.WGS84.cartographicToCartesian(\n [degrees(east), degrees(south), maxHeight],\n scratchSouthEast\n );\n const centerInCartesian = new Vector3().addVectors(northWest, southEast).multiplyScalar(0.5);\n const radius = new Vector3().subVectors(northWest, southEast).len() / 2.0;\n\n // TODO improve region boundingVolume\n // for now, create a sphere as the boundingVolume instead of box\n return createSphere(\n [centerInCartesian[0], centerInCartesian[1], centerInCartesian[2], radius],\n new Matrix4()\n );\n }\n\n if (boundingVolumeHeader.sphere) {\n return createSphere(boundingVolumeHeader.sphere, transform, result);\n }\n\n throw new Error('3D Tile: boundingVolume must contain a sphere, region, or box');\n}\n\nfunction createBox(box, transform, result) {\n // https://math.gl/modules/culling/docs/api-reference/oriented-bounding-box\n // 1. A half-axes based representation.\n // box: An array of 12 numbers that define an oriented bounding box.\n // The first three elements define the x, y, and z values for the center of the box.\n // The next three elements (with indices 3, 4, and 5) define the x axis direction and half-length.\n // The next three elements (indices 6, 7, and 8) define the y axis direction and half-length.\n // The last three elements (indices 9, 10, and 11) define the z axis direction and half-length.\n // 2. A half-size-quaternion based representation.\n // box: An array of 10 numbers that define an oriented bounding box.\n // The first three elements define the x, y, and z values for the center of the box in a right-handed 3-axis (x, y, z) Cartesian coordinate system where the z-axis is up.\n // The next three elements (with indices 3, 4, and 5) define the halfSize.\n // The last four elements (indices 6, 7, 8 and 10) define the quaternion.\n const center = new Vector3(box[0], box[1], box[2]);\n transform.transform(center, center);\n let origin: number[] = [];\n if (box.length === 10) {\n const halfSize = box.slice(3, 6);\n const quaternion = new Quaternion();\n quaternion.fromArray(box, 6);\n const x = new Vector3([1, 0, 0]);\n const y = new Vector3([0, 1, 0]);\n const z = new Vector3([0, 0, 1]);\n x.transformByQuaternion(quaternion);\n x.scale(halfSize[0]);\n y.transformByQuaternion(quaternion);\n y.scale(halfSize[1]);\n z.transformByQuaternion(quaternion);\n z.scale(halfSize[2]);\n origin = [...x.toArray(), ...y.toArray(), ...z.toArray()];\n } else {\n origin = [...box.slice(3, 6), ...box.slice(6, 9), ...box.slice(9, 12)];\n }\n const xAxis = transform.transformAsVector(origin.slice(0, 3));\n const yAxis = transform.transformAsVector(origin.slice(3, 6));\n const zAxis = transform.transformAsVector(origin.slice(6, 9));\n const halfAxes = new Matrix3([\n xAxis[0],\n xAxis[1],\n xAxis[2],\n yAxis[0],\n yAxis[1],\n yAxis[2],\n zAxis[0],\n zAxis[1],\n zAxis[2]\n ]);\n\n if (defined(result)) {\n result.center = center;\n result.halfAxes = halfAxes;\n return result;\n }\n\n return new OrientedBoundingBox(center, halfAxes);\n}\n\n/*\nfunction createBoxFromTransformedRegion(region, transform, initialTransform, result) {\n const rectangle = Rectangle.unpack(region, 0, scratchRectangle);\n const minimumHeight = region[4];\n const maximumHeight = region[5];\n\n const orientedBoundingBox = OrientedBoundingBox.fromRectangle(\n rectangle,\n minimumHeight,\n maximumHeight,\n Ellipsoid.WGS84,\n scratchOrientedBoundingBox\n );\n const center = orientedBoundingBox.center;\n const halfAxes = orientedBoundingBox.halfAxes;\n\n // A region bounding volume is not transformed by the transform in the tileset JSON,\n // but may be transformed by additional transforms applied in Cesium.\n // This is why the transform is calculated as the difference between the initial transform and the current transform.\n transform = Matrix4.multiplyTransformation(\n transform,\n Matrix4.inverseTransformation(initialTransform, scratchTransform),\n scratchTransform\n );\n center = Matrix4.multiplyByPoint(transform, center, center);\n const rotationScale = Matrix4.getRotation(transform, scratchMatrix);\n halfAxes = Matrix3.multiply(rotationScale, halfAxes, halfAxes);\n\n if (defined(result) && result instanceof TileOrientedBoundingBox) {\n result.update(center, halfAxes);\n return result;\n }\n\n return new TileOrientedBoundingBox(center, halfAxes);\n}\n\nfunction createRegion(region, transform, initialTransform, result) {\n if (!Matrix4.equalsEpsilon(transform, initialTransform, CesiumMath.EPSILON8)) {\n return createBoxFromTransformedRegion(region, transform, initialTransform, result);\n }\n\n if (defined(result)) {\n return result;\n }\n\n const rectangleRegion = Rectangle.unpack(region, 0, scratchRectangle);\n\n return new TileBoundingRegion({\n rectangle: rectangleRegion,\n minimumHeight: region[4],\n maximumHeight: region[5]\n });\n}\n*/\n\nfunction createSphere(sphere, transform, result?) {\n // Find the transformed center\n const center = new Vector3(sphere[0], sphere[1], sphere[2]);\n transform.transform(center, center);\n const scale = transform.getScale(scratchScale);\n\n const uniformScale = Math.max(Math.max(scale[0], scale[1]), scale[2]);\n const radius = sphere[3] * uniformScale;\n\n if (defined(result)) {\n result.center = center;\n result.radius = radius;\n return result;\n }\n\n return new BoundingSphere(center, radius);\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\n// TODO - Dynamic screen space error provides an optimization when looking at\n// tilesets from above\n\n/* eslint-disable */\n// @ts-nocheck\nimport {Matrix4, Vector3, clamp} from '@math.gl/core';\n\nconst scratchPositionNormal = new Vector3();\nconst scratchCartographic = new Vector3();\nconst scratchMatrix = new Matrix4();\nconst scratchCenter = new Vector3();\nconst scratchPosition = new Vector3();\nconst scratchDirection = new Vector3();\n\n// eslint-disable-next-line max-statements, complexity\nexport function calculateDynamicScreenSpaceError(root, {camera, mapProjection}, options = {}) {\n const {dynamicScreenSpaceErrorHeightFalloff = 0.25, dynamicScreenSpaceErrorDensity = 0.00278} =\n options;\n\n let up;\n let direction;\n let height;\n let minimumHeight;\n let maximumHeight;\n\n const tileBoundingVolume = root.contentBoundingVolume;\n\n if (tileBoundingVolume instanceof TileBoundingRegion) {\n up = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);\n direction = camera.directionWC;\n height = camera.positionCartographic.height;\n minimumHeight = tileBoundingVolume.minimumHeight;\n maximumHeight = tileBoundingVolume.maximumHeight;\n } else {\n // Transform camera position and direction into the local coordinate system of the tileset\n const transformLocal = Matrix4.inverseTransformation(root.computedTransform, scratchMatrix);\n const ellipsoid = mapProjection.ellipsoid;\n const boundingVolume = tileBoundingVolume.boundingVolume;\n const centerLocal = Matrix4.multiplyByPoint(\n transformLocal,\n boundingVolume.center,\n scratchCenter\n );\n if (Cartesian3.magnitude(centerLocal) > ellipsoid.minimumRadius) {\n // The tileset is defined in WGS84. Approximate the minimum and maximum height.\n const centerCartographic = Cartographic.fromCartesian(\n centerLocal,\n ellipsoid,\n scratchCartographic\n );\n up = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);\n direction = camera.directionWC;\n height = camera.positionCartographic.height;\n minimumHeight = 0.0;\n maximumHeight = centerCartographic.height * 2.0;\n } else {\n // The tileset is defined in local coordinates (z-up)\n const positionLocal = Matrix4.multiplyByPoint(\n transformLocal,\n camera.positionWC,\n scratchPosition\n );\n up = Cartesian3.UNIT_Z;\n direction = Matrix4.multiplyByPointAsVector(\n transformLocal,\n camera.directionWC,\n scratchDirection\n );\n direction = Cartesian3.normalize(direction, direction);\n height = positionLocal.z;\n if (tileBoundingVolume instanceof TileOrientedBoundingBox) {\n // Assuming z-up, the last component stores the half-height of the box\n const boxHeight = root._header.boundingVolume.box[11];\n minimumHeight = centerLocal.z - boxHeight;\n maximumHeight = centerLocal.z + boxHeight;\n } else if (tileBoundingVolume instanceof TileBoundingSphere) {\n const radius = boundingVolume.radius;\n minimumHeight = centerLocal.z - radius;\n maximumHeight = centerLocal.z + radius;\n }\n }\n }\n\n // The range where the density starts to lessen. Start at the quarter height of the tileset.\n const heightFalloff = dynamicScreenSpaceErrorHeightFalloff;\n const heightClose = minimumHeight + (maximumHeight - minimumHeight) * heightFalloff;\n const heightFar = maximumHeight;\n\n const t = clamp((height - heightClose) / (heightFar - heightClose), 0.0, 1.0);\n\n // Increase density as the camera tilts towards the horizon\n const dot = Math.abs(Cartesian3.dot(direction, up));\n\n let horizonFactor = 1.0 - dot;\n\n // Weaken the horizon factor as the camera height increases, implying the camera is further away from the tileset.\n // The goal is to increase density for the \"street view\", not when viewing the tileset from a distance.\n horizonFactor = horizonFactor * (1.0 - t);\n\n return dynamicScreenSpaceErrorDensity * horizonFactor;\n}\n\nexport function fog(distanceToCamera, density) {\n const scalar = distanceToCamera * density;\n return 1.0 - Math.exp(-(scalar * scalar));\n}\n\nexport function getDynamicScreenSpaceError(tileset, distanceToCamera) {\n if (tileset.dynamicScreenSpaceError && tileset.dynamicScreenSpaceErrorComputedDensity) {\n const density = tileset.dynamicScreenSpaceErrorComputedDensity;\n const factor = tileset.dynamicScreenSpaceErrorFactor;\n // TODO: Refined screen space error that minimizes tiles in non-first-person\n const dynamicError = fog(distanceToCamera, density) * factor;\n return dynamicError;\n }\n\n return 0;\n}\n\nexport function getTiles3DScreenSpaceError(tile, frameState, useParentLodMetric) {\n const tileset = tile.tileset;\n const parentLodMetricValue = (tile.parent && tile.parent.lodMetricValue) || tile.lodMetricValue;\n const lodMetricValue = useParentLodMetric ? parentLodMetricValue : tile.lodMetricValue;\n\n // Leaf tiles do not have any error so save the computation\n if (lodMetricValue === 0.0) {\n return 0.0;\n }\n\n // TODO: Orthographic Frustum needs special treatment?\n // this._getOrthograhicScreenSpaceError();\n\n // Avoid divide by zero when viewer is inside the tile\n const distance = Math.max(tile._distanceToCamera, 1e-7);\n const {height, sseDenominator} = frameState;\n const {viewDistanceScale} = tileset.options;\n let error = (lodMetricValue * height * (viewDistanceScale || 1.0)) / (distance * sseDenominator);\n\n error -= getDynamicScreenSpaceError(tileset, distance);\n\n return error;\n}\n","import {toRadians} from '@math.gl/core';\n\nconst WGS84_RADIUS_X = 6378137.0;\n// use this to bias the lod switching (1+ results in increasing the LOD quality)\nconst qualityFactor = Math.PI / 2; // empirical derived bias factor\n/* eslint-disable max-statements */\nexport function lodJudge(tile, frameState) {\n const viewport = frameState.viewport;\n const metersPerPixel = viewport.metersPerPixel;\n\n const mbsLat = tile.header.mbs[1];\n const mbsLon = tile.header.mbs[0];\n const mbsZ = tile.header.mbs[2];\n const mbsR = tile.header.mbs[3];\n\n const {height, width, latitude, longitude} = viewport;\n\n const viewportCenter = [longitude, latitude];\n const mbsCenter = [mbsLon, mbsLat, mbsZ];\n const mbsLatProjected = [longitude, mbsLat];\n const mbsLonProjected = [mbsLon, latitude];\n\n const diagonalInMeters = Math.sqrt(height * height + width * width) * metersPerPixel[0];\n const distanceInMeters = getDistanceFromLatLon(viewportCenter, mbsCenter);\n\n const visibleHeight = height * 0.5 + mbsR / WGS84_RADIUS_X;\n const visibleWidth = width * 0.5 + mbsR / WGS84_RADIUS_X;\n\n if (distanceInMeters > diagonalInMeters + mbsR / WGS84_RADIUS_X) {\n return 'OUT';\n }\n if (getDistanceFromLatLon(viewportCenter, mbsLatProjected) > visibleHeight) {\n return 'OUT';\n }\n if (getDistanceFromLatLon(viewportCenter, mbsLonProjected) > visibleWidth) {\n return 'OUT';\n }\n\n if (tile.lodMetricValue === 0) {\n return 'DIG';\n }\n\n // For the maxScreenThreshold error metric, maxError means that you should replace the node with it's children\n // as soon as the nodes bounding sphere has a screen radius larger than maxError pixels.\n // In this sense a value of 0 means you should always load it's children,\n // or if it's a leaf node, you should always display it.\n let screenSize = getI3ScreenSize(tile, frameState); // in pixels\n screenSize *= qualityFactor;\n if (screenSize < 0.5) {\n return 'OUT';\n }\n if (!tile.header.children || screenSize <= tile.lodMetricValue) {\n return 'DRAW';\n } else if (tile.header.children) {\n return 'DIG';\n }\n return 'OUT';\n}\n\n/* eslint-enable max-statements */\n\nfunction projectVertexToSphere([x, y, z]) {\n const azim = toRadians(x);\n const incl = toRadians(y);\n const radius = 1.0 + z / WGS84_RADIUS_X;\n const radCosInc = radius * Math.cos(incl);\n x = radCosInc * Math.cos(azim);\n y = radCosInc * Math.sin(azim);\n z = radius * Math.sin(incl);\n return [x, y, z];\n}\n\nfunction getDistanceFromLatLon(observer: number[], center: number[]) {\n const [observerLon, observerLat, observerZ = 0.0] = observer;\n const [centerLon, centerLat, centerZ = 0.0] = center;\n\n const projectedCenter = projectVertexToSphere([centerLon, centerLat, centerZ]);\n const projectedObserver = projectVertexToSphere([observerLon, observerLat, observerZ]);\n const dx = projectedObserver[0] - projectedCenter[0];\n const dy = projectedObserver[1] - projectedCenter[1];\n const dz = projectedObserver[2] - projectedCenter[2];\n return dx * dx + dy * dy + dz * dz;\n}\n\nexport function getI3ScreenSize(tile, frameState) {\n const viewport = frameState.viewport;\n const mbsLat = tile.header.mbs[1];\n const mbsLon = tile.header.mbs[0];\n const mbsZ = tile.header.mbs[2];\n const mbsR = tile.header.mbs[3];\n\n const mbsCenter = [mbsLon, mbsLat, mbsZ];\n const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);\n const dSquared = getDistanceFromLatLon(cameraPositionCartographic, mbsCenter);\n const mbsRNormalized = mbsR / WGS84_RADIUS_X;\n const d = dSquared - mbsRNormalized * mbsRNormalized;\n const fltMax = 3.4028235e38; // convert from 0x7f7fffff which is the maximum\n if (d <= 0.0) {\n return 0.5 * fltMax;\n }\n // https://stackoverflow.com/questions/21648630/radius-of-projected-sphere-in-screen-space\n // There is a formula there to calculate projected radius:\n // return 1.0 / Math.tan(fov) * r / Math.sqrt(d * d - r * r); // Right\n // Hack: 300 is a Magic number to get the correct LoD. Possibly, d and r are calculated in a wrong way.\n const screenSizeFactor =\n ((getTanOfHalfVFAngle(frameState) * mbsRNormalized) / Math.sqrt(d)) * 300;\n return screenSizeFactor;\n}\n\nfunction getTanOfHalfVFAngle(frameState) {\n const {projectionMatrix} = frameState.viewport;\n const t = projectionMatrix[5];\n return t;\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {assert} from '@loaders.gl/loader-utils';\n\n/**\n * A wrapper around arrays so that the internal length of the array can be manually managed.\n *\n * @alias ManagedArray\n * @constructor\n * @private\n *\n * @param {Number} [length=0] The initial length of the array.\n */\nexport default class ManagedArray {\n constructor(length = 0) {\n this._array = new Array(length);\n this._map = new Map();\n this._length = length;\n }\n\n /**\n * Gets or sets the length of the array.\n * If the set length is greater than the length of the internal array, the internal array is resized.\n *\n * @memberof ManagedArray.prototype\n * @type Number\n */\n get length() {\n return this._length;\n }\n\n set length(length) {\n this._length = length;\n if (length > this._array.length) {\n this._array.length = length;\n }\n }\n\n /**\n * Gets the internal array.\n *\n * @memberof ManagedArray.prototype\n * @type Array\n * @readonly\n */\n get values() {\n return this._array;\n }\n\n /**\n * Gets the element at an index.\n *\n * @param {Number} index The index to get.\n */\n get(index) {\n assert(index < this._array.length);\n return this._array[index];\n }\n\n /**\n * Sets the element at an index. Resizes the array if index is greater than the length of the array.\n *\n * @param {Number} index The index to set.\n * @param {*} element The element to set at index.\n */\n set(index, element) {\n assert(index >= 0);\n\n if (index >= this.length) {\n this.length = index + 1;\n }\n\n if (this._map.has(this._array[index])) {\n this._map.delete(this._array[index]);\n }\n\n this._array[index] = element;\n this._map.set(element, index);\n }\n\n delete(element) {\n const index = this._map.get(element);\n if (index >= 0) {\n this._array.splice(index, 1);\n this._map.delete(element);\n this.length--;\n }\n }\n\n /**\n * Returns the last element in the array without modifying the array.\n *\n * @returns {*} The last element in the array.\n */\n peek() {\n return this._array[this._length - 1];\n }\n\n /**\n * Push an element into the array.\n *\n * @param {*} element The element to push.\n */\n push(element) {\n if (!this._map.has(element)) {\n const index = this.length++;\n this._array[index] = element;\n this._map.set(element, index);\n }\n }\n\n /**\n * Pop an element from the array.\n *\n * @returns {*} The last element in the array.\n */\n pop() {\n const element = this._array[--this.length];\n this._map.delete(element);\n return element;\n }\n\n /**\n * Resize the internal array if length > _array.length.\n *\n * @param {Number} length The length.\n */\n reserve(length) {\n assert(length >= 0);\n\n if (length > this._array.length) {\n this._array.length = length;\n }\n }\n\n /**\n * Resize the array.\n *\n * @param {Number} length The length.\n */\n resize(length) {\n assert(length >= 0);\n\n this.length = length;\n }\n\n /**\n * Trim the internal array to the specified length. Defaults to the current length.\n *\n * @param {Number} [length] The length.\n */\n trim(length) {\n if (length === null || length === undefined) {\n length = this.length;\n }\n this._array.length = length;\n }\n\n reset() {\n this._array = [];\n this._map = new Map();\n this._length = 0;\n }\n\n find(target) {\n return this._map.has(target);\n }\n}\n","import ManagedArray from '../../utils/managed-array';\nimport {TILE_REFINEMENT} from '../../constants';\n\nexport type TilesetTraverserProps = {\n loadSiblings?: boolean;\n skipLevelOfDetail?: boolean;\n maximumScreenSpaceError?: number;\n onTraversalEnd?: (frameState) => any;\n viewportTraversersMap?: {[key: string]: any};\n basePath?: string;\n};\n\nexport type Props = {\n loadSiblings: boolean;\n skipLevelOfDetail: boolean;\n updateTransforms: boolean;\n maximumScreenSpaceError: number;\n onTraversalEnd: (frameState) => any;\n viewportTraversersMap: {[key: string]: any};\n basePath: string;\n};\n\nexport const DEFAULT_PROPS: Props = {\n loadSiblings: false,\n skipLevelOfDetail: false,\n maximumScreenSpaceError: 2,\n updateTransforms: true,\n onTraversalEnd: () => {},\n viewportTraversersMap: {},\n basePath: ''\n};\n\nexport default class TilesetTraverser {\n options: Props;\n\n root: any;\n requestedTiles: object;\n selectedTiles: object;\n emptyTiles: object;\n\n protected _traversalStack: ManagedArray;\n protected _emptyTraversalStack: ManagedArray;\n protected _frameNumber: number | null;\n\n // TODO nested props\n constructor(options: TilesetTraverserProps) {\n this.options = {...DEFAULT_PROPS, ...options};\n // TRAVERSAL\n // temporary storage to hold the traversed tiles during a traversal\n this._traversalStack = new ManagedArray();\n this._emptyTraversalStack = new ManagedArray();\n\n // set in every traverse cycle\n this._frameNumber = null;\n\n // fulfill in traverse call\n this.root = null;\n\n // RESULT\n // tiles should be rendered\n this.selectedTiles = {};\n // tiles should be loaded from server\n this.requestedTiles = {};\n // tiles does not have render content\n this.emptyTiles = {};\n }\n\n // tiles should be visible\n traverse(root, frameState, options) {\n this.root = root; // for root screen space error\n this.options = {...this.options, ...options};\n\n // reset result\n this.reset();\n\n // update tile (visibility and expiration)\n this.updateTile(root, frameState);\n\n this._frameNumber = frameState.frameNumber;\n this.executeTraversal(root, frameState);\n }\n\n reset() {\n this.requestedTiles = {};\n this.selectedTiles = {};\n this.emptyTiles = {};\n this._traversalStack.reset();\n this._emptyTraversalStack.reset();\n }\n\n // execute traverse\n // Depth-first traversal that traverses all visible tiles and marks tiles for selection.\n // If skipLevelOfDetail is off then a tile does not refine until all children are loaded.\n // This is the traditional replacement refinement approach and is called the base traversal.\n // Tiles that have a greater screen space error than the base screen space error are part of the base traversal,\n // all other tiles are part of the skip traversal. The skip traversal allows for skipping levels of the tree\n // and rendering children and parent tiles simultaneously.\n /* eslint-disable-next-line complexity, max-statements */\n executeTraversal(root, frameState) {\n // stack to store traversed tiles, only visible tiles should be added to stack\n // visible: visible in the current view frustum\n const stack = this._traversalStack;\n root._selectionDepth = 1;\n\n stack.push(root);\n while (stack.length > 0) {\n // 1. pop tile\n const tile = stack.pop();\n\n // 2. check if tile needs to be refine, needs refine if a tile's LoD is not sufficient and tile has available children (available content)\n let shouldRefine = false;\n if (this.canTraverse(tile, frameState)) {\n this.updateChildTiles(tile, frameState);\n shouldRefine = this.updateAndPushChildren(\n tile,\n frameState,\n stack,\n tile.hasRenderContent ? tile._selectionDepth + 1 : tile._selectionDepth\n );\n }\n\n // 3. decide if should render (select) this tile\n // - tile does not have render content\n // - tile has render content and tile is `add` type (pointcloud)\n // - tile has render content and tile is `replace` type (photogrammetry) and can't refine any further\n const parent = tile.parent;\n const parentRefines = Boolean(!parent || parent._shouldRefine);\n const stoppedRefining = !shouldRefine;\n\n if (!tile.hasRenderContent) {\n this.emptyTiles[tile.id] = tile;\n this.loadTile(tile, frameState);\n if (stoppedRefining) {\n this.selectTile(tile, frameState);\n }\n // additive tiles\n } else if (tile.refine === TILE_REFINEMENT.ADD) {\n // Additive tiles are always loaded and selected\n this.loadTile(tile, frameState);\n this.selectTile(tile, frameState);\n\n // replace tiles\n } else if (tile.refine === TILE_REFINEMENT.REPLACE) {\n // Always load tiles in the base traversal\n // Select tiles that can't refine further\n this.loadTile(tile, frameState);\n if (stoppedRefining) {\n this.selectTile(tile, frameState);\n }\n }\n\n // 3. update cache, most recent touched tiles have higher priority to be fetched from server\n this.touchTile(tile, frameState);\n\n // 4. update tile refine prop and parent refinement status to trickle down to the descendants\n tile._shouldRefine = shouldRefine && parentRefines;\n }\n\n this.options.onTraversalEnd(frameState);\n }\n\n updateChildTiles(tile, frameState) {\n const children = tile.children;\n for (const child of children) {\n this.updateTile(child, frameState);\n }\n return true;\n }\n\n /* eslint-disable complexity, max-statements */\n updateAndPushChildren(tile, frameState, stack, depth) {\n const {loadSiblings, skipLevelOfDetail} = this.options;\n\n const children = tile.children;\n\n // sort children tiles\n children.sort(this.compareDistanceToCamera.bind(this));\n\n // For traditional replacement refinement only refine if all children are loaded.\n // Empty tiles are exempt since it looks better if children stream in as they are loaded to fill the empty space.\n const checkRefines =\n tile.refine === TILE_REFINEMENT.REPLACE && tile.hasRenderContent && !skipLevelOfDetail;\n\n let hasVisibleChild = false;\n let refines = true;\n\n for (const child of children) {\n child._selectionDepth = depth;\n if (child.isVisibleAndInRequestVolume) {\n if (stack.find(child)) {\n stack.delete(child);\n }\n stack.push(child);\n hasVisibleChild = true;\n } else if (checkRefines || loadSiblings) {\n // Keep non-visible children loaded since they are still needed before the parent can refine.\n // Or loadSiblings is true so always load tiles regardless of visibility.\n this.loadTile(child, frameState);\n this.touchTile(child, frameState);\n }\n\n if (checkRefines) {\n let childRefines;\n if (!child._inRequestVolume) {\n childRefines = false;\n } else if (!child.hasRenderContent) {\n childRefines = this.executeEmptyTraversal(child, frameState);\n } else {\n childRefines = child.contentAvailable;\n }\n refines = refines && childRefines;\n\n if (!refines) {\n return false;\n }\n }\n }\n\n if (!hasVisibleChild) {\n refines = false;\n }\n return refines;\n }\n /* eslint-enable complexity, max-statements */\n\n updateTile(tile, frameState) {\n this.updateTileVisibility(tile, frameState);\n }\n\n // tile to render in the browser\n selectTile(tile, frameState) {\n if (this.shouldSelectTile(tile)) {\n // The tile can be selected right away and does not require traverseAndSelect\n tile._selectedFrame = frameState.frameNumber;\n this.selectedTiles[tile.id] = tile;\n }\n }\n\n // tile to load from server\n loadTile(tile, frameState) {\n if (this.shouldLoadTile(tile)) {\n tile._requestedFrame = frameState.frameNumber;\n tile._priority = tile._getPriority();\n this.requestedTiles[tile.id] = tile;\n }\n }\n\n // cache tile\n touchTile(tile, frameState) {\n tile.tileset._cache.touch(tile);\n tile._touchedFrame = frameState.frameNumber;\n }\n\n // tile should be visible\n // tile should have children\n // tile LoD (level of detail) is not sufficient under current viewport\n canTraverse(tile, frameState, useParentMetric = false, ignoreVisibility = false) {\n if (!tile.hasChildren) {\n return false;\n }\n\n // cesium specific\n if (tile.hasTilesetContent) {\n // Traverse external this to visit its root tile\n // Don't traverse if the subtree is expired because it will be destroyed\n return !tile.contentExpired;\n }\n\n if (!ignoreVisibility && !tile.isVisibleAndInRequestVolume) {\n return false;\n }\n\n return this.shouldRefine(tile, frameState, useParentMetric);\n }\n\n shouldLoadTile(tile) {\n // if request tile is in current frame\n // and has unexpired render content\n return tile.hasUnloadedContent || tile.contentExpired;\n }\n\n shouldSelectTile(tile) {\n // if select tile is in current frame\n // and content available\n return tile.contentAvailable && !this.options.skipLevelOfDetail;\n }\n\n // Decide if tile LoD (level of detail) is not sufficient under current viewport\n shouldRefine(tile, frameState, useParentMetric) {\n let screenSpaceError = tile._screenSpaceError;\n if (useParentMetric) {\n screenSpaceError = tile.getScreenSpaceError(frameState, true);\n }\n\n return screenSpaceError > this.options.maximumScreenSpaceError;\n }\n\n updateTileVisibility(tile, frameState) {\n const viewportIds: string[] = [];\n if (this.options.viewportTraversersMap) {\n for (const key in this.options.viewportTraversersMap) {\n const value = this.options.viewportTraversersMap[key];\n if (value === frameState.viewport.id) {\n viewportIds.push(key);\n }\n }\n } else {\n viewportIds.push(frameState.viewport.id);\n }\n tile.updateVisibility(frameState, viewportIds);\n }\n\n // UTILITIES\n\n compareDistanceToCamera(b, a) {\n return b._distanceToCamera - a._distanceToCamera;\n }\n\n anyChildrenVisible(tile, frameState) {\n let anyVisible = false;\n for (const child of tile.children) {\n child.updateVisibility(frameState);\n anyVisible = anyVisible || child.isVisibleAndInRequestVolume;\n }\n return anyVisible;\n }\n\n // Depth-first traversal that checks if all nearest descendants with content are loaded.\n // Ignores visibility.\n executeEmptyTraversal(root, frameState) {\n let allDescendantsLoaded = true;\n const stack = this._emptyTraversalStack;\n\n stack.push(root);\n\n while (stack.length > 0 && allDescendantsLoaded) {\n const tile = stack.pop();\n\n this.updateTile(tile, frameState);\n\n if (!tile.isVisibleAndInRequestVolume) {\n // Load tiles that aren't visible since they are still needed for the parent to refine\n this.loadTile(tile, frameState);\n }\n\n this.touchTile(tile, frameState);\n\n // Only traverse if the tile is empty - traversal stop at descendants with content\n const traverse = !tile.hasRenderContent && this.canTraverse(tile, frameState, false, true);\n\n if (traverse) {\n const children = tile.children;\n for (const child of children) {\n // eslint-disable-next-line max-depth\n if (stack.find(child)) {\n stack.delete(child);\n }\n stack.push(child);\n }\n } else if (!tile.contentAvailable) {\n allDescendantsLoaded = false;\n }\n }\n\n return allDescendantsLoaded;\n }\n}\n\n// TODO\n// enable expiration\n// enable optimization hint\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\nimport {Vector3, Matrix4} from '@math.gl/core';\nimport {CullingVolume} from '@math.gl/culling';\n\nimport {load} from '@loaders.gl/core';\nimport {TILE_REFINEMENT, TILE_CONTENT_STATE, TILESET_TYPE} from '../constants';\n\nimport {FrameState} from './helpers/frame-state';\nimport {createBoundingVolume} from './helpers/bounding-volume';\nimport {getTiles3DScreenSpaceError} from './helpers/tiles-3d-lod';\nimport {getI3ScreenSize} from './helpers/i3s-lod';\nimport {get3dTilesOptions} from './helpers/3d-tiles-options';\nimport TilesetTraverser from './traversers/tileset-traverser';\n\n// Note: circular dependency\nimport type Tileset3D from './tileset-3d';\n\nconst scratchVector = new Vector3();\n\nfunction defined(x) {\n return x !== undefined && x !== null;\n}\n\n/**\n * @param tileset - Tileset3D instance\n * @param header - tile header - JSON loaded from a dataset\n * @param parentHeader - parent TileHeader instance\n * @param extendedId - optional ID to separate copies of a tile for different viewports.\n * const extendedId = `${tile.id}-${frameState.viewport.id}`;\n */\nexport type TileHeaderProps = {\n tileset: Tileset3D;\n header: Object;\n parentHeader: TileHeader;\n extendedId: string;\n};\n\n/**\n * A Tile3DHeader represents a tile as Tileset3D. When a tile is first created, its content is not loaded;\n * the content is loaded on-demand when needed based on the view.\n * Do not construct this directly, instead access tiles through {@link Tileset3D#tileVisible}.\n */\nexport default class TileHeader {\n tileset: Tileset3D;\n header: any;\n id: string;\n url: string;\n parent: TileHeader;\n refine: number;\n type: string;\n contentUrl: string;\n lodMetricType: string;\n lodMetricValue: number;\n boundingVolume: any;\n content: any;\n contentState: any;\n gpuMemoryUsageInBytes: number;\n children: TileHeader[];\n depth: number;\n viewportIds: any[];\n transform: Matrix4;\n\n // Container to store application specific data\n userData: {[key: string]: any};\n computedTransform: any;\n hasEmptyContent: boolean;\n hasTilesetContent: boolean;\n\n traverser: object;\n\n // @ts-ignore\n private _cacheNode: any;\n private _frameNumber: any;\n // TODO i3s specific, needs to remove\n // @ts-ignore\n private _lodJudge: any;\n // TODO Cesium 3d tiles specific\n private _expireDate: any;\n private _expiredContent: any;\n // @ts-ignore\n private _shouldRefine: boolean;\n\n // Members this are updated every frame for tree traversal and rendering optimizations:\n // @ts-ignore\n private _distanceToCamera: number;\n // @ts-ignore\n private _centerZDepth: number;\n private _screenSpaceError: number;\n private _visibilityPlaneMask: any;\n private _visible?: boolean;\n private _inRequestVolume: boolean;\n\n // @ts-ignore\n private _stackLength: number;\n // @ts-ignore\n private _selectionDepth: number;\n\n // @ts-ignore\n private _touchedFrame: number;\n // @ts-ignore\n private _visitedFrame: number;\n private _selectedFrame: number;\n // @ts-ignore\n private _requestedFrame: number;\n\n // @ts-ignore\n private _priority: number;\n\n private _contentBoundingVolume: any;\n private _viewerRequestVolume: any;\n\n _initialTransform: Matrix4;\n\n /**\n * @constructs\n * Create a TileHeader instance\n * @param tileset - Tileset3D instance\n * @param header - tile header - JSON loaded from a dataset\n * @param parentHeader - parent TileHeader instance\n * @param extendedId - optional ID to separate copies of a tile for different viewports.\n * const extendedId = `${tile.id}-${frameState.viewport.id}`;\n */\n // eslint-disable-next-line max-statements\n constructor(\n tileset: Tileset3D,\n header: {[key: string]: any},\n parentHeader?: TileHeader,\n extendedId = ''\n ) {\n // PUBLIC MEMBERS\n // original tile data\n this.header = header;\n\n // The tileset containing this tile.\n this.tileset = tileset;\n this.id = extendedId || header.id;\n this.url = header.url;\n\n // This tile's parent or `undefined` if this tile is the root.\n // @ts-ignore\n this.parent = parentHeader;\n this.refine = this._getRefine(header.refine);\n this.type = header.type;\n this.contentUrl = header.contentUrl;\n\n // The error, in meters, introduced if this tile is rendered and its children are not.\n this.lodMetricType = 'geometricError';\n this.lodMetricValue = 0;\n\n // Specifies the type of refine that is used when traversing this tile for rendering.\n this.boundingVolume = null;\n\n // The tile's content. This represents the actual tile's payload,\n // not the content's metadata in the tileset JSON file.\n this.content = null;\n this.contentState = TILE_CONTENT_STATE.UNLOADED;\n this.gpuMemoryUsageInBytes = 0;\n\n // The tile's children - an array of Tile3D objects.\n this.children = [];\n\n this.hasEmptyContent = false;\n this.hasTilesetContent = false;\n\n this.depth = 0;\n this.viewportIds = [];\n\n // Container to store application specific data\n this.userData = {};\n\n // PRIVATE MEMBERS\n this._priority = 0;\n this._touchedFrame = 0;\n this._visitedFrame = 0;\n this._selectedFrame = 0;\n this._requestedFrame = 0;\n this._screenSpaceError = 0;\n\n this._cacheNode = null;\n this._frameNumber = null;\n this._cacheNode = null;\n\n this.traverser = new TilesetTraverser({});\n this._shouldRefine = false;\n this._distanceToCamera = 0;\n this._centerZDepth = 0;\n this._visible = undefined;\n this._inRequestVolume = false;\n this._stackLength = 0;\n this._selectionDepth = 0;\n this._initialTransform = new Matrix4();\n this.transform = new Matrix4();\n\n this._initializeLodMetric(header);\n this._initializeTransforms(header);\n this._initializeBoundingVolumes(header);\n this._initializeContent(header);\n this._initializeRenderingState(header);\n\n // TODO i3s specific, needs to remove\n this._lodJudge = null;\n\n // TODO Cesium 3d tiles specific\n this._expireDate = null;\n this._expiredContent = null;\n\n Object.seal(this);\n }\n\n destroy() {\n this.header = null;\n }\n\n isDestroyed() {\n return this.header === null;\n }\n\n get selected() {\n return this._selectedFrame === this.tileset._frameNumber;\n }\n\n get isVisible() {\n return this._visible;\n }\n\n get isVisibleAndInRequestVolume() {\n return this._visible && this._inRequestVolume;\n }\n\n /** Returns true if tile is not an empty tile and not an external tileset */\n get hasRenderContent() {\n return !this.hasEmptyContent && !this.hasTilesetContent;\n }\n\n /** Returns true if tile has children */\n get hasChildren() {\n return this.children.length > 0 || (this.header.children && this.header.children.length > 0);\n }\n\n /**\n * Determines if the tile's content is ready. This is automatically `true` for\n * tiles with empty content.\n */\n get contentReady() {\n return this.contentState === TILE_CONTENT_STATE.READY || this.hasEmptyContent;\n }\n\n /**\n * Determines if the tile has available content to render. `true` if the tile's\n * content is ready or if it has expired content this renders while new content loads; otherwise,\n */\n get contentAvailable() {\n return Boolean(\n (this.contentReady && this.hasRenderContent) || (this._expiredContent && !this.contentFailed)\n );\n }\n\n /** Returns true if tile has renderable content but it's unloaded */\n get hasUnloadedContent() {\n return this.hasRenderContent && this.contentUnloaded;\n }\n\n /**\n * Determines if the tile's content has not be requested. `true` if tile's\n * content has not be requested; otherwise, `false`.\n */\n get contentUnloaded() {\n return this.contentState === TILE_CONTENT_STATE.UNLOADED;\n }\n\n /**\n * Determines if the tile's content is expired. `true` if tile's\n * content is expired; otherwise, `false`.\n */\n get contentExpired() {\n return this.contentState === TILE_CONTENT_STATE.EXPIRED;\n }\n\n // Determines if the tile's content failed to load. `true` if the tile's\n // content failed to load; otherwise, `false`.\n get contentFailed() {\n return this.contentState === TILE_CONTENT_STATE.FAILED;\n }\n\n /** Get the tile's screen space error. */\n getScreenSpaceError(frameState, useParentLodMetric) {\n switch (this.tileset.type) {\n case TILESET_TYPE.I3S:\n return getI3ScreenSize(this, frameState);\n case TILESET_TYPE.TILES3D:\n return getTiles3DScreenSpaceError(this, frameState, useParentLodMetric);\n default:\n // eslint-disable-next-line\n throw new Error('Unsupported tileset type');\n }\n }\n\n /*\n * If skipLevelOfDetail is off try to load child tiles as soon as possible so that their parent can refine sooner.\n * Tiles are prioritized by screen space error.\n */\n // eslint-disable-next-line complexity\n _getPriority() {\n const traverser = this.tileset._traverser;\n const {skipLevelOfDetail} = traverser.options;\n\n /*\n * Tiles that are outside of the camera's frustum could be skipped if we are in 'ADD' mode\n * or if we are using 'Skip Traversal' in 'REPLACE' mode.\n * Otherewise, all 'touched' child tiles have to be loaded and displayed,\n * this may include tiles that are outide of the camera frustum (so that we can hide the parent tile).\n */\n const maySkipTile = this.refine === TILE_REFINEMENT.ADD || skipLevelOfDetail;\n\n // Check if any reason to abort\n if (maySkipTile && !this.isVisible && this._visible !== undefined) {\n return -1;\n }\n // Condition used in `cancelOutOfViewRequests` function in CesiumJS/Cesium3DTileset.js\n if (this.tileset._frameNumber - this._touchedFrame >= 1) {\n return -1;\n }\n if (this.contentState === TILE_CONTENT_STATE.UNLOADED) {\n return -1;\n }\n\n // Based on the priority function `getPriorityReverseScreenSpaceError` in CesiumJS. Scheduling priority is based on the parent's screen space error when possible.\n const parent = this.parent;\n const useParentScreenSpaceError =\n parent && (!maySkipTile || this._screenSpaceError === 0.0 || parent.hasTilesetContent);\n const screenSpaceError = useParentScreenSpaceError\n ? parent._screenSpaceError\n : this._screenSpaceError;\n\n const rootScreenSpaceError = traverser.root ? traverser.root._screenSpaceError : 0.0;\n\n // Map higher SSE to lower values (e.g. root tile is highest priority)\n return Math.max(rootScreenSpaceError - screenSpaceError, 0);\n }\n\n /**\n * Requests the tile's content.\n * The request may not be made if the Request Scheduler can't prioritize it.\n */\n // eslint-disable-next-line max-statements, complexity\n async loadContent(): Promise<boolean> {\n if (this.hasEmptyContent) {\n return false;\n }\n\n if (this.content) {\n return true;\n }\n\n const expired = this.contentExpired;\n\n if (expired) {\n this._expireDate = null;\n }\n\n this.contentState = TILE_CONTENT_STATE.LOADING;\n\n const requestToken = await this.tileset._requestScheduler.scheduleRequest(\n this.id,\n this._getPriority.bind(this)\n );\n\n if (!requestToken) {\n // cancelled\n this.contentState = TILE_CONTENT_STATE.UNLOADED;\n return false;\n }\n\n try {\n const contentUrl = this.tileset.getTileUrl(this.contentUrl);\n // The content can be a binary tile ot a JSON tileset\n const loader = this.tileset.loader;\n const options = {\n ...this.tileset.loadOptions,\n [loader.id]: {\n ...this.tileset.loadOptions[loader.id],\n isTileset: this.type === 'json',\n ...this._getLoaderSpecificOptions(loader.id)\n }\n };\n\n this.content = await load(contentUrl, loader, options);\n\n if (this.tileset.options.contentLoader) {\n await this.tileset.options.contentLoader(this);\n }\n\n if (this._isTileset()) {\n // Add tile headers for the nested tilset's subtree\n // Async update of the tree should be fine since there would never be edits to the same node\n // TODO - we need to capture the child tileset's URL\n this.tileset._initializeTileHeaders(this.content, this);\n }\n\n this.contentState = TILE_CONTENT_STATE.READY;\n this._onContentLoaded();\n return true;\n } catch (error) {\n // Tile is unloaded before the content finishes loading\n this.contentState = TILE_CONTENT_STATE.FAILED;\n throw error;\n } finally {\n requestToken.done();\n }\n }\n\n // Unloads the tile's content.\n unloadContent() {\n if (this.content && this.content.destroy) {\n this.content.destroy();\n }\n this.content = null;\n if (this.header.content && this.header.content.destroy) {\n this.header.content.destroy();\n }\n this.header.content = null;\n this.contentState = TILE_CONTENT_STATE.UNLOADED;\n return true;\n }\n\n /**\n * Update the tile's visibility\n * @param {Object} frameState - frame state for tile culling\n * @param {string[]} viewportIds - a list of viewport ids that show this tile\n * @return {void}\n */\n updateVisibility(frameState, viewportIds) {\n if (this._frameNumber === frameState.frameNumber) {\n // Return early if visibility has already been checked during the traversal.\n // The visibility may have already been checked if the cullWithChildrenBounds optimization is used.\n return;\n }\n\n const parent = this.parent;\n const parentVisibilityPlaneMask = parent\n ? parent._visibilityPlaneMask\n : CullingVolume.MASK_INDETERMINATE;\n\n if (this.tileset._traverser.options.updateTransforms) {\n const parentTransform = parent ? parent.computedTransform : this.tileset.modelMatrix;\n this._updateTransform(parentTransform);\n }\n\n this._distanceToCamera = this.distanceToTile(frameState);\n this._screenSpaceError = this.getScreenSpaceError(frameState, false);\n this._visibilityPlaneMask = this.visibility(frameState, parentVisibilityPlaneMask); // Use parent's plane mask to speed up visibility test\n this._visible = this._visibilityPlaneMask !== CullingVolume.MASK_OUTSIDE;\n this._inRequestVolume = this.insideViewerRequestVolume(frameState);\n\n this._frameNumber = frameState.frameNumber;\n this.viewportIds = viewportIds;\n }\n\n // Determines whether the tile's bounding volume intersects the culling volume.\n // @param {FrameState} frameState The frame state.\n // @param {Number} parentVisibilityPlaneMask The parent's plane mask to speed up the visibility check.\n // @returns {Number} A plane mask as described above in {@link CullingVolume#computeVisibilityWithPlaneMask}.\n visibility(frameState, parentVisibilityPlaneMask) {\n const {cullingVolume} = frameState;\n const {boundingVolume} = this;\n\n // TODO Cesium specific - restore clippingPlanes\n // const {clippingPlanes, clippingPlanesOriginMatrix} = tileset;\n // if (clippingPlanes && clippingPlanes.enabled) {\n // const intersection = clippingPlanes.computeIntersectionWithBoundingVolume(\n // boundingVolume,\n // clippingPlanesOriginMatrix\n // );\n // this._isClipped = intersection !== Intersect.INSIDE;\n // if (intersection === Intersect.OUTSIDE) {\n // return CullingVolume.MASK_OUTSIDE;\n // }\n // }\n\n // return cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);\n return cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);\n }\n\n // Assuming the tile's bounding volume intersects the culling volume, determines\n // whether the tile's content's bounding volume intersects the culling volume.\n // @param {FrameState} frameState The frame state.\n // @returns {Intersect} The result of the intersection: the tile's content is completely outside, completely inside, or intersecting the culling volume.\n contentVisibility() {\n return true;\n\n // TODO restore\n /*\n // Assumes the tile's bounding volume intersects the culling volume already, so\n // just return Intersect.INSIDE if there is no content bounding volume.\n if (!defined(this.contentBoundingVolume)) {\n return Intersect.INSIDE;\n }\n\n if (this._visibilityPlaneMask === CullingVolume.MASK_INSIDE) {\n // The tile's bounding volume is completely inside the culling volume so\n // the content bounding volume must also be inside.\n return Intersect.INSIDE;\n }\n\n // PERFORMANCE_IDEA: is it possible to burn less CPU on this test since we know the\n // tile's (not the content's) bounding volume intersects the culling volume?\n const cullingVolume = frameState.cullingVolume;\n const boundingVolume = tile.contentBoundingVolume;\n\n const tileset = this.tileset;\n const clippingPlanes = tileset.clippingPlanes;\n if (defined(clippingPlanes) && clippingPlanes.enabled) {\n const intersection = clippingPlanes.computeIntersectionWithBoundingVolume(\n boundingVolume,\n tileset.clippingPlanesOriginMatrix\n );\n this._isClipped = intersection !== Intersect.INSIDE;\n if (intersection === Intersect.OUTSIDE) {\n return Intersect.OUTSIDE;\n }\n }\n\n return cullingVolume.computeVisibility(boundingVolume);\n */\n }\n\n /**\n * Computes the (potentially approximate) distance from the closest point of the tile's bounding volume to the camera.\n * @param frameState The frame state.\n * @returns {Number} The distance, in meters, or zero if the camera is inside the bounding volume.\n */\n distanceToTile(frameState: FrameState): number {\n const boundingVolume = this.boundingVolume;\n return Math.sqrt(Math.max(boundingVolume.distanceSquaredTo(frameState.camera.position), 0));\n }\n\n /**\n * Computes the tile's camera-space z-depth.\n * @param frameState The frame state.\n * @returns The distance, in meters.\n */\n cameraSpaceZDepth({camera}): number {\n const boundingVolume = this.boundingVolume; // Gets the underlying OrientedBoundingBox or BoundingSphere\n scratchVector.subVectors(boundingVolume.center, camera.position);\n return camera.direction.dot(scratchVector);\n }\n\n /**\n * Checks if the camera is inside the viewer request volume.\n * @param {FrameState} frameState The frame state.\n * @returns {Boolean} Whether the camera is inside the volume.\n */\n insideViewerRequestVolume(frameState: FrameState) {\n const viewerRequestVolume = this._viewerRequestVolume;\n return (\n !viewerRequestVolume || viewerRequestVolume.distanceSquaredTo(frameState.camera.position) <= 0\n );\n }\n\n // TODO Cesium specific\n\n // Update whether the tile has expired.\n updateExpiration() {\n if (defined(this._expireDate) && this.contentReady && !this.hasEmptyContent) {\n const now = Date.now();\n // @ts-ignore Date.lessThan - replace with ms compare?\n if (Date.lessThan(this._expireDate, now)) {\n this.contentState = TILE_CONTENT_STATE.EXPIRED;\n this._expiredContent = this.content;\n }\n }\n }\n\n get extras() {\n return this.header.extras;\n }\n\n // INTERNAL METHODS\n\n _initializeLodMetric(header) {\n if ('lodMetricType' in header) {\n this.lodMetricType = header.lodMetricType;\n } else {\n this.lodMetricType = (this.parent && this.parent.lodMetricType) || this.tileset.lodMetricType;\n // eslint-disable-next-line\n console.warn(`3D Tile: Required prop lodMetricType is undefined. Using parent lodMetricType`);\n }\n\n // This is used to compute screen space error, i.e., the error measured in pixels.\n if ('lodMetricValue' in header) {\n this.lodMetricValue = header.lodMetricValue;\n } else {\n this.lodMetricValue =\n (this.parent && this.parent.lodMetricValue) || this.tileset.lodMetricValue;\n // eslint-disable-next-line\n console.warn(\n '3D Tile: Required prop lodMetricValue is undefined. Using parent lodMetricValue'\n );\n }\n }\n\n _initializeTransforms(tileHeader) {\n // The local transform of this tile.\n this.transform = tileHeader.transform ? new Matrix4(tileHeader.transform) : new Matrix4();\n\n const parent = this.parent;\n const tileset = this.tileset;\n\n const parentTransform =\n parent && parent.computedTransform\n ? parent.computedTransform.clone()\n : tileset.modelMatrix.clone();\n this.computedTransform = new Matrix4(parentTransform).multiplyRight(this.transform);\n\n const parentInitialTransform =\n parent && parent._initialTransform ? parent._initialTransform.clone() : new Matrix4();\n this._initialTransform = new Matrix4(parentInitialTransform).multiplyRight(this.transform);\n }\n\n _initializeBoundingVolumes(tileHeader) {\n this._contentBoundingVolume = null;\n this._viewerRequestVolume = null;\n\n this._updateBoundingVolume(tileHeader);\n }\n\n _initializeContent(tileHeader) {\n // Empty tile by default\n this.content = {_tileset: this.tileset, _tile: this};\n this.hasEmptyContent = true;\n this.contentState = TILE_CONTENT_STATE.UNLOADED;\n\n // When `true`, the tile's content points to an external tileset.\n // This is `false` until the tile's content is loaded.\n this.hasTilesetContent = false;\n\n if (tileHeader.contentUrl) {\n this.content = null;\n this.hasEmptyContent = false;\n }\n }\n\n // TODO - remove anything not related to basic visibility detection\n _initializeRenderingState(header) {\n this.depth = header.level || (this.parent ? this.parent.depth + 1 : 0);\n this._shouldRefine = false;\n\n // Members this are updated every frame for tree traversal and rendering optimizations:\n this._distanceToCamera = 0;\n this._centerZDepth = 0;\n this._screenSpaceError = 0;\n this._visibilityPlaneMask = CullingVolume.MASK_INDETERMINATE;\n this._visible = undefined;\n this._inRequestVolume = false;\n\n this._stackLength = 0;\n this._selectionDepth = 0;\n\n this._frameNumber = 0;\n this._touchedFrame = 0;\n this._visitedFrame = 0;\n this._selectedFrame = 0;\n this._requestedFrame = 0;\n\n this._priority = 0.0;\n }\n\n _getRefine(refine) {\n // Inherit from parent tile if omitted.\n return refine || (this.parent && this.parent.refine) || TILE_REFINEMENT.REPLACE;\n }\n\n _isTileset() {\n return this.contentUrl.indexOf('.json') !== -1;\n }\n\n _onContentLoaded() {\n // Vector and Geometry tile rendering do not support the skip LOD optimization.\n switch (this.content && this.content.type) {\n case 'vctr':\n case 'geom':\n // @ts-ignore\n this.tileset._traverser.disableSkipLevelOfDetail = true;\n break;\n default:\n }\n\n // The content may be tileset json\n if (this._isTileset()) {\n this.hasTilesetContent = true;\n }\n }\n\n _updateBoundingVolume(header) {\n // Update the bounding volumes\n this.boundingVolume = createBoundingVolume(\n header.boundingVolume,\n this.computedTransform,\n this.boundingVolume\n );\n\n const content = header.content;\n if (!content) {\n return;\n }\n\n // TODO Cesium specific\n // Non-leaf tiles may have a content bounding-volume, which is a tight-fit bounding volume\n // around only the features in the tile. This box is useful for culling for rendering,\n // but not for culling for traversing the tree since it does not guarantee spatial coherence, i.e.,\n // since it only bounds features in the tile, not the entire tile, children may be\n // outside of this box.\n if (content.boundingVolume) {\n this._contentBoundingVolume = createBoundingVolume(\n content.boundingVolume,\n this.computedTransform,\n this._contentBoundingVolume\n );\n }\n if (header.viewerRequestVolume) {\n this._viewerRequestVolume = createBoundingVolume(\n header.viewerRequestVolume,\n this.computedTransform,\n this._viewerRequestVolume\n );\n }\n }\n\n // Update the tile's transform. The transform is applied to the tile's bounding volumes.\n _updateTransform(parentTransform = new Matrix4()) {\n const computedTransform = parentTransform.clone().multiplyRight(this.transform);\n const didTransformChange = !computedTransform.equals(this.computedTransform);\n\n if (!didTransformChange) {\n return;\n }\n\n this.computedTransform = computedTransform;\n\n this._updateBoundingVolume(this.header);\n }\n\n // Get options which are applicable only for the particular loader\n _getLoaderSpecificOptions(loaderId) {\n switch (loaderId) {\n case 'i3s':\n return {\n ...this.tileset.options.i3s,\n tile: this.header,\n tileset: this.tileset.tileset,\n isTileHeader: false\n };\n case '3d-tiles':\n case 'cesium-ion':\n default:\n return get3dTilesOptions(this.tileset.tileset);\n }\n }\n}\n","export function get3dTilesOptions(tileset) {\n return {\n assetGltfUpAxis: (tileset.asset && tileset.asset.gltfUpAxis) || 'Y'\n };\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {TILE3D_OPTIMIZATION_HINT, TILE_REFINEMENT} from '../../constants';\nimport TilesetTraverser from './tileset-traverser';\n\nexport default class Tileset3DTraverser extends TilesetTraverser {\n compareDistanceToCamera(a, b) {\n // Sort by farthest child first since this is going on a stack\n return b._distanceToCamera === 0 && a._distanceToCamera === 0\n ? b._centerZDepth - a._centerZDepth\n : b._distanceToCamera - a._distanceToCamera;\n }\n\n updateTileVisibility(tile, frameState) {\n super.updateTileVisibility(tile, frameState);\n\n // Optimization - if none of the tile's children are visible then this tile isn't visible\n if (!tile.isVisibleAndInRequestVolume) {\n return;\n }\n\n const hasChildren = tile.children.length > 0;\n if (tile.hasTilesetContent && hasChildren) {\n // Use the root tile's visibility instead of this tile's visibility.\n // The root tile may be culled by the children bounds optimization in which\n // case this tile should also be culled.\n const firstChild = tile.children[0];\n this.updateTileVisibility(firstChild, frameState);\n tile._visible = firstChild._visible;\n return;\n }\n\n if (this.meetsScreenSpaceErrorEarly(tile, frameState)) {\n tile._visible = false;\n return;\n }\n\n const replace = tile.refine === TILE_REFINEMENT.REPLACE;\n const useOptimization =\n tile._optimChildrenWithinParent === TILE3D_OPTIMIZATION_HINT.USE_OPTIMIZATION;\n if (replace && useOptimization && hasChildren) {\n if (!this.anyChildrenVisible(tile, frameState)) {\n tile._visible = false;\n return;\n }\n }\n }\n\n meetsScreenSpaceErrorEarly(tile, frameState) {\n const {parent} = tile;\n if (!parent || parent.hasTilesetContent || parent.refine !== TILE_REFINEMENT.ADD) {\n return false;\n }\n\n // Use parent's geometric error with child's box to see if the tile already meet the SSE\n return !this.shouldRefine(tile, frameState, true);\n }\n}\n","const STATUS = {\n REQUESTED: 'REQUESTED',\n COMPLETED: 'COMPLETED',\n ERROR: 'ERROR'\n};\n\n// A helper class to manage tile metadata fetching\nexport default class I3STileManager {\n private _statusMap: object;\n\n constructor() {\n this._statusMap = {};\n }\n\n add(request, key, callback, frameState) {\n if (!this._statusMap[key]) {\n this._statusMap[key] = {request, callback, key, frameState, status: STATUS.REQUESTED};\n request()\n .then((data) => {\n this._statusMap[key].status = STATUS.COMPLETED;\n this._statusMap[key].callback(data, frameState);\n })\n .catch((error) => {\n this._statusMap[key].status = STATUS.ERROR;\n callback(error);\n });\n }\n }\n\n update(key, frameState) {\n if (this._statusMap[key]) {\n this._statusMap[key].frameState = frameState;\n }\n }\n\n find(key) {\n return this._statusMap[key];\n }\n}\n","import {load} from '@loaders.gl/core';\nimport TilesetTraverser from './tileset-traverser';\n\nimport {lodJudge} from '../helpers/i3s-lod';\nimport TileHeader from '../tile-3d';\nimport I3STileManager from './i3s-tile-manager';\n\nexport default class I3STilesetTraverser extends TilesetTraverser {\n private _tileManager: I3STileManager;\n\n constructor(options) {\n super(options);\n this._tileManager = new I3STileManager();\n }\n\n shouldRefine(tile, frameState) {\n // TODO refactor loaJudge\n tile._lodJudge = lodJudge(tile, frameState);\n return tile._lodJudge === 'DIG';\n }\n\n updateChildTiles(tile, frameState): boolean {\n const children = tile.header.children || [];\n // children which are already fetched and constructed as Tile3D instances\n const childTiles = tile.children;\n const tileset = tile.tileset;\n\n for (const child of children) {\n const extendedId = `${child.id}-${frameState.viewport.id}`;\n // if child tile is not fetched\n const childTile = childTiles && childTiles.find((t) => t.id === extendedId);\n if (!childTile) {\n let request = () => this._loadTile(child.id, tileset);\n const cachedRequest = this._tileManager.find(extendedId);\n if (!cachedRequest) {\n // eslint-disable-next-line max-depth\n if (tileset.tileset.nodePages) {\n request = () => tileset.tileset.nodePagesTile.formTileFromNodePages(child.id);\n }\n this._tileManager.add(\n request,\n extendedId,\n (header) => this._onTileLoad(header, tile, extendedId),\n frameState\n );\n } else {\n // update frameNumber since it is still needed in current frame\n this._tileManager.update(extendedId, frameState);\n }\n } else if (childTile) {\n // if child tile is fetched and available\n this.updateTile(childTile, frameState);\n }\n }\n return false;\n }\n\n async _loadTile(nodeId, tileset) {\n const {loader} = tileset;\n const nodeUrl = tileset.getTileUrl(`${tileset.url}/nodes/${nodeId}`);\n // load metadata\n const options = {\n ...tileset.loadOptions,\n i3s: {\n ...tileset.loadOptions.i3s,\n isTileHeader: true,\n loadContent: false\n }\n };\n\n return await load(nodeUrl, loader, options);\n }\n\n /**\n * The callback to init TileHeader instance after loading the tile JSON\n * @param {Object} header - the tile JSON from a dataset\n * @param {TileHeader} tile - the parent TileHeader instance\n * @param {string} extendedId - optional ID to separate copies of a tile for different viewports.\n * const extendedId = `${tile.id}-${frameState.viewport.id}`;\n * @return {void}\n */\n _onTileLoad(header, tile, extendedId) {\n // after child tile is fetched\n const childTile = new TileHeader(tile.tileset, header, tile, extendedId);\n tile.children.push(childTile);\n const frameState = this._tileManager.find(childTile.id).frameState;\n this.updateTile(childTile, frameState);\n\n // after tile fetched, resume traversal if still in current update/traversal frame\n if (this._frameNumber === frameState.frameNumber) {\n this.executeTraversal(childTile, frameState);\n }\n }\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\n/*\n\n The Tileset loading and rendering flow is as below,\n A rendered (i.e. deck.gl `Tile3DLayer`) triggers `tileset.update()` after a `tileset` is loaded\n `tileset` starts traversing the tile tree and update `requestTiles` (tiles of which content need\n to be fetched) and `selectedTiles` (tiles ready for rendering under the current viewport).\n `Tile3DLayer` will update rendering based on `selectedTiles`.\n `Tile3DLayer` also listens to `onTileLoad` callback and trigger another round of `update and then traversal`\n when new tiles are loaded.\n\n As I3S tileset have stored `tileHeader` file (metadata) and tile content files (geometry, texture, ...) separately.\n During each traversal, it issues `tilHeader` requests if that `tileHeader` is not yet fetched,\n after the tile header is fulfilled, it will resume the traversal starting from the tile just fetched (not root).\n\n Tile3DLayer\n |\n await load(tileset)\n |\n tileset.update()\n | async load tileHeader\n tileset.traverse() -------------------------- Queued\n | resume traversal after fetched |\n |----------------------------------------|\n |\n | async load tile content\n tilset.requestedTiles ----------------------------- RequestScheduler\n |\n tilset.selectedTiles (ready for rendering) |\n | Listen to |\n Tile3DLayer ----------- onTileLoad ----------------------|\n | | notify new tile is available\n updateLayers |\n tileset.update // trigger another round of update\n*/\n\nimport {Matrix4, Vector3} from '@math.gl/core';\nimport {Ellipsoid} from '@math.gl/geospatial';\nimport {Stats} from '@probe.gl/stats';\nimport {\n RequestScheduler,\n assert,\n path,\n LoaderWithParser,\n LoaderOptions\n} from '@loaders.gl/loader-utils';\nimport TilesetCache from './tileset-cache';\nimport {calculateTransformProps} from './helpers/transform-utils';\nimport {FrameState, getFrameState} from './helpers/frame-state';\nimport {getZoomFromBoundingVolume} from './helpers/zoom';\nimport Tile3D from './tile-3d';\nimport Tileset3DTraverser from './traversers/tileset-3d-traverser';\nimport TilesetTraverser from './traversers/tileset-traverser';\nimport I3SetTraverser from './traversers/i3s-tileset-traverser';\nimport {TILESET_TYPE} from '../constants';\n\nexport type Tileset3DProps = {\n // loading\n throttleRequests?: boolean;\n maxRequests?: number;\n loadOptions?: LoaderOptions;\n loadTiles?: boolean;\n basePath?: string;\n maximumMemoryUsage?: number;\n\n // Metadata\n description?: string;\n attributions?: string[];\n\n // Transforms\n ellipsoid?: object;\n modelMatrix?: Matrix4;\n\n // Traversal\n maximumScreenSpaceError?: number;\n viewportTraversersMap?: any;\n updateTransforms?: boolean;\n viewDistanceScale?: number;\n\n // Callbacks\n onTileLoad?: (tile: Tile3D) => any;\n onTileUnload?: (tile: Tile3D) => any;\n onTileError?: (tile: Tile3D, message: string, url: string) => any;\n contentLoader?: (tile: Tile3D) => Promise<void>;\n onTraversalComplete?: (selectedTiles: Tile3D[]) => Tile3D[];\n};\n\ntype Props = {\n description: string;\n ellipsoid: object;\n modelMatrix: Matrix4;\n throttleRequests: boolean;\n maximumMemoryUsage: number;\n onTileLoad: (tile: Tile3D) => any;\n onTileUnload: (tile: Tile3D) => any;\n onTileError: (tile: Tile3D, message: string, url: string) => any;\n onTraversalComplete: (selectedTiles: Tile3D[]) => Tile3D[];\n maximumScreenSpaceError: number;\n viewportTraversersMap: any;\n attributions: string[];\n maxRequests: number;\n loadTiles: boolean;\n loadOptions: LoaderOptions;\n updateTransforms: boolean;\n viewDistanceScale: number;\n basePath: string;\n contentLoader?: (tile: Tile3D) => Promise<void>;\n i3s: {[key: string]: any};\n};\n\nconst DEFAULT_PROPS: Props = {\n description: '',\n\n ellipsoid: Ellipsoid.WGS84,\n // A 4x4 transformation matrix this transforms the entire tileset.\n modelMatrix: new Matrix4(),\n\n // Set to false to disable network request throttling\n throttleRequests: true,\n\n // Number of simultaneous requsts, if throttleRequests is true\n maxRequests: 64,\n\n maximumMemoryUsage: 32,\n\n /**\n * Callback. Indicates this a tile's content was loaded\n * @param tile {TileHeader}\n */\n onTileLoad: () => {},\n /**\n * Callback. Indicates this a tile's content was unloaded\n * @param tile {TileHeader}\n */\n onTileUnload: () => {},\n onTileError: () => {},\n /**\n * Callback. Allows post-process selectedTiles right after traversal.\n * @param selectedTiles {TileHeader[]}\n * @returns TileHeader[] - output array of tiles to return to deck.gl\n */\n onTraversalComplete: (selectedTiles: Tile3D[]) => selectedTiles,\n\n // Optional async tile content loader\n contentLoader: undefined,\n\n // View distance scale modifier\n viewDistanceScale: 1.0,\n\n // TODO CESIUM\n // The maximum screen space error used to drive level of detail refinement.\n maximumScreenSpaceError: 8,\n\n loadTiles: true,\n updateTransforms: true,\n viewportTraversersMap: null,\n\n loadOptions: {fetch: {}},\n\n attributions: [],\n basePath: '',\n\n i3s: {}\n};\n\n// Tracked Stats\nconst TILES_TOTAL = 'Tiles In Tileset(s)';\nconst TILES_IN_MEMORY = 'Tiles In Memory';\nconst TILES_IN_VIEW = 'Tiles In View';\nconst TILES_RENDERABLE = 'Tiles To Render';\nconst TILES_LOADED = 'Tiles Loaded';\nconst TILES_LOADING = 'Tiles Loading';\nconst TILES_UNLOADED = 'Tiles Unloaded';\nconst TILES_LOAD_FAILED = 'Failed Tile Loads';\nconst POINTS_COUNT = 'Points';\nconst TILES_GPU_MEMORY = 'Tile Memory Use';\n\nexport default class Tileset3D {\n // props: Tileset3DProps;\n options: Props;\n loadOptions: {[key: string]: any};\n\n type: string;\n tileset: {[key: string]: any};\n loader: LoaderWithParser;\n url: string;\n basePath: string;\n modelMatrix: Matrix4;\n ellipsoid: any;\n lodMetricType: string;\n lodMetricValue: number;\n refine: string;\n root: Tile3D | null;\n roots: {[key: string]: Tile3D};\n asset: {[key: string]: any};\n\n description: string;\n properties: any;\n extras: any;\n attributions: any;\n credits: any;\n\n stats: Stats;\n\n traverseCounter: number;\n geometricError: number;\n selectedTiles: Tile3D[];\n\n cartographicCenter: Vector3 | null;\n cartesianCenter: Vector3 | null;\n zoom: number;\n boundingVolume: any;\n\n // METRICS\n // The maximum amount of GPU memory (in MB) that may be used to cache tiles.\n // Tiles not in view are unloaded to enforce private\n // The total amount of GPU memory in bytes used by the tileset.\n gpuMemoryUsageInBytes: any;\n dynamicScreenSpaceErrorComputedDensity: any;\n\n // TRAVERSAL\n _traverser: TilesetTraverser;\n private _cache: TilesetCache;\n _requestScheduler: RequestScheduler;\n\n _frameNumber: number;\n private _queryParamsString: string;\n private _queryParams: any;\n private _extensionsUsed: any;\n private _tiles: {[id: string]: Tile3D};\n\n // counter for tracking tiles requests\n private _pendingCount: any;\n\n // HOLD TRAVERSAL RESULTS\n private lastUpdatedVieports: any[] | null;\n private _requestedTiles: any;\n private _emptyTiles: any;\n private frameStateData: any;\n\n maximumMemoryUsage: number;\n\n /**\n * Create a new Tileset3D\n * @param json\n * @param props\n */\n // eslint-disable-next-line max-statements\n constructor(json: any, options?: Tileset3DProps) {\n assert(json);\n\n // PUBLIC MEMBERS\n this.options = {...DEFAULT_PROPS, ...options};\n // raw data\n this.tileset = json;\n this.loader = json.loader;\n // could be 3d tiles, i3s\n this.type = json.type;\n // The url to a tileset JSON file.\n this.url = json.url;\n this.basePath = json.basePath || path.dirname(this.url);\n this.modelMatrix = this.options.modelMatrix;\n this.ellipsoid = this.options.ellipsoid;\n\n // Geometric error when the tree is not rendered at all\n this.lodMetricType = json.lodMetricType;\n this.lodMetricValue = json.lodMetricValue;\n this.refine = json.root.refine;\n\n this.loadOptions = this.options.loadOptions || {};\n\n this.root = null;\n this.roots = {};\n // view props\n this.cartographicCenter = null;\n this.cartesianCenter = null;\n this.zoom = 1;\n this.boundingVolume = null;\n\n // TRAVERSAL\n this.traverseCounter = 0;\n this.geometricError = 0;\n this._traverser = this._initializeTraverser();\n this._cache = new TilesetCache();\n this._requestScheduler = new RequestScheduler({\n throttleRequests: this.options.throttleRequests,\n maxRequests: this.options.maxRequests\n });\n // update tracker\n // increase in each update cycle\n this._frameNumber = 0;\n\n // counter for tracking tiles requests\n this._pendingCount = 0;\n\n // HOLD TRAVERSAL RESULTS\n this._tiles = {};\n this.selectedTiles = [];\n this._emptyTiles = [];\n this._requestedTiles = [];\n this.frameStateData = {};\n this.lastUpdatedVieports = null;\n\n this._queryParams = {};\n this._queryParamsString = '';\n\n // METRICS\n // The maximum amount of GPU memory (in MB) that may be used to cache tiles.\n // Tiles not in view are unloaded to enforce this.\n this.maximumMemoryUsage = this.options.maximumMemoryUsage || 32;\n // The total amount of GPU memory in bytes used by the tileset.\n this.gpuMemoryUsageInBytes = 0;\n this.stats = new Stats({id: this.url});\n this._initializeStats();\n\n // EXTRACTED FROM TILESET\n this._extensionsUsed = undefined;\n this.dynamicScreenSpaceErrorComputedDensity = 0.0; // Updated based on the camera position and direction\n // Metadata for the entire tileset\n this.extras = null;\n this.asset = {};\n this.credits = {};\n this.description = this.options.description || '';\n\n this._initializeTileSet(json);\n }\n\n /** Release resources */\n destroy(): void {\n this._destroy();\n }\n\n /** Is the tileset loaded (update needs to have been called at least once) */\n isLoaded(): boolean {\n // Check that `_frameNumber !== 0` which means that update was called at least once\n return this._pendingCount === 0 && this._frameNumber !== 0;\n }\n\n get tiles(): object[] {\n return Object.values(this._tiles);\n }\n\n get frameNumber(): number {\n return this._frameNumber;\n }\n\n get queryParams(): string {\n if (!this._queryParamsString) {\n this._queryParamsString = getQueryParamString(this._queryParams);\n }\n return this._queryParamsString;\n }\n\n setProps(props: Tileset3DProps): void {\n this.options = {...this.options, ...props};\n }\n\n /** @deprecated */\n setOptions(options: Tileset3DProps): void {\n this.options = {...this.options, ...options};\n }\n\n /**\n * Return a loadable tile url for a specific tile subpath\n * @param tilePath a tile subpath\n */\n getTileUrl(tilePath: string): string {\n const isDataUrl = tilePath.startsWith('data:');\n if (isDataUrl) {\n return tilePath;\n }\n return `${tilePath}${this.queryParams}`;\n }\n\n // TODO CESIUM specific\n hasExtension(extensionName: string): boolean {\n return Boolean(this._extensionsUsed && this._extensionsUsed.indexOf(extensionName) > -1);\n }\n\n /**\n * Update visible tiles relying on a list of viewports\n * @param viewports - list of viewports\n */\n // eslint-disable-next-line max-statements, complexity\n update(viewports: any[]): void {\n if ('loadTiles' in this.options && !this.options.loadTiles) {\n return;\n }\n if (this.traverseCounter > 0) {\n return;\n }\n if (!viewports && this.lastUpdatedVieports) {\n viewports = this.lastUpdatedVieports;\n } else {\n this.lastUpdatedVieports = viewports;\n }\n if (!(viewports instanceof Array)) {\n viewports = [viewports];\n }\n\n this._cache.reset();\n this._frameNumber++;\n this.traverseCounter = viewports.length;\n const viewportsToTraverse: string[] = [];\n // First loop to decrement traverseCounter\n for (const viewport of viewports) {\n const id = viewport.id as string;\n if (this._needTraverse(id)) {\n viewportsToTraverse.push(id);\n } else {\n this.traverseCounter--;\n }\n }\n\n // Second loop to traverse\n for (const viewport of viewports) {\n const id = viewport.id as string;\n if (!this.roots[id]) {\n this.roots[id] = this._initializeTileHeaders(this.tileset, null);\n }\n\n if (!viewportsToTraverse.includes(id)) {\n continue; // eslint-disable-line no-continue\n }\n const frameState = getFrameState(viewport, this._frameNumber);\n this._traverser.traverse(this.roots[id], frameState, this.options);\n }\n }\n\n /**\n * Check if traversal is needed for particular viewport\n * @param {string} viewportId - id of a viewport\n * @return {boolean}\n */\n _needTraverse(viewportId: string): boolean {\n let traverserId = viewportId;\n if (this.options.viewportTraversersMap) {\n traverserId = this.options.viewportTraversersMap[viewportId];\n }\n if (traverserId !== viewportId) {\n return false;\n }\n\n return true;\n }\n\n /**\n * The callback to post-process tiles after traversal procedure\n * @param frameState - frame state for tile culling\n */\n _onTraversalEnd(frameState: FrameState): void {\n const id = frameState.viewport.id;\n if (!this.frameStateData[id]) {\n this.frameStateData[id] = {selectedTiles: [], _requestedTiles: [], _emptyTiles: []};\n }\n const currentFrameStateData = this.frameStateData[id];\n const selectedTiles = Object.values(this._traverser.selectedTiles);\n currentFrameStateData.selectedTiles = selectedTiles;\n currentFrameStateData._requestedTiles = Object.values(this._traverser.requestedTiles);\n currentFrameStateData._emptyTiles = Object.values(this._traverser.emptyTiles);\n\n this.traverseCounter--;\n if (this.traverseCounter > 0) {\n return;\n }\n\n this._updateTiles();\n }\n\n /**\n * Update tiles relying on data from all traversers\n */\n _updateTiles(): void {\n this.selectedTiles = [];\n this._requestedTiles = [];\n this._emptyTiles = [];\n\n for (const frameStateKey in this.frameStateData) {\n const frameStateDataValue = this.frameStateData[frameStateKey];\n this.selectedTiles = this.selectedTiles.concat(frameStateDataValue.selectedTiles);\n this._requestedTiles = this._requestedTiles.concat(frameStateDataValue._requestedTiles);\n this._emptyTiles = this._emptyTiles.concat(frameStateDataValue._emptyTiles);\n }\n\n this.selectedTiles = this.options.onTraversalComplete(this.selectedTiles);\n\n for (const tile of this.selectedTiles) {\n this._tiles[tile.id] = tile;\n }\n\n this._loadTiles();\n this._unloadTiles();\n this._updateStats();\n }\n\n _tilesChanged(oldSelectedTiles, selectedTiles) {\n if (oldSelectedTiles.length !== selectedTiles.length) {\n return true;\n }\n const set1 = new Set(oldSelectedTiles.map((t) => t.id));\n const set2 = new Set(selectedTiles.map((t) => t.id));\n let changed = oldSelectedTiles.filter((x) => !set2.has(x.id)).length > 0;\n changed = changed || selectedTiles.filter((x) => !set1.has(x.id)).length > 0;\n return changed;\n }\n\n _loadTiles() {\n // Sort requests by priority before making any requests.\n // This makes it less likely this requests will be cancelled after being issued.\n // requestedTiles.sort((a, b) => a._priority - b._priority);\n for (const tile of this._requestedTiles) {\n if (tile.contentUnloaded) {\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n this._loadTile(tile);\n }\n }\n }\n\n _unloadTiles() {\n // unload tiles from cache when hit maximumMemoryUsage\n this._cache.unloadTiles(this, (tileset, tile) => tileset._unloadTile(tile));\n }\n\n _updateStats() {\n let tilesRenderable = 0;\n let pointsRenderable = 0;\n for (const tile of this.selectedTiles) {\n if (tile.contentAvailable && tile.content) {\n tilesRenderable++;\n if (tile.content.pointCount) {\n pointsRenderable += tile.content.pointCount;\n }\n }\n }\n\n this.stats.get(TILES_IN_VIEW).count = this.selectedTiles.length;\n this.stats.get(TILES_RENDERABLE).count = tilesRenderable;\n this.stats.get(POINTS_COUNT).count = pointsRenderable;\n }\n\n _initializeTileSet(tilesetJson) {\n this.root = this._initializeTileHeaders(tilesetJson, null);\n\n // TODO CESIUM Specific\n if (this.type === TILESET_TYPE.TILES3D) {\n this._initializeCesiumTileset(tilesetJson);\n }\n\n if (this.type === TILESET_TYPE.I3S) {\n this._initializeI3STileset();\n }\n // Calculate cartographicCenter & zoom props to help apps center view on tileset\n this._calculateViewProps();\n }\n\n // Called during initialize Tileset to initialize the tileset's cartographic center (longitude, latitude) and zoom.\n _calculateViewProps() {\n const root = this.root as Tile3D;\n assert(root);\n const {center} = root.boundingVolume;\n // TODO - handle all cases\n if (!center) {\n // eslint-disable-next-line\n console.warn('center was not pre-calculated for the root tile');\n this.cartographicCenter = new Vector3();\n this.zoom = 1;\n return;\n }\n this.cartographicCenter = Ellipsoid.WGS84.cartesianToCartographic(center, new Vector3());\n this.cartesianCenter = center;\n this.zoom = getZoomFromBoundingVolume(root.boundingVolume);\n }\n\n _initializeStats() {\n this.stats.get(TILES_TOTAL);\n this.stats.get(TILES_LOADING);\n this.stats.get(TILES_IN_MEMORY);\n this.stats.get(TILES_IN_VIEW);\n this.stats.get(TILES_RENDERABLE);\n this.stats.get(TILES_LOADED);\n this.stats.get(TILES_UNLOADED);\n this.stats.get(TILES_LOAD_FAILED);\n this.stats.get(POINTS_COUNT, 'memory');\n this.stats.get(TILES_GPU_MEMORY, 'memory');\n }\n\n // Installs the main tileset JSON file or a tileset JSON file referenced from a tile.\n // eslint-disable-next-line max-statements\n _initializeTileHeaders(tilesetJson, parentTileHeader) {\n // A tileset JSON file referenced from a tile may exist in a different directory than the root tileset.\n // Get the basePath relative to the external tileset.\n const rootTile = new Tile3D(this, tilesetJson.root, parentTileHeader); // resource\n\n // If there is a parentTileHeader, add the root of the currently loading tileset\n // to parentTileHeader's children, and update its depth.\n if (parentTileHeader) {\n parentTileHeader.children.push(rootTile);\n rootTile.depth = parentTileHeader.depth + 1;\n }\n\n // Cesium 3d tiles knows the hierarchy beforehand\n if (this.type === TILESET_TYPE.TILES3D) {\n const stack: Tile3D[] = [];\n stack.push(rootTile);\n\n while (stack.length > 0) {\n const tile = stack.pop() as Tile3D;\n this.stats.get(TILES_TOTAL).incrementCount();\n const children = tile.header.children || [];\n for (const childHeader of children) {\n const childTile = new Tile3D(this, childHeader, tile);\n tile.children.push(childTile);\n childTile.depth = tile.depth + 1;\n stack.push(childTile);\n }\n }\n }\n\n return rootTile;\n }\n\n _initializeTraverser() {\n let TraverserClass;\n const type = this.type;\n switch (type) {\n case TILESET_TYPE.TILES3D:\n TraverserClass = Tileset3DTraverser;\n break;\n case TILESET_TYPE.I3S:\n TraverserClass = I3SetTraverser;\n break;\n default:\n TraverserClass = TilesetTraverser;\n }\n\n return new TraverserClass({\n basePath: this.basePath,\n onTraversalEnd: this._onTraversalEnd.bind(this)\n });\n }\n\n _destroyTileHeaders(parentTile) {\n this._destroySubtree(parentTile);\n }\n\n async _loadTile(tile) {\n let loaded;\n try {\n this._onStartTileLoading();\n loaded = await tile.loadContent();\n } catch (error) {\n this._onTileLoadError(tile, error);\n } finally {\n this._onEndTileLoading();\n this._onTileLoad(tile, loaded);\n }\n }\n\n _onTileLoadError(tile, error) {\n this.stats.get(TILES_LOAD_FAILED).incrementCount();\n\n const message = error.message || error.toString();\n const url = tile.url;\n // TODO - Allow for probe log to be injected instead of console?\n console.error(`A 3D tile failed to load: ${tile.url} ${message}`); // eslint-disable-line\n this.options.onTileError(tile, message, url);\n }\n\n _onTileLoad(tile, loaded) {\n if (!loaded) {\n return;\n }\n\n // add coordinateOrigin and modelMatrix to tile\n if (tile && tile.content) {\n calculateTransformProps(tile, tile.content);\n }\n\n this._addTileToCache(tile);\n this.options.onTileLoad(tile);\n }\n\n _onStartTileLoading() {\n this._pendingCount++;\n this.stats.get(TILES_LOADING).incrementCount();\n }\n\n _onEndTileLoading() {\n this._pendingCount--;\n this.stats.get(TILES_LOADING).decrementCount();\n }\n\n _addTileToCache(tile) {\n this._cache.add(this, tile, (tileset) => tileset._updateCacheStats(tile));\n }\n\n _updateCacheStats(tile) {\n this.stats.get(TILES_LOADED).incrementCount();\n this.stats.get(TILES_IN_MEMORY).incrementCount();\n\n // Good enough? Just use the raw binary ArrayBuffer's byte length.\n this.gpuMemoryUsageInBytes += tile.content.byteLength || 0;\n this.stats.get(TILES_GPU_MEMORY).count = this.gpuMemoryUsageInBytes;\n }\n\n _unloadTile(tile) {\n this.gpuMemoryUsageInBytes -= (tile.content && tile.content.byteLength) || 0;\n\n this.stats.get(TILES_IN_MEMORY).decrementCount();\n this.stats.get(TILES_UNLOADED).incrementCount();\n this.stats.get(TILES_GPU_MEMORY).count = this.gpuMemoryUsageInBytes;\n\n this.options.onTileUnload(tile);\n tile.unloadContent();\n }\n\n // Traverse the tree and destroy all tiles\n _destroy() {\n const stack: Tile3D[] = [];\n\n if (this.root) {\n stack.push(this.root);\n }\n\n while (stack.length > 0) {\n const tile: Tile3D = stack.pop() as Tile3D;\n\n for (const child of tile.children) {\n stack.push(child);\n }\n\n this._destroyTile(tile);\n }\n this.root = null;\n }\n\n // Traverse the tree and destroy all sub tiles\n _destroySubtree(tile) {\n const root = tile;\n const stack: Tile3D[] = [];\n stack.push(root);\n while (stack.length > 0) {\n tile = stack.pop();\n for (const child of tile.children) {\n stack.push(child);\n }\n if (tile !== root) {\n this._destroyTile(tile);\n }\n }\n root.children = [];\n }\n\n _destroyTile(tile) {\n this._cache.unloadTile(this, tile);\n this._unloadTile(tile);\n tile.destroy();\n }\n\n _initializeCesiumTileset(tilesetJson) {\n this.asset = tilesetJson.asset;\n if (!this.asset) {\n throw new Error('Tileset must have an asset property.');\n }\n if (this.asset.version !== '0.0' && this.asset.version !== '1.0') {\n throw new Error('The tileset must be 3D Tiles version 0.0 or 1.0.');\n }\n\n // Note: `asset.tilesetVersion` is version of the tileset itself (not the version of the 3D TILES standard)\n // We add this version as a `v=1.0` query param to fetch the right version and not get an older cached version\n if ('tilesetVersion' in this.asset) {\n this._queryParams.v = this.asset.tilesetVersion;\n }\n\n // TODO - ion resources have a credits property we can use for additional attribution.\n this.credits = {\n attributions: this.options.attributions || []\n };\n this.description = this.options.description || '';\n\n // Gets the tileset's properties dictionary object, which contains metadata about per-feature properties.\n this.properties = tilesetJson.properties;\n this.geometricError = tilesetJson.geometricError;\n this._extensionsUsed = tilesetJson.extensionsUsed;\n // Returns the extras property at the top of the tileset JSON (application specific metadata).\n this.extras = tilesetJson.extras;\n }\n\n _initializeI3STileset() {\n if (this.loadOptions.i3s && 'token' in this.loadOptions.i3s) {\n this._queryParams.token = this.loadOptions.i3s.token;\n }\n }\n}\n\nfunction getQueryParamString(queryParams): string {\n const queryParamStrings: string[] = [];\n for (const key of Object.keys(queryParams)) {\n queryParamStrings.push(`${key}=${queryParams[key]}`);\n }\n switch (queryParamStrings.length) {\n case 0:\n return '';\n case 1:\n return `?${queryParamStrings[0]}`;\n default:\n return `?${queryParamStrings.join('&')}`;\n }\n}\n"],"sourceRoot":""}