{"mappings":"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","sources":["hq.bundle.js","node_modules/@deck.gl/mapbox/src/mapbox-layer.js","node_modules/@deck.gl/mapbox/src/deck-utils.js","node_modules/@deck.gl/core/src/index.js","node_modules/@deck.gl/core/src/lib/init.js","node_modules/@loaders.gl/core/src/index.ts","node_modules/@loaders.gl/core/src/lib/fetch/fetch-file.ts","node_modules/@loaders.gl/loader-utils/src/index.ts","node_modules/@loaders.gl/loader-utils/src/lib/env-utils/assert.ts","node_modules/@parcel/transformer-js/src/esmodule-helpers.js","node_modules/@loaders.gl/loader-utils/src/lib/env-utils/globals.ts","node_modules/process/browser.js","node_modules/@loaders.gl/loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts","node_modules/@loaders.gl/worker-utils/src/index.ts","node_modules/@loaders.gl/worker-utils/src/lib/env-utils/version.ts","node_modules/@loaders.gl/worker-utils/src/lib/env-utils/assert.ts","node_modules/@loaders.gl/worker-utils/src/lib/env-utils/globals.ts","node_modules/@loaders.gl/worker-utils/src/lib/worker-farm/worker-job.ts","node_modules/@babel/runtime/helpers/esm/defineProperty.js","node_modules/@loaders.gl/worker-utils/src/lib/worker-farm/worker-thread.ts","node_modules/@loaders.gl/worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts","node_modules/@loaders.gl/worker-utils/src/lib/worker-utils/get-transfer-list.ts","node_modules/@loaders.gl/worker-utils/src/lib/worker-farm/worker-farm.ts","node_modules/@loaders.gl/worker-utils/src/lib/worker-farm/worker-pool.ts","node_modules/@loaders.gl/worker-utils/src/lib/worker-farm/worker-body.ts","node_modules/@loaders.gl/worker-utils/src/lib/worker-api/process-on-worker.ts","node_modules/@loaders.gl/worker-utils/src/lib/worker-utils/remove-nontransferable-options.ts","node_modules/@loaders.gl/worker-utils/src/lib/worker-api/get-worker-url.ts","node_modules/@loaders.gl/worker-utils/src/lib/worker-api/create-worker.ts","node_modules/@loaders.gl/worker-utils/src/lib/async-queue/async-queue.ts","node_modules/@loaders.gl/worker-utils/src/lib/worker-api/validate-worker-version.ts","node_modules/@loaders.gl/worker-utils/src/lib/library-utils/library-utils.ts","node_modules/@loaders.gl/loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts","node_modules/@loaders.gl/loader-utils/src/lib/parser-utils/parse-json.ts","node_modules/@loaders.gl/loader-utils/src/lib/binary-utils/get-first-characters.ts","node_modules/@loaders.gl/loader-utils/src/lib/binary-utils/array-buffer-utils.ts","node_modules/@loaders.gl/loader-utils/src/lib/binary-utils/buffer-utils.ts","node_modules/@loaders.gl/loader-utils/src/lib/binary-utils/memory-copy-utils.ts","node_modules/@loaders.gl/loader-utils/src/lib/binary-utils/binary-copy-utils.ts","node_modules/@loaders.gl/loader-utils/src/lib/binary-utils/encode-utils.ts","node_modules/@loaders.gl/loader-utils/src/lib/iterators/text-iterators.ts","node_modules/@loaders.gl/loader-utils/src/lib/iterators/async-iteration.ts","node_modules/@loaders.gl/loader-utils/src/lib/request-utils/request-scheduler.ts","node_modules/@probe.gl/stats/src/index.js","node_modules/@probe.gl/stats/src/lib/stats.js","node_modules/@probe.gl/stats/src/lib/stat.js","node_modules/@probe.gl/stats/src/utils/hi-res-timestamp.js","node_modules/@loaders.gl/loader-utils/src/lib/path-utils/file-aliases.ts","node_modules/@loaders.gl/loader-utils/src/json-loader.ts","node_modules/@loaders.gl/loader-utils/src/lib/path-utils/path.ts","node_modules/@loaders.gl/loader-utils/src/lib/filesystems/node-filesystem.ts","node_modules/@loaders.gl/core/src/lib/utils/response-utils.ts","node_modules/@loaders.gl/core/src/javascript-utils/is-type.ts","node_modules/@loaders.gl/core/src/lib/utils/resource-utils.ts","node_modules/@loaders.gl/core/src/lib/utils/mime-type-utils.ts","node_modules/@loaders.gl/core/src/lib/fetch/read-array-buffer.ts","node_modules/@loaders.gl/core/src/lib/fetch/read-file.ts","node_modules/@loaders.gl/core/src/lib/fetch/write-file.ts","node_modules/@loaders.gl/core/src/lib/api/set-loader-options.ts","node_modules/@loaders.gl/core/src/lib/loader-utils/option-utils.ts","node_modules/@loaders.gl/core/src/lib/loader-utils/loggers.ts","node_modules/probe.gl/src/index.js","node_modules/probe.gl/src/init.js","node_modules/probe.gl/src/utils/globals.js","node_modules/probe.gl/src/env/is-browser.js","node_modules/probe.gl/src/env/is-electron.js","node_modules/probe.gl/src/env/globals.js","node_modules/probe.gl/src/lib/log.js","node_modules/probe.gl/src/utils/local-storage.js","node_modules/probe.gl/src/utils/formatters.js","node_modules/probe.gl/src/utils/color.js","node_modules/probe.gl/src/utils/autobind.js","node_modules/probe.gl/src/utils/assert.js","node_modules/probe.gl/src/utils/hi-res-timestamp.js","node_modules/probe.gl/src/env/get-browser.js","node_modules/@loaders.gl/core/src/lib/loader-utils/option-defaults.ts","node_modules/@loaders.gl/core/src/lib/api/register-loaders.ts","node_modules/@loaders.gl/core/src/lib/loader-utils/normalize-loader.ts","node_modules/@loaders.gl/core/src/lib/api/select-loader.ts","node_modules/@loaders.gl/core/src/lib/api/parse.ts","node_modules/@loaders.gl/core/src/lib/loader-utils/get-data.ts","node_modules/@loaders.gl/core/src/iterators/make-iterator/make-iterator.ts","node_modules/@loaders.gl/core/src/iterators/make-iterator/make-string-iterator.ts","node_modules/@loaders.gl/core/src/iterators/make-iterator/make-array-buffer-iterator.ts","node_modules/@loaders.gl/core/src/iterators/make-iterator/make-blob-iterator.ts","node_modules/@loaders.gl/core/src/iterators/make-iterator/make-stream-iterator.ts","node_modules/@loaders.gl/core/src/lib/loader-utils/loader-context.ts","node_modules/@loaders.gl/core/src/lib/api/parse-sync.ts","node_modules/@loaders.gl/core/src/lib/api/parse-in-batches.ts","node_modules/@loaders.gl/core/src/lib/api/load.ts","node_modules/@loaders.gl/core/src/lib/api/load-in-batches.ts","node_modules/@loaders.gl/core/src/lib/api/encode.ts","node_modules/@loaders.gl/core/src/lib/api/save.ts","node_modules/@loaders.gl/core/src/iterators/make-stream/make-stream.ts","node_modules/@loaders.gl/core/src/iterators/make-stream/make-dom-stream.ts","node_modules/@loaders.gl/core/src/null-loader.ts","node_modules/@loaders.gl/core/src/lib/progress/fetch-progress.ts","node_modules/@loaders.gl/core/src/lib/filesystems/browser-filesystem.ts","node_modules/@loaders.gl/images/src/index.ts","node_modules/@loaders.gl/images/src/image-loader.ts","node_modules/@loaders.gl/images/src/lib/utils/version.ts","node_modules/@loaders.gl/images/src/lib/parsers/parse-image.ts","node_modules/@loaders.gl/images/src/lib/utils/assert.js","node_modules/@loaders.gl/images/src/lib/category-api/image-type.ts","node_modules/@loaders.gl/images/src/lib/utils/globals.ts","node_modules/@loaders.gl/images/src/lib/category-api/parsed-image-api.ts","node_modules/@loaders.gl/images/src/lib/parsers/parse-to-image.ts","node_modules/@loaders.gl/images/src/lib/parsers/svg-utils.ts","node_modules/@loaders.gl/images/src/lib/parsers/parse-to-image-bitmap.ts","node_modules/@loaders.gl/images/src/lib/parsers/parse-to-node-image.ts","node_modules/@loaders.gl/images/src/lib/category-api/binary-image-api.ts","node_modules/@loaders.gl/images/src/image-writer.ts","node_modules/@loaders.gl/images/src/lib/encoders/encode-image.ts","node_modules/@loaders.gl/images/src/lib/texture-api/load-image.ts","node_modules/@loaders.gl/images/src/lib/texture-api/generate-url.ts","node_modules/@loaders.gl/images/src/lib/texture-api/deep-load.ts","node_modules/@loaders.gl/images/src/lib/texture-api/async-deep-map.ts","node_modules/probe.gl/env.js","node_modules/probe.gl/src/env/index.js","node_modules/@babel/runtime/helpers/interopRequireDefault.js","node_modules/@babel/runtime/helpers/typeof.js","node_modules/@deck.gl/core/src/utils/log.js","node_modules/@deck.gl/core/src/debug/index.js","node_modules/@deck.gl/core/src/debug/loggers.js","node_modules/@deck.gl/core/src/utils/json-loader.js","node_modules/@deck.gl/core/src/shaderlib/index.js","node_modules/@luma.gl/core/src/index.js","node_modules/@luma.gl/gltools/src/index.js","node_modules/@luma.gl/gltools/src/utils/log.js","node_modules/@luma.gl/gltools/src/utils/webgl-checks.js","node_modules/@luma.gl/gltools/src/utils/assert.js","node_modules/@luma.gl/gltools/src/polyfill/polyfill-context.js","node_modules/@luma.gl/gltools/src/polyfill/polyfill-vertex-array-object.js","node_modules/@luma.gl/gltools/src/polyfill/polyfill-table.js","node_modules/@luma.gl/gltools/src/polyfill/get-parameter-polyfill.js","node_modules/@luma.gl/gltools/src/state-tracker/unified-parameter-api.js","node_modules/@luma.gl/gltools/src/state-tracker/webgl-parameter-tables.js","node_modules/@luma.gl/gltools/src/state-tracker/track-context-state.js","node_modules/@luma.gl/gltools/src/utils/utils.js","node_modules/@luma.gl/gltools/src/context/context.js","node_modules/@luma.gl/gltools/src/utils/device-pixels.js","node_modules/@luma.gl/webgl/src/index.js","node_modules/@luma.gl/webgl/src/init.js","node_modules/@luma.gl/webgl/src/webgl-utils/request-animation-frame.js","node_modules/@luma.gl/webgl/src/webgl-utils/texture-utils.js","node_modules/@luma.gl/webgl/src/classes/texture-2d.js","node_modules/@luma.gl/webgl/src/classes/texture.js","node_modules/@luma.gl/webgl/src/classes/resource.js","node_modules/@luma.gl/webgl/src/webgl-utils/constants-to-keys.js","node_modules/@luma.gl/webgl/src/utils/assert.js","node_modules/@luma.gl/webgl/src/utils/utils.js","node_modules/@luma.gl/webgl/src/utils/stub-methods.js","node_modules/@luma.gl/webgl/src/classes/buffer.js","node_modules/@luma.gl/webgl/src/classes/accessor.js","node_modules/@luma.gl/webgl/src/webgl-utils/typed-array-utils.js","node_modules/@luma.gl/webgl/src/utils/check-props.js","node_modules/@luma.gl/webgl/src/classes/texture-formats.js","node_modules/@luma.gl/webgl/src/utils/load-file.js","node_modules/@luma.gl/webgl/src/classes/texture-cube.js","node_modules/@luma.gl/webgl/src/classes/texture-3d.js","node_modules/@luma.gl/webgl/src/classes/framebuffer.js","node_modules/@luma.gl/webgl/src/classes/renderbuffer.js","node_modules/@luma.gl/webgl/src/classes/renderbuffer-formats.js","node_modules/@luma.gl/webgl/src/classes/clear.js","node_modules/@luma.gl/webgl/src/classes/copy-and-blit.js","node_modules/@luma.gl/webgl/src/webgl-utils/format-utils.js","node_modules/@luma.gl/webgl/src/features/index.js","node_modules/@luma.gl/webgl/src/features/limits.js","node_modules/@luma.gl/webgl/src/features/webgl-limits-table.js","node_modules/@luma.gl/webgl/src/features/webgl-features-table.js","node_modules/@luma.gl/webgl/src/features/features.js","node_modules/@luma.gl/webgl/src/features/check-glsl-extension.js","node_modules/@luma.gl/webgl/src/features/check-old-ie.js","node_modules/@luma.gl/webgl/src/classes/shader.js","node_modules/@luma.gl/webgl/src/glsl-utils/index.js","node_modules/@luma.gl/webgl/src/glsl-utils/format-glsl-error.js","node_modules/@luma.gl/webgl/src/glsl-utils/get-shader-name.js","node_modules/@luma.gl/webgl/src/glsl-utils/get-shader-type-name.js","node_modules/@luma.gl/webgl/src/glsl-utils/get-shader-version.js","node_modules/@luma.gl/webgl/src/classes/program.js","node_modules/@luma.gl/webgl/src/classes/uniforms.js","node_modules/@luma.gl/webgl/src/classes/program-configuration.js","node_modules/@luma.gl/webgl/src/webgl-utils/attribute-utils.js","node_modules/@luma.gl/webgl/src/classes/query.js","node_modules/@luma.gl/webgl/src/classes/transform-feedback.js","node_modules/@luma.gl/webgl/src/classes/vertex-array-object.js","node_modules/@luma.gl/webgl/src/utils/array-utils-flat.js","node_modules/@luma.gl/webgl/src/classes/vertex-array.js","node_modules/@luma.gl/webgl/src/classes/uniform-buffer-layout.js","node_modules/@luma.gl/webgl/src/debug/debug-uniforms.js","node_modules/@luma.gl/webgl/src/utils/format-value.js","node_modules/@luma.gl/webgl/src/debug/debug-vertex-array.js","node_modules/@luma.gl/webgl/src/debug/debug-program-configuration.js","node_modules/@luma.gl/engine/src/index.js","node_modules/@luma.gl/engine/src/lib/animation-loop.js","node_modules/@luma.gl/engine/src/lib/model.js","node_modules/@luma.gl/engine/src/lib/program-manager.js","node_modules/@luma.gl/shadertools/src/index.js","node_modules/@luma.gl/shadertools/src/lib/assemble-shaders.js","node_modules/@luma.gl/shadertools/src/lib/constants.js","node_modules/@luma.gl/shadertools/src/lib/resolve-modules.js","node_modules/@luma.gl/shadertools/src/lib/shader-module.js","node_modules/@luma.gl/shadertools/src/utils/index.js","node_modules/@luma.gl/shadertools/src/utils/assert.js","node_modules/@luma.gl/shadertools/src/lib/filters/prop-types.js","node_modules/@luma.gl/shadertools/src/lib/platform-defines.js","node_modules/@luma.gl/shadertools/src/utils/webgl-info.js","node_modules/@luma.gl/shadertools/src/utils/is-old-ie.js","node_modules/@luma.gl/shadertools/src/lib/inject-shader.js","node_modules/@luma.gl/shadertools/src/modules/module-injectors.js","node_modules/@luma.gl/shadertools/src/lib/transpile-shader.js","node_modules/@luma.gl/shadertools/src/utils/shader-utils.js","node_modules/@luma.gl/shadertools/src/modules/index.js","node_modules/@luma.gl/shadertools/src/modules/utils/random.js","node_modules/@luma.gl/shadertools/src/modules/fp32/fp32.js","node_modules/@luma.gl/shadertools/src/modules/fp64/fp64.js","node_modules/@luma.gl/shadertools/src/modules/fp64/fp64-utils.js","node_modules/@luma.gl/shadertools/src/modules/project/project.js","node_modules/@math.gl/core/src/index.js","node_modules/@math.gl/core/src/lib/common.js","node_modules/@math.gl/core/src/lib/assert.js","node_modules/@math.gl/core/src/classes/vector2.js","node_modules/@math.gl/core/src/classes/base/vector.js","node_modules/@math.gl/core/src/classes/base/math-array.js","node_modules/@math.gl/core/src/lib/validators.js","node_modules/gl-matrix/esm/vec2.js","node_modules/gl-matrix/esm/common.js","node_modules/@math.gl/core/src/lib/gl-matrix-extras.js","node_modules/@math.gl/core/src/classes/vector3.js","node_modules/gl-matrix/esm/vec3.js","node_modules/@math.gl/core/src/classes/vector4.js","node_modules/@math.gl/core/src/classes/matrix3.js","node_modules/@math.gl/core/src/classes/base/matrix.js","node_modules/gl-matrix/esm/mat3.js","node_modules/@math.gl/core/src/classes/matrix4.js","node_modules/gl-matrix/esm/mat4.js","node_modules/gl-matrix/esm/vec4.js","node_modules/@math.gl/core/src/classes/quaternion.js","node_modules/gl-matrix/esm/quat.js","node_modules/@math.gl/core/src/lib/math-utils.js","node_modules/@math.gl/core/src/classes/spherical-coordinates.js","node_modules/@math.gl/core/src/classes/pose.js","node_modules/@math.gl/core/src/classes/euler.js","node_modules/@luma.gl/shadertools/src/modules/lights/lights.js","node_modules/@luma.gl/shadertools/src/modules/dirlight/dirlight.js","node_modules/@luma.gl/shadertools/src/modules/picking/picking.js","node_modules/@luma.gl/shadertools/src/modules/phong-lighting/phong-lighting.js","node_modules/@luma.gl/shadertools/src/modules/pbr/pbr.js","node_modules/@luma.gl/shadertools/src/modules/image-blur-filters/tiltshift.js","node_modules/@luma.gl/shadertools/src/modules/image-blur-filters/triangleblur.js","node_modules/@luma.gl/shadertools/src/modules/image-blur-filters/zoomblur.js","node_modules/@luma.gl/shadertools/src/modules/image-adjust-filters/brightnesscontrast.js","node_modules/@luma.gl/shadertools/src/modules/image-adjust-filters/denoise.js","node_modules/@luma.gl/shadertools/src/modules/image-adjust-filters/huesaturation.js","node_modules/@luma.gl/shadertools/src/modules/image-adjust-filters/noise.js","node_modules/@luma.gl/shadertools/src/modules/image-adjust-filters/sepia.js","node_modules/@luma.gl/shadertools/src/modules/image-adjust-filters/vibrance.js","node_modules/@luma.gl/shadertools/src/modules/image-adjust-filters/vignette.js","node_modules/@luma.gl/shadertools/src/modules/image-fun-filters/colorhalftone.js","node_modules/@luma.gl/shadertools/src/modules/image-fun-filters/dotscreen.js","node_modules/@luma.gl/shadertools/src/modules/image-fun-filters/edgework.js","node_modules/@luma.gl/shadertools/src/modules/image-fun-filters/hexagonalpixelate.js","node_modules/@luma.gl/shadertools/src/modules/image-fun-filters/ink.js","node_modules/@luma.gl/shadertools/src/modules/image-fun-filters/magnify.js","node_modules/@luma.gl/shadertools/src/modules/image-warp-filters/bulgepinch.js","node_modules/@luma.gl/shadertools/src/modules/image-warp-filters/warp.js","node_modules/@luma.gl/shadertools/src/modules/image-warp-filters/swirl.js","node_modules/@luma.gl/shadertools/src/modules/fxaa/fxaa.js","node_modules/@luma.gl/shadertools/src/modules/transform/transform.js","node_modules/@luma.gl/engine/src/lib/model-utils.js","node_modules/@luma.gl/engine/src/transform/transform.js","node_modules/@luma.gl/engine/src/transform/buffer-transform.js","node_modules/@luma.gl/engine/src/transform/texture-transform.js","node_modules/@luma.gl/engine/src/transform/transform-shader-utils.js","node_modules/@luma.gl/engine/src/geometry/geometry.js","node_modules/@luma.gl/engine/src/geometries/cone-geometry.js","node_modules/@luma.gl/engine/src/geometries/truncated-cone-geometry.js","node_modules/@luma.gl/engine/src/geometries/cube-geometry.js","node_modules/@luma.gl/engine/src/geometries/cylinder-geometry.js","node_modules/@luma.gl/engine/src/geometries/ico-sphere-geometry.js","node_modules/@luma.gl/engine/src/geometries/plane-geometry.js","node_modules/@luma.gl/engine/src/geometry/geometry-utils.js","node_modules/@luma.gl/engine/src/geometries/sphere-geometry.js","node_modules/@luma.gl/engine/src/animation/timeline.js","node_modules/@luma.gl/engine/src/animation/key-frames.js","node_modules/@luma.gl/engine/src/utils/clip-space.js","node_modules/@deck.gl/core/src/shaderlib/project/project.js","node_modules/@deck.gl/core/src/shaderlib/misc/geometry.js","node_modules/@deck.gl/core/src/shaderlib/project/project.glsl.js","node_modules/@deck.gl/core/src/lib/constants.js","node_modules/@deck.gl/core/src/shaderlib/project/viewport-uniforms.js","node_modules/@deck.gl/core/src/utils/memoize.js","node_modules/@deck.gl/core/src/shaderlib/project32/project32.js","node_modules/@deck.gl/core/src/shaderlib/shadow/shadow.js","node_modules/math.gl/src/index.js","node_modules/@math.gl/web-mercator/src/index.js","node_modules/@math.gl/web-mercator/src/web-mercator-viewport.js","node_modules/@math.gl/web-mercator/src/math-utils.js","node_modules/@math.gl/web-mercator/src/web-mercator-utils.js","node_modules/@math.gl/web-mercator/src/assert.js","node_modules/@math.gl/web-mercator/src/fit-bounds.js","node_modules/@math.gl/web-mercator/src/get-bounds.js","node_modules/@math.gl/web-mercator/src/normalize-viewport-props.js","node_modules/@math.gl/web-mercator/src/fly-to-viewport.js","node_modules/@deck.gl/core/src/shaderlib/picking/picking.js","node_modules/@deck.gl/core/src/effects/lighting/lighting-effect.js","node_modules/@deck.gl/core/src/effects/lighting/ambient-light.js","node_modules/@deck.gl/core/src/effects/lighting/directional-light.js","node_modules/@deck.gl/core/src/lib/effect.js","node_modules/@deck.gl/core/src/passes/shadow-pass.js","node_modules/@deck.gl/core/src/passes/layers-pass.js","node_modules/@deck.gl/core/src/passes/pass.js","node_modules/@deck.gl/core/src/effects/lighting/point-light.js","node_modules/@deck.gl/core/src/shaderlib/project/project-functions.js","node_modules/@deck.gl/core/src/viewports/web-mercator-viewport.js","node_modules/@deck.gl/core/src/viewports/viewport.js","node_modules/@deck.gl/core/src/utils/math-utils.js","node_modules/@deck.gl/core/src/utils/typed-array-manager.js","node_modules/@deck.gl/core/src/lib/index.js","node_modules/@deck.gl/core/src/lib/deck.js","node_modules/@deck.gl/core/src/lib/layer-manager.js","node_modules/@deck.gl/core/src/lifecycle/constants.js","node_modules/@deck.gl/core/src/utils/flatten.js","node_modules/@deck.gl/core/src/lib/resource/resource-manager.js","node_modules/@deck.gl/core/src/lib/resource/resource.js","node_modules/@deck.gl/core/src/lib/view-manager.js","node_modules/@deck.gl/core/src/utils/deep-equal.js","node_modules/@deck.gl/core/src/views/map-view.js","node_modules/@deck.gl/core/src/views/view.js","node_modules/@deck.gl/core/src/utils/positions.js","node_modules/@deck.gl/core/src/utils/assert.js","node_modules/@deck.gl/core/src/controllers/map-controller.js","node_modules/@deck.gl/core/src/controllers/controller.js","node_modules/@deck.gl/core/src/controllers/transition-manager.js","node_modules/@deck.gl/core/src/transitions/transition.js","node_modules/@deck.gl/core/src/transitions/linear-interpolator.js","node_modules/@deck.gl/core/src/transitions/transition-interpolator.js","node_modules/@deck.gl/core/src/controllers/view-state.js","node_modules/@deck.gl/core/src/lib/effect-manager.js","node_modules/@deck.gl/core/src/lib/deck-renderer.js","node_modules/@deck.gl/core/src/passes/draw-layers-pass.js","node_modules/@deck.gl/core/src/passes/pick-layers-pass.js","node_modules/@deck.gl/core/src/lib/deck-picker.js","node_modules/@deck.gl/core/src/lib/picking/query-object.js","node_modules/@deck.gl/core/src/lib/picking/pick-info.js","node_modules/@deck.gl/core/src/lib/tooltip.js","node_modules/mjolnir.js/src/index.js","node_modules/mjolnir.js/src/event-manager.js","node_modules/@babel/runtime/helpers/esm/slicedToArray.js","node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","node_modules/@babel/runtime/helpers/esm/classCallCheck.js","node_modules/@babel/runtime/helpers/esm/createClass.js","node_modules/mjolnir.js/src/utils/hammer.browser.js","node_modules/hammerjs/hammer.js","node_modules/mjolnir.js/src/utils/hammer-overrides.js","node_modules/mjolnir.js/src/inputs/wheel-input.js","node_modules/mjolnir.js/src/constants.js","node_modules/mjolnir.js/src/utils/globals.js","node_modules/mjolnir.js/src/inputs/move-input.js","node_modules/mjolnir.js/src/inputs/key-input.js","node_modules/mjolnir.js/src/inputs/contextmenu-input.js","node_modules/mjolnir.js/src/utils/event-registrar.js","node_modules/@babel/runtime/helpers/esm/typeof.js","node_modules/mjolnir.js/src/utils/event-utils.js","node_modules/@deck.gl/core/src/lib/layer.js","node_modules/@deck.gl/core/src/lib/attribute/attribute-manager.js","node_modules/@deck.gl/core/src/lib/attribute/attribute.js","node_modules/@deck.gl/core/src/lib/attribute/data-column.js","node_modules/@deck.gl/core/src/lib/attribute/shader-attribute.js","node_modules/@deck.gl/core/src/lib/attribute/gl-utils.js","node_modules/@deck.gl/core/src/utils/iterable-utils.js","node_modules/@deck.gl/core/src/utils/range.js","node_modules/@deck.gl/core/src/lib/attribute/attribute-transition-utils.js","node_modules/@deck.gl/core/src/utils/array-utils.js","node_modules/@deck.gl/core/src/lib/attribute/attribute-transition-manager.js","node_modules/@deck.gl/core/src/transitions/gpu-interpolation-transition.js","node_modules/@deck.gl/core/src/transitions/gpu-spring-transition.js","node_modules/@deck.gl/core/src/lib/uniform-transition-manager.js","node_modules/@deck.gl/core/src/transitions/cpu-interpolation-transition.js","node_modules/@deck.gl/core/src/transitions/cpu-spring-transition.js","node_modules/@deck.gl/core/src/lifecycle/props.js","node_modules/@deck.gl/core/src/utils/count.js","node_modules/@deck.gl/core/src/utils/shader.js","node_modules/@deck.gl/core/src/lifecycle/component.js","node_modules/@deck.gl/core/src/lifecycle/create-props.js","node_modules/@deck.gl/core/src/lifecycle/prop-types.js","node_modules/@deck.gl/core/src/utils/texture.js","node_modules/@deck.gl/core/src/lifecycle/component-state.js","node_modules/@deck.gl/core/src/lib/layer-state.js","node_modules/@deck.gl/core/src/lib/composite-layer.js","node_modules/@deck.gl/core/src/lib/layer-extension.js","node_modules/@deck.gl/core/src/effects/lighting/camera-light.js","node_modules/@deck.gl/core/src/effects/lighting/sun-light.js","node_modules/@deck.gl/core/src/effects/lighting/suncalc.js","node_modules/@deck.gl/core/src/effects/post-process-effect.js","node_modules/@deck.gl/core/src/passes/screen-pass.js","node_modules/@deck.gl/core/src/viewports/globe-viewport.js","node_modules/@deck.gl/core/src/views/first-person-view.js","node_modules/@deck.gl/core/src/controllers/first-person-controller.js","node_modules/@deck.gl/core/src/views/orbit-view.js","node_modules/@deck.gl/core/src/controllers/orbit-controller.js","node_modules/@deck.gl/core/src/views/orthographic-view.js","node_modules/@deck.gl/core/src/controllers/orthographic-controller.js","node_modules/@deck.gl/core/src/views/globe-view.js","node_modules/@deck.gl/core/src/controllers/globe-controller.js","node_modules/@deck.gl/core/src/transitions/viewport-fly-to-interpolator.js","node_modules/@deck.gl/core/src/utils/tesselator.js","node_modules/@deck.gl/layers/src/scatterplot-layer/scatterplot-layer.js","node_modules/@deck.gl/layers/src/scatterplot-layer/scatterplot-layer-vertex.glsl.js","node_modules/@deck.gl/layers/src/scatterplot-layer/scatterplot-layer-fragment.glsl.js","node_modules/@deck.gl/mesh-layers/src/simple-mesh-layer/simple-mesh-layer.js","node_modules/@deck.gl/mesh-layers/src/utils/matrix.js","node_modules/@deck.gl/mesh-layers/src/simple-mesh-layer/simple-mesh-layer-vertex.glsl.js","node_modules/@deck.gl/mesh-layers/src/simple-mesh-layer/simple-mesh-layer-fragment.glsl.js","node_modules/@mapbox/polyline/src/polyline.js","node_modules/kdbush/src/index.js","node_modules/kdbush/src/sort.js","node_modules/kdbush/src/range.js","node_modules/kdbush/src/within.js","node_modules/geokdbush/index.js","node_modules/tinyqueue/index.js","node_modules/just-throttle/index.js"],"sourcesContent":["import MapboxLayer from '@deck.gl/mapbox/dist/esm/mapbox-layer';\nimport { AmbientLight } from '@deck.gl/core/dist/esm/effects/lighting/ambient-light';\nimport SunLight from '@deck.gl/core/dist/esm/effects/lighting/sun-light';\nimport LightingEffect from '@deck.gl/core/dist/esm/effects/lighting/lighting-effect';\nimport ScatterplotLayer from '@deck.gl/layers/dist/esm/scatterplot-layer/scatterplot-layer';\n// import SolidPolygonLayer from '@deck.gl/layers/dist/esm/solid-polygon-layer/solid-polygon-layer';\nimport SimpleMeshLayer from '@deck.gl/mesh-layers/dist/esm/simple-mesh-layer/simple-mesh-layer';\nimport TruncatedConeGeometry from '@luma.gl/engine/dist/esm/geometries/truncated-cone-geometry';\nimport SphereGeometry from '@luma.gl/engine/dist/esm/geometries/sphere-geometry';\nimport polyline from '@mapbox/polyline';\nimport KDBush from 'kdbush';\nimport geokdbush from 'geokdbush';\n// import circle from '@turf/circle';\nimport throttle from 'just-throttle';\n\nexport {\n  MapboxLayer,\n  AmbientLight,\n  SunLight,\n  LightingEffect,\n  ScatterplotLayer,\n  // SolidPolygonLayer,\n  SimpleMeshLayer,\n  SphereGeometry,\n  TruncatedConeGeometry,\n  polyline,\n  KDBush,\n  geokdbush,\n  // circle,\n  throttle,\n};\n","import {getDeckInstance, addLayer, removeLayer, updateLayer, drawLayer} from './deck-utils';\n\nexport default class MapboxLayer {\n  /* eslint-disable no-this-before-super */\n  constructor(props) {\n    if (!props.id) {\n      throw new Error('Layer must have an unique id');\n    }\n\n    this.id = props.id;\n    this.type = 'custom';\n    this.renderingMode = props.renderingMode || '3d';\n    this.map = null;\n    this.deck = null;\n    this.props = props;\n  }\n\n  /* Mapbox custom layer methods */\n\n  onAdd(map, gl) {\n    this.map = map;\n    this.deck = getDeckInstance({map, gl, deck: this.props.deck});\n    addLayer(this.deck, this);\n  }\n\n  onRemove() {\n    removeLayer(this.deck, this);\n  }\n\n  setProps(props) {\n    // id cannot be changed\n    Object.assign(this.props, props, {id: this.id});\n    // safe guard in case setProps is called before onAdd\n    if (this.deck) {\n      updateLayer(this.deck, this);\n    }\n  }\n\n  render(gl, matrix) {\n    drawLayer(this.deck, this.map, this);\n  }\n}\n","import {Deck, WebMercatorViewport} from '@deck.gl/core';\n\nexport function getDeckInstance({map, gl, deck}) {\n  // Only create one deck instance per context\n  if (map.__deck) {\n    return map.__deck;\n  }\n\n  const customRender = deck && deck.props._customRender;\n\n  const deckProps = {\n    useDevicePixels: true,\n    _customRender: () => {\n      map.triggerRepaint();\n      if (customRender) {\n        // customRender may be subscribed by DeckGL React component to update child props\n        // make sure it is still called\n        customRender();\n      }\n    },\n    // TODO: import these defaults from a single source of truth\n    parameters: {\n      depthMask: true,\n      depthTest: true,\n      blendFunc: [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA],\n      blendEquation: gl.FUNC_ADD\n    },\n    userData: {\n      isExternal: false,\n      mapboxLayers: new Set()\n    }\n  };\n\n  if (deck) {\n    deck.setProps(deckProps);\n    deck.props.userData.isExternal = true;\n  } else {\n    // Using external gl context - do not set css size\n    Object.assign(deckProps, {\n      gl,\n      width: false,\n      height: false,\n      touchAction: 'unset',\n      viewState: getViewState(map)\n    });\n    deck = new Deck(deckProps);\n\n    // If deck is externally provided (React use case), we use deck's viewState to\n    // drive the map.\n    // Otherwise (pure JS use case), we use the map's viewState to drive deck.\n    map.on('move', () => onMapMove(deck, map));\n    map.on('remove', () => {\n      deck.finalize();\n      map.__deck = null;\n    });\n  }\n  deck.props.userData.mapboxVersion = getMapboxVersion(map);\n  map.__deck = deck;\n  map.on('render', () => {\n    if (deck.layerManager) afterRender(deck, map);\n  });\n\n  return deck;\n}\n\nexport function addLayer(deck, layer) {\n  deck.props.userData.mapboxLayers.add(layer);\n  updateLayers(deck);\n}\n\nexport function removeLayer(deck, layer) {\n  deck.props.userData.mapboxLayers.delete(layer);\n  updateLayers(deck);\n}\n\nexport function updateLayer(deck, layer) {\n  updateLayers(deck);\n}\n\nexport function drawLayer(deck, map, layer) {\n  let {currentViewport} = deck.props.userData;\n  if (!currentViewport) {\n    // This is the first layer drawn in this render cycle.\n    // Generate viewport from the current map state.\n    currentViewport = getViewport(deck, map, true);\n    deck.props.userData.currentViewport = currentViewport;\n  }\n  if (!deck.layerManager) {\n    return;\n  }\n  deck._drawLayers('mapbox-repaint', {\n    viewports: [currentViewport],\n    layerFilter: ({layer: deckLayer}) => layer.id === deckLayer.id,\n    clearCanvas: false\n  });\n}\n\nfunction getViewState(map) {\n  const {lng, lat} = map.getCenter();\n  return {\n    longitude: lng,\n    latitude: lat,\n    zoom: map.getZoom(),\n    bearing: map.getBearing(),\n    pitch: map.getPitch()\n  };\n}\n\nfunction getMapboxVersion(map) {\n  // parse mapbox version string\n  let major = 0;\n  let minor = 0;\n  if (map.version) {\n    [major, minor] = map.version\n      .split('.')\n      .slice(0, 2)\n      .map(Number);\n  }\n  return {major, minor};\n}\n\nfunction getViewport(deck, map, useMapboxProjection = true) {\n  const {mapboxVersion} = deck.props.userData;\n\n  return new WebMercatorViewport(\n    Object.assign(\n      {\n        x: 0,\n        y: 0,\n        width: deck.width,\n        height: deck.height,\n        repeat: true\n      },\n      getViewState(map),\n      useMapboxProjection\n        ? {\n            // match mapbox's projection matrix\n            // A change of near plane was made in 1.3.0\n            // https://github.com/mapbox/mapbox-gl-js/pull/8502\n            nearZMultiplier:\n              (mapboxVersion.major === 1 && mapboxVersion.minor >= 3) || mapboxVersion.major >= 2\n                ? 0.02\n                : 1 / (deck.height || 1)\n          }\n        : {\n            // use deck.gl's own default\n            nearZMultiplier: 0.1\n          }\n    )\n  );\n}\n\nfunction afterRender(deck, map) {\n  const {mapboxLayers, isExternal} = deck.props.userData;\n\n  if (isExternal) {\n    // Draw non-Mapbox layers\n    const mapboxLayerIds = Array.from(mapboxLayers, layer => layer.id);\n    const hasNonMapboxLayers = deck.props.layers.some(layer => !mapboxLayerIds.includes(layer.id));\n    if (hasNonMapboxLayers) {\n      deck._drawLayers('mapbox-repaint', {\n        viewports: [getViewport(deck, map, false)],\n        layerFilter: ({layer}) => !mapboxLayerIds.includes(layer.id),\n        clearCanvas: false\n      });\n    }\n  }\n\n  // End of render cycle, clear generated viewport\n  deck.props.userData.currentViewport = null;\n}\n\nfunction onMapMove(deck, map) {\n  deck.setProps({\n    viewState: getViewState(map)\n  });\n  // Camera changed, will trigger a map repaint right after this\n  // Clear any change flag triggered by setting viewState so that deck does not request\n  // a second repaint\n  deck.needsRedraw({clearRedrawFlags: true});\n}\n\nfunction updateLayers(deck) {\n  if (deck.props.userData.isExternal) {\n    return;\n  }\n\n  const layers = [];\n  deck.props.userData.mapboxLayers.forEach(deckLayer => {\n    const LayerType = deckLayer.props.type;\n    const layer = new LayerType(deckLayer.props);\n    layers.push(layer);\n  });\n  deck.setProps({layers});\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n/* eslint-disable max-len */\n\n// Intialize globals, check version\nimport './lib/init';\n\n// Import shaderlib to make sure shader modules are initialized\nimport './shaderlib';\n\n// Core Library\nexport {COORDINATE_SYSTEM, UNIT} from './lib/constants';\n\n// Effects\nexport {default as LightingEffect} from './effects/lighting/lighting-effect';\nexport {AmbientLight} from './effects/lighting/ambient-light';\nexport {DirectionalLight} from './effects/lighting/directional-light';\nexport {PointLight} from './effects/lighting/point-light';\nexport {default as _CameraLight} from './effects/lighting/camera-light';\nexport {default as _SunLight} from './effects/lighting/sun-light';\nexport {default as PostProcessEffect} from './effects/post-process-effect';\n\n// Passes\nexport {default as _LayersPass} from './passes/layers-pass';\n\n// Experimental Pure JS (non-React) bindings\nexport {default as Deck} from './lib/deck';\n\nexport {default as LayerManager} from './lib/layer-manager';\nexport {default as AttributeManager} from './lib/attribute/attribute-manager';\nexport {default as Layer} from './lib/layer';\nexport {default as CompositeLayer} from './lib/composite-layer';\nexport {default as DeckRenderer} from './lib/deck-renderer';\n\n// Viewports\nexport {default as Viewport} from './viewports/viewport';\nexport {default as WebMercatorViewport} from './viewports/web-mercator-viewport';\nexport {default as _GlobeViewport} from './viewports/globe-viewport';\n\n// Shader modules\nexport {picking, project, project32, gouraudLighting, phongLighting, shadow} from './shaderlib';\n\nexport {default as View} from './views/view';\nexport {default as MapView} from './views/map-view';\nexport {default as FirstPersonView} from './views/first-person-view';\nexport {default as OrbitView} from './views/orbit-view';\nexport {default as OrthographicView} from './views/orthographic-view';\nexport {default as _GlobeView} from './views/globe-view';\n\n// Controllers\nexport {default as Controller} from './controllers/controller';\nexport {default as MapController} from './controllers/map-controller';\nexport {default as _GlobeController} from './controllers/globe-controller';\nexport {default as FirstPersonController} from './controllers/first-person-controller';\nexport {default as OrbitController} from './controllers/orbit-controller';\nexport {default as OrthographicController} from './controllers/orthographic-controller';\n\n// Extensions interface\nexport {default as Effect} from './lib/effect';\nexport {default as LayerExtension} from './lib/layer-extension';\n\n// Transitions\nexport {TRANSITION_EVENTS} from './controllers/transition-manager';\nexport {default as TransitionInterpolator} from './transitions/transition-interpolator';\nexport {default as LinearInterpolator} from './transitions/linear-interpolator';\nexport {default as FlyToInterpolator} from './transitions/viewport-fly-to-interpolator';\n\n// Layer utilities\nexport {default as log} from './utils/log';\nexport {createIterable} from './utils/iterable-utils';\nexport {fp64LowPart} from './utils/math-utils';\nexport {default as Tesselator} from './utils/tesselator'; // Export? move to luma.gl or math.gl?\n\n// Experimental utilities\nexport {fillArray as _fillArray, flatten as _flatten} from './utils/flatten'; // Export? move to luma.gl or math.gl?\nexport {count as _count} from './utils/count';\nexport {default as _memoize} from './utils/memoize';\nexport {mergeShaders as _mergeShaders} from './utils/shader';\nexport {compareProps as _compareProps} from './lifecycle/props';\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {registerLoaders} from '@loaders.gl/core';\nimport {ImageLoader} from '@loaders.gl/images';\n\nimport {global} from 'probe.gl/env';\nimport log from '../utils/log';\nimport {register} from '../debug';\nimport jsonLoader from '../utils/json-loader';\n\n// Version detection using babel plugin\n// Fallback for tests and SSR since global variable is defined by Webpack.\n/* global __VERSION__ */\nconst version =\n  typeof __VERSION__ !== 'undefined' ? __VERSION__ : global.DECK_VERSION || 'untranspiled source';\n\n// Note: a `deck` object not created by deck.gl may exist in the global scope\nconst existingVersion = global.deck && global.deck.VERSION;\n\nif (existingVersion && existingVersion !== version) {\n  throw new Error(`deck.gl - multiple versions detected: ${existingVersion} vs ${version}`);\n}\n\nif (!existingVersion) {\n  log.log(1, `deck.gl ${version}`)();\n\n  global.deck = Object.assign(global.deck || {}, {\n    VERSION: version,\n    version,\n    log,\n    // experimental\n    _registerLoggers: register\n  });\n\n  registerLoaders([jsonLoader, [ImageLoader, {imagebitmap: {premultiplyAlpha: 'none'}}]]);\n}\n\nexport default global.deck;\n","// FILE READING AND WRITING\nexport {fetchFile} from './lib/fetch/fetch-file';\n\nexport {readArrayBuffer} from './lib/fetch/read-array-buffer';\nexport {readFileSync} from './lib/fetch/read-file';\nexport {writeFile, writeFileSync} from './lib/fetch/write-file';\n\n// CONFIGURATION\nexport {setLoaderOptions} from './lib/api/set-loader-options';\nexport {registerLoaders} from './lib/api/register-loaders';\nexport {selectLoader, selectLoaderSync} from './lib/api/select-loader';\n\n// LOADING (READING + PARSING)\nexport {parse} from './lib/api/parse';\nexport {parseSync} from './lib/api/parse-sync';\nexport {parseInBatches} from './lib/api/parse-in-batches';\n\nexport {load} from './lib/api/load';\nexport {loadInBatches} from './lib/api/load-in-batches';\n\n// ENCODING (ENCODING AND WRITING)\nexport {encode, encodeSync, encodeInBatches, encodeText, encodeURLtoURL} from './lib/api/encode';\nexport {save, saveSync} from './lib/api/save';\n\n// CORE UTILS SHARED WITH LOADERS (RE-EXPORTED FROM LOADER-UTILS)\nexport {setPathPrefix, getPathPrefix, resolvePath} from '@loaders.gl/loader-utils';\nexport {RequestScheduler} from '@loaders.gl/loader-utils';\n\n// ITERATOR UTILS\nexport {makeIterator} from './iterators/make-iterator/make-iterator';\nexport {makeStream} from './iterators/make-stream/make-stream';\nexport {makeDOMStream} from './iterators/make-stream/make-dom-stream';\nexport {default as makeNodeStream} from './iterators/make-stream/make-node-stream';\n\n// CORE LOADERS\nexport {NullWorkerLoader, NullLoader} from './null-loader';\nexport {JSONLoader} from '@loaders.gl/loader-utils';\n\n// EXPERIMENTAL\nexport {default as _fetchProgress} from './lib/progress/fetch-progress';\nexport {default as _BrowserFileSystem} from './lib/filesystems/browser-filesystem';\n\n// FOR TESTING\nexport {_unregisterLoaders} from './lib/api/register-loaders';\n\n//\n// TODO - MOVE TO LOADER-UTILS AND DEPRECATE IN CORE?\n//\n\nexport {isBrowser, isWorker, self, window, global, document} from '@loaders.gl/loader-utils';\nexport {assert} from '@loaders.gl/loader-utils';\nexport {forEach, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\n\nexport {\n  makeTextDecoderIterator,\n  makeTextEncoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from '@loaders.gl/loader-utils';\n\n// \"JAVASCRIPT\" UTILS - move to loader-utils?\nexport {\n  isPureObject,\n  isPromise,\n  isIterable,\n  isAsyncIterable,\n  isIterator,\n  isResponse,\n  isReadableStream,\n  isWritableStream\n} from './javascript-utils/is-type';\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","// TYPES\nexport type {\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions,\n  Writer,\n  WriterOptions,\n  DataType,\n  SyncDataType,\n  BatchableDataType,\n  IFileSystem,\n  IRandomAccessReadFileSystem\n} from './types';\n\n// GENERAL UTILS\nexport {assert} from './lib/env-utils/assert';\nexport {\n  isBrowser,\n  isWorker,\n  nodeVersion,\n  self,\n  window,\n  global,\n  document\n} from './lib/env-utils/globals';\n\n// LOADERS.GL-SPECIFIC WORKER UTILS\nexport {createLoaderWorker} from './lib/worker-loader-utils/create-loader-worker';\nexport {parseWithWorker, canParseWithWorker} from './lib/worker-loader-utils/parse-with-worker';\n\n// PARSER UTILS\nexport {parseJSON} from './lib/parser-utils/parse-json';\n\n// MEMORY COPY UTILS\nexport {\n  toArrayBuffer,\n  sliceArrayBuffer,\n  concatenateArrayBuffers,\n  concatenateTypedArrays,\n  compareArrayBuffers\n} from './lib/binary-utils/array-buffer-utils';\nexport {padToNBytes, copyToArray, copyArrayBuffer} from './lib/binary-utils/memory-copy-utils';\nexport {\n  copyPaddedArrayBufferToDataView,\n  copyPaddedStringToDataView\n} from './lib/binary-utils/binary-copy-utils';\nexport {\n  padStringToByteAlignment,\n  copyStringToDataView,\n  copyBinaryToDataView\n} from './lib/binary-utils/encode-utils';\nexport {getFirstCharacters, getMagicString} from './lib/binary-utils/get-first-characters';\n\n// ITERATOR UTILS\nexport {\n  makeTextEncoderIterator,\n  makeTextDecoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from './lib/iterators/text-iterators';\nexport {forEach, concatenateArrayBuffersAsync} from './lib/iterators/async-iteration';\n\n// REQUEST UTILS\nexport {default as RequestScheduler} from './lib/request-utils/request-scheduler';\n\n// PATH HELPERS\nexport {setPathPrefix, getPathPrefix, resolvePath} from './lib/path-utils/file-aliases';\nexport {addAliases as _addAliases} from './lib/path-utils/file-aliases';\n\n// MICRO LOADERS\nexport {JSONLoader} from './json-loader';\n\n// NODE support\n\n// Node.js emulation (can be used in browser)\n\n// `path` replacement (avoids bundling big path polyfill)\nimport * as path from './lib/path-utils/path';\nexport {path};\n\n// Avoid direct use of `Buffer` which pulls in 50KB polyfill\nexport {isBuffer, toBuffer, bufferToArrayBuffer} from './lib/binary-utils/buffer-utils';\n\n// Note.js wrappers (can be safely imported, but not used in browser)\n\n// Use instead of importing 'util'\nimport * as util from './lib/node/util';\nexport {util};\n// TODO - remove\nexport {promisify} from './lib/node/util';\n\n// Use instead of importing 'fs';`\nimport * as fs from './lib/node/fs';\nexport {fs};\n\n// EXPERIMENTAL\nexport {default as _NodeFileSystem} from './lib/filesystems/node-filesystem';\n","/**\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","exports.interopDefault = function(a) {\n  return a && a.__esModule ? a : {default: a};\n};\n\nexports.defineInteropFlag = function(a) {\n  Object.defineProperty(a, '__esModule', {value: true});\n};\n\nexports.exportAll = function(source, dest) {\n  Object.keys(source).forEach(function(key) {\n    if (key === 'default' || key === '__esModule' || dest.hasOwnProperty(key)) {\n      return;\n    }\n\n    Object.defineProperty(dest, key, {\n      enumerable: true,\n      get: function() {\n        return source[key];\n      },\n    });\n  });\n\n  return dest;\n};\n\nexports.export = function(dest, destName, get) {\n  Object.defineProperty(dest, destName, {\n    enumerable: true,\n    get: get,\n  });\n};\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","// 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","/* eslint-disable no-restricted-globals */\nimport type {LoaderWithParser} from '../../types';\nimport {WorkerBody} from '@loaders.gl/worker-utils';\n// import {validateLoaderVersion} from './validate-loader-version';\n\nlet requestId = 0;\n\n/**\n * Set up a WebWorkerGlobalScope to talk with the main thread\n * @param loader\n */\nexport function createLoaderWorker(loader: LoaderWithParser) {\n  // Check that we are actually in a worker thread\n  if (typeof self === 'undefined') {\n    return;\n  }\n\n  WorkerBody.onmessage = async (type, payload) => {\n    switch (type) {\n      case 'process':\n        try {\n          // validateLoaderVersion(loader, data.source.split('@')[1]);\n\n          const {input, options = {}} = payload;\n\n          const result = await parseData({\n            loader,\n            arrayBuffer: input,\n            options,\n            context: {\n              parse: parseOnMainThread\n            }\n          });\n          WorkerBody.postMessage('done', {result});\n        } catch (error) {\n          const message = error instanceof Error ? error.message : '';\n          WorkerBody.postMessage('error', {error: message});\n        }\n        break;\n      default:\n    }\n  };\n}\n\nfunction parseOnMainThread(arrayBuffer: ArrayBuffer, options: {[key: string]: any}): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const id = requestId++;\n\n    /**\n     */\n    const onMessage = (type, payload) => {\n      if (payload.id !== id) {\n        // not ours\n        return;\n      }\n\n      switch (type) {\n        case 'done':\n          WorkerBody.removeEventListener(onMessage);\n          resolve(payload.result);\n          break;\n\n        case 'error':\n          WorkerBody.removeEventListener(onMessage);\n          reject(payload.error);\n          break;\n\n        default:\n        // ignore\n      }\n    };\n\n    WorkerBody.addEventListener(onMessage);\n\n    // Ask the main thread to decode data\n    const payload = {id, input: arrayBuffer, options};\n    WorkerBody.postMessage('process', payload);\n  });\n}\n\n// TODO - Support byteOffset and byteLength (enabling parsing of embedded binaries without copies)\n// TODO - Why not support async loader.parse* funcs here?\n// TODO - Why not reuse a common function instead of reimplementing loader.parse* selection logic? Keeping loader small?\n// TODO - Lack of appropriate parser functions can be detected when we create worker, no need to wait until parse\nasync function parseData({loader, arrayBuffer, options, context}) {\n  let data;\n  let parser;\n  if (loader.parseSync || loader.parse) {\n    data = arrayBuffer;\n    parser = loader.parseSync || loader.parse;\n  } else if (loader.parseTextSync) {\n    const textDecoder = new TextDecoder();\n    data = textDecoder.decode(arrayBuffer);\n    parser = loader.parseTextSync;\n  } else {\n    throw new Error(`Could not load data with ${loader.name} loader`);\n  }\n\n  // TODO - proper merge in of loader options...\n  options = {\n    ...options,\n    modules: (loader && loader.options && loader.options.modules) || {},\n    worker: false\n  };\n\n  return await parser(data, {...options}, context, loader);\n}\n","import type {WorkerObject} from './types';\nimport {VERSION} from './lib/env-utils/version';\n\n// TYPES\nexport type {\n  WorkerObject,\n  WorkerOptions,\n  // Protocol\n  WorkerMessage,\n  WorkerMessageType,\n  WorkerMessageData,\n  WorkerMessagePayload\n} from './types';\n\n// GENERAL UTILS\nexport {assert} from './lib/env-utils/assert';\nexport {isBrowser, isWorker} from './lib/env-utils/globals';\n\n// WORKER UTILS - TYPES\nexport {default as WorkerJob} from './lib/worker-farm/worker-job';\nexport {default as WorkerThread} from './lib/worker-farm/worker-thread';\n\n// WORKER FARMS\nexport {default as WorkerFarm} from './lib/worker-farm/worker-farm';\nexport {default as WorkerPool} from './lib/worker-farm/worker-pool';\nexport {default as WorkerBody} from './lib/worker-farm/worker-body';\n\nexport {processOnWorker, canProcessOnWorker} from './lib/worker-api/process-on-worker';\nexport {createWorker} from './lib/worker-api/create-worker';\n\n// WORKER UTILS - EXPORTS\nexport {getWorkerURL} from './lib/worker-api/get-worker-url';\nexport {validateWorkerVersion} from './lib/worker-api/validate-worker-version';\nexport {getTransferList} from './lib/worker-utils/get-transfer-list';\n\n// LIBRARY UTILS\nexport {getLibraryUrl, loadLibrary} from './lib/library-utils/library-utils';\n\n// PARSER UTILS\nexport {default as AsyncQueue} from './lib/async-queue/async-queue';\n\n// PROCESS UTILS\nexport {default as ChildProcessProxy} from './lib/process-utils/child-process-proxy';\n\n// WORKER OBJECTS\n\n/** A null worker to test that worker processing is functional */\nexport const NullWorker: WorkerObject = {\n  id: 'null',\n  name: 'null',\n  module: 'worker-utils',\n  version: VERSION,\n  options: {\n    null: {}\n  }\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","// 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","// 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","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","export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}","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}. `;\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 {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 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 {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 type {WorkerMessageData, WorkerMessageType, WorkerMessagePayload} from '../../types';\nimport {getTransferList} from '../worker-utils/get-transfer-list';\n\nconst onMessageWrapperMap = new Map();\n\n/**\n * Type safe wrapper for worker code\n */\nexport default class WorkerBody {\n  /*\n   * (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n   */\n  static set onmessage(onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any) {\n    // eslint-disable-next-line no-restricted-globals\n    self.onmessage = (message) => {\n      if (!isKnownMessage(message)) {\n        return;\n      }\n\n      // Confusingly the message itself also has a 'type' field which is always set to 'message'\n      const {type, payload} = message.data;\n      onMessage(type, payload);\n    };\n  }\n\n  static addEventListener(\n    onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n  ) {\n    let onMessageWrapper = onMessageWrapperMap.get(onMessage);\n\n    if (!onMessageWrapper) {\n      onMessageWrapper = (message) => {\n        if (!isKnownMessage(message)) {\n          return;\n        }\n\n        // Confusingly the message itself also has a 'type' field which is always set to 'message'\n        const {type, payload} = message.data;\n        onMessage(type, payload);\n      };\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    self.addEventListener('message', onMessageWrapper);\n  }\n\n  static removeEventListener(\n    onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n  ) {\n    const onMessageWrapper = onMessageWrapperMap.get(onMessage);\n    onMessageWrapperMap.delete(onMessage);\n    // eslint-disable-next-line no-restricted-globals\n    self.removeEventListener('message', onMessageWrapper);\n  }\n\n  /**\n   * Send a message from a worker to creating thread (main thread)\n   * @param type\n   * @param payload\n   */\n  static postMessage(type: WorkerMessageType, payload: WorkerMessagePayload): void {\n    if (self) {\n      const data: WorkerMessageData = {source: 'loaders.gl', type, payload};\n      const transferList = getTransferList(payload);\n      // eslint-disable-next-line no-restricted-globals\n      // @ts-ignore\n      self.postMessage(data, transferList);\n    }\n  }\n}\n\n// Filter out noise messages sent to workers\nfunction isKnownMessage(message) {\n  const {type, data} = message;\n  return (\n    type === 'message' &&\n    data &&\n    typeof data.source === 'string' &&\n    data.source.startsWith('loaders.gl')\n  );\n}\n","import type {\n  WorkerObject,\n  WorkerOptions,\n  WorkerContext,\n  WorkerMessageType,\n  WorkerMessagePayload\n} from '../../types';\nimport type WorkerJob from '../worker-farm/worker-job';\nimport WorkerFarm from '../worker-farm/worker-farm';\nimport {removeNontransferableOptions} from '../worker-utils/remove-nontransferable-options';\nimport {getWorkerURL, getWorkerName} from './get-worker-url';\n\ntype ProcessOnWorkerOptions = WorkerOptions & {\n  jobName?: string;\n  [key: string]: any;\n};\n\n/**\n * Determines if we can parse with worker\n * @param loader\n * @param data\n * @param options\n */\nexport function canProcessOnWorker(worker: WorkerObject, options?: WorkerOptions) {\n  if (!WorkerFarm.isSupported()) {\n    return false;\n  }\n\n  return worker.worker && options?.worker;\n}\n\n/**\n * This function expects that the worker thread sends certain messages,\n * Creating such a worker can be automated if the worker is wrapper by a call to\n * createWorker in @loaders.gl/worker-utils.\n */\nexport async function processOnWorker(\n  worker: WorkerObject,\n  data: any,\n  options: ProcessOnWorkerOptions = {},\n  context: WorkerContext = {}\n): Promise<any> {\n  const name = getWorkerName(worker);\n  const url = getWorkerURL(worker, options);\n\n  const workerFarm = WorkerFarm.getWorkerFarm(options);\n  const workerPool = workerFarm.getWorkerPool({name, url});\n\n  const jobName = options.jobName || worker.name;\n  const job = await workerPool.startJob(\n    jobName,\n    // eslint-disable-next-line\n    onMessage.bind(null, context)\n  );\n\n  // Kick off the processing in the worker\n  const transferableOptions = removeNontransferableOptions(options);\n  job.postMessage('process', {input: data, options: transferableOptions});\n\n  const result = await job.result;\n  return result.result;\n}\n\n/**\n * Job completes when we receive the result\n * @param job\n * @param message\n */\nasync function onMessage(\n  context: WorkerContext,\n  job: WorkerJob,\n  type: WorkerMessageType,\n  payload: WorkerMessagePayload\n) {\n  switch (type) {\n    case 'done':\n      // Worker is done\n      job.done(payload);\n      break;\n\n    case 'error':\n      // Worker encountered an error\n      job.error(payload.error);\n      break;\n\n    case 'process':\n      // Worker is asking for us (main thread) to process something\n      const {id, input, options} = payload;\n      try {\n        if (!context.process) {\n          job.postMessage('error', {id, error: 'Worker not set up to process on main thread'});\n          return;\n        }\n        const result = await context.process(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(`process-on-worker: unknown message ${type}`);\n  }\n}\n","/**\n * Safely stringify JSON (drop non serializable values like functions and regexps)\n * @param value\n */\nexport function removeNontransferableOptions(object: object): object {\n  // options.log object contains functions which cannot be transferred\n  // TODO - decide how to handle logging on workers\n  // TODO - warn if options stringification is long\n  return JSON.parse(stringifyJSON(object));\n}\n\nfunction stringifyJSON(v) {\n  const cache = new Set();\n  return JSON.stringify(v, (key, value) => {\n    if (typeof value === 'object' && value !== null) {\n      if (cache.has(value)) {\n        // Circular reference found\n        try {\n          // If this value does not reference a parent it can be deduped\n          return JSON.parse(JSON.stringify(value));\n        } catch (err) {\n          // discard key if value cannot be deduped\n          return undefined;\n        }\n      }\n      // Store value in our set\n      cache.add(value);\n    }\n    return value;\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 = 'latest';\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 type {\n  WorkerMessageType,\n  WorkerMessagePayload,\n  WorkerContext,\n  Process,\n  ProcessInBatches\n} from '../../types';\nimport AsyncQueue from '../async-queue/async-queue';\nimport WorkerBody from '../worker-farm/worker-body';\n// import {validateWorkerVersion} from './validate-worker-version';\n\n/** Counter for jobs */\nlet requestId = 0;\nlet inputBatches;\nlet options;\n\nexport type ProcessOnMainThread = (data: any, options?: {[key: string]: any}, context?) => any;\n\n/**\n * Set up a WebWorkerGlobalScope to talk with the main thread\n */\nexport function createWorker(process: Process, processInBatches?: ProcessInBatches): void {\n  // Check that we are actually in a worker thread\n  if (typeof self === 'undefined') {\n    return;\n  }\n\n  const context: WorkerContext = {\n    process: processOnMainThread\n  };\n\n  // eslint-disable-next-line complexity\n  WorkerBody.onmessage = async (type: WorkerMessageType, payload: WorkerMessagePayload) => {\n    try {\n      switch (type) {\n        case 'process':\n          if (!process) {\n            throw new Error('Worker does not support atomic processing');\n          }\n          const result = await process(payload.input, payload.options || {}, context);\n          WorkerBody.postMessage('done', {result});\n          break;\n\n        case 'process-in-batches':\n          if (!processInBatches) {\n            throw new Error('Worker does not support batched processing');\n          }\n          inputBatches = new AsyncQueue();\n          options = payload.options || {};\n          const resultIterator = processInBatches(inputBatches, options, context?.processInBatches);\n          for await (const batch of resultIterator) {\n            WorkerBody.postMessage('output-batch', {result: batch});\n          }\n          WorkerBody.postMessage('done', {});\n          break;\n\n        case 'input-batch':\n          inputBatches.push(payload.input);\n          break;\n\n        case 'input-done':\n          inputBatches.close();\n          break;\n\n        default:\n      }\n    } catch (error) {\n      const message = error instanceof Error ? error.message : '';\n      WorkerBody.postMessage('error', {error: message});\n    }\n  };\n}\n\nfunction processOnMainThread(arrayBuffer, options = {}) {\n  return new Promise((resolve, reject) => {\n    const id = requestId++;\n\n    /**\n     */\n    const onMessage = (type, payload) => {\n      if (payload.id !== id) {\n        // not ours\n        return;\n      }\n\n      switch (type) {\n        case 'done':\n          WorkerBody.removeEventListener(onMessage);\n          resolve(payload.result);\n          break;\n\n        case 'error':\n          WorkerBody.removeEventListener(onMessage);\n          reject(payload.error);\n          break;\n\n        default:\n        // ignore\n      }\n    };\n\n    WorkerBody.addEventListener(onMessage);\n\n    // Ask the main thread to decode data\n    const payload = {id, input: arrayBuffer, options};\n    WorkerBody.postMessage('process', payload);\n  });\n}\n","// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license\n// http://2ality.com/2016/10/asynchronous-iteration.html\n\n/**\n * Async Queue\n * - AsyncIterable: An async iterator can be\n * - Values can be pushed onto the queue\n * @example\n *   const asyncQueue = new AsyncQueue();\n *   setTimeout(() => asyncQueue.enqueue('tick'), 1000);\n *   setTimeout(() => asyncQueue.enqueue(new Error('done')), 10000);\n *   for await (const value of asyncQueue) {\n *     console.log(value); // tick\n *   }\n */\nexport default class AsyncQueue<T> {\n  private _values: any[];\n  private _settlers: any[];\n  private _closed: boolean;\n\n  constructor() {\n    this._values = []; // enqueues > dequeues\n    this._settlers = []; // dequeues > enqueues\n    this._closed = false;\n  }\n\n  /** Return an async iterator for this queue */\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    return this;\n  }\n\n  /** Push a new value - the async iterator will yield a promise resolved to this value */\n  push(value: T): void {\n    return this.enqueue(value);\n  }\n\n  /**\n   * Push a new value - the async iterator will yield a promise resolved to this value\n   * Add an error - the async iterator will yield a promise rejected with this value\n   */\n  enqueue(value: T | Error): void {\n    if (this._closed) {\n      throw new Error('Closed');\n    }\n\n    if (this._settlers.length > 0) {\n      if (this._values.length > 0) {\n        throw new Error('Illegal internal state');\n      }\n      const settler = this._settlers.shift();\n      if (value instanceof Error) {\n        settler.reject(value);\n      } else {\n        settler.resolve({value});\n      }\n    } else {\n      this._values.push(value);\n    }\n  }\n\n  /** Indicate that we not waiting for more values - The async iterator will be done */\n  close(): void {\n    while (this._settlers.length > 0) {\n      const settler = this._settlers.shift();\n      settler.resolve({done: true});\n    }\n    this._closed = true;\n  }\n\n  // ITERATOR IMPLEMENTATION\n\n  /** @returns a Promise for an IteratorResult */\n  next(): Promise<IteratorResult<T, any>> {\n    // If values in queue, yield the first value\n    if (this._values.length > 0) {\n      const value = this._values.shift();\n      if (value instanceof Error) {\n        return Promise.reject(value);\n      }\n      return Promise.resolve({done: false, value});\n    }\n\n    // If queue is closed, the iterator is done\n    if (this._closed) {\n      if (this._settlers.length > 0) {\n        throw new Error('Illegal internal state');\n      }\n      return Promise.resolve({done: true, value: undefined});\n    }\n\n    // Yield a promise that waits for new values to be enqueued\n    return new Promise((resolve, reject) => {\n      this._settlers.push({resolve, reject});\n    });\n  }\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","/* global importScripts */\nimport {global, isBrowser, isWorker} from '../env-utils/globals';\nimport * as node from '../node/require-utils.node';\nimport {assert} from '../env-utils/assert';\nimport {VERSION as __VERSION__} from '../env-utils/version';\n\n// TODO - unpkg.com doesn't seem to have a `latest` specifier for alpha releases...\nconst LATEST = 'beta';\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : LATEST;\n\nconst loadLibraryPromises = {}; // promises\n\n/**\n * Dynamically loads a library (\"module\")\n *\n * - wasm library: Array buffer is returned\n * - js library: Parse JS is returned\n *\n * Method depends on environment\n * - browser - script element is created and installed on document\n * - worker - eval is called on global context\n * - node - file is required\n *\n * @param libraryUrl\n * @param moduleName\n * @param options\n */\nexport async function loadLibrary(\n  libraryUrl: string,\n  moduleName: string | null = null,\n  options: object = {}\n): Promise<any> {\n  if (moduleName) {\n    libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);\n  }\n\n  // Ensure libraries are only loaded once\n  loadLibraryPromises[libraryUrl] =\n    loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);\n  return await loadLibraryPromises[libraryUrl];\n}\n\n// TODO - sort out how to resolve paths for main/worker and dev/prod\nexport function getLibraryUrl(library, moduleName?: string, options?): string {\n  // Check if already a URL\n  if (library.startsWith('http')) {\n    return library;\n  }\n\n  // Allow application to import and supply libraries through `options.modules`\n  const modules = options.modules || {};\n  if (modules[library]) {\n    return modules[library];\n  }\n\n  // Load from local files, not from CDN scripts in Node.js\n  // TODO - needs to locate the modules directory when installed!\n  if (!isBrowser) {\n    return `modules/${moduleName}/dist/libs/${library}`;\n  }\n\n  // In browser, load from external scripts\n  if (options.CDN) {\n    assert(options.CDN.startsWith('http'));\n    return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${library}`;\n  }\n\n  // TODO - loading inside workers requires paths relative to worker script location...\n  if (isWorker) {\n    return `../src/libs/${library}`;\n  }\n\n  return `modules/${moduleName}/src/libs/${library}`;\n}\n\nasync function loadLibraryFromFile(libraryUrl) {\n  if (libraryUrl.endsWith('wasm')) {\n    const response = await fetch(libraryUrl);\n    return await response.arrayBuffer();\n  }\n\n  if (!isBrowser) {\n    return node.requireFromFile && (await node.requireFromFile(libraryUrl));\n  }\n  if (isWorker) {\n    return importScripts(libraryUrl);\n  }\n  // TODO - fix - should be more secure than string parsing since observes CORS\n  // if (isBrowser) {\n  //   return await loadScriptFromFile(libraryUrl);\n  // }\n\n  const response = await fetch(libraryUrl);\n  const scriptSource = await response.text();\n  return loadLibraryFromString(scriptSource, libraryUrl);\n}\n\n/*\nasync function loadScriptFromFile(libraryUrl) {\n  const script = document.createElement('script');\n  script.src = libraryUrl;\n  return await new Promise((resolve, reject) => {\n    script.onload = data => {\n      resolve(data);\n    };\n    script.onerror = reject;\n  });\n}\n*/\n\n// TODO - Needs security audit...\n//  - Raw eval call\n//  - Potentially bypasses CORS\n// Upside is that this separates fetching and parsing\n// we could create a`LibraryLoader` or`ModuleLoader`\nfunction loadLibraryFromString(scriptSource, id) {\n  if (!isBrowser) {\n    return node.requireFromString && node.requireFromString(scriptSource, id);\n  }\n\n  if (isWorker) {\n    // Use lvalue trick to make eval run in global scope\n    eval.call(global, scriptSource); // eslint-disable-line no-eval\n    // https://stackoverflow.com/questions/9107240/1-evalthis-vs-evalthis-in-javascript\n    // http://perfectionkills.com/global-eval-what-are-the-options/\n    return null;\n  }\n\n  const script = document.createElement('script');\n  script.id = id;\n  // most browsers like a separate text node but some throw an error. The second method covers those.\n  try {\n    script.appendChild(document.createTextNode(scriptSource));\n  } catch (e) {\n    script.text = scriptSource;\n  }\n  document.body.appendChild(script);\n  return null;\n}\n\n// TODO - technique for module injection into worker, from THREE.DracoLoader...\n/*\nfunction combineWorkerWithLibrary(worker, jsContent) {\n  var fn = wWorker.toString();\n  var body = [\n    '// injected',\n    jsContent,\n    '',\n    '// worker',\n    fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}'))\n  ].join('\\n');\n  this.workerSourceURL = URL.createObjectURL(new Blob([body]));\n}\n*/\n","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 {getFirstCharacters} from '../binary-utils/get-first-characters';\n\n/**\n * Minimal JSON parser that throws more meaningful error messages\n */\nexport function parseJSON(string: string): any {\n  try {\n    return JSON.parse(string);\n  } catch (_) {\n    throw new Error(`Failed to parse JSON from data starting with \"${getFirstCharacters(string)}\"`);\n  }\n}\n","export function getFirstCharacters(data, length = 5): string {\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\nexport function getMagicString(\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number,\n  length: number\n): string {\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 {TypedArray} from '../../types';\nimport * as node 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 (node.isBuffer(data)) {\n    // TODO - per docs we should just be able to call buffer.buffer, but there are issues\n    data = node.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 * as node from '../node/buffer';\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(data: any): ArrayBuffer {\n  if (node.toArrayBuffer) {\n    // TODO - per docs we should just be able to call buffer.buffer, but there are issues\n    return node.toArrayBuffer(data);\n  }\n  return data;\n}\n","import {assert} from '../env-utils/assert';\n\n/**\n * Calculate new size of an arrayBuffer to be aligned to an n-byte boundary\n * This function increases `byteLength` by the minimum delta,\n * allowing the total length to be divided by `padding`\n * @param byteLength\n * @param padding\n */\nexport function padToNBytes(byteLength: number, padding: number): number {\n  assert(byteLength >= 0); // `Incorrect 'byteLength' value: ${byteLength}`\n  assert(padding > 0); // `Incorrect 'padding' value: ${padding}`\n  return (byteLength + (padding - 1)) & ~(padding - 1);\n}\n\n/**\n * Creates a new Uint8Array based on two different ArrayBuffers\n * @param targetBuffer The first buffer.\n * @param sourceBuffer The second buffer.\n * @return The new ArrayBuffer created out of the two.\n */\nexport function copyArrayBuffer(\n  targetBuffer: ArrayBuffer,\n  sourceBuffer: ArrayBuffer,\n  byteOffset: number,\n  byteLength: number = sourceBuffer.byteLength\n): ArrayBuffer {\n  const targetArray = new Uint8Array(targetBuffer, byteOffset, byteLength);\n  const sourceArray = new Uint8Array(sourceBuffer);\n  targetArray.set(sourceArray);\n  return targetBuffer;\n}\n\n/**\n * Copy from source to target at the targetOffset\n *\n * @param source - The data to copy\n * @param target - The destination to copy data into\n * @param targetOffset - The start offset into target to place the copied data\n * @returns the new offset taking into account proper padding\n */\nexport function copyToArray(source: ArrayBuffer | any, target: any, targetOffset: number): number {\n  let sourceArray;\n\n  if (source instanceof ArrayBuffer) {\n    sourceArray = new Uint8Array(source);\n  } else {\n    // Pack buffer onto the big target array\n    //\n    // 'source.data.buffer' could be a view onto a larger buffer.\n    // We MUST use this constructor to ensure the byteOffset and byteLength is\n    // set to correct values from 'source.data' and not the underlying\n    // buffer for target.set() to work properly.\n    const srcByteOffset = source.byteOffset;\n    const srcByteLength = source.byteLength;\n    // In gltf parser it is set as \"arrayBuffer\" instead of \"buffer\"\n    // https://github.com/visgl/loaders.gl/blob/1e3a82a0a65d7b6a67b1e60633453e5edda2960a/modules/gltf/src/lib/parse-gltf.js#L85\n    sourceArray = new Uint8Array(source.buffer || source.arrayBuffer, srcByteOffset, srcByteLength);\n  }\n\n  // Pack buffer onto the big target array\n  target.set(sourceArray, targetOffset);\n\n  return targetOffset + padToNBytes(sourceArray.byteLength, 4);\n}\n","import {TypedArray} from '../../types';\nimport {padToNBytes} from './memory-copy-utils';\n\n/**\n * Copy sourceBuffer to dataView with some padding\n *\n * @param {DataView | null} dataView - destination data container. If null - only new offset is calculated\n * @param {number} byteOffset - destination byte offset to copy to\n * @param {Array | TypedArray} sourceBuffer - source data buffer\n * @param {number} padding - pad the resulting array to multiple of \"padding\" bytes. Additional bytes are filled with 0x20 (ASCII space)\n *\n * @return new byteOffset of resulting dataView\n */\nexport function copyPaddedArrayBufferToDataView(\n  dataView: DataView | null,\n  byteOffset: number,\n  sourceBuffer: TypedArray,\n  padding: number\n) {\n  const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);\n  const padLength = paddedLength - sourceBuffer.byteLength;\n\n  if (dataView) {\n    // Copy array\n    const targetArray = new Uint8Array(\n      dataView.buffer,\n      dataView.byteOffset + byteOffset,\n      sourceBuffer.byteLength\n    );\n    const sourceArray = new Uint8Array(sourceBuffer);\n    targetArray.set(sourceArray);\n\n    // Add PADDING\n    for (let i = 0; i < padLength; ++i) {\n      // json chunk is padded with spaces (ASCII 0x20)\n      dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 0x20);\n    }\n  }\n  byteOffset += paddedLength;\n  return byteOffset;\n}\n\n/**\n * Copy string to dataView with some padding\n *\n * @param {DataView | null} dataView - destination data container. If null - only new offset is calculated\n * @param {number} byteOffset - destination byte offset to copy to\n * @param {string} string - source string\n * @param {number} padding - pad the resulting array to multiple of \"padding\" bytes. Additional bytes are filled with 0x20 (ASCII space)\n *\n * @return new byteOffset of resulting dataView\n */\nexport function copyPaddedStringToDataView(\n  dataView: DataView | null,\n  byteOffset: number,\n  string: string,\n  padding: number\n): number {\n  const textEncoder = new TextEncoder();\n  // PERFORMANCE IDEA: We encode twice, once to get size and once to store\n  // PERFORMANCE IDEA: Use TextEncoder.encodeInto() to avoid temporary copy\n  const stringBuffer = textEncoder.encode(string);\n\n  byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);\n\n  return byteOffset;\n}\n","// Note: These were broken out from gltf loader...\n// eslint-disable-next-line complexity\n\n// PERFORMANCE IDEA: No need to copy string twice...\nexport function padStringToByteAlignment(string, byteAlignment) {\n  const length = string.length;\n  const paddedLength = Math.ceil(length / byteAlignment) * byteAlignment; // Round up to the required alignment\n  const padding = paddedLength - length;\n  let whitespace = '';\n  for (let i = 0; i < padding; ++i) {\n    whitespace += ' ';\n  }\n  return string + whitespace;\n}\n\nexport function copyStringToDataView(dataView, byteOffset, string, byteLength) {\n  if (dataView) {\n    for (let i = 0; i < byteLength; i++) {\n      dataView.setUint8(byteOffset + i, string.charCodeAt(i));\n    }\n  }\n  return byteOffset + byteLength;\n}\n\nexport function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {\n  if (dataView) {\n    for (let i = 0; i < byteLength; i++) {\n      dataView.setUint8(byteOffset + i, binary[i]);\n    }\n  }\n  return byteOffset + byteLength;\n}\n","// TextDecoder iterators\n// TextDecoder will keep any partial undecoded bytes between calls to `decode`\n\nexport async function* makeTextDecoderIterator(\n  arrayBufferIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options: TextDecoderOptions = {}\n): AsyncIterable<string> {\n  const textDecoder = new TextDecoder(undefined, options);\n  for await (const arrayBuffer of arrayBufferIterator) {\n    yield typeof arrayBuffer === 'string'\n      ? arrayBuffer\n      : textDecoder.decode(arrayBuffer, {stream: true});\n  }\n}\n\n// TextEncoder iterator\n// TODO - this is not useful unless min chunk size is given\n// TextEncoder will keep any partial undecoded bytes between calls to `encode`\n// If iterator does not yield strings, assume arrayBuffer and return unencoded\n\nexport async function* makeTextEncoderIterator(\n  textIterator: AsyncIterable<string> | Iterable<ArrayBuffer>\n): AsyncIterable<ArrayBuffer> {\n  const textEncoder = new TextEncoder();\n  for await (const text of textIterator) {\n    yield typeof text === 'string' ? textEncoder.encode(text) : text;\n  }\n}\n\n/**\n * @param textIterator async iterable yielding strings\n * @returns an async iterable over lines\n * See http://2ality.com/2018/04/async-iter-nodejs.html\n */\n\nexport async function* makeLineIterator(\n  textIterator: AsyncIterable<string>\n): AsyncIterable<string> {\n  let previous = '';\n  for await (const textChunk of textIterator) {\n    previous += textChunk;\n    let eolIndex;\n    while ((eolIndex = previous.indexOf('\\n')) >= 0) {\n      // line includes the EOL\n      const line = previous.slice(0, eolIndex + 1);\n      previous = previous.slice(eolIndex + 1);\n      yield line;\n    }\n  }\n\n  if (previous.length > 0) {\n    yield previous;\n  }\n}\n\n/**\n * @param lineIterator async iterable yielding lines\n * @returns async iterable yielding numbered lines\n *\n * See http://2ality.com/2018/04/async-iter-nodejs.html\n */\nexport async function* makeNumberedLineIterator(\n  lineIterator: AsyncIterable<string>\n): AsyncIterable<{counter: number; line: string}> {\n  let counter = 1;\n  for await (const line of lineIterator) {\n    yield {counter, line};\n    counter++;\n  }\n}\n","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 {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","// STATS (PERFORMANCE PROFILING)\nexport {default as Stats} from './lib/stats';\nexport {default as Stat} from './lib/stat';\n\n// UTILITIES\nexport {default as _getHiResTimestamp} from './utils/hi-res-timestamp';\n","import Stat from './stat';\n\nexport default class Stats {\n  constructor({id, stats}) {\n    this.id = id;\n    this.stats = {};\n\n    this._initializeStats(stats);\n\n    Object.seal(this);\n  }\n\n  // Acquire a stat. Create if it doesn't exist.\n  get(name, type = 'count') {\n    return this._getOrCreate({name, type});\n  }\n\n  get size() {\n    return Object.keys(this.stats).length;\n  }\n\n  // Reset all stats\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\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 {name, type} = stat;\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    return this.stats[name];\n  }\n}\n","import getHiResTimestamp from '../utils/hi-res-timestamp';\n\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\n    return this;\n  }\n\n  // Call to increment count (+1)\n  incrementCount() {\n    this.addCount(1);\n\n    return this;\n  }\n\n  // Call to decrement count (-1)\n  decrementCount() {\n    this.subtractCount(1);\n\n    return this;\n  }\n\n  // Increase count\n  addCount(value) {\n    this._count += value;\n    this._samples++;\n    this._checkSampling();\n\n    return this;\n  }\n\n  // Decrease count\n  subtractCount(value) {\n    this._count -= value;\n    this._samples++;\n    this._checkSampling();\n\n    return this;\n  }\n\n  // Add an arbitrary timing and bump the count\n  addTime(time) {\n    this._time += time;\n    this.lastTiming = time;\n    this._samples++;\n    this._checkSampling();\n\n    return this;\n  }\n\n  // Start a timer\n  timeStart() {\n    this._startTime = getHiResTimestamp();\n    this._timerPending = true;\n\n    return this;\n  }\n\n  // End a timer. Adds to time and bumps the timing count.\n  timeEnd() {\n    if (!this._timerPending) {\n      return this;\n    }\n\n    this.addTime(getHiResTimestamp() - this._startTime);\n    this._timerPending = false;\n    this._checkSampling();\n\n    return this;\n  }\n\n  getSampleAverageCount() {\n    return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;\n  }\n\n  // Calculate average time / count for the previous window\n  getSampleAverageTime() {\n    return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;\n  }\n\n  // Calculate counts per second for the previous window\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  // Calculate average time / count\n  getAverageTime() {\n    return this.samples > 0 ? this.time / this.samples : 0;\n  }\n\n  // Calculate counts per second\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\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","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nexport default function getHiResTimestamp() {\n  let timestamp;\n  // Get best timer available.\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","// 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","import type {LoaderWithParser} from './types';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/**\n * A JSON Micro loader (minimal bundle size)\n * Alternative to `@loaders.gl/json`\n */\nexport const JSONLoader = {\n  name: 'JSON',\n  id: 'json',\n  module: 'json',\n  version: VERSION,\n  extensions: ['json', 'geojson'],\n  mimeTypes: ['application/json'],\n  category: 'json',\n  text: true,\n  parseTextSync,\n  parse: async (arrayBuffer) => parseTextSync(new TextDecoder().decode(arrayBuffer)),\n  options: {}\n};\n\n// TODO - deprecated\nfunction parseTextSync(text) {\n  return JSON.parse(text);\n}\n\nexport const _typecheckJSONLoader: LoaderWithParser = JSONLoader;\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 * as fs from '../node/fs';\nimport {IFileSystem, IRandomAccessReadFileSystem} from '@loaders.gl/loader-utils';\n// import {fetchFile} from \"../fetch/fetch-file\"\n// import {selectLoader} from \"../api/select-loader\";\n\ntype Stat = {\n  size: number;\n  isDirectory: () => boolean;\n  info?: fs.Stats;\n};\n\ntype ReadOptions = {\n  buffer?: Buffer;\n  offset?: number;\n  length?: number;\n  position?: number;\n};\n\n/**\n * FileSystem pass-through for Node.js\n * Compatible with BrowserFileSystem.\n * @param options\n */\nexport default class NodeFileSystem implements IFileSystem, IRandomAccessReadFileSystem {\n  // implements IFileSystem\n  constructor(options: {[key: string]: any}) {\n    this.fetch = options._fetch;\n  }\n\n  async readdir(dirname = '.', options?: {}): Promise<any[]> {\n    return await fs.readdir(dirname, options);\n  }\n\n  async stat(path: string, options?: {}): Promise<Stat> {\n    const info = await fs.stat(path, options);\n    return {size: Number(info.size), isDirectory: () => false, info};\n  }\n\n  async fetch(path: string, options: {[key: string]: any}) {\n    // Falls back to handle https:/http:/data: etc fetches\n    // eslint-disable-next-line\n    const fallbackFetch = options.fetch || this.fetch;\n    return fallbackFetch(path, options);\n  }\n\n  // implements IRandomAccessFileSystem\n  async open(path: string, flags: string | number, mode?: any): Promise<number> {\n    return await fs.open(path, flags);\n  }\n\n  async close(fd: number): Promise<void> {\n    return await fs.close(fd);\n  }\n\n  async fstat(fd: number): Promise<Stat> {\n    const info = await fs.fstat(fd);\n    return info;\n  }\n\n  async read(\n    fd: number,\n    // @ts-ignore Possibly null\n    {buffer = null, offset = 0, length = buffer.byteLength, position = null}: ReadOptions\n  ): Promise<{bytesRead: number; buffer: Buffer}> {\n    let totalBytesRead = 0;\n    // Read in loop until we get required number of bytes\n    while (totalBytesRead < length) {\n      const {bytesRead} = await fs.read(\n        fd,\n        buffer,\n        offset + totalBytesRead,\n        length - totalBytesRead,\n        position + totalBytesRead\n      );\n      totalBytesRead += bytesRead;\n    }\n    return {bytesRead: totalBytesRead, buffer};\n  }\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 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\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\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 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 {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","// 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","//\nimport {fs} from '@loaders.gl/loader-utils';\n\n/**\n * Reads a chunk from a random access file\n * @param file\n * @param start\n * @param length\n * @returns\n */\nexport async function readArrayBuffer(\n  file: Blob | ArrayBuffer | string | number,\n  start: number,\n  length: number\n): Promise<ArrayBuffer> {\n  if (typeof file === 'number') {\n    return await fs._readToArrayBuffer(file, start, length);\n  }\n  // TODO - we can do better for ArrayBuffer and string\n  if (!(file instanceof Blob)) {\n    file = new Blob([file]);\n  }\n  const slice = file.slice(start, start + length);\n  return await readBlob(slice);\n}\n\n/**\n * Read a slice of a Blob or File, without loading the entire file into memory\n * The trick when reading File objects is to read successive \"slices\" of the File\n * Per spec https://w3c.github.io/FileAPI/, slicing a File only updates the start and end fields\n * Actually reading from file happens in `readAsArrayBuffer`\n * @param blob to read\n */\nexport async function readBlob(blob: Blob): Promise<ArrayBuffer> {\n  return await new Promise((resolve, reject) => {\n    const fileReader = new FileReader();\n    fileReader.onload = (event: ProgressEvent<FileReader>) =>\n      resolve(event?.target?.result as ArrayBuffer);\n    // TODO - reject with a proper Error\n    fileReader.onerror = (error: ProgressEvent<FileReader>) => reject(error);\n    fileReader.readAsArrayBuffer(blob);\n  });\n}\n","// File read\nimport {isBrowser, resolvePath, fs, toArrayBuffer} from '@loaders.gl/loader-utils';\nimport {assert} from '@loaders.gl/loader-utils';\n\n// TODO - this is not tested\n// const isDataURL = (url) => url.startsWith('data:');\n\n/**\n * In a few cases (data URIs, node.js) \"files\" can be read synchronously\n */\nexport function readFileSync(url: string, options: object = {}) {\n  url = resolvePath(url);\n\n  // Only support this if we can also support sync data URL decoding in browser\n  // if (isDataURL(url)) {\n  //   return decodeDataUri(url);\n  // }\n\n  if (!isBrowser) {\n    const buffer = fs.readFileSync(url, options);\n    return typeof buffer !== 'string' ? toArrayBuffer(buffer) : buffer;\n  }\n\n  // @ts-ignore\n  if (!options.nothrow) {\n    // throw new Error('Cant load URI synchronously');\n    assert(false);\n  }\n\n  return null;\n}\n","// file write\nimport {isBrowser, assert, resolvePath} from '@loaders.gl/loader-utils';\nimport {fs, toBuffer} from '@loaders.gl/loader-utils';\n\nexport async function writeFile(\n  filePath: string,\n  arrayBufferOrString: ArrayBuffer | string,\n  options?\n): Promise<void> {\n  filePath = resolvePath(filePath);\n  if (!isBrowser) {\n    await fs.writeFile(filePath, toBuffer(arrayBufferOrString), {flag: 'w'});\n  }\n  assert(false);\n}\n\nexport function writeFileSync(\n  filePath: string,\n  arrayBufferOrString: ArrayBuffer | string,\n  options?\n): void {\n  filePath = resolvePath(filePath);\n  if (!isBrowser) {\n    fs.writeFileSync(filePath, toBuffer(arrayBufferOrString), {flag: 'w'});\n  }\n  assert(false);\n}\n","import {setGlobalOptions} from '../loader-utils/option-utils';\n\n/**\n * Set global loader options\n * @param options\n */\nexport function setLoaderOptions(options: object): void {\n  setGlobalOptions(options);\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","// 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 './init';\nimport {default as Log} from './lib/log';\n\nexport {VERSION} from './utils/globals';\n\n// ENVIRONMENT\nexport {self, window, global, document, process, console} from './env/globals';\nexport {default as isBrowser, isBrowserMainThread} from './env/is-browser';\nexport {default as getBrowser, isMobile} from './env/get-browser';\nexport {default as isElectron} from './env/is-electron';\n\n// ENVIRONMENT'S ASSERT IS 5-15KB, SO WE PROVIDE OUR OWN\nexport {default as assert} from './utils/assert';\n\n// LOGGING\nexport {default as Log} from './lib/log';\nexport {COLOR} from './utils/color';\n\n// DEFAULT EXPORT IS A LOG INSTANCE\nexport default new Log({id: 'probe.gl'});\n\n// UTILITIES\nexport {addColor} from './utils/color';\nexport {leftPad, rightPad} from './utils/formatters';\nexport {autobind} from './utils/autobind';\nexport {default as LocalStorage} from './utils/local-storage';\nexport {default as getHiResTimestamp} from './utils/hi-res-timestamp';\n\n// DEPRECATED (Should be imported directly from @probe.gl/stats)\nexport {Stats, Stat} from '@probe.gl/stats';\n","import {global} from './utils/globals';\n// @ts-ignore\nglobal.probe = {};\n","import checkIfBrowser from '../env/is-browser';\n\nexport {self, window, global, document, process, console} from '../env/globals';\n\n// Extract injected version from package.json (injected by babel plugin)\n/* global __VERSION__ */\n// @ts-ignore\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'untranspiled source';\n\nexport const isBrowser = checkIfBrowser();\n","// This function is needed in initialization stages,\n// make sure it can be imported in isolation\n\nimport isElectron from './is-electron';\n\nexport default function isBrowser() {\n  // Check if in browser by duck-typing Node context\n  const isNode =\n    // @ts-ignore\n    typeof process === 'object' && String(process) === '[object process]' && !process.browser;\n\n  return !isNode || isElectron();\n}\n\n// document does not exist on worker thread\nexport function isBrowserMainThread() {\n  return isBrowser() && typeof document !== 'undefined';\n}\n","// based on https://github.com/cheton/is-electron\n// https://github.com/electron/electron/issues/2288\n/* eslint-disable complexity */\nexport default function isElectron(mockUserAgent) {\n  // Renderer process\n  if (\n    typeof window !== 'undefined' &&\n    typeof window.process === 'object' &&\n    // @ts-ignore\n    window.process.type === 'renderer'\n  ) {\n    return true;\n  }\n  // Main process\n  if (\n    typeof process !== 'undefined' &&\n    typeof process.versions === 'object' &&\n    // @ts-ignore\n    Boolean(process.versions.electron)\n  ) {\n    return true;\n  }\n  // Detect the user agent when the `nodeIntegration` option is set to true\n  const realUserAgent =\n    typeof navigator === 'object' && typeof navigator.userAgent === 'string' && navigator.userAgent;\n  const userAgent = mockUserAgent || realUserAgent;\n  if (userAgent && userAgent.indexOf('Electron') >= 0) {\n    return true;\n  }\n  return false;\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  process: typeof process === 'object' && process\n};\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;\n\nexport {\n  self_ as self,\n  window_ as window,\n  global_ as global,\n  document_ as document,\n  process_ as process,\n  console_ as console\n};\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/* eslint-disable no-console */\nimport {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';\n\n/* eslint-disable no-console */\n\n// Instrumentation in other packages may override console methods, so preserve them here\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};\n\nconst DEFAULT_SETTINGS = {\n  enabled: true,\n  level: 0\n};\n\nfunction noop() {}\n\nconst cache = {};\nconst ONCE = {once: true};\n\n/*\nfunction throttle(tag, timeout) {\n  const prevTime = cache[tag];\n  const time = Date.now();\n  if (!prevTime || (time - prevTime > timeout)) {\n    cache[tag] = time;\n    return true;\n  }\n  return false;\n}\n\n// Assertions don't generate standard exceptions and don't print nicely\nfunction checkForAssertionErrors(args) {\n  const isAssertion =\n    args &&\n    args.length > 0 &&\n    typeof args[0] === 'object' &&\n    args[0] !== null &&\n    args[0].name === 'AssertionError';\n\n  if (isAssertion) {\n    args = Array.prototype.slice.call(args);\n    args.unshift(`assert(${args[0].message})`);\n  }\n  return args;\n}\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  return 'empty';\n}\n\n// A console wrapper\n\nexport default class Log {\n  constructor({id} = {id: ''}) {\n    this.id = id;\n    this.VERSION = VERSION;\n    this._startTs = getHiResTimestamp();\n    this._deltaTs = getHiResTimestamp();\n    // TODO - fix support from throttling groups\n    this.LOG_THROTTLE_TIMEOUT = 0; // Time before throttled messages are logged again\n    this._storage = new LocalStorage(`__probe-${this.id}__`, DEFAULT_SETTINGS);\n    this.userData = {};\n\n    this.timeStamp(`${this.id} started`);\n\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  // @return {Number} milliseconds, with fractions\n  getTotal() {\n    return Number((getHiResTimestamp() - this._startTs).toPrecision(10));\n  }\n\n  // @return {Number} milliseconds, with fractions\n  getDelta() {\n    return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10));\n  }\n\n  // Deprecated\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  // Configure\n\n  enable(enabled = true) {\n    this._storage.updateConfiguration({enabled});\n    return this;\n  }\n\n  setLevel(level) {\n    this._storage.updateConfiguration({level});\n    return this;\n  }\n\n  // Unconditional logging\n\n  assert(condition, message) {\n    assert(condition, message);\n  }\n\n  // Warn, but only once, no console flooding\n  warn(message) {\n    // @ts-ignore\n    return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE);\n  }\n\n  // Print an error\n  error(message) {\n    // @ts-ignore\n    return this._getLogFunction(0, message, originalConsole.error, arguments);\n  }\n\n  deprecated(oldUsage, newUsage) {\n    return this.warn(`\\`${oldUsage}\\` is deprecated and will be removed \\\nin a later version. Use \\`${newUsage}\\` instead`);\n  }\n\n  removed(oldUsage, newUsage) {\n    return this.error(`\\`${oldUsage}\\` has been removed. Use \\`${newUsage}\\` instead`);\n  }\n\n  // Conditional logging\n\n  // Log to a group\n  probe(logLevel, message) {\n    // @ts-ignore\n    return this._getLogFunction(logLevel, message, originalConsole.log, arguments, {\n      time: true,\n      once: true\n    });\n  }\n\n  // Log a debug message\n  log(logLevel, message) {\n    // @ts-ignore\n    return this._getLogFunction(logLevel, message, originalConsole.debug, arguments);\n  }\n\n  // Log a normal message\n  info(logLevel, message) {\n    // @ts-ignore\n    return this._getLogFunction(logLevel, message, console.info, arguments);\n  }\n\n  // Log a normal message, but only once, no console flooding\n  once(logLevel, message) {\n    return this._getLogFunction(\n      logLevel,\n      message,\n      originalConsole.debug || originalConsole.info,\n      // @ts-ignore\n      arguments,\n      ONCE\n    );\n  }\n\n  // Logs an object as a table\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    return noop;\n  }\n\n  // logs an image under Chrome\n  image({logLevel, priority, image, message = '', scale = 1}) {\n    if (!this._shouldLog(logLevel || priority)) {\n      return noop;\n    }\n    return isBrowser\n      ? logImageInBrowser({image, message, scale})\n      : logImageInNode({image, message, scale});\n  }\n\n  // Logs the current settings as a table\n  settings() {\n    if (console.table) {\n      console.table(this._storage.config);\n    } else {\n      console.log(this._storage.config);\n    }\n  }\n\n  // logs the current status of the setting\n  get(setting) {\n    return this._storage.config[setting];\n  }\n\n  // update the status of the setting\n  set(setting, value) {\n    this._storage.updateConfiguration({[setting]: value});\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(\n      logLevel,\n      message,\n      console.timeEnd ? console.timeEnd : console.info\n    );\n  }\n\n  timeStamp(logLevel, message) {\n    return this._getLogFunction(logLevel, message, console.timeStamp || noop);\n  }\n\n  group(logLevel, message, opts = {collapsed: false}) {\n    opts = normalizeArguments({logLevel, message, opts});\n    const {collapsed} = opts;\n    opts.method = (collapsed ? console.groupCollapsed : console.group) || console.info;\n\n    return this._getLogFunction(opts);\n  }\n\n  groupCollapsed(logLevel, message, opts = {}) {\n    return this.group(logLevel, message, Object.assign({}, opts, {collapsed: true}));\n  }\n\n  groupEnd(logLevel) {\n    return this._getLogFunction(logLevel, '', console.groupEnd || noop);\n  }\n\n  // EXPERIMENTAL\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  // PRIVATE METHODS\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      // normalized opts + timings\n      opts = normalizeArguments({logLevel, message, args, opts});\n      method = method || opts.method;\n      assert(method);\n\n      opts.total = this.getTotal();\n      opts.delta = this.getDelta();\n      // reset delta timer\n      this._deltaTs = getHiResTimestamp();\n\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      // TODO - Make throttling work with groups\n      // if (opts.nothrottle || !throttle(tag, this.LOG_THROTTLE_TIMEOUT)) {\n      //   return noop;\n      // }\n\n      message = decorateMessage(this.id, opts.message, opts);\n\n      // Bind console function so that it can be called after being returned\n      return method.bind(console, message, ...opts.args);\n    }\n    return noop;\n  }\n}\n\nLog.VERSION = VERSION;\n\n// Get logLevel from first argument:\n// - log(logLevel, message, args) => logLevel\n// - log(message, args) => 0\n// - log({logLevel, ...}, message, args) => logLevel\n// - log({logLevel, message, args}) => logLevel\nfunction normalizeLogLevel(logLevel) {\n  if (!logLevel) {\n    return 0;\n  }\n  let resolvedLevel;\n\n  switch (typeof logLevel) {\n    case 'number':\n      resolvedLevel = logLevel;\n      break;\n\n    case 'object':\n      // Backward compatibility\n      // TODO - deprecate `priority`\n      resolvedLevel = logLevel.logLevel || logLevel.priority || 0;\n      break;\n\n    default:\n      return 0;\n  }\n  // 'log level must be a number'\n  assert(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);\n\n  return resolvedLevel;\n}\n\n// \"Normalizes\" the various argument patterns into an object with known types\n// - log(logLevel, message, args) => {logLevel, message, args}\n// - log(message, args) => {logLevel: 0, message, args}\n// - log({logLevel, ...}, message, args) => {logLevel, message, args}\n// - log({logLevel, message, args}) => {logLevel, message, args}\nexport function normalizeArguments(opts) {\n  const {logLevel, message} = opts;\n  opts.logLevel = normalizeLogLevel(logLevel);\n  // We use `arguments` instead of rest parameters (...args) because IE\n  // does not support the syntax. Rest parameters is transpiled to code with\n  // perf impact. Doing it here instead avoids constructing args when logging is\n  // disabled.\n  // TODO - remove when/if IE support is dropped\n  const args = opts.args ? Array.from(opts.args) : [];\n  /* eslint-disable no-empty */\n  // args should only contain arguments that appear after `message`\n  while (args.length && args.shift() !== message) {}\n  /* eslint-enable no-empty */\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      opts.message = logLevel;\n      break;\n\n    case 'object':\n      Object.assign(opts, logLevel);\n      break;\n\n    default:\n  }\n\n  // Resolve functions into strings by calling them\n  if (typeof opts.message === 'function') {\n    opts.message = opts.message();\n  }\n  const messageType = typeof opts.message;\n  // 'log message must be a string' or object\n  assert(messageType === 'string' || messageType === 'object');\n\n  // original opts + normalized opts + opts arg + fixed up message\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 ? `${id}: ${time}  ${message}` : `${id}: ${message}`;\n    message = addColor(message, opts.color, opts.background);\n  }\n  return message;\n}\n\n// Use the asciify module to log an image under node.js\nfunction logImageInNode({image, message = '', scale = 1}) {\n  // Note: Runtime load of the \"asciify-image\" module, avoids including in browser bundles\n  let asciify = null;\n  try {\n    asciify = module.require('asciify-image');\n  } catch (error) {\n    // asciify not installed, silently ignore\n  }\n  if (asciify) {\n    return () =>\n      asciify(image, {fit: 'box', width: `${Math.round(80 * scale)}%`}).then(data =>\n        console.log(data)\n      );\n  }\n  return noop;\n}\n\nfunction logImageInBrowser({image, message = '', scale = 1}) {\n  if (typeof image === 'string') {\n    const img = new Image();\n    img.onload = () => {\n      const args = formatImage(img, message, scale);\n      console.log(...args);\n    };\n    img.src = image;\n    return noop;\n  }\n  const element = image.nodeName || '';\n  if (element.toLowerCase() === 'img') {\n    console.log(...formatImage(image, message, scale));\n    return noop;\n  }\n  if (element.toLowerCase() === 'canvas') {\n    const img = new Image();\n    img.onload = () => console.log(...formatImage(img, message, scale));\n    img.src = image.toDataURL();\n    return noop;\n  }\n  return noop;\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nfunction getStorage(type) {\n  try {\n    /** @type {Storage} */\n    // @ts-ignore\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\n// Store keys in local storage via simple interface\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    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    if (this.storage) {\n      const serialized = JSON.stringify(this.config);\n      this.storage.setItem(this.id, serialized);\n    }\n    return this;\n  }\n\n  // Get config from persistent store, if available\n  _loadConfiguration() {\n    let configuration = {};\n    if (this.storage) {\n      const serializedConfiguration = this.storage.getItem(this.id);\n      configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};\n    }\n    Object.assign(this.config, configuration);\n    return this;\n  }\n}\n","// TODO: Currently unused, keeping in case we want it later for log formatting\nexport function formatTime(ms) {\n  let formatted;\n  if (ms < 10) {\n    formatted = `${ms.toFixed(2)}ms`;\n  } else if (ms < 100) {\n    formatted = `${ms.toFixed(1)}ms`;\n  } else if (ms < 1000) {\n    formatted = `${ms.toFixed(0)}ms`;\n  } else {\n    formatted = `${(ms / 1000).toFixed(2)}s`;\n  }\n  return formatted;\n}\n\nexport function leftPad(string, length = 8) {\n  const padLength = Math.max(length - string.length, 0);\n  return `${' '.repeat(padLength)}${string}`;\n}\n\nexport function rightPad(string, length = 8) {\n  const padLength = Math.max(length - string.length, 0);\n  return `${string}${' '.repeat(padLength)}`;\n}\n\nexport function formatValue(v, opts = {}) {\n  const EPSILON = 1e-16;\n  const {isInteger = false} = opts;\n  if (Array.isArray(v) || ArrayBuffer.isView(v)) {\n    return formatArrayValue(v, opts);\n  }\n  if (!Number.isFinite(v)) {\n    return String(v);\n  }\n  if (Math.abs(v) < EPSILON) {\n    return isInteger ? '0' : '0.';\n  }\n  if (isInteger) {\n    return v.toFixed(0);\n  }\n  if (Math.abs(v) > 100 && Math.abs(v) < 10000) {\n    return v.toFixed(0);\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\n// Helper to formatValue\nfunction formatArrayValue(v, opts) {\n  const {maxElts = 16, size = 1} = opts;\n  let string = '[';\n  for (let i = 0; i < v.length && i < maxElts; ++i) {\n    if (i > 0) {\n      string += `,${i % size === 0 ? ' ' : ''}`;\n    }\n    string += formatValue(v[i], opts);\n  }\n  const terminator = v.length > maxElts ? '...' : ']';\n  return `${string}${terminator}`;\n}\n\n// Inspired by https://github.com/hughsk/console-image (MIT license)\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\n  const style = [\n    'font-size:1px;',\n    `padding:${Math.floor(height / 2)}px ${Math.floor(width / 2)}px;`,\n    `line-height:${height}px;`,\n    `background:url(${imageUrl});`,\n    `background-size:${width}px ${height}px;`,\n    'color:transparent;'\n  ].join('');\n\n  return [`${message} %c+`, style];\n}\n","import {isBrowser} from './globals';\n\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\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 = `\\u001b[${color}m${string}\\u001b[39m`;\n    }\n    if (background) {\n      // background colors values are +10\n      color = getColor(background);\n      string = `\\u001b[${background + 10}m${string}\\u001b[49m`;\n    }\n  }\n  return string;\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/**\n * Binds the \"this\" argument of all functions on a class instance to the instance\n * @param {Object} obj - class instance (typically a react component)\n */\nexport function autobind(obj, predefined = ['constructor']) {\n  const proto = Object.getPrototypeOf(obj);\n  const propNames = Object.getOwnPropertyNames(proto);\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","export default function assert(condition, message) {\n  if (!condition) {\n    throw new Error(message || 'Assertion failed');\n  }\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// @ts-nocheck\n\n/**\n * Common environment setup\n */\nimport {window, process, isBrowser} from './globals';\n\nexport default function getHiResTimestamp() {\n  let timestamp;\n  // Get best timer available.\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","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// This function is needed in initialization stages,\n// make sure it can be imported in isolation\n\nimport {window} from './globals';\nimport isBrowser from './is-browser';\nimport isElectron from './is-electron';\n\nexport function isMobile() {\n  // @ts-ignore\n  return typeof window.orientation !== 'undefined';\n}\n\n// Simple browser detection\n// `mockUserAgent` parameter allows user agent to be overridden for testing\n/* eslint-disable complexity */\nexport default function getBrowser(mockUserAgent) {\n  if (!mockUserAgent && !isBrowser()) {\n    return 'Node';\n  }\n\n  if (isElectron(mockUserAgent)) {\n    return 'Electron';\n  }\n\n  const navigator_ = typeof navigator !== 'undefined' ? navigator : {};\n  const userAgent = mockUserAgent || navigator_.userAgent || '';\n  // const appVersion = navigator_.appVersion || '';\n\n  // NOTE: Order of tests matter, as many agents list Chrome etc.\n  if (userAgent.indexOf('Edge') > -1) {\n    return 'Edge';\n  }\n  const isMSIE = userAgent.indexOf('MSIE ') !== -1;\n  const isTrident = userAgent.indexOf('Trident/') !== -1;\n  if (isMSIE || isTrident) {\n    return 'IE';\n  }\n  // @ts-ignore\n  if (window.chrome) {\n    return 'Chrome';\n  }\n  // @ts-ignore\n  if (window.safari) {\n    return 'Safari';\n  }\n  // @ts-ignore\n  if (window.mozInnerScreenX) {\n    return 'Firefox';\n  }\n  return 'Unknown';\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 {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 {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","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 {\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 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 = 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 {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 {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 {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 {\n  SyncDataType,\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions\n} from '@loaders.gl/loader-utils';\nimport {assert} from '@loaders.gl/loader-utils';\nimport {selectLoaderSync} from './select-loader';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getArrayBufferOrStringFromDataSync} from '../loader-utils/get-data';\nimport {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\n\n/**\n * Parses `data` synchronously using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport function parseSync(\n  data: SyncDataType,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): any {\n  assert(!context || typeof context === 'object'); // parseSync no longer accepts final url\n\n  // Signature: parseSync(data, options)\n  // Uses registered loaders\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  options = options || {};\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  const loader = selectLoaderSync(data, candidateLoaders, options);\n  // Note: if nothrow option was set, it is possible that 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);\n\n  // Extract a url for auto detection\n  const {url} = getResourceUrlAndType(data);\n\n  const parse = () => {\n    throw new Error('parseSync called parse');\n  };\n  context = getLoaderContext({url, parseSync, parse, loaders: loaders as Loader[]}, options);\n\n  return parseWithLoaderSync(loader as LoaderWithParser, data, options, context);\n}\n\n// TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator\nfunction parseWithLoaderSync(\n  loader: LoaderWithParser,\n  data: SyncDataType,\n  options: LoaderOptions,\n  context: LoaderContext\n) {\n  data = getArrayBufferOrStringFromDataSync(data, loader, options);\n\n  if (loader.parseTextSync && typeof data === 'string') {\n    return loader.parseTextSync(data, options); // , context, loader);\n  }\n\n  if (loader.parseSync && data instanceof ArrayBuffer) {\n    return loader.parseSync(data, options, context); // , loader);\n  }\n\n  // TBD - If synchronous parser not available, return null\n  throw new Error(\n    `${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${\n      context.url || ''\n    }`\n  );\n}\n","import type {Batch} from '@loaders.gl/schema';\nimport type {\n  BatchableDataType,\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions\n} from '@loaders.gl/loader-utils';\nimport {assert, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getLoaderContext} from '../loader-utils/loader-context';\nimport {getAsyncIterableFromData} from '../loader-utils/get-data';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n// Ensure `parse` is available in context if loader falls back to `parse`\nimport {parse} from './parse';\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 parseInBatches(\n  data: BatchableDataType,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<any>> {\n  assert(!context || typeof context === 'object'); // parseInBatches no longer accepts final url\n\n  // Signature: parseInBatches(data, options, url) - Uses registered loaders\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  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  // Note - only uses URL and contentType for streams and iterator inputs\n  const loader = await selectLoader(data as ArrayBuffer, loaders as Loader[], options);\n  // Note: if options.nothrow was set, it is possible that no loader was found, if so just return null\n  if (!loader) {\n    // @ts-ignore\n    return null;\n  }\n\n  // Normalize options\n  // @ts-ignore\n  options = normalizeOptions(options, loader, loaders, url);\n  // @ts-ignore\n  context = getLoaderContext(\n    // @ts-ignore\n    {url, parseInBatches, parse, loaders: loaders as Loader[]},\n    options,\n    context\n  );\n\n  return await parseWithLoaderInBatches(loader as LoaderWithParser, data, options, context);\n}\n\n/**\n * Loader has been selected and context has been prepared, see if we need to emit a metadata batch\n */\nasync function parseWithLoaderInBatches(\n  loader: LoaderWithParser,\n  data: BatchableDataType,\n  options: LoaderOptions,\n  context: LoaderContext\n): Promise<AsyncIterable<any>> {\n  const outputIterator = await parseToOutputIterator(loader, data, options, context);\n\n  // Generate metadata batch if requested\n  if (!options.metadata) {\n    return outputIterator;\n  }\n\n  const metadataBatch = {\n    batchType: 'metadata',\n    metadata: {\n      _loader: loader,\n      _context: context\n    },\n    // Populate with some default fields to avoid crashing\n    data: [],\n    bytesUsed: 0\n  };\n\n  async function* makeMetadataBatchIterator(iterator) {\n    yield metadataBatch;\n    yield* iterator;\n  }\n\n  return makeMetadataBatchIterator(outputIterator);\n}\n\n/**\n * Prep work is done, now it is time to start parsing into an output operator\n * The approach depends on which parse function the loader exposes\n * `parseInBatches` (preferred), `parse` (fallback)\n */\nasync function parseToOutputIterator(\n  loader: LoaderWithParser,\n  data: BatchableDataType,\n  options: LoaderOptions,\n  context: LoaderContext\n): Promise<AsyncIterable<any>> {\n  // Get an iterator from the input\n  const inputIterator = await getAsyncIterableFromData(data, options);\n\n  // Apply any iterator transforms (options.transforms)\n  const transformedIterator = await applyInputTransforms(inputIterator, options?.transforms || []);\n\n  // If loader supports parseInBatches, we are done\n  if (loader.parseInBatches) {\n    return loader.parseInBatches(transformedIterator, options, context);\n  }\n\n  // Fallback: load atomically using `parse` concatenating input iterator into single chunk\n  async function* parseChunkInBatches() {\n    const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);\n    // Call `parse` instead of `loader.parse` to ensure we can call workers etc.\n    const parsedData = await parse(\n      arrayBuffer,\n      loader,\n      // TODO - Hack: supply loaders MIME type to ensure we match it\n      {...options, mimeType: loader.mimeTypes[0]},\n      context\n    );\n    // yield a single batch, the output from loader.parse()\n    // TODO - run through batch builder to apply options etc...\n    const batch: Batch = {\n      mimeType: loader.mimeTypes[0],\n      shape: Array.isArray(parsedData) ? 'row-table' : 'unknown',\n      batchType: 'data',\n      data: parsedData,\n      length: Array.isArray(parsedData) ? parsedData.length : 1\n    };\n    yield batch;\n  }\n\n  return parseChunkInBatches();\n}\n\ntype TransformBatches = (\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n) => AsyncIterable<ArrayBuffer>;\n\n/**\n * Create an iterator chain with any transform iterators (crypto, decompression)\n * @param inputIterator\n * @param options\n */\nasync function applyInputTransforms(\n  inputIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  transforms: TransformBatches[] = []\n): Promise<AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>> {\n  let iteratorChain = inputIterator;\n  for await (const transformBatches of transforms) {\n    iteratorChain = transformBatches(iteratorChain);\n  }\n  return iteratorChain;\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","import type {LoaderWithParser, LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {getFetchFunction} from '../loader-utils/option-utils';\n\nimport {parseInBatches} from './parse-in-batches';\n\ntype FileType = string | File | Blob | Response | (string | File | Blob | Response)[] | FileList;\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport function loadInBatches(\n  files: FileType,\n  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<any>>;\n\nexport function loadInBatches(\n  files: FileType[] | FileList,\n  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<any>>;\n\nexport function loadInBatches(files, loaders, options, context) {\n  // Signature: load(url, options)\n  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders;\n    loaders = null;\n  }\n\n  // Select fetch function\n  const fetch = getFetchFunction(options || {});\n\n  // Single url/file\n  if (!Array.isArray(files)) {\n    return loadOneFileInBatches(files, loaders, options, fetch);\n  }\n\n  // Multiple URLs / files\n  const promises = files.map((file) => loadOneFileInBatches(file, loaders, options, fetch));\n\n  // No point in waiting here for all responses before starting to stream individual streams?\n  return promises;\n}\n\nasync function loadOneFileInBatches(file, loaders, options, fetch) {\n  if (typeof file === 'string') {\n    const url = file;\n    const response = await fetch(url);\n    return await parseInBatches(response, loaders, options);\n  }\n  return await parseInBatches(file, loaders, options);\n}\n","import type {Writer, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {concatenateArrayBuffers, resolvePath} from '@loaders.gl/loader-utils';\nimport {isBrowser} from '@loaders.gl/loader-utils';\nimport {writeFile} from '../fetch/write-file';\nimport {fetchFile} from '../fetch/fetch-file';\n\n/**\n * Encode loaded data into a binary ArrayBuffer using the specified Writer.\n */\nexport async function encode(\n  data: any,\n  writer: Writer,\n  options?: LoaderOptions\n): Promise<ArrayBuffer> {\n  if (writer.encode) {\n    return await writer.encode(data, options);\n  }\n\n  if (writer.encodeSync) {\n    return writer.encodeSync(data, options);\n  }\n\n  if (writer.encodeText) {\n    return new TextEncoder().encode(await writer.encodeText(data, options));\n  }\n\n  if (writer.encodeInBatches) {\n    // Create an iterator representing the data\n    // TODO - Assumes this is a table\n    const batches = encodeInBatches(data, writer, options);\n\n    // Concatenate the output\n    const chunks: any[] = [];\n    for await (const batch of batches) {\n      chunks.push(batch);\n    }\n    // @ts-ignore\n    return concatenateArrayBuffers(...chunks);\n  }\n\n  if (!isBrowser && writer.encodeURLtoURL) {\n    // TODO - how to generate filenames with correct extensions?\n    const tmpInputFilename = getTemporaryFilename('input');\n    await writeFile(tmpInputFilename, data);\n\n    const tmpOutputFilename = getTemporaryFilename('output');\n\n    const outputFilename = await encodeURLtoURL(\n      tmpInputFilename,\n      tmpOutputFilename,\n      writer,\n      options\n    );\n\n    const response = await fetchFile(outputFilename);\n    return response.arrayBuffer();\n  }\n\n  throw new Error('Writer could not encode data');\n}\n\n/**\n * Encode loaded data into a binary ArrayBuffer using the specified Writer.\n */\nexport function encodeSync(data: any, writer: Writer, options?: LoaderOptions): ArrayBuffer {\n  if (writer.encodeSync) {\n    return writer.encodeSync(data, options);\n  }\n  throw new Error('Writer could not synchronously encode data');\n}\n\n/**\n * Encode loaded data to text using the specified Writer\n * @note This is a convenience function not intended for production use on large input data.\n * It is not optimized for performance. Data maybe converted from text to binary and back.\n * @throws if the writer does not generate text output\n */\nexport async function encodeText(\n  data: any,\n  writer: Writer,\n  options?: LoaderOptions\n): Promise<string> {\n  if (writer.text && writer.encodeText) {\n    return await writer.encodeText(data, options);\n  }\n\n  if (writer.text && (writer.encode || writer.encodeInBatches)) {\n    const arrayBuffer = await encode(data, writer, options);\n    return new TextDecoder().decode(arrayBuffer);\n  }\n\n  throw new Error('Writer could not encode data as text');\n}\n\n/**\n * Encode loaded data into a sequence (iterator) of binary ArrayBuffers using the specified Writer.\n */\nexport function encodeInBatches(\n  data: any,\n  writer: Writer,\n  options?: LoaderOptions\n): AsyncIterable<ArrayBuffer> {\n  if (writer.encodeInBatches) {\n    const dataIterator = getIterator(data);\n    return writer.encodeInBatches(dataIterator, options);\n  }\n  // TODO -fall back to atomic encode?\n  throw new Error('Writer could not encode data in batches');\n}\n\n/**\n * Encode data stored in a file (on disk) to another file.\n * @note Node.js only. This function enables using command-line converters as \"writers\".\n */\nexport async function encodeURLtoURL(\n  inputUrl,\n  outputUrl,\n  writer: Writer,\n  options\n): Promise<string> {\n  inputUrl = resolvePath(inputUrl);\n  outputUrl = resolvePath(outputUrl);\n  if (isBrowser || !writer.encodeURLtoURL) {\n    throw new Error();\n  }\n  const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);\n  return outputFilename;\n}\n\n/**\n * @todo TODO - this is an unacceptable hack!!!\n */\nfunction getIterator(data) {\n  const dataIterator = [{table: data, start: 0, end: data.length}];\n  return dataIterator;\n}\n\n/**\n * @todo Move to utils\n */\nfunction getTemporaryFilename(filename: string): string {\n  return `/tmp/${filename}`;\n}\n","import type {Writer, WriterOptions} from '@loaders.gl/loader-utils';\nimport {encode, encodeSync} from './encode';\nimport {writeFile, writeFileSync} from '../fetch/write-file';\n\nexport async function save(data, url, writer: Writer, options: WriterOptions) {\n  const encodedData = await encode(data, writer, options);\n  return await writeFile(url, encodedData);\n}\n\nexport function saveSync(data, url, writer, options) {\n  const encodedData = encodeSync(data, writer, options);\n  return writeFileSync(url, encodedData);\n}\n","import type {ReadableStreamType} from '../../javascript-utils/is-type';\nimport type {MakeDOMStreamOptions} from './make-dom-stream';\nimport type {MakeNodeStreamOptions} from './make-node-stream';\n\nimport {isBrowser} from '@loaders.gl/loader-utils';\nimport {makeDOMStream} from './make-dom-stream';\nimport makeNodeStream from './make-node-stream';\n\nexport type MakeStreamOptions = MakeDOMStreamOptions | MakeNodeStreamOptions;\n\n/**\n * Returns a stream for an (async) iterator (works in both Node.js and browsers)\n */\nexport function makeStream(\n  data: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>,\n  options?: MakeStreamOptions\n): ReadableStreamType {\n  return isBrowser ? makeDOMStream(data, options) : makeNodeStream(data, options);\n}\n","export type MakeDOMStreamOptions = {\n  /** Stream allocates an arrayBuffer. Enables use of a default reader. */\n  autoAllocateChunkSize?: number;\n  /** Total number of chunks in queue before back pressure is applied */\n  highWaterMark?: number;\n};\n\n/** Builds a DOM stream from an iterator */\nexport function makeDOMStream<ArrayBuffer>(\n  source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>,\n  options?: MakeDOMStreamOptions\n): ReadableStream {\n  const iterator = source[Symbol.asyncIterator]\n    ? (source as AsyncIterable<ArrayBuffer>)[Symbol.asyncIterator]()\n    : (source as Iterable<ArrayBuffer>)[Symbol.iterator]();\n\n  return new ReadableStream<Uint8Array>(\n    {\n      // Create a byte stream (enables `Response(stream).arrayBuffer()`)\n      // Only supported on Chrome\n      // See: https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController\n      // @ts-expect-error Only Chrome supports byte streams\n      type: 'bytes',\n\n      async pull(controller) {\n        try {\n          const {done, value} = await iterator.next();\n          if (done) {\n            controller.close();\n          } else {\n            // TODO - ignores controller.desiredSize\n            controller.enqueue(new Uint8Array(value));\n          }\n        } catch (error) {\n          controller.error(error);\n        }\n      },\n\n      async cancel() {\n        await iterator?.return?.();\n      }\n    },\n    // options: QueingStrategy<Uint8Array>\n    {\n      // This is bytes, not chunks\n      highWaterMark: 2 ** 24,\n      ...options\n    }\n  );\n}\n","// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nimport {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullWorkerLoader: Loader = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  worker: true,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  tests: [() => false],\n  options: {\n    null: {}\n  }\n};\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullLoader: LoaderWithParser = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  parse: async (arrayBuffer) => arrayBuffer,\n  parseSync: (arrayBuffer) => arrayBuffer,\n  parseInBatches: async function* generator(asyncIterator) {\n    for await (const batch of asyncIterator) {\n      yield batch;\n    }\n  },\n  tests: [() => false],\n  options: {\n    null: {}\n  }\n};\n","// Forked from github AnthumChris/fetch-progress-indicators under MIT license\n\n/**\n * Intercepts the Response stream and creates a new Response\n */\nexport default async function fetchProgress(\n  response: Response | Promise<Response>,\n  onProgress: any, // TODO better callback types\n  onDone = () => {},\n  onError = () => {}\n) {\n  response = await response;\n  if (!response.ok) {\n    // ERROR checking needs to be done separately\n    return response;\n  }\n  const body = response.body;\n  if (!body) {\n    // 'ReadableStream not yet supported in this browser.\n    return response;\n  }\n  const contentLength = response.headers.get('content-length') || 0;\n  const totalBytes = contentLength && parseInt(contentLength);\n  if (!(contentLength > 0)) {\n    return response;\n  }\n  // Currently override only implemented in browser\n  if (typeof ReadableStream === 'undefined' || !body.getReader) {\n    return response;\n  }\n\n  // Create a new stream that invisbly wraps original stream\n  const progressStream = new ReadableStream({\n    async start(controller) {\n      const reader = body.getReader();\n      await read(controller, reader, 0, totalBytes, onProgress, onDone, onError);\n    }\n  });\n\n  return new Response(progressStream);\n}\n\n// Forward to original streams controller\n// TODO - this causes a crazy deep \"async stack\"... rewrite as async iterator?\n// eslint-disable-next-line max-params\nasync function read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError) {\n  try {\n    const {done, value} = await reader.read();\n    if (done) {\n      onDone();\n      controller.close();\n      return;\n    }\n    loadedBytes += value.byteLength;\n    const percent = Math.round((loadedBytes / totalBytes) * 100);\n    onProgress(percent, {loadedBytes, totalBytes});\n    controller.enqueue(value);\n    await read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);\n  } catch (error) {\n    controller.error(error);\n    onError(error);\n  }\n}\n","import type {FileSystem} from './filesystem';\n\ntype BrowserFileSystemOptions = {\n  fetch?: typeof fetch;\n};\n\n/**\n * FileSystem adapter for a browser FileList.\n * Holds a list of browser 'File' objects.\n */\nexport default class BrowserFileSystem implements FileSystem {\n  private _fetch: typeof fetch;\n  private files: {[filename: string]: File} = {};\n  private lowerCaseFiles: {[filename: string]: File} = {};\n  private usedFiles: {[filename: string]: boolean} = {};\n\n  /**\n   * A FileSystem API wrapper around a list of browser 'File' objects\n   * @param files\n   * @param options\n   */\n  constructor(files: FileList | File[], options?: BrowserFileSystemOptions) {\n    this._fetch = options?.fetch || fetch;\n\n    for (let i = 0; i < files.length; ++i) {\n      const file = files[i];\n      this.files[file.name] = file;\n      this.lowerCaseFiles[file.name.toLowerCase()] = file;\n      this.usedFiles[file.name] = false;\n    }\n\n    this.fetch = this.fetch.bind(this);\n  }\n\n  // implements IFileSystem\n\n  /**\n   * Implementation of fetch against this file system\n   * Delegates to global fetch for http{s}:// or data://\n   */\n  async fetch(path: string, options?: RequestInit): Promise<Response> {\n    // Fallback to handle https:/http:/data: etc fetches\n    if (path.includes('://')) {\n      return this._fetch(path, options);\n    }\n\n    // Local fetches are served from the list of files\n    const file = this.files[path];\n    if (!file) {\n      return new Response(path, {status: 400, statusText: 'NOT FOUND'});\n    }\n\n    const headers = new Headers(options?.headers);\n    const range = headers.get('Range');\n    const bytes = range && /bytes=($1)-($2)/.exec(range);\n\n    if (bytes) {\n      const start = parseInt(bytes[1]);\n      const end = parseInt(bytes[2]);\n      // The trick when reading File objects is to read successive \"slices\" of the File\n      // Per spec https://w3c.github.io/FileAPI/, slicing a File should only update the start and end fields\n      // Actually reading from file should happen in `readAsArrayBuffer` (and as far we can tell it does)\n      const data = await file.slice(start, end).arrayBuffer();\n      const response = new Response(data);\n      Object.defineProperty(response, 'url', {value: path});\n      return response;\n    }\n\n    // return makeResponse()\n    const response = new Response(file);\n    Object.defineProperty(response, 'url', {value: path});\n    return response;\n  }\n\n  /**\n   * List filenames in this filesystem\n   * @param dirname\n   * @returns\n   */\n  async readdir(dirname?: string): Promise<string[]> {\n    const files: string[] = [];\n    for (const path in this.files) {\n      files.push(path);\n    }\n    // TODO filter by dirname\n    return files;\n  }\n\n  /**\n   * Return information (size) about files in this file system\n   */\n  async stat(path: string, options?: object): Promise<{size: number}> {\n    const file = this.files[path];\n    if (!file) {\n      throw new Error(path);\n    }\n    return {size: file.size};\n  }\n\n  /**\n   * Just removes the file from the list\n   */\n  async unlink(path: string): Promise<void> {\n    delete this.files[path];\n    delete this.lowerCaseFiles[path];\n    this.usedFiles[path] = true;\n  }\n\n  // implements IRandomAccessFileSystem\n\n  // RANDOM ACCESS\n  async open(pathname: string, flags, mode?): Promise<any> {\n    return this.files[pathname];\n  }\n\n  /**\n   * Read a range into a buffer\n   * @todo - handle position memory\n   * @param buffer is the buffer that the data (read from the fd) will be written to.\n   * @param offset is the offset in the buffer to start writing at.\n   * @param length is an integer specifying the number of bytes to read.\n   * @param position is an argument specifying where to begin reading from in the file. If position is null, data will be read from the current file position, and the file position will be updated. If position is an integer, the file position will remain unchanged.\n   */\n  async read(\n    fd: any,\n    buffer: ArrayBuffer,\n    offset: number = 0,\n    length: number = buffer.byteLength,\n    position: number | null = null\n  ): Promise<{bytesRead: number; buffer: ArrayBuffer}> {\n    const file = fd as File;\n    const startPosition = 0; // position\n    const arrayBuffer = await file.slice(startPosition, startPosition + length).arrayBuffer();\n    // copy into target buffer\n    return {bytesRead: length, buffer: arrayBuffer};\n  }\n\n  async close(fd: number): Promise<void> {\n    // NO OP\n  }\n\n  // fstat(fd: number): Promise<object>; // Stat\n\n  // PRIVATE\n\n  // Supports case independent paths, and file usage tracking\n  _getFile(path, used) {\n    // Prefer case match, but fall back to case indepent.\n    const file = this.files[path] || this.lowerCaseFiles[path];\n    if (file && used) {\n      this.usedFiles[path] = true;\n    }\n    return file;\n  }\n}\n","// TYPES\nexport type {ImageDataType, ImageType, ImageTypeEnum} from './types';\n\n// LOADERS AND WRITERS\nexport {ImageLoader} from './image-loader';\nexport {ImageWriter} from './image-writer';\n\n// IMAGE CATEGORY API\n\n// Binary Image API\nexport {getBinaryImageMetadata} from './lib/category-api/binary-image-api';\n\n// Parsed Image API\nexport {isImageTypeSupported, getDefaultImageType} from './lib/category-api/image-type';\n\nexport {\n  isImage,\n  getImageType,\n  getImageSize,\n  getImageData\n} from './lib/category-api/parsed-image-api';\n\n// DEPRECATED - Remove in V3 (fix dependency in luma.gl)\nexport {loadImage} from './lib/texture-api/load-image';\n","import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {VERSION} from './lib/utils/version';\nimport parseImage from './lib/parsers/parse-image';\nimport {getBinaryImageMetadata} from './lib/category-api/binary-image-api';\n\nconst EXTENSIONS = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'ico', 'svg'];\nconst MIME_TYPES = [\n  'image/png',\n  'image/jpeg',\n  'image/gif',\n  'image/webp',\n  'image/bmp',\n  'image/vnd.microsoft.icon',\n  'image/svg+xml'\n];\n\n/**\n * Loads a platform-specific image type\n * Note: This type can be used as input data to WebGL texture creation\n */\nexport const ImageLoader = {\n  id: 'image',\n  module: 'images',\n  name: 'Images',\n  version: VERSION,\n  mimeTypes: MIME_TYPES,\n  extensions: EXTENSIONS,\n  parse: parseImage,\n  // TODO: byteOffset, byteLength;\n  tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],\n  options: {\n    image: {\n      type: 'auto',\n      decode: true // if format is HTML\n    }\n    // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor\n  }\n};\n\nexport const _typecheckImageLoader: LoaderWithParser = ImageLoader;\n","// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n","import {assert} from '../utils/assert';\nimport {isImageTypeSupported, getDefaultImageType} from '../category-api/image-type';\nimport {getImageData} from '../category-api/parsed-image-api';\nimport parseToImage from './parse-to-image';\nimport parseToImageBitmap from './parse-to-image-bitmap';\nimport parseToNodeImage from './parse-to-node-image';\n\n// Parse to platform defined image type (data on node, ImageBitmap or HTMLImage on browser)\n// eslint-disable-next-line complexity\nexport default async function parseImage(arrayBuffer, options, context) {\n  options = options || {};\n  const imageOptions = options.image || {};\n\n  // The user can request a specific output format via `options.image.type`\n  const imageType = imageOptions.type || 'auto';\n\n  const {url} = context || {};\n\n  // Note: For options.image.type === `data`, we may still need to load as `image` or `imagebitmap`\n  const loadType = getLoadableImageType(imageType);\n\n  let image;\n  switch (loadType) {\n    case 'imagebitmap':\n      image = await parseToImageBitmap(arrayBuffer, options, url);\n      break;\n    case 'image':\n      image = await parseToImage(arrayBuffer, options, url);\n      break;\n    case 'data':\n      // Node.js loads imagedata directly\n      image = await parseToNodeImage(arrayBuffer, options);\n      break;\n    default:\n      assert(false);\n  }\n\n  // Browser: if options.image.type === 'data', we can now extract data from the loaded image\n  if (imageType === 'data') {\n    image = getImageData(image);\n  }\n\n  return image;\n}\n\n// Get a loadable image type from image type\nfunction getLoadableImageType(type) {\n  switch (type) {\n    case 'auto':\n    case 'data':\n      // Browser: For image data we need still need to load using an image format\n      // Node: the default image type is `data`.\n      return getDefaultImageType();\n    default:\n      // Throw an error if not supported\n      isImageTypeSupported(type);\n      return type;\n  }\n}\n","export function assert(condition, message) {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n","import type {ImageTypeEnum} from '../../types';\nimport {global, isBrowser} from '../utils/globals';\n\n// @ts-ignore TS2339: Property does not exist on type\nconst {_parseImageNode} = global;\n\nconst IMAGE_SUPPORTED = typeof Image !== 'undefined'; // NOTE: \"false\" positives if jsdom is installed\nconst IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== 'undefined';\nconst NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);\nconst DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;\n\n/**\n * Checks if a loaders.gl image type is supported\n * @param type image type string\n */\nexport function isImageTypeSupported(type: string): boolean {\n  switch (type) {\n    case 'auto':\n      // Should only ever be false in Node.js, if polyfills have not been installed...\n      return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;\n\n    case 'imagebitmap':\n      return IMAGE_BITMAP_SUPPORTED;\n    case 'image':\n      return IMAGE_SUPPORTED;\n    case 'data':\n      return DATA_SUPPORTED;\n\n    default:\n      throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);\n  }\n}\n\n/**\n * Returns the \"most performant\" supported image type on this platform\n * @returns image type string\n */\nexport function getDefaultImageType(): ImageTypeEnum {\n  if (IMAGE_BITMAP_SUPPORTED) {\n    return 'imagebitmap';\n  }\n  if (IMAGE_SUPPORTED) {\n    return 'image';\n  }\n  if (DATA_SUPPORTED) {\n    return 'data';\n  }\n\n  // This should only happen in Node.js\n  throw new Error('Install \\'@loaders.gl/polyfills\\' to parse images under Node.js');\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// 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_ = 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 || {};\n\nexport {self_ as self, window_ as window, global_ as global, document_ as document};\n\nexport const isBrowser =\n  // @ts-ignore\n  typeof process !== 'object' || String(process) !== '[object process]' || process.browser;\n\nexport const isWorker = typeof importScripts === 'function';\n\n// Extract node major version\nconst matches =\n  typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);\nexport const nodeVersion = (matches && parseFloat(matches[1])) || 0;\n","import type {ImageType, ImageTypeEnum, ImageDataType} from '../../types';\n\nexport function isImage(image: ImageType): boolean {\n  return Boolean(getImageTypeOrNull(image));\n}\n\nexport function deleteImage(image: ImageType): void {\n  switch (getImageType(image)) {\n    case 'imagebitmap':\n      (image as ImageBitmap).close();\n      break;\n    default:\n    // Nothing to do for images and image data objects\n  }\n}\n\nexport function getImageType(image: ImageType): ImageTypeEnum {\n  const format = getImageTypeOrNull(image);\n  if (!format) {\n    throw new Error('Not an image');\n  }\n  return format;\n}\n\nexport function getImageSize(image: ImageType): {width: number; height: number} {\n  return getImageData(image);\n}\n\nexport function getImageData(image: ImageType): ImageDataType | ImageData {\n  switch (getImageType(image)) {\n    case 'data':\n      return image as unknown as ImageData;\n\n    case 'image':\n    case 'imagebitmap':\n      // Extract the image data from the image via a canvas\n      const canvas = document.createElement('canvas');\n      // TODO - reuse the canvas?\n      const context = canvas.getContext('2d');\n      if (!context) {\n        throw new Error('getImageData');\n      }\n      // @ts-ignore\n      canvas.width = image.width;\n      // @ts-ignore\n      canvas.height = image.height;\n      // @ts-ignore\n      context.drawImage(image, 0, 0);\n      // @ts-ignore\n      return context.getImageData(0, 0, image.width, image.height);\n\n    default:\n      throw new Error('getImageData');\n  }\n}\n\n// PRIVATE\n\n// eslint-disable-next-line complexity\nfunction getImageTypeOrNull(image) {\n  if (typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {\n    return 'imagebitmap';\n  }\n  if (typeof Image !== 'undefined' && image instanceof Image) {\n    return 'image';\n  }\n  if (image && typeof image === 'object' && image.data && image.width && image.height) {\n    return 'data';\n  }\n  return null;\n}\n","import {getBlobOrSVGDataUrl} from './svg-utils';\n\n// Parses html image from array buffer\nexport default async function parseToImage(arrayBuffer, options, url) {\n  // Note: image parsing requires conversion to Blob (for createObjectURL).\n  // Potentially inefficient for not using `response.blob()` (and for File / Blob inputs)...\n  // But presumably not worth adding 'blob' flag to loader objects?\n\n  const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);\n  const URL = self.URL || self.webkitURL;\n  const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);\n  try {\n    return await loadToImage(objectUrl || blobOrDataUrl, options);\n  } finally {\n    if (objectUrl) {\n      URL.revokeObjectURL(objectUrl);\n    }\n  }\n}\n\nexport async function loadToImage(url, options) {\n  const image = new Image();\n  image.src = url;\n\n  // The `image.onload()` callback does not guarantee that the image has been decoded\n  // so a main thread \"freeze\" can be incurred when using the image for the first time.\n  // `Image.decode()` returns a promise that completes when image is decoded.\n\n  // https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decode\n  // Note: When calling `img.decode()`, we do not need to wait for `img.onload()`\n  // Note: `HTMLImageElement.decode()` is not available in Edge and IE11\n  if (options.image && options.image.decode && image.decode) {\n    await image.decode();\n    return image;\n  }\n\n  // Create a promise that tracks onload/onerror callbacks\n  return await new Promise((resolve, reject) => {\n    try {\n      image.onload = () => resolve(image);\n      image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n","// SVG parsing has limitations, e.g:\n// https://bugs.chromium.org/p/chromium/issues/detail?id=606319\n\nconst SVG_DATA_URL_PATTERN = /^data:image\\/svg\\+xml/;\nconst SVG_URL_PATTERN = /\\.svg((\\?|#).*)?$/;\n\nexport function isSVG(url) {\n  return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));\n}\n\nexport function getBlobOrSVGDataUrl(arrayBuffer, url) {\n  if (isSVG(url)) {\n    // Prepare a properly tagged data URL, and load using normal mechanism\n    const textDecoder = new TextDecoder();\n    let xmlText = textDecoder.decode(arrayBuffer);\n    // TODO Escape in browser to support e.g. Chinese characters\n    try {\n      if (typeof unescape === 'function' && typeof encodeURIComponent === 'function') {\n        xmlText = unescape(encodeURIComponent(xmlText));\n      }\n    } catch (error) {\n      throw new Error((error as Error).message);\n    }\n    // base64 encoding is safer. utf-8 fails in some browsers\n    const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;\n    return src;\n  }\n  return getBlob(arrayBuffer, url);\n}\n\nexport function getBlob(arrayBuffer, url) {\n  if (isSVG(url)) {\n    // https://bugs.chromium.org/p/chromium/issues/detail?id=606319\n    // return new Blob([new Uint8Array(arrayBuffer)], {type: 'image/svg+xml'});\n    throw new Error('SVG cannot be parsed directly to imagebitmap');\n  }\n  // TODO - how to determine mime type? Param? Sniff here?\n  return new Blob([new Uint8Array(arrayBuffer)]); // MIME type not needed?\n}\n","import {isSVG, getBlob} from './svg-utils';\nimport parseToImage from './parse-to-image';\n\nconst EMPTY_OBJECT = {};\n\nlet imagebitmapOptionsSupported = true;\n\n/**\n * Asynchronously parses an array buffer into an ImageBitmap - this contains the decoded data\n * ImageBitmaps are supported on worker threads, but not supported on Edge, IE11 and Safari\n * https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap#Browser_compatibility\n *\n * TODO - createImageBitmap supports source rect (5 param overload), pass through?\n */\nexport default async function parseToImageBitmap(arrayBuffer, options, url) {\n  let blob;\n\n  // Cannot parse SVG directly to ImageBitmap, parse to Image first\n  if (isSVG(url)) {\n    // Note: this only works on main thread\n    const image = await parseToImage(arrayBuffer, options, url);\n    blob = image;\n  } else {\n    // Create blob from the array buffer\n    blob = getBlob(arrayBuffer, url);\n  }\n\n  const imagebitmapOptions = options && options.imagebitmap;\n\n  return await safeCreateImageBitmap(blob, imagebitmapOptions);\n}\n\n/**\n * Safely creates an imageBitmap with options\n * *\n * Firefox crashes if imagebitmapOptions is supplied\n * Avoid supplying if not provided or supported, remember if not supported\n */\nasync function safeCreateImageBitmap(blob, imagebitmapOptions = null) {\n  if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {\n    imagebitmapOptions = null;\n  }\n\n  if (imagebitmapOptions) {\n    try {\n      // @ts-ignore Options\n      return await createImageBitmap(blob, imagebitmapOptions);\n    } catch (error) {\n      console.warn(error); // eslint-disable-line\n      imagebitmapOptionsSupported = false;\n    }\n  }\n\n  return await createImageBitmap(blob);\n}\n\nfunction isEmptyObject(object) {\n  // @ts-ignore\n  for (const key in object || EMPTY_OBJECT) {\n    return false;\n  }\n  return true;\n}\n","import {global} from '../utils/globals';\nimport {assert} from '../utils/assert';\nimport {getBinaryImageMetadata} from '../category-api/binary-image-api';\n\n// Use polyfills if installed to p[arsed image using get-pixels\nexport default function parseToNodeImage(arrayBuffer, options) {\n  const {mimeType} = getBinaryImageMetadata(arrayBuffer) || {};\n\n  // @ts-ignore\n  const {_parseImageNode} = global;\n  assert(_parseImageNode); // '@loaders.gl/polyfills not installed'\n\n  return _parseImageNode(arrayBuffer, mimeType, options);\n}\n","// Attributions\n// * Based on binary-gltf-utils under MIT license: Copyright (c) 2016-17 Karl Cheng\n\n// TODO: make these functions work for Node.js buffers?\n// Quarantine references to Buffer to prevent bundler from adding big polyfills\n// import {bufferToArrayBuffer} from '../node/buffer-to-array-buffer';\n// TODO - this should be handled in @loaders.gl/polyfills\n\n/** MIME type, width and height extracted from binary compressed image data */\nexport type BinaryImageMetadata = {\n  mimeType: string;\n  width: number;\n  height: number;\n};\n\nconst BIG_ENDIAN = false;\nconst LITTLE_ENDIAN = true;\n\n/**\n * Extracts `{mimeType, width and height}` from a memory buffer containing a known image format\n * Currently supports `image/png`, `image/jpeg`, `image/bmp` and `image/gif`.\n * @param binaryData image file memory to parse\n * @returns metadata or null if memory is not a valid image file format layout.\n */\nexport function getBinaryImageMetadata(\n  binaryData: DataView | ArrayBuffer\n): BinaryImageMetadata | null {\n  const dataView = toDataView(binaryData);\n  return (\n    getPngMetadata(dataView) ||\n    getJpegMetadata(dataView) ||\n    getGifMetadata(dataView) ||\n    getBmpMetadata(dataView)\n  );\n}\n\n// PNG\n\nfunction getPngMetadata(binaryData) {\n  const dataView = toDataView(binaryData);\n  // Check file contains the first 4 bytes of the PNG signature.\n  const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 0x89504e47;\n  if (!isPng) {\n    return null;\n  }\n\n  // Extract size from a binary PNG file\n  return {\n    mimeType: 'image/png',\n    width: dataView.getUint32(16, BIG_ENDIAN),\n    height: dataView.getUint32(20, BIG_ENDIAN)\n  };\n}\n\n// GIF\n\n// Extract size from a binary GIF file\n// TODO: GIF is not this simple\nfunction getGifMetadata(binaryData) {\n  const dataView = toDataView(binaryData);\n  // Check first 4 bytes of the GIF signature (\"GIF8\").\n  const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 0x47494638;\n  if (!isGif) {\n    return null;\n  }\n\n  // GIF is little endian.\n  return {\n    mimeType: 'image/gif',\n    width: dataView.getUint16(6, LITTLE_ENDIAN),\n    height: dataView.getUint16(8, LITTLE_ENDIAN)\n  };\n}\n\n// BMP\n\n// TODO: BMP is not this simple\nexport function getBmpMetadata(binaryData) {\n  const dataView = toDataView(binaryData);\n  // Check magic number is valid (first 2 characters should be \"BM\").\n  // The mandatory bitmap file header is 14 bytes long.\n  const isBmp =\n    dataView.byteLength >= 14 &&\n    dataView.getUint16(0, BIG_ENDIAN) === 0x424d &&\n    dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;\n\n  if (!isBmp) {\n    return null;\n  }\n\n  // BMP is little endian.\n  return {\n    mimeType: 'image/bmp',\n    width: dataView.getUint32(18, LITTLE_ENDIAN),\n    height: dataView.getUint32(22, LITTLE_ENDIAN)\n  };\n}\n\n// JPEG\n\n// Extract width and height from a binary JPEG file\nfunction getJpegMetadata(binaryData) {\n  const dataView = toDataView(binaryData);\n  // Check file contains the JPEG \"start of image\" (SOI) marker\n  // followed by another marker.\n  const isJpeg =\n    dataView.byteLength >= 3 &&\n    dataView.getUint16(0, BIG_ENDIAN) === 0xffd8 &&\n    dataView.getUint8(2) === 0xff;\n\n  if (!isJpeg) {\n    return null;\n  }\n\n  const {tableMarkers, sofMarkers} = getJpegMarkers();\n\n  // Exclude the two byte SOI marker.\n  let i = 2;\n  while (i + 9 < dataView.byteLength) {\n    const marker = dataView.getUint16(i, BIG_ENDIAN);\n\n    // The frame that contains the width and height of the JPEG image.\n    if (sofMarkers.has(marker)) {\n      return {\n        mimeType: 'image/jpeg',\n        height: dataView.getUint16(i + 5, BIG_ENDIAN), // Number of lines\n        width: dataView.getUint16(i + 7, BIG_ENDIAN) // Number of pixels per line\n      };\n    }\n\n    // Miscellaneous tables/data preceding the frame header.\n    if (!tableMarkers.has(marker)) {\n      return null;\n    }\n\n    // Length includes size of length parameter but not the two byte header.\n    i += 2;\n    i += dataView.getUint16(i, BIG_ENDIAN);\n  }\n\n  return null;\n}\n\nfunction getJpegMarkers() {\n  // Tables/misc header markers.\n  // DQT, DHT, DAC, DRI, COM, APP_n\n  const tableMarkers = new Set([0xffdb, 0xffc4, 0xffcc, 0xffdd, 0xfffe]);\n  for (let i = 0xffe0; i < 0xfff0; ++i) {\n    tableMarkers.add(i);\n  }\n\n  // SOF markers and DHP marker.\n  // These markers are after tables/misc data.\n  const sofMarkers = new Set([\n    0xffc0, 0xffc1, 0xffc2, 0xffc3, 0xffc5, 0xffc6, 0xffc7, 0xffc9, 0xffca, 0xffcb, 0xffcd, 0xffce,\n    0xffcf, 0xffde\n  ]);\n\n  return {tableMarkers, sofMarkers};\n}\n\n// TODO - move into image module?\nfunction toDataView(data) {\n  if (data instanceof DataView) {\n    return data;\n  }\n  if (ArrayBuffer.isView(data)) {\n    return new DataView(data.buffer);\n  }\n\n  // TODO: make these functions work for Node.js buffers?\n  // if (bufferToArrayBuffer) {\n  //   data = bufferToArrayBuffer(data);\n  // }\n\n  // Careful - Node Buffers will look like ArrayBuffers (keep after isBuffer)\n  if (data instanceof ArrayBuffer) {\n    return new DataView(data);\n  }\n  throw new Error('toDataView');\n}\n","// import type {Writer} from '@loaders.gl/loader-utils';\nimport {VERSION} from './lib/utils/version';\nimport {encodeImage} from './lib/encoders/encode-image';\n\nexport const ImageWriter = {\n  name: 'Images',\n  id: 'image',\n  module: 'images',\n  version: VERSION,\n  extensions: ['jpeg'],\n  options: {\n    image: {\n      mimeType: 'image/png',\n      jpegQuality: null\n    }\n  },\n  encode: encodeImage\n};\n","// Image loading/saving for browser and Node.js\nimport {global} from '../utils/globals';\nimport {getImageSize} from '../category-api/parsed-image-api';\n\n// @ts-ignore TS2339: Property does not exist on type\nconst {_encodeImageNode} = global;\n\n/**\n * Returns data bytes representing a compressed image in PNG or JPG format,\n * This data can be saved using file system (f) methods or used in a request.\n * @param image - ImageBitmap Image or Canvas\n * @param options\n * param opt.type='png' - png, jpg or image/png, image/jpg are valid\n * param mimeType= - Whether to include a data URI header\n */\nexport async function encodeImage(\n  image: any,\n  options?: {[key: string]: any}\n): Promise<ArrayBuffer> {\n  options = options || {};\n  options.image = options.image || ({} as {[key: string]: any});\n\n  return _encodeImageNode\n    ? _encodeImageNode(image, {type: options.image.mimeType})\n    : encodeImageInBrowser(image, options);\n}\n\n// In case we get exceptions from canvas.toBlob(resolve, type, quality)\nlet qualityParamSupported = true;\n\n/**\n *\n * @param image\n * @param options\n * @note Based on canvas.toBlob\n * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob\n */\nasync function encodeImageInBrowser(image, options) {\n  const {mimeType, jpegQuality} = options.image;\n\n  const {width, height} = getImageSize(image);\n\n  // create a canvas and resize it to the size of our image\n  const canvas = document.createElement('canvas');\n  canvas.width = width;\n  canvas.height = height;\n\n  drawImageToCanvas(image, canvas);\n\n  // The actual encoding is done asynchronously with `canvas.toBlob()`\n  const blob = await new Promise<Blob | null>((resolve) => {\n    // get it back as a Blob\n    if (jpegQuality && qualityParamSupported) {\n      try {\n        canvas.toBlob(resolve, mimeType, jpegQuality);\n        return;\n      } catch (error) {\n        qualityParamSupported = false;\n      }\n    }\n    canvas.toBlob(resolve, mimeType);\n  });\n\n  if (!blob) {\n    throw new Error('image encoding failed');\n  }\n\n  return await blob.arrayBuffer();\n}\n\nfunction drawImageToCanvas(image, canvas, x = 0, y = 0) {\n  // Try optimized path for ImageBitmaps via bitmaprenderer context\n  if (x === 0 && y === 0 && typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {\n    const context = canvas.getContext('bitmaprenderer');\n    if (context) {\n      // transfer the ImageBitmap to it\n      context.transferFromImageBitmap(image);\n      return canvas;\n    }\n  }\n\n  // Available on most platforms, except IE11 and Andriod WebViews...\n  const context = canvas.getContext('2d');\n  if (image.data) {\n    // ImageData constructor expects clamped array even though getImageData does not return a clamped array...\n    const clampedArray = new Uint8ClampedArray(image.data);\n    const imageData = new ImageData(clampedArray, image.width, image.height);\n    context.putImageData(imageData, 0, 0);\n    return canvas;\n  }\n\n  // Fall back to generic image/image bitmap rendering path\n  context.drawImage(image, 0, 0);\n  return canvas;\n}\n","import {assert} from '../utils/assert';\nimport parseImage from '../parsers/parse-image';\nimport {getImageSize} from '../category-api/parsed-image-api';\nimport {generateUrl} from './generate-url';\nimport {deepLoad, shallowLoad} from './deep-load';\n\nexport async function loadImage(getUrl, options = {}) {\n  const imageUrls = await getImageUrls(getUrl, options);\n  return await deepLoad(imageUrls, parseImage, options);\n}\n\nexport async function getImageUrls(getUrl, options, urlOptions = {}) {\n  const mipLevels = (options && options.image && options.image.mipLevels) || 0;\n  return mipLevels !== 0\n    ? await getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions)\n    : generateUrl(getUrl, options, urlOptions);\n}\n\nasync function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) {\n  const urls: string[] = [];\n\n  // If no mip levels supplied, we need to load the level 0 image and calculate based on size\n  if (mipLevels === 'auto') {\n    const url = generateUrl(getUrl, options, {...urlOptions, lod: 0});\n    const image = await shallowLoad(url, parseImage, options);\n\n    const {width, height} = getImageSize(image);\n    mipLevels = getMipLevels({width, height});\n\n    // TODO - push image and make `deepLoad` pass through non-url values, avoid loading twice?\n    urls.push(url);\n  }\n\n  // We now know how many mipLevels we need, remaining image urls can now be constructed\n  assert(mipLevels > 0);\n\n  for (let mipLevel = urls.length; mipLevel < mipLevels; ++mipLevel) {\n    const url = generateUrl(getUrl, options, {...urlOptions, lod: mipLevel});\n    urls.push(url);\n  }\n\n  return urls;\n}\n\n// Calculates number of mipmaps based on texture size (log2)\nexport function getMipLevels({width, height}) {\n  return 1 + Math.floor(Math.log2(Math.max(width, height)));\n}\n","import {resolvePath} from '@loaders.gl/loader-utils';\nimport {assert} from '../utils/assert';\n\n// Generate a url by calling getUrl with mix of options, applying options.baseUrl\nexport function generateUrl(getUrl, options, urlOptions) {\n  // Get url\n  let url = getUrl;\n  if (typeof getUrl === 'function') {\n    url = getUrl({...options, ...urlOptions});\n  }\n  assert(typeof url === 'string');\n\n  // Apply options.baseUrl\n  const {baseUrl} = options;\n  if (baseUrl) {\n    url = baseUrl[baseUrl.length - 1] === '/' ? `${baseUrl}${url}` : `${baseUrl}/${url}`;\n  }\n\n  return resolvePath(url);\n}\n","import {asyncDeepMap} from './async-deep-map';\n\nexport async function deepLoad(urlTree, load, options) {\n  return await asyncDeepMap(urlTree, (url) => shallowLoad(url, load, options));\n}\n\nexport async function shallowLoad(url, load, options) {\n  // console.error('loading', url);\n  const response = await fetch(url, options.fetch);\n  const arrayBuffer = await response.arrayBuffer();\n  return await load(arrayBuffer, options);\n}\n","/*\nAsynchronously maps a deep structure of values (e.g. objects and arrays of urls).\n\nE.g. a mipmapped cubemap\n{\n  [CUBE_FACE_FRONT]: [\n    \"image-front-0.jpg\",\n    \"image-front-1.jpg\",\n    \"image-front-2.jpg\",\n  ],\n  [CUBE_MAP_BACK]: [\n    ...\n  ]\n}\n*/\n\nconst isObject = (value) => value && typeof value === 'object';\n\n// Loads a deep structure of urls (objects and arrays of urls)\n// Returns an object with six key-value pairs containing the images (or image mip arrays)\n// for each cube face\nexport async function asyncDeepMap(tree, func, options = {}) {\n  return await mapSubtree(tree, func, options);\n}\n\nexport async function mapSubtree(object, func, options) {\n  if (Array.isArray(object)) {\n    return await mapArray(object, func, options);\n  }\n\n  if (isObject(object)) {\n    return await mapObject(object, func, options);\n  }\n\n  // TODO - ignore non-urls, non-arraybuffers?\n  const url = object;\n  return await func(url, options);\n}\n\n// HELPERS\n\nasync function mapObject(object, func, options) {\n  const promises: Promise<any>[] = [];\n  const values = {};\n\n  for (const key in object) {\n    const url = object[key];\n    const promise = mapSubtree(url, func, options).then((value) => {\n      values[key] = value;\n    });\n    promises.push(promise);\n  }\n\n  await Promise.all(promises);\n\n  return values;\n}\n\nasync function mapArray(urlArray, func, options = {}) {\n  const promises = urlArray.map((url) => mapSubtree(url, func, options));\n  return await Promise.all(promises);\n}\n","// This file enables: import 'probe.gl/bench'.\n// Note: Must be published using package.json \"files\" field\nmodule.exports = require('./dist/es5/env');\n","// ENVIRONMENT\nexport {self, window, global, document, process, console} from './globals';\nexport {default as isBrowser, isBrowserMainThread} from './is-browser';\nexport {default as getBrowser, isMobile} from './get-browser';\nexport {default as isElectron} from './is-electron';\n","function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\n\nmodule.exports = _interopRequireDefault;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    module.exports = _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  } else {\n    module.exports = _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  }\n\n  return _typeof(obj);\n}\n\nmodule.exports = _typeof;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","import {Log} from 'probe.gl';\n\nexport default new Log({id: 'deck'});\n","import deckLog from '../utils/log';\nimport {getLoggers} from './loggers';\n\n/* debug utility */\n\nlet loggers = {};\n\n// Conditionally load default loggers in development mode\n// eslint-disable-next-line\nif (process.env.NODE_ENV !== 'production') {\n  loggers = getLoggers(deckLog);\n}\n\nexport function register(handlers) {\n  loggers = handlers;\n}\n\nexport default function debug(eventType) {\n  if (deckLog.level > 0 && loggers[eventType]) {\n    // Not using ...args to defeat perf hit from array construction\n    loggers[eventType].call(...arguments);\n  }\n}\n","const logState = {\n  attributeUpdateMessages: []\n};\n\nconst LOG_LEVEL_MAJOR_UPDATE = 1; // Events with direct perf impact\nconst LOG_LEVEL_MINOR_UPDATE = 2; // Events that may affect perf\nconst LOG_LEVEL_UPDATE_DETAIL = 3;\nconst LOG_LEVEL_INFO = 4;\nconst LOG_LEVEL_DRAW = 2;\n\nexport const getLoggers = log => ({\n  /* Layer events */\n\n  'layer.changeFlag': (layer, key, flags) => {\n    log.log(LOG_LEVEL_UPDATE_DETAIL, `${layer.id} ${key}: `, flags[key])();\n  },\n\n  'layer.initialize': layer => {\n    log.log(LOG_LEVEL_MAJOR_UPDATE, `Initializing ${layer}`)();\n  },\n  'layer.update': (layer, needsUpdate) => {\n    if (needsUpdate) {\n      const flags = layer.getChangeFlags();\n      log.log(\n        LOG_LEVEL_MINOR_UPDATE,\n        `Updating ${layer} because: ${Object.keys(flags)\n          .filter(key => flags[key])\n          .join(', ')}`\n      )();\n    } else {\n      log.log(LOG_LEVEL_INFO, `${layer} does not need update`)();\n    }\n  },\n  'layer.matched': (layer, changed) => {\n    if (changed) {\n      log.log(LOG_LEVEL_INFO, `Matched ${layer}, state transfered`)();\n    }\n  },\n  'layer.finalize': layer => {\n    log.log(LOG_LEVEL_MAJOR_UPDATE, `Finalizing ${layer}`)();\n  },\n\n  /* CompositeLayer events */\n\n  'compositeLayer.renderLayers': (layer, updated, subLayers) => {\n    if (updated) {\n      log.log(\n        LOG_LEVEL_MINOR_UPDATE,\n        `Composite layer rendered new subLayers ${layer}`,\n        subLayers\n      )();\n    } else {\n      log.log(LOG_LEVEL_INFO, `Composite layer reused subLayers ${layer}`, subLayers)();\n    }\n  },\n\n  /* LayerManager events */\n\n  'layerManager.setLayers': (layerManager, updated, layers) => {\n    if (updated) {\n      log.log(LOG_LEVEL_MINOR_UPDATE, `Updating ${layers.length} deck layers`)();\n    }\n  },\n\n  'layerManager.activateViewport': (layerManager, viewport) => {\n    log.log(LOG_LEVEL_UPDATE_DETAIL, 'Viewport changed', viewport)();\n  },\n\n  /* AttributeManager events */\n\n  'attributeManager.invalidate': (attributeManager, trigger, attributeNames) => {\n    log.log(\n      LOG_LEVEL_MAJOR_UPDATE,\n      attributeNames\n        ? `invalidated attributes ${attributeNames} (${trigger}) for ${attributeManager.id}`\n        : `invalidated all attributes for ${attributeManager.id}`\n    )();\n  },\n\n  'attributeManager.updateStart': attributeManager => {\n    logState.attributeUpdateMessages.length = 0;\n    logState.attributeManagerUpdateStart = Date.now();\n  },\n  'attributeManager.updateEnd': (attributeManager, numInstances) => {\n    const timeMs = Math.round(Date.now() - logState.attributeManagerUpdateStart);\n    log.groupCollapsed(\n      LOG_LEVEL_MINOR_UPDATE,\n      `Updated attributes for ${numInstances} instances in ${attributeManager.id} in ${timeMs}ms`\n    )();\n    for (const updateMessage of logState.attributeUpdateMessages) {\n      log.log(LOG_LEVEL_UPDATE_DETAIL, updateMessage)();\n    }\n    log.groupEnd(LOG_LEVEL_MINOR_UPDATE)();\n  },\n\n  /* Attribute events */\n\n  'attribute.updateStart': attribute => {\n    logState.attributeUpdateStart = Date.now();\n  },\n  'attribute.allocate': (attribute, numInstances) => {\n    const message = `${attribute.id} allocated ${numInstances}`;\n    logState.attributeUpdateMessages.push(message);\n  },\n  'attribute.updateEnd': (attribute, numInstances) => {\n    const timeMs = Math.round(Date.now() - logState.attributeUpdateStart);\n    const message = `${attribute.id} updated ${numInstances} in ${timeMs}ms`;\n    logState.attributeUpdateMessages.push(message);\n  },\n\n  /* Render events */\n\n  'deckRenderer.renderLayers': (deckRenderer, renderStats, opts) => {\n    const {pass, redrawReason, stats} = opts;\n    for (const status of renderStats) {\n      const {totalCount, visibleCount, compositeCount, pickableCount} = status;\n      const primitiveCount = totalCount - compositeCount;\n      const hiddenCount = primitiveCount - visibleCount;\n\n      log.log(\n        LOG_LEVEL_DRAW,\n        `RENDER #${deckRenderer.renderCount} \\\n  ${visibleCount} (of ${totalCount} layers) to ${pass} because ${redrawReason} \\\n  (${hiddenCount} hidden, ${compositeCount} composite ${pickableCount} pickable)`\n      )();\n\n      if (stats) {\n        stats.get('Redraw Layers').add(visibleCount);\n      }\n    }\n  }\n});\n","function isJSON(text) {\n  const firstChar = text[0];\n  const lastChar = text[text.length - 1];\n  return (firstChar === '{' && lastChar === '}') || (firstChar === '[' && lastChar === ']');\n}\n\n// TODO - replace with the version in loaders.gl\nexport default {\n  name: 'JSON',\n  // TODO - can we stream process geojson?\n  extensions: ['json', 'geojson'],\n  mimeTypes: ['application/json', 'application/geo+json'],\n  testText: isJSON,\n  parseTextSync: JSON.parse\n};\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {ProgramManager} from '@luma.gl/core';\nimport {gouraudLighting, phongLighting} from '@luma.gl/core';\nimport project from './project/project';\nimport project32 from './project32/project32';\nimport shadow from './shadow/shadow';\nimport picking from './picking/picking';\n\nconst DEFAULT_MODULES = [project];\n\nconst SHADER_HOOKS = [\n  'vs:DECKGL_FILTER_SIZE(inout vec3 size, VertexGeometry geometry)',\n  'vs:DECKGL_FILTER_GL_POSITION(inout vec4 position, VertexGeometry geometry)',\n  'vs:DECKGL_FILTER_COLOR(inout vec4 color, VertexGeometry geometry)',\n  'fs:DECKGL_FILTER_COLOR(inout vec4 color, FragmentGeometry geometry)'\n];\n\nexport function createProgramManager(gl) {\n  const programManager = ProgramManager.getDefaultProgramManager(gl);\n\n  for (const shaderModule of DEFAULT_MODULES) {\n    programManager.addDefaultModule(shaderModule);\n  }\n  for (const shaderHook of SHADER_HOOKS) {\n    programManager.addShaderHook(shaderHook);\n  }\n\n  return programManager;\n}\n\nexport {picking, project, project32, gouraudLighting, phongLighting, shadow};\n","// CORE MODULE EXPORTS FOR LUMA.GL\n\n// GLTOOLS\nexport {\n  createGLContext,\n  instrumentGLContext,\n  isWebGL,\n  isWebGL2,\n  getParameters,\n  setParameters,\n  withParameters,\n  resetParameters,\n  cssToDeviceRatio,\n  cssToDevicePixels\n} from '@luma.gl/gltools';\n\n// WEBGL\nexport {\n  lumaStats,\n  FEATURES,\n  hasFeature,\n  hasFeatures,\n  Buffer,\n  Program,\n  Framebuffer,\n  Renderbuffer,\n  Texture2D,\n  TextureCube,\n  clear,\n  // Copy and Blit\n  readPixelsToArray,\n  readPixelsToBuffer,\n  cloneTextureFrom,\n  copyToTexture,\n  // WebGL2 classes & Extensions\n  Texture3D,\n  TransformFeedback\n} from '@luma.gl/webgl';\n\n// ENGINE\nexport {\n  AnimationLoop,\n  Model,\n  Transform,\n  ProgramManager,\n  Timeline,\n  Geometry,\n  ClipSpace,\n  ConeGeometry,\n  CubeGeometry,\n  CylinderGeometry,\n  IcoSphereGeometry,\n  PlaneGeometry,\n  SphereGeometry,\n  TruncatedConeGeometry\n} from '@luma.gl/engine';\n\n// TODO/CLEAN UP FOR V7\n//  We should have a minimal set of forwarding exports from shadertools (ideally none)\n//  Analyze risk of breaking apps\nexport {\n  // HELPERS\n  normalizeShaderModule,\n  // SHADER MODULES\n  fp32,\n  fp64,\n  project,\n  dirlight,\n  picking,\n  gouraudLighting,\n  phongLighting,\n  pbr\n} from '@luma.gl/shadertools';\n\n// UTILS: undocumented API for other luma.gl modules\nexport {log, assert, uid} from '@luma.gl/webgl';\n","// Utils\nexport {log} from './utils/log';\nexport {\n  isWebGL,\n  isWebGL2,\n  getWebGL2Context,\n  assertWebGLContext,\n  assertWebGL2Context\n} from './utils/webgl-checks';\n\n// Polyfills to support a subset of WebGL2 APIs on WebGL1 contexts\nexport {polyfillContext} from './polyfill/polyfill-context';\n\n// unified parameter APIs\nexport {\n  getParameters,\n  setParameters,\n  resetParameters,\n  withParameters\n} from './state-tracker/unified-parameter-api';\n\n// state tracking\nexport {\n  trackContextState,\n  pushContextState,\n  popContextState\n} from './state-tracker/track-context-state';\n\nexport {\n  createGLContext,\n  resizeGLContext,\n  instrumentGLContext,\n  getContextDebugInfo\n} from './context/context';\n\nexport {cssToDeviceRatio, cssToDevicePixels} from './utils/device-pixels';\n","import {Log} from 'probe.gl';\n\nexport const log = new Log({id: 'luma.gl'});\n","import {assert} from './assert';\n\nconst ERR_CONTEXT = 'Invalid WebGLRenderingContext';\nexport const ERR_WEBGL = ERR_CONTEXT;\nexport const ERR_WEBGL2 = 'Requires WebGL2';\n\nexport function isWebGL(gl) {\n  if (typeof WebGLRenderingContext !== 'undefined' && gl instanceof WebGLRenderingContext) {\n    return true;\n  }\n  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {\n    return true;\n  }\n  // Look for debug contexts, headless gl etc\n  return Boolean(gl && Number.isFinite(gl._version));\n}\n\nexport function isWebGL2(gl) {\n  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {\n    return true;\n  }\n  // Look for debug contexts, headless gl etc\n  return Boolean(gl && gl._version === 2);\n}\n\nexport function getWebGL2Context(gl) {\n  return isWebGL2(gl) ? gl : null;\n}\n\nexport function assertWebGLContext(gl) {\n  assert(isWebGL(gl), ERR_CONTEXT);\n  return gl;\n}\n\nexport function assertWebGL2Context(gl) {\n  assert(isWebGL2(gl), ERR_WEBGL2);\n  return gl;\n}\n","// Avoid bundling assert polyfill module\nexport function assert(condition, message) {\n  if (!condition) {\n    throw new Error(message || 'luma.gl: assertion failed.');\n  }\n}\n","// WebGL1/WebGL2 extension polyfill support\n//\n// Provides a function that creates polyfills for WebGL2 functions based\n// on available extensions and installs them on a supplied target (could be\n// the WebGLContext or its prototype, or a separate object).\n//\n// This is intended to be a stand-alone file with minimal dependencies,\n// easy to reuse or repurpose in other projects.\n\n/** @typedef {import('./polyfill-context')} types */\n\nimport {polyfillVertexArrayObject} from './polyfill-vertex-array-object';\nimport {assert} from '../utils/assert';\n\nimport {WEBGL2_CONTEXT_POLYFILLS, WEBGL2_CONTEXT_OVERRIDES} from './polyfill-table';\n\n/** @type {types['polyfillContext']} */\nexport function polyfillContext(gl) {\n  // @ts-ignore\n  gl.luma = gl.luma || {};\n  // @ts-ignore\n  const {luma} = gl;\n\n  if (!luma.polyfilled) {\n    polyfillVertexArrayObject(gl);\n    initializeExtensions(gl);\n    installPolyfills(gl, WEBGL2_CONTEXT_POLYFILLS);\n    installOverrides(gl, {target: luma, target2: gl});\n    luma.polyfilled = true;\n  }\n\n  // TODO - only supporting a few members\n  /** @type {WebGL2RenderingContext} */\n  // @ts-ignore\n  return gl;\n}\n\n// TODO - is this still required?\nconst global_ = typeof global !== 'undefined' ? global : window;\n// @ts-ignore\nglobal_.polyfillContext = polyfillContext;\n\nfunction initializeExtensions(gl) {\n  gl.luma.extensions = {};\n  // `getSupportedExtensions` can return null when context is lost.\n  const EXTENSIONS = gl.getSupportedExtensions() || [];\n  for (const extension of EXTENSIONS) {\n    gl.luma[extension] = gl.getExtension(extension);\n  }\n}\n\n// Install simple overrides (mostly get* functions)\nfunction installOverrides(gl, {target, target2}) {\n  Object.keys(WEBGL2_CONTEXT_OVERRIDES).forEach(key => {\n    if (typeof WEBGL2_CONTEXT_OVERRIDES[key] === 'function') {\n      // install an override, if no implementation was detected\n      const originalFunc = gl[key] ? gl[key].bind(gl) : () => {};\n      const polyfill = WEBGL2_CONTEXT_OVERRIDES[key].bind(null, gl, originalFunc);\n      target[key] = polyfill;\n      target2[key] = polyfill;\n    }\n  });\n}\n\nfunction installPolyfills(gl, polyfills) {\n  for (const extension of Object.getOwnPropertyNames(polyfills)) {\n    if (extension !== 'overrides') {\n      polyfillExtension(gl, {extension, target: gl.luma, target2: gl});\n    }\n  }\n}\n\n// Polyfills a single WebGL extension into the `target` object\nfunction polyfillExtension(gl, {extension, target, target2}) {\n  const defaults = WEBGL2_CONTEXT_POLYFILLS[extension];\n  assert(defaults);\n\n  const {meta = {}} = defaults;\n  const {suffix = ''} = meta;\n\n  const ext = gl.getExtension(extension);\n\n  for (const key of Object.keys(defaults)) {\n    const extKey = `${key}${suffix}`;\n\n    let polyfill = null;\n    if (key === 'meta') {\n      // ignore\n    } else if (typeof gl[key] === 'function') {\n      // WebGL2 implementation is already\n    } else if (ext && typeof ext[extKey] === 'function') {\n      // pick extension implemenentation,if available\n      polyfill = (...args) => ext[extKey](...args);\n    } else if (typeof defaults[key] === 'function') {\n      // pick the mock implementation, if no implementation was detected\n      polyfill = defaults[key].bind(target);\n    }\n\n    if (polyfill) {\n      target[key] = polyfill;\n      target2[key] = polyfill;\n    }\n  }\n}\n","/*\n** Copyright (c) 2015 The Khronos Group Inc.\n**\n** Permission is hereby granted, free of charge, to any person obtaining a\n** copy of this software and/or associated documentation files (the\n** \"Materials\"), to deal in the Materials without restriction, including\n** without limitation the rights to use, copy, modify, merge, publish,\n** distribute, sublicense, and/or sell copies of the Materials, and to\n** permit persons to whom the Materials are furnished to do so, subject to\n** the following conditions:\n**\n** The above copyright notice and this permission notice shall be included\n** in all copies or substantial portions of the Materials.\n**\n** THE MATERIALS ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\n** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.\n*/\n\n// Modified to use ES6 and polyfill a provided context rather than\n// the global class.\n\n// @ts-nocheck external code\n\nimport {global} from 'probe.gl/env';\n\nconst glErrorShadow = {};\n\nfunction error(msg) {\n  if (global.console && global.console.error) {\n    global.console.error(msg);\n  }\n}\n\nfunction log(msg) {\n  if (global.console && global.console.log) {\n    global.console.log(msg);\n  }\n}\n\nfunction synthesizeGLError(err, opt_msg) {\n  glErrorShadow[err] = true;\n  if (opt_msg !== undefined) {\n    error(opt_msg);\n  }\n}\n\nfunction wrapGLError(gl) {\n  const f = gl.getError;\n  gl.getError = function getError() {\n    let err;\n    do {\n      err = f.apply(gl);\n      if (err !== gl.NO_ERROR) {\n        glErrorShadow[err] = true;\n      }\n    } while (err !== gl.NO_ERROR);\n\n    for (err in glErrorShadow) {\n      if (glErrorShadow[err]) {\n        delete glErrorShadow[err];\n        return parseInt(err, 10);\n      }\n    }\n\n    return gl.NO_ERROR;\n  };\n}\n\nconst WebGLVertexArrayObjectOES = function WebGLVertexArrayObjectOES(ext) {\n  const gl = ext.gl;\n\n  this.ext = ext;\n  this.isAlive = true;\n  this.hasBeenBound = false;\n\n  this.elementArrayBuffer = null;\n  this.attribs = new Array(ext.maxVertexAttribs);\n  for (let n = 0; n < this.attribs.length; n++) {\n    const attrib = new WebGLVertexArrayObjectOES.VertexAttrib(gl);\n    this.attribs[n] = attrib;\n  }\n\n  this.maxAttrib = 0;\n};\n\nWebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl) {\n  this.enabled = false;\n  this.buffer = null;\n  this.size = 4;\n  this.type = gl.FLOAT;\n  this.normalized = false;\n  this.stride = 16;\n  this.offset = 0;\n\n  this.cached = '';\n  this.recache();\n};\nWebGLVertexArrayObjectOES.VertexAttrib.prototype.recache = function recache() {\n  this.cached = [this.size, this.type, this.normalized, this.stride, this.offset].join(':');\n};\n\nconst OESVertexArrayObject = function OESVertexArrayObject(gl) {\n  const self = this;\n  this.gl = gl;\n\n  wrapGLError(gl);\n\n  const original = (this.original = {\n    getParameter: gl.getParameter,\n    enableVertexAttribArray: gl.enableVertexAttribArray,\n    disableVertexAttribArray: gl.disableVertexAttribArray,\n    bindBuffer: gl.bindBuffer,\n    getVertexAttrib: gl.getVertexAttrib,\n    vertexAttribPointer: gl.vertexAttribPointer\n  });\n\n  gl.getParameter = function getParameter(pname) {\n    if (pname === self.VERTEX_ARRAY_BINDING_OES) {\n      if (self.currentVertexArrayObject === self.defaultVertexArrayObject) {\n        return null;\n      }\n      return self.currentVertexArrayObject;\n    }\n    return original.getParameter.apply(this, arguments);\n  };\n\n  gl.enableVertexAttribArray = function enableVertexAttribArray(index) {\n    const vao = self.currentVertexArrayObject;\n    vao.maxAttrib = Math.max(vao.maxAttrib, index);\n    const attrib = vao.attribs[index];\n    attrib.enabled = true;\n    return original.enableVertexAttribArray.apply(this, arguments);\n  };\n  gl.disableVertexAttribArray = function disableVertexAttribArray(index) {\n    const vao = self.currentVertexArrayObject;\n    vao.maxAttrib = Math.max(vao.maxAttrib, index);\n    const attrib = vao.attribs[index];\n    attrib.enabled = false;\n    return original.disableVertexAttribArray.apply(this, arguments);\n  };\n\n  gl.bindBuffer = function bindBuffer(target, buffer) {\n    switch (target) {\n      case gl.ARRAY_BUFFER:\n        self.currentArrayBuffer = buffer;\n        break;\n      case gl.ELEMENT_ARRAY_BUFFER:\n        self.currentVertexArrayObject.elementArrayBuffer = buffer;\n        break;\n      default:\n    }\n    return original.bindBuffer.apply(this, arguments);\n  };\n\n  gl.getVertexAttrib = function getVertexAttrib(index, pname) {\n    const vao = self.currentVertexArrayObject;\n    const attrib = vao.attribs[index];\n    switch (pname) {\n      case gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:\n        return attrib.buffer;\n      case gl.VERTEX_ATTRIB_ARRAY_ENABLED:\n        return attrib.enabled;\n      case gl.VERTEX_ATTRIB_ARRAY_SIZE:\n        return attrib.size;\n      case gl.VERTEX_ATTRIB_ARRAY_STRIDE:\n        return attrib.stride;\n      case gl.VERTEX_ATTRIB_ARRAY_TYPE:\n        return attrib.type;\n      case gl.VERTEX_ATTRIB_ARRAY_NORMALIZED:\n        return attrib.normalized;\n      default:\n        return original.getVertexAttrib.apply(this, arguments);\n    }\n  };\n\n  gl.vertexAttribPointer = function vertexAttribPointer(\n    indx,\n    size,\n    type,\n    normalized,\n    stride,\n    offset\n  ) {\n    const vao = self.currentVertexArrayObject;\n    vao.maxAttrib = Math.max(vao.maxAttrib, indx);\n    const attrib = vao.attribs[indx];\n    attrib.buffer = self.currentArrayBuffer;\n    attrib.size = size;\n    attrib.type = type;\n    attrib.normalized = normalized;\n    attrib.stride = stride;\n    attrib.offset = offset;\n    attrib.recache();\n    return original.vertexAttribPointer.apply(this, arguments);\n  };\n\n  if (gl.instrumentExtension) {\n    gl.instrumentExtension(this, 'OES_vertex_array_object');\n  }\n\n  // undefined for headless gl\n  if (gl.canvas) {\n    gl.canvas.addEventListener(\n      'webglcontextrestored',\n      () => {\n        log('OESVertexArrayObject emulation library context restored');\n        self.reset_();\n      },\n      true\n    );\n  }\n\n  this.reset_();\n};\n\nOESVertexArrayObject.prototype.VERTEX_ARRAY_BINDING_OES = 0x85b5;\n\nOESVertexArrayObject.prototype.reset_ = function reset_() {\n  const contextWasLost = this.vertexArrayObjects !== undefined;\n  if (contextWasLost) {\n    for (let ii = 0; ii < this.vertexArrayObjects.length; ++ii) {\n      this.vertexArrayObjects.isAlive = false;\n    }\n  }\n  const gl = this.gl;\n  this.maxVertexAttribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);\n\n  this.defaultVertexArrayObject = new WebGLVertexArrayObjectOES(this);\n  this.currentVertexArrayObject = null;\n  this.currentArrayBuffer = null;\n  this.vertexArrayObjects = [this.defaultVertexArrayObject];\n\n  this.bindVertexArrayOES(null);\n};\n\nOESVertexArrayObject.prototype.createVertexArrayOES = function createVertexArrayOES() {\n  const arrayObject = new WebGLVertexArrayObjectOES(this);\n  this.vertexArrayObjects.push(arrayObject);\n  return arrayObject;\n};\n\nOESVertexArrayObject.prototype.deleteVertexArrayOES = function deleteVertexArrayOES(arrayObject) {\n  arrayObject.isAlive = false;\n  this.vertexArrayObjects.splice(this.vertexArrayObjects.indexOf(arrayObject), 1);\n  if (this.currentVertexArrayObject === arrayObject) {\n    this.bindVertexArrayOES(null);\n  }\n};\n\nOESVertexArrayObject.prototype.isVertexArrayOES = function isVertexArrayOES(arrayObject) {\n  if (arrayObject && arrayObject instanceof WebGLVertexArrayObjectOES) {\n    if (arrayObject.hasBeenBound && arrayObject.ext === this) {\n      return true;\n    }\n  }\n  return false;\n};\n\nOESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(arrayObject) {\n  const gl = this.gl;\n  if (arrayObject && !arrayObject.isAlive) {\n    synthesizeGLError(\n      gl.INVALID_OPERATION,\n      'bindVertexArrayOES: attempt to bind deleted arrayObject'\n    );\n    return;\n  }\n  const original = this.original;\n\n  const oldVAO = this.currentVertexArrayObject;\n  this.currentVertexArrayObject = arrayObject || this.defaultVertexArrayObject;\n  this.currentVertexArrayObject.hasBeenBound = true;\n  const newVAO = this.currentVertexArrayObject;\n\n  if (oldVAO === newVAO) {\n    return;\n  }\n\n  if (!oldVAO || newVAO.elementArrayBuffer !== oldVAO.elementArrayBuffer) {\n    original.bindBuffer.call(gl, gl.ELEMENT_ARRAY_BUFFER, newVAO.elementArrayBuffer);\n  }\n\n  let currentBinding = this.currentArrayBuffer;\n  const maxAttrib = Math.max(oldVAO ? oldVAO.maxAttrib : 0, newVAO.maxAttrib);\n  for (let n = 0; n <= maxAttrib; n++) {\n    const attrib = newVAO.attribs[n];\n    const oldAttrib = oldVAO ? oldVAO.attribs[n] : null;\n\n    if (!oldVAO || attrib.enabled !== oldAttrib.enabled) {\n      if (attrib.enabled) {\n        original.enableVertexAttribArray.call(gl, n);\n      } else {\n        original.disableVertexAttribArray.call(gl, n);\n      }\n    }\n\n    if (attrib.enabled) {\n      let bufferChanged = false;\n      if (!oldVAO || attrib.buffer !== oldAttrib.buffer) {\n        if (currentBinding !== attrib.buffer) {\n          original.bindBuffer.call(gl, gl.ARRAY_BUFFER, attrib.buffer);\n          currentBinding = attrib.buffer;\n        }\n        bufferChanged = true;\n      }\n\n      if (bufferChanged || attrib.cached !== oldAttrib.cached) {\n        original.vertexAttribPointer.call(\n          gl,\n          n,\n          attrib.size,\n          attrib.type,\n          attrib.normalized,\n          attrib.stride,\n          attrib.offset\n        );\n      }\n    }\n  }\n\n  if (this.currentArrayBuffer !== currentBinding) {\n    original.bindBuffer.call(gl, gl.ARRAY_BUFFER, this.currentArrayBuffer);\n  }\n};\n\nexport function polyfillVertexArrayObject(gl) {\n  if (typeof gl.createVertexArray === 'function') {\n    // VAOs directly supported on object (i.e. WebGL 2 context)\n    return;\n  }\n\n  const original_getSupportedExtensions = gl.getSupportedExtensions;\n  gl.getSupportedExtensions = function getSupportedExtensions() {\n    const list = original_getSupportedExtensions.call(this) || [];\n    if (list.indexOf('OES_vertex_array_object') < 0) {\n      list.push('OES_vertex_array_object');\n    }\n    return list;\n  };\n\n  const original_getExtension = gl.getExtension;\n  gl.getExtension = function getExtension(name) {\n    const ext = original_getExtension.call(this, name);\n    if (ext) {\n      return ext;\n    }\n    if (name !== 'OES_vertex_array_object') {\n      return null;\n    }\n\n    if (!gl.__OESVertexArrayObject) {\n      this.__OESVertexArrayObject = new OESVertexArrayObject(this);\n    }\n    return this.__OESVertexArrayObject;\n  };\n}\n","import GL from '@luma.gl/constants';\nimport {assert} from '../utils/assert';\nimport {isWebGL2} from '../utils/webgl-checks';\n\nimport {getParameterPolyfill} from './get-parameter-polyfill';\n\nconst OES_vertex_array_object = 'OES_vertex_array_object';\nconst ANGLE_instanced_arrays = 'ANGLE_instanced_arrays';\nconst WEBGL_draw_buffers = 'WEBGL_draw_buffers';\nconst EXT_disjoint_timer_query = 'EXT_disjoint_timer_query';\nconst EXT_texture_filter_anisotropic = 'EXT_texture_filter_anisotropic';\n\nconst ERR_VAO_NOT_SUPPORTED = 'VertexArray requires WebGL2 or OES_vertex_array_object extension';\n\n// Return object with webgl2 flag and an extension\nfunction getExtensionData(gl, extension) {\n  return {\n    webgl2: isWebGL2(gl),\n    ext: gl.getExtension(extension)\n  };\n}\n\n// function mapExtensionConstant(gl, constant) {\n//   switch (constant) {\n//   case ext.FRAGMENT_SHADER_DERIVATIVE_HINT_OES: return GL.FRAGMENT_SHADER_DERIVATIVE_HINT;\n//   }\n// }\n\nexport const WEBGL2_CONTEXT_POLYFILLS = {\n  // POLYFILL TABLE\n  [OES_vertex_array_object]: {\n    meta: {suffix: 'OES'},\n    // NEW METHODS\n    createVertexArray: () => {\n      assert(false, ERR_VAO_NOT_SUPPORTED);\n    },\n    deleteVertexArray: () => {},\n    bindVertexArray: () => {},\n    isVertexArray: () => false\n  },\n  [ANGLE_instanced_arrays]: {\n    meta: {\n      suffix: 'ANGLE'\n      // constants: {\n      //   VERTEX_ATTRIB_ARRAY_DIVISOR: 'VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE'\n      // }\n    },\n    vertexAttribDivisor(location, divisor) {\n      // Accept divisor 0 even if instancing is not supported (0 = no instancing)\n      assert(divisor === 0, 'WebGL instanced rendering not supported');\n    },\n    drawElementsInstanced: () => {},\n    drawArraysInstanced: () => {}\n  },\n  [WEBGL_draw_buffers]: {\n    meta: {\n      suffix: 'WEBGL'\n    },\n    drawBuffers: () => {\n      assert(false);\n    }\n  },\n  [EXT_disjoint_timer_query]: {\n    meta: {suffix: 'EXT'},\n    // WebGL1: Polyfills the WebGL2 Query API\n    createQuery: () => {\n      assert(false);\n    },\n    deleteQuery: () => {\n      assert(false);\n    },\n    beginQuery: () => {\n      assert(false);\n    },\n    endQuery: () => {},\n    getQuery(handle, pname) {\n      // @ts-ignore\n      return this.getQueryObject(handle, pname);\n    },\n    // The WebGL1 extension uses getQueryObject rather then getQueryParameter\n    getQueryParameter(handle, pname) {\n      // @ts-ignore\n      return this.getQueryObject(handle, pname);\n    },\n    getQueryObject: () => {}\n  }\n};\n\nexport const WEBGL2_CONTEXT_OVERRIDES = {\n  // Ensure readBuffer is a no-op\n  readBuffer: (gl, originalFunc, attachment) => {\n    if (isWebGL2(gl)) {\n      originalFunc(attachment);\n    } else {\n      // assert(attachment !== GL_COLOR_ATTACHMENT0 && attachment !== GL_FRONT);\n    }\n  },\n  // Override for getVertexAttrib that returns sane values for non-WebGL1 constants\n  getVertexAttrib: (gl, originalFunc, location, pname) => {\n    // const gl = this; // eslint-disable-line\n    const {webgl2, ext} = getExtensionData(gl, ANGLE_instanced_arrays);\n\n    let result;\n    switch (pname) {\n      // WebGL1 attributes will never be integer\n      case GL.VERTEX_ATTRIB_ARRAY_INTEGER:\n        result = !webgl2 ? false : undefined;\n        break;\n      // if instancing is not available, return 0 meaning divisor has not been set\n      case GL.VERTEX_ATTRIB_ARRAY_DIVISOR:\n        result = !webgl2 && !ext ? 0 : undefined;\n        break;\n      default:\n    }\n\n    return result !== undefined ? result : originalFunc(location, pname);\n  },\n  // Handle transform feedback and uniform block queries in WebGL1\n  getProgramParameter: (gl, originalFunc, program, pname) => {\n    if (!isWebGL2(gl)) {\n      switch (pname) {\n        case GL.TRANSFORM_FEEDBACK_BUFFER_MODE:\n          return GL.SEPARATE_ATTRIBS;\n        case GL.TRANSFORM_FEEDBACK_VARYINGS:\n          return 0;\n        case GL.ACTIVE_UNIFORM_BLOCKS:\n          return 0;\n        default:\n      }\n    }\n    return originalFunc(program, pname);\n  },\n  getInternalformatParameter: (gl, originalFunc, target, format, pname) => {\n    if (!isWebGL2(gl)) {\n      switch (pname) {\n        case GL.SAMPLES:\n          return new Int32Array([0]);\n        default:\n      }\n    }\n    return gl.getInternalformatParameter(target, format, pname);\n  },\n  getTexParameter(gl, originalFunc, target, pname) {\n    switch (pname) {\n      case GL.TEXTURE_MAX_ANISOTROPY_EXT:\n        const {extensions} = gl.luma;\n        const ext = extensions[EXT_texture_filter_anisotropic];\n        pname = (ext && ext.TEXTURE_MAX_ANISOTROPY_EXT) || GL.TEXTURE_MAX_ANISOTROPY_EXT;\n        break;\n      default:\n    }\n    return originalFunc(target, pname);\n  },\n  getParameter: getParameterPolyfill,\n  hint(gl, originalFunc, pname, value) {\n    // TODO - handle GL.FRAGMENT_SHADER_DERIVATIVE_HINT:\n    // switch (pname) {\n    // case GL.FRAGMENT_SHADER_DERIVATIVE_HINT:\n    // }\n    return originalFunc(pname, value);\n  }\n};\n","/* eslint-disable no-inline-comments, max-len, camelcase */\nimport GL from '@luma.gl/constants';\nimport {isWebGL2} from '../utils/webgl-checks';\n\nconst OES_element_index = 'OES_element_index';\nconst WEBGL_draw_buffers = 'WEBGL_draw_buffers';\nconst EXT_disjoint_timer_query = 'EXT_disjoint_timer_query';\nconst EXT_disjoint_timer_query_webgl2 = 'EXT_disjoint_timer_query_webgl2';\nconst EXT_texture_filter_anisotropic = 'EXT_texture_filter_anisotropic';\nconst WEBGL_debug_renderer_info = 'WEBGL_debug_renderer_info';\n\nconst GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8b8b;\nconst GL_DONT_CARE = 0x1100;\nconst GL_GPU_DISJOINT_EXT = 0x8fbb;\nconst GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84ff;\nconst GL_UNMASKED_VENDOR_WEBGL = 0x9245; // vendor string of the graphics driver.\nconst GL_UNMASKED_RENDERER_WEBGL = 0x9246; // renderer string of the graphics driver.\n\nconst getWebGL2ValueOrZero = gl => (!isWebGL2(gl) ? 0 : undefined);\n\n// if a function returns undefined in this table,\n// the original getParameter will be called, defeating the override\nconst WEBGL_PARAMETERS = {\n  [GL.READ_BUFFER]: gl => (!isWebGL2(gl) ? GL.COLOR_ATTACHMENT0 : undefined),\n\n  // WebGL2 context parameters\n  [GL_FRAGMENT_SHADER_DERIVATIVE_HINT]: gl => (!isWebGL2(gl) ? GL_DONT_CARE : undefined),\n\n  [GL.RASTERIZER_DISCARD]: getWebGL2ValueOrZero,\n\n  [GL.SAMPLES]: getWebGL2ValueOrZero,\n\n  // WebGL2 extension context parameters\n  [GL_GPU_DISJOINT_EXT]: (gl, getParameter) => {\n    const ext = isWebGL2(gl)\n      ? gl.getExtension(EXT_disjoint_timer_query_webgl2)\n      : gl.getExtension(EXT_disjoint_timer_query);\n    return ext && ext.GPU_DISJOINT_EXT ? getParameter(ext.GPU_DISJOINT_EXT) : 0;\n  },\n\n  // Extension fixed values\n  [GL_UNMASKED_VENDOR_WEBGL]: (gl, getParameter) => {\n    const ext = gl.getExtension(WEBGL_debug_renderer_info);\n    return getParameter((ext && ext.UNMASKED_VENDOR_WEBGL) || GL.VENDOR);\n  },\n\n  [GL_UNMASKED_RENDERER_WEBGL]: (gl, getParameter) => {\n    const ext = gl.getExtension(WEBGL_debug_renderer_info);\n    return getParameter((ext && ext.UNMASKED_RENDERER_WEBGL) || GL.RENDERER);\n  },\n\n  // Extension LIMITS\n  [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl, getParameter) => {\n    const ext = gl.luma.extensions[EXT_texture_filter_anisotropic];\n    return ext ? getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1.0;\n  },\n\n  // WebGL2 Limits\n  [GL.MAX_3D_TEXTURE_SIZE]: getWebGL2ValueOrZero,\n  [GL.MAX_ARRAY_TEXTURE_LAYERS]: getWebGL2ValueOrZero,\n  [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: getWebGL2ValueOrZero,\n  [GL.MAX_COLOR_ATTACHMENTS]: (gl, getParameter) => {\n    if (!isWebGL2(gl)) {\n      const ext = gl.getExtension(WEBGL_draw_buffers);\n      return ext ? getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL) : 0;\n    }\n    return undefined;\n  },\n  [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,\n  [GL.MAX_COMBINED_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,\n  [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,\n  [GL.MAX_DRAW_BUFFERS]: gl => {\n    if (!isWebGL2(gl)) {\n      const ext = gl.getExtension(WEBGL_draw_buffers);\n      return ext ? ext.MAX_DRAW_BUFFERS_WEBGL : 0;\n    }\n    return undefined;\n  },\n  [GL.MAX_ELEMENT_INDEX]:\n    // Guess: per webglstats.com 99.6% of webgl2 supports 2147483647\n    gl => (gl.getExtension(OES_element_index) ? 2147483647 : 65535),\n  [GL.MAX_ELEMENTS_INDICES]:\n    // Guess: \"Reasonably safe\" per webglstats.com - could be higher/lower (on some mobile devices)\n    gl => (gl.getExtension(OES_element_index) ? 16777216 : 65535),\n  [GL.MAX_ELEMENTS_VERTICES]:\n    // Guess: \"Reasonably safe\" per webglstats.com - could be higher/lower (on some mobile devices)\n    gl => 16777216,\n  [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: getWebGL2ValueOrZero,\n  [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,\n  [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,\n  [GL.MAX_SAMPLES]: getWebGL2ValueOrZero,\n  [GL.MAX_SERVER_WAIT_TIMEOUT]: getWebGL2ValueOrZero,\n  [GL.MAX_TEXTURE_LOD_BIAS]: getWebGL2ValueOrZero,\n  [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: getWebGL2ValueOrZero,\n  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: getWebGL2ValueOrZero,\n  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: getWebGL2ValueOrZero,\n  [GL.MAX_UNIFORM_BLOCK_SIZE]: getWebGL2ValueOrZero,\n  [GL.MAX_UNIFORM_BUFFER_BINDINGS]: getWebGL2ValueOrZero,\n  [GL.MAX_VARYING_COMPONENTS]: getWebGL2ValueOrZero,\n  [GL.MAX_VERTEX_OUTPUT_COMPONENTS]: getWebGL2ValueOrZero,\n  [GL.MAX_VERTEX_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,\n  [GL.MAX_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,\n  [GL.MIN_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,\n  [GL.MAX_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,\n  [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: getWebGL2ValueOrZero\n};\n\n// A \"replacement\" gl.getParameter that accepts \"enums\" from extensions and WebGL2\n// and returns reasonably safe defaults\nexport function getParameterPolyfill(gl, originalGetParameter, pname) {\n  // Return mock limits (usually 0) for WebGL2 constants to ensure these\n  // can be queries without error\n  const limit = WEBGL_PARAMETERS[pname];\n  // @ts-ignore TODO pname parameter not declared\n  const value = typeof limit === 'function' ? limit(gl, originalGetParameter, pname) : limit;\n  const result = value !== undefined ? value : originalGetParameter(pname);\n  return result;\n}\n","// Provides a unified API for getting and setting any WebGL parameter\n// Also knows default values of all parameters, enabling fast cache initialization\n// Provides base functionality for the state caching.\nimport {\n  GL_PARAMETER_DEFAULTS,\n  GL_PARAMETER_SETTERS,\n  GL_COMPOSITE_PARAMETER_SETTERS,\n  GL_PARAMETER_GETTERS\n} from './webgl-parameter-tables';\n\nimport {pushContextState, popContextState} from './track-context-state';\nimport {assert} from '../utils/assert';\nimport {isWebGL} from '../utils/webgl-checks';\nimport {isObjectEmpty} from '../utils/utils';\n\n// Sets any GL parameter regardless of function (gl.blendMode, ...)\n// Note: requires a `cache` object to be set on the context (gl.state.cache)\n// This object is used to fill in any missing values for composite setter functions\nexport function setParameters(gl, values) {\n  assert(isWebGL(gl), 'setParameters requires a WebGL context');\n\n  if (isObjectEmpty(values)) {\n    return;\n  }\n\n  const compositeSetters = {};\n\n  // HANDLE PRIMITIVE SETTERS (and make note of any composite setters)\n\n  for (const key in values) {\n    const glConstant = Number(key);\n    const setter = GL_PARAMETER_SETTERS[key];\n    if (setter) {\n      // Composite setters should only be called once, so save them\n      if (typeof setter === 'string') {\n        compositeSetters[setter] = true;\n      } else {\n        // if (gl[glConstant] !== undefined) {\n        // TODO - added above check since this is being called on WebGL2 values in WebGL1...\n        // TODO - deep equal on values? only call setter if value has changed?\n        // NOTE - the setter will automatically update this.state\n        setter(gl, values[key], glConstant);\n      }\n    }\n  }\n\n  // HANDLE COMPOSITE SETTERS\n\n  // NOTE: any non-provided values needed by composite setters are filled in from state cache\n  // The cache parameter is automatically retrieved from the context\n  // This depends on `trackContextState`, which is technically a \"circular\" dependency.\n  // But it is too inconvenient to always require a cache parameter here.\n  // This is the ONLY external dependency in this module/\n  const cache = gl.state && gl.state.cache;\n  if (cache) {\n    for (const key in compositeSetters) {\n      // TODO - avoid calling composite setters if values have not changed.\n      const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key];\n      // Note - if `trackContextState` has been called,\n      // the setter will automatically update this.state.cache\n      compositeSetter(gl, values, cache);\n    }\n  }\n\n  // Add a log for the else case?\n}\n\n// Copies the state from a context (gl.getParameter should not be overriden)\n// Reads the entire WebGL state from a context\n// Caveat: This generates a huge amount of synchronous driver roundtrips and should be\n// considered a very slow operation, to be used only if/when a context already manipulated\n// by external code needs to be synchronized for the first time\n// @return {Object} - a newly created map, with values keyed by GL parameters\nexport function getParameters(gl, parameters) {\n  // default to querying all parameters\n  parameters = parameters || GL_PARAMETER_DEFAULTS;\n  // support both arrays of parameters and objects (keys represent parameters)\n\n  if (typeof parameters === 'number') {\n    // single GL enum\n    const key = parameters;\n    const getter = GL_PARAMETER_GETTERS[key];\n    return getter ? getter(gl, key) : gl.getParameter(key);\n  }\n\n  const parameterKeys = Array.isArray(parameters) ? parameters : Object.keys(parameters);\n\n  const state = {};\n  for (const key of parameterKeys) {\n    const getter = GL_PARAMETER_GETTERS[key];\n    state[key] = getter ? getter(gl, Number(key)) : gl.getParameter(Number(key));\n  }\n  return state;\n}\n\n// Reset all parameters to a (almost) pure context state\n// NOTE: viewport and scissor will be set to the values in GL_PARAMETER_DEFAULTS,\n//   NOT the canvas size dimensions, so they will have to be properly set after\n//   calling this function.\nexport function resetParameters(gl) {\n  setParameters(gl, GL_PARAMETER_DEFAULTS);\n}\n\n// Stores current \"global\" WebGL context settings, changes selected parameters,\n// executes function, restores parameters\nexport function withParameters(gl, parameters, func) {\n  if (isObjectEmpty(parameters)) {\n    // Avoid setting state if no parameters provided. Just call and return\n    return func(gl);\n  }\n\n  const {nocatch = true} = parameters;\n\n  pushContextState(gl);\n  setParameters(gl, parameters);\n\n  // Setup is done, call the function\n  let value;\n\n  if (nocatch) {\n    // Avoid try catch to minimize stack size impact for safe execution paths\n    value = func(gl);\n    popContextState(gl);\n  } else {\n    // Wrap in a try-catch to ensure that parameters are restored on exceptions\n    try {\n      value = func(gl);\n    } finally {\n      popContextState(gl);\n    }\n  }\n\n  return value;\n}\n","// Tables describing WebGL parameters\nimport GL from '@luma.gl/constants';\nimport {isWebGL2} from '../utils/webgl-checks';\n\n// DEFAULT SETTINGS - FOR FAST CACHE INITIALIZATION AND CONTEXT RESETS\n\n/* eslint-disable no-shadow */\n\nexport const GL_PARAMETER_DEFAULTS = {\n  [GL.BLEND]: false,\n  [GL.BLEND_COLOR]: new Float32Array([0, 0, 0, 0]),\n  [GL.BLEND_EQUATION_RGB]: GL.FUNC_ADD,\n  [GL.BLEND_EQUATION_ALPHA]: GL.FUNC_ADD,\n  [GL.BLEND_SRC_RGB]: GL.ONE,\n  [GL.BLEND_DST_RGB]: GL.ZERO,\n  [GL.BLEND_SRC_ALPHA]: GL.ONE,\n  [GL.BLEND_DST_ALPHA]: GL.ZERO,\n  [GL.COLOR_CLEAR_VALUE]: new Float32Array([0, 0, 0, 0]), // TBD\n  [GL.COLOR_WRITEMASK]: [true, true, true, true],\n  [GL.CULL_FACE]: false,\n  [GL.CULL_FACE_MODE]: GL.BACK,\n  [GL.DEPTH_TEST]: false,\n  [GL.DEPTH_CLEAR_VALUE]: 1,\n  [GL.DEPTH_FUNC]: GL.LESS,\n  [GL.DEPTH_RANGE]: new Float32Array([0, 1]), // TBD\n  [GL.DEPTH_WRITEMASK]: true,\n  [GL.DITHER]: true,\n  // FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.\n  [GL.FRAMEBUFFER_BINDING]: null,\n  [GL.FRONT_FACE]: GL.CCW,\n  [GL.GENERATE_MIPMAP_HINT]: GL.DONT_CARE,\n  [GL.LINE_WIDTH]: 1,\n  [GL.POLYGON_OFFSET_FILL]: false,\n  [GL.POLYGON_OFFSET_FACTOR]: 0,\n  [GL.POLYGON_OFFSET_UNITS]: 0,\n  [GL.SAMPLE_COVERAGE_VALUE]: 1.0,\n  [GL.SAMPLE_COVERAGE_INVERT]: false,\n  [GL.SCISSOR_TEST]: false,\n  // Note: Dynamic value. If scissor test enabled we expect users to set correct scissor box\n  [GL.SCISSOR_BOX]: new Int32Array([0, 0, 1024, 1024]),\n  [GL.STENCIL_TEST]: false,\n  [GL.STENCIL_CLEAR_VALUE]: 0,\n  [GL.STENCIL_WRITEMASK]: 0xffffffff,\n  [GL.STENCIL_BACK_WRITEMASK]: 0xffffffff,\n  [GL.STENCIL_FUNC]: GL.ALWAYS,\n  [GL.STENCIL_REF]: 0,\n  [GL.STENCIL_VALUE_MASK]: 0xffffffff,\n  [GL.STENCIL_BACK_FUNC]: GL.ALWAYS,\n  [GL.STENCIL_BACK_REF]: 0,\n  [GL.STENCIL_BACK_VALUE_MASK]: 0xffffffff,\n  [GL.STENCIL_FAIL]: GL.KEEP,\n  [GL.STENCIL_PASS_DEPTH_FAIL]: GL.KEEP,\n  [GL.STENCIL_PASS_DEPTH_PASS]: GL.KEEP,\n  [GL.STENCIL_BACK_FAIL]: GL.KEEP,\n  [GL.STENCIL_BACK_PASS_DEPTH_FAIL]: GL.KEEP,\n  [GL.STENCIL_BACK_PASS_DEPTH_PASS]: GL.KEEP,\n  // Dynamic value: We use [0, 0, 1024, 1024] as default, but usually this is updated in each frame.\n  [GL.VIEWPORT]: [0, 0, 1024, 1024],\n  // WEBGL1 PIXEL PACK/UNPACK MODES\n  [GL.PACK_ALIGNMENT]: 4,\n  [GL.UNPACK_ALIGNMENT]: 4,\n  [GL.UNPACK_FLIP_Y_WEBGL]: false,\n  [GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: false,\n  [GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: GL.BROWSER_DEFAULT_WEBGL,\n\n  // WEBGL2 / EXTENSIONS\n  // gl1: 'OES_standard_derivatives'\n  [GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: GL.DONT_CARE,\n  [GL.READ_FRAMEBUFFER_BINDING]: null,\n  [GL.RASTERIZER_DISCARD]: false,\n  [GL.PACK_ROW_LENGTH]: 0,\n  [GL.PACK_SKIP_PIXELS]: 0,\n  [GL.PACK_SKIP_ROWS]: 0,\n  [GL.UNPACK_ROW_LENGTH]: 0,\n  [GL.UNPACK_IMAGE_HEIGHT]: 0,\n  [GL.UNPACK_SKIP_PIXELS]: 0,\n  [GL.UNPACK_SKIP_ROWS]: 0,\n  [GL.UNPACK_SKIP_IMAGES]: 0\n};\n\n// SETTER TABLES - ENABLES SETTING ANY PARAMETER WITH A COMMON API\n\nconst enable = (gl, value, key) => (value ? gl.enable(key) : gl.disable(key));\nconst hint = (gl, value, key) => gl.hint(key, value);\nconst pixelStorei = (gl, value, key) => gl.pixelStorei(key, value);\n\nconst drawFramebuffer = (gl, value) => {\n  const target = isWebGL2(gl) ? GL.DRAW_FRAMEBUFFER : GL.FRAMEBUFFER;\n  return gl.bindFramebuffer(target, value);\n};\nconst readFramebuffer = (gl, value) => {\n  return gl.bindFramebuffer(GL.READ_FRAMEBUFFER, value);\n};\n\n// Utility\nfunction isArray(array) {\n  return Array.isArray(array) || ArrayBuffer.isView(array);\n}\n\n// Map from WebGL parameter names to corresponding WebGL setter functions\n// WegGL constants are read by parameter names, but set by function names\n// NOTE: When value type is a string, it will be handled by 'GL_COMPOSITE_PARAMETER_SETTERS'\nexport const GL_PARAMETER_SETTERS = {\n  [GL.BLEND]: enable,\n  [GL.BLEND_COLOR]: (gl, value) => gl.blendColor(...value),\n  [GL.BLEND_EQUATION_RGB]: 'blendEquation',\n  [GL.BLEND_EQUATION_ALPHA]: 'blendEquation',\n  [GL.BLEND_SRC_RGB]: 'blendFunc',\n  [GL.BLEND_DST_RGB]: 'blendFunc',\n  [GL.BLEND_SRC_ALPHA]: 'blendFunc',\n  [GL.BLEND_DST_ALPHA]: 'blendFunc',\n  [GL.COLOR_CLEAR_VALUE]: (gl, value) => gl.clearColor(...value),\n  [GL.COLOR_WRITEMASK]: (gl, value) => gl.colorMask(...value),\n  [GL.CULL_FACE]: enable,\n  [GL.CULL_FACE_MODE]: (gl, value) => gl.cullFace(value),\n  [GL.DEPTH_TEST]: enable,\n  [GL.DEPTH_CLEAR_VALUE]: (gl, value) => gl.clearDepth(value),\n  [GL.DEPTH_FUNC]: (gl, value) => gl.depthFunc(value),\n  [GL.DEPTH_RANGE]: (gl, value) => gl.depthRange(...value),\n  [GL.DEPTH_WRITEMASK]: (gl, value) => gl.depthMask(value),\n  [GL.DITHER]: enable,\n  [GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: hint,\n  // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.\n  [GL.FRAMEBUFFER_BINDING]: drawFramebuffer,\n  [GL.FRONT_FACE]: (gl, value) => gl.frontFace(value),\n  [GL.GENERATE_MIPMAP_HINT]: hint,\n  [GL.LINE_WIDTH]: (gl, value) => gl.lineWidth(value),\n  [GL.POLYGON_OFFSET_FILL]: enable,\n  [GL.POLYGON_OFFSET_FACTOR]: 'polygonOffset',\n  [GL.POLYGON_OFFSET_UNITS]: 'polygonOffset',\n  [GL.RASTERIZER_DISCARD]: enable,\n  [GL.SAMPLE_COVERAGE_VALUE]: 'sampleCoverage',\n  [GL.SAMPLE_COVERAGE_INVERT]: 'sampleCoverage',\n  [GL.SCISSOR_TEST]: enable,\n  [GL.SCISSOR_BOX]: (gl, value) => gl.scissor(...value),\n  [GL.STENCIL_TEST]: enable,\n  [GL.STENCIL_CLEAR_VALUE]: (gl, value) => gl.clearStencil(value),\n  [GL.STENCIL_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(GL.FRONT, value),\n  [GL.STENCIL_BACK_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(GL.BACK, value),\n  [GL.STENCIL_FUNC]: 'stencilFuncFront',\n  [GL.STENCIL_REF]: 'stencilFuncFront',\n  [GL.STENCIL_VALUE_MASK]: 'stencilFuncFront',\n  [GL.STENCIL_BACK_FUNC]: 'stencilFuncBack',\n  [GL.STENCIL_BACK_REF]: 'stencilFuncBack',\n  [GL.STENCIL_BACK_VALUE_MASK]: 'stencilFuncBack',\n  [GL.STENCIL_FAIL]: 'stencilOpFront',\n  [GL.STENCIL_PASS_DEPTH_FAIL]: 'stencilOpFront',\n  [GL.STENCIL_PASS_DEPTH_PASS]: 'stencilOpFront',\n  [GL.STENCIL_BACK_FAIL]: 'stencilOpBack',\n  [GL.STENCIL_BACK_PASS_DEPTH_FAIL]: 'stencilOpBack',\n  [GL.STENCIL_BACK_PASS_DEPTH_PASS]: 'stencilOpBack',\n  [GL.VIEWPORT]: (gl, value) => gl.viewport(...value),\n\n  // WEBGL1 PIXEL PACK/UNPACK MODES\n  [GL.PACK_ALIGNMENT]: pixelStorei,\n  [GL.UNPACK_ALIGNMENT]: pixelStorei,\n  [GL.UNPACK_FLIP_Y_WEBGL]: pixelStorei,\n  [GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: pixelStorei,\n  [GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: pixelStorei,\n\n  // WEBGL2 PIXEL PACK/UNPACK MODES\n  // RASTERIZER_DISCARD ...\n  [GL.PACK_ROW_LENGTH]: pixelStorei,\n  [GL.PACK_SKIP_PIXELS]: pixelStorei,\n  [GL.PACK_SKIP_ROWS]: pixelStorei,\n  [GL.READ_FRAMEBUFFER_BINDING]: readFramebuffer,\n  [GL.UNPACK_ROW_LENGTH]: pixelStorei,\n  [GL.UNPACK_IMAGE_HEIGHT]: pixelStorei,\n  [GL.UNPACK_SKIP_PIXELS]: pixelStorei,\n  [GL.UNPACK_SKIP_ROWS]: pixelStorei,\n  [GL.UNPACK_SKIP_IMAGES]: pixelStorei,\n\n  // Function-style setters\n  framebuffer: (gl, framebuffer) => {\n    // accepts 1) a WebGLFramebuffer 2) null (default framebuffer), or 3) luma.gl Framebuffer class\n    // framebuffer is null when restoring to default framebuffer, otherwise use the WebGL handle.\n    const handle = framebuffer && 'handle' in framebuffer ? framebuffer.handle : framebuffer;\n    return gl.bindFramebuffer(GL.FRAMEBUFFER, handle);\n  },\n  blend: (gl, value) => (value ? gl.enable(GL.BLEND) : gl.disable(GL.BLEND)),\n  blendColor: (gl, value) => gl.blendColor(...value),\n  blendEquation: (gl, args) => {\n    args = isArray(args) ? args : [args, args];\n    gl.blendEquationSeparate(...args);\n  },\n  blendFunc: (gl, args) => {\n    args = isArray(args) && args.length === 2 ? [...args, ...args] : args;\n    gl.blendFuncSeparate(...args);\n  },\n\n  clearColor: (gl, value) => gl.clearColor(...value),\n  clearDepth: (gl, value) => gl.clearDepth(value),\n  clearStencil: (gl, value) => gl.clearStencil(value),\n\n  colorMask: (gl, value) => gl.colorMask(...value),\n\n  cull: (gl, value) => (value ? gl.enable(GL.CULL_FACE) : gl.disable(GL.CULL_FACE)),\n  cullFace: (gl, value) => gl.cullFace(value),\n\n  depthTest: (gl, value) => (value ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST)),\n  depthFunc: (gl, value) => gl.depthFunc(value),\n  depthMask: (gl, value) => gl.depthMask(value),\n  depthRange: (gl, value) => gl.depthRange(...value),\n\n  dither: (gl, value) => (value ? gl.enable(GL.DITHER) : gl.disable(GL.DITHER)),\n\n  derivativeHint: (gl, value) => {\n    // gl1: 'OES_standard_derivatives'\n    gl.hint(GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);\n  },\n\n  frontFace: (gl, value) => gl.frontFace(value),\n\n  mipmapHint: (gl, value) => gl.hint(GL.GENERATE_MIPMAP_HINT, value),\n\n  lineWidth: (gl, value) => gl.lineWidth(value),\n\n  polygonOffsetFill: (gl, value) =>\n    value ? gl.enable(GL.POLYGON_OFFSET_FILL) : gl.disable(GL.POLYGON_OFFSET_FILL),\n  polygonOffset: (gl, value) => gl.polygonOffset(...value),\n\n  sampleCoverage: (gl, value) => gl.sampleCoverage(...value),\n\n  scissorTest: (gl, value) => (value ? gl.enable(GL.SCISSOR_TEST) : gl.disable(GL.SCISSOR_TEST)),\n  scissor: (gl, value) => gl.scissor(...value),\n\n  stencilTest: (gl, value) => (value ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST)),\n  stencilMask: (gl, value) => {\n    value = isArray(value) ? value : [value, value];\n    const [mask, backMask] = value;\n    gl.stencilMaskSeparate(GL.FRONT, mask);\n    gl.stencilMaskSeparate(GL.BACK, backMask);\n  },\n  stencilFunc: (gl, args) => {\n    args = isArray(args) && args.length === 3 ? [...args, ...args] : args;\n    const [func, ref, mask, backFunc, backRef, backMask] = args;\n    gl.stencilFuncSeparate(GL.FRONT, func, ref, mask);\n    gl.stencilFuncSeparate(GL.BACK, backFunc, backRef, backMask);\n  },\n  stencilOp: (gl, args) => {\n    args = isArray(args) && args.length === 3 ? [...args, ...args] : args;\n    const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args;\n    gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);\n    gl.stencilOpSeparate(GL.BACK, backSfail, backDpfail, backDppass);\n  },\n\n  viewport: (gl, value) => gl.viewport(...value)\n};\n\nfunction getValue(glEnum, values, cache) {\n  return values[glEnum] !== undefined ? values[glEnum] : cache[glEnum];\n}\n\n// COMPOSITE_WEBGL_PARAMETER_\nexport const GL_COMPOSITE_PARAMETER_SETTERS = {\n  blendEquation: (gl, values, cache) =>\n    gl.blendEquationSeparate(\n      getValue(GL.BLEND_EQUATION_RGB, values, cache),\n      getValue(GL.BLEND_EQUATION_ALPHA, values, cache)\n    ),\n  blendFunc: (gl, values, cache) =>\n    gl.blendFuncSeparate(\n      getValue(GL.BLEND_SRC_RGB, values, cache),\n      getValue(GL.BLEND_DST_RGB, values, cache),\n      getValue(GL.BLEND_SRC_ALPHA, values, cache),\n      getValue(GL.BLEND_DST_ALPHA, values, cache)\n    ),\n  polygonOffset: (gl, values, cache) =>\n    gl.polygonOffset(\n      getValue(GL.POLYGON_OFFSET_FACTOR, values, cache),\n      getValue(GL.POLYGON_OFFSET_UNITS, values, cache)\n    ),\n  sampleCoverage: (gl, values, cache) =>\n    gl.sampleCoverage(\n      getValue(GL.SAMPLE_COVERAGE_VALUE, values, cache),\n      getValue(GL.SAMPLE_COVERAGE_INVERT, values, cache)\n    ),\n  stencilFuncFront: (gl, values, cache) =>\n    gl.stencilFuncSeparate(\n      GL.FRONT,\n      getValue(GL.STENCIL_FUNC, values, cache),\n      getValue(GL.STENCIL_REF, values, cache),\n      getValue(GL.STENCIL_VALUE_MASK, values, cache)\n    ),\n  stencilFuncBack: (gl, values, cache) =>\n    gl.stencilFuncSeparate(\n      GL.BACK,\n      getValue(GL.STENCIL_BACK_FUNC, values, cache),\n      getValue(GL.STENCIL_BACK_REF, values, cache),\n      getValue(GL.STENCIL_BACK_VALUE_MASK, values, cache)\n    ),\n  stencilOpFront: (gl, values, cache) =>\n    gl.stencilOpSeparate(\n      GL.FRONT,\n      getValue(GL.STENCIL_FAIL, values, cache),\n      getValue(GL.STENCIL_PASS_DEPTH_FAIL, values, cache),\n      getValue(GL.STENCIL_PASS_DEPTH_PASS, values, cache)\n    ),\n  stencilOpBack: (gl, values, cache) =>\n    gl.stencilOpSeparate(\n      GL.BACK,\n      getValue(GL.STENCIL_BACK_FAIL, values, cache),\n      getValue(GL.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache),\n      getValue(GL.STENCIL_BACK_PASS_DEPTH_PASS, values, cache)\n    )\n};\n\n// Setter functions intercepted for cache updates\nexport const GL_HOOKED_SETTERS = {\n  // GENERIC SETTERS\n\n  enable: (update, capability) =>\n    update({\n      [capability]: true\n    }),\n  disable: (update, capability) =>\n    update({\n      [capability]: false\n    }),\n  pixelStorei: (update, pname, value) =>\n    update({\n      [pname]: value\n    }),\n  hint: (update, pname, hint) =>\n    update({\n      [pname]: hint\n    }),\n\n  // SPECIFIC SETTERS\n\n  bindFramebuffer: (update, target, framebuffer) => {\n    switch (target) {\n      case GL.FRAMEBUFFER:\n        return update({\n          [GL.DRAW_FRAMEBUFFER_BINDING]: framebuffer,\n          [GL.READ_FRAMEBUFFER_BINDING]: framebuffer\n        });\n      case GL.DRAW_FRAMEBUFFER:\n        return update({[GL.DRAW_FRAMEBUFFER_BINDING]: framebuffer});\n      case GL.READ_FRAMEBUFFER:\n        return update({[GL.READ_FRAMEBUFFER_BINDING]: framebuffer});\n      default:\n        return null;\n    }\n  },\n  blendColor: (update, r, g, b, a) =>\n    update({\n      [GL.BLEND_COLOR]: new Float32Array([r, g, b, a])\n    }),\n\n  blendEquation: (update, mode) =>\n    update({\n      [GL.BLEND_EQUATION_RGB]: mode,\n      [GL.BLEND_EQUATION_ALPHA]: mode\n    }),\n\n  blendEquationSeparate: (update, modeRGB, modeAlpha) =>\n    update({\n      [GL.BLEND_EQUATION_RGB]: modeRGB,\n      [GL.BLEND_EQUATION_ALPHA]: modeAlpha\n    }),\n\n  blendFunc: (update, src, dst) =>\n    update({\n      [GL.BLEND_SRC_RGB]: src,\n      [GL.BLEND_DST_RGB]: dst,\n      [GL.BLEND_SRC_ALPHA]: src,\n      [GL.BLEND_DST_ALPHA]: dst\n    }),\n\n  blendFuncSeparate: (update, srcRGB, dstRGB, srcAlpha, dstAlpha) =>\n    update({\n      [GL.BLEND_SRC_RGB]: srcRGB,\n      [GL.BLEND_DST_RGB]: dstRGB,\n      [GL.BLEND_SRC_ALPHA]: srcAlpha,\n      [GL.BLEND_DST_ALPHA]: dstAlpha\n    }),\n\n  clearColor: (update, r, g, b, a) =>\n    update({\n      [GL.COLOR_CLEAR_VALUE]: new Float32Array([r, g, b, a])\n    }),\n\n  clearDepth: (update, depth) =>\n    update({\n      [GL.DEPTH_CLEAR_VALUE]: depth\n    }),\n\n  clearStencil: (update, s) =>\n    update({\n      [GL.STENCIL_CLEAR_VALUE]: s\n    }),\n\n  colorMask: (update, r, g, b, a) =>\n    update({\n      [GL.COLOR_WRITEMASK]: [r, g, b, a]\n    }),\n\n  cullFace: (update, mode) =>\n    update({\n      [GL.CULL_FACE_MODE]: mode\n    }),\n\n  depthFunc: (update, func) =>\n    update({\n      [GL.DEPTH_FUNC]: func\n    }),\n\n  depthRange: (update, zNear, zFar) =>\n    update({\n      [GL.DEPTH_RANGE]: new Float32Array([zNear, zFar])\n    }),\n\n  depthMask: (update, mask) =>\n    update({\n      [GL.DEPTH_WRITEMASK]: mask\n    }),\n\n  frontFace: (update, face) =>\n    update({\n      [GL.FRONT_FACE]: face\n    }),\n\n  lineWidth: (update, width) =>\n    update({\n      [GL.LINE_WIDTH]: width\n    }),\n\n  polygonOffset: (update, factor, units) =>\n    update({\n      [GL.POLYGON_OFFSET_FACTOR]: factor,\n      [GL.POLYGON_OFFSET_UNITS]: units\n    }),\n\n  sampleCoverage: (update, value, invert) =>\n    update({\n      [GL.SAMPLE_COVERAGE_VALUE]: value,\n      [GL.SAMPLE_COVERAGE_INVERT]: invert\n    }),\n\n  scissor: (update, x, y, width, height) =>\n    update({\n      [GL.SCISSOR_BOX]: new Int32Array([x, y, width, height])\n    }),\n\n  stencilMask: (update, mask) =>\n    update({\n      [GL.STENCIL_WRITEMASK]: mask,\n      [GL.STENCIL_BACK_WRITEMASK]: mask\n    }),\n\n  stencilMaskSeparate: (update, face, mask) =>\n    update({\n      [face === GL.FRONT ? GL.STENCIL_WRITEMASK : GL.STENCIL_BACK_WRITEMASK]: mask\n    }),\n\n  stencilFunc: (update, func, ref, mask) =>\n    update({\n      [GL.STENCIL_FUNC]: func,\n      [GL.STENCIL_REF]: ref,\n      [GL.STENCIL_VALUE_MASK]: mask,\n      [GL.STENCIL_BACK_FUNC]: func,\n      [GL.STENCIL_BACK_REF]: ref,\n      [GL.STENCIL_BACK_VALUE_MASK]: mask\n    }),\n\n  stencilFuncSeparate: (update, face, func, ref, mask) =>\n    update({\n      [face === GL.FRONT ? GL.STENCIL_FUNC : GL.STENCIL_BACK_FUNC]: func,\n      [face === GL.FRONT ? GL.STENCIL_REF : GL.STENCIL_BACK_REF]: ref,\n      [face === GL.FRONT ? GL.STENCIL_VALUE_MASK : GL.STENCIL_BACK_VALUE_MASK]: mask\n    }),\n\n  stencilOp: (update, fail, zfail, zpass) =>\n    update({\n      [GL.STENCIL_FAIL]: fail,\n      [GL.STENCIL_PASS_DEPTH_FAIL]: zfail,\n      [GL.STENCIL_PASS_DEPTH_PASS]: zpass,\n      [GL.STENCIL_BACK_FAIL]: fail,\n      [GL.STENCIL_BACK_PASS_DEPTH_FAIL]: zfail,\n      [GL.STENCIL_BACK_PASS_DEPTH_PASS]: zpass\n    }),\n\n  stencilOpSeparate: (update, face, fail, zfail, zpass) =>\n    update({\n      [face === GL.FRONT ? GL.STENCIL_FAIL : GL.STENCIL_BACK_FAIL]: fail,\n      [face === GL.FRONT ? GL.STENCIL_PASS_DEPTH_FAIL : GL.STENCIL_BACK_PASS_DEPTH_FAIL]: zfail,\n      [face === GL.FRONT ? GL.STENCIL_PASS_DEPTH_PASS : GL.STENCIL_BACK_PASS_DEPTH_PASS]: zpass\n    }),\n\n  viewport: (update, x, y, width, height) =>\n    update({\n      [GL.VIEWPORT]: [x, y, width, height]\n    })\n};\n\n// GETTER TABLE - FOR READING OUT AN ENTIRE CONTEXT\n\nconst isEnabled = (gl, key) => gl.isEnabled(key);\n\n// Exceptions for any keys that cannot be queried by gl.getParameters\nexport const GL_PARAMETER_GETTERS = {\n  [GL.BLEND]: isEnabled,\n  [GL.CULL_FACE]: isEnabled,\n  [GL.DEPTH_TEST]: isEnabled,\n  [GL.DITHER]: isEnabled,\n  [GL.POLYGON_OFFSET_FILL]: isEnabled,\n  [GL.SAMPLE_ALPHA_TO_COVERAGE]: isEnabled,\n  [GL.SAMPLE_COVERAGE]: isEnabled,\n  [GL.SCISSOR_TEST]: isEnabled,\n  [GL.STENCIL_TEST]: isEnabled,\n\n  // WebGL 2\n  [GL.RASTERIZER_DISCARD]: isEnabled\n};\n","// Support for listening to context state changes and intercepting state queries\n// NOTE: this system does not handle buffer bindings\n/** @typedef {import('./track-context-state')} types */\n\nimport {GL_PARAMETER_DEFAULTS, GL_HOOKED_SETTERS} from './webgl-parameter-tables';\nimport {setParameters, getParameters} from './unified-parameter-api';\nimport {assert} from '../utils/assert';\nimport {deepArrayEqual} from '../utils/utils';\n\n// HELPER FUNCTIONS - INSTALL GET/SET INTERCEPTORS (SPYS) ON THE CONTEXT\n\n// Overrides a WebGLRenderingContext state \"getter\" function\n// to return values directly from cache\nfunction installGetterOverride(gl, functionName) {\n  // Get the original function from the WebGLRenderingContext\n  const originalGetterFunc = gl[functionName].bind(gl);\n\n  // Wrap it with a spy so that we can update our state cache when it gets called\n  gl[functionName] = function get(...params) {\n    const pname = params[0];\n\n    // WebGL limits are not prepopulated in the cache, it's neither undefined in GL_PARAMETER_DEFAULTS\n    // nor intercepted by GL_HOOKED_SETTERS. Query the original getter.\n    if (!(pname in gl.state.cache)) {\n      return originalGetterFunc(...params);\n    }\n\n    // Optionally call the original function to do a \"hard\" query from the WebGLRenderingContext\n    return gl.state.enable\n      ? // Call the getter the params so that it can e.g. serve from a cache\n        gl.state.cache[pname]\n      : // Optionally call the original function to do a \"hard\" query from the WebGLRenderingContext\n        originalGetterFunc(...params);\n  };\n\n  // Set the name of this anonymous function to help in debugging and profiling\n  Object.defineProperty(gl[functionName], 'name', {\n    value: `${functionName}-from-cache`,\n    configurable: false\n  });\n}\n\n// Overrides a WebGLRenderingContext state \"setter\" function\n// to call a setter spy before the actual setter. Allows us to keep a cache\n// updated with a copy of the WebGL context state.\nfunction installSetterSpy(gl, functionName, setter) {\n  // Get the original function from the WebGLRenderingContext\n  const originalSetterFunc = gl[functionName].bind(gl);\n\n  // Wrap it with a spy so that we can update our state cache when it gets called\n  gl[functionName] = function set(...params) {\n    // Update the value\n    // Call the setter with the state cache and the params so that it can store the parameters\n    const {valueChanged, oldValue} = setter(gl.state._updateCache, ...params);\n\n    // Call the original WebGLRenderingContext func to make sure the context actually gets updated\n    if (valueChanged) {\n      originalSetterFunc(...params);\n    }\n\n    // Note: if the original function fails to set the value, our state cache will be bad\n    // No solution for this at the moment, but assuming that this is unlikely to be a real problem\n    // We could call the setter after the originalSetterFunc. Concern is that this would\n    // cause different behavior in debug mode, where originalSetterFunc can throw exceptions\n\n    return oldValue;\n  };\n\n  // Set the name of this anonymous function to help in debugging and profiling\n  Object.defineProperty(gl[functionName], 'name', {\n    value: `${functionName}-to-cache`,\n    configurable: false\n  });\n}\n\nfunction installProgramSpy(gl) {\n  const originalUseProgram = gl.useProgram.bind(gl);\n\n  gl.useProgram = function useProgramLuma(handle) {\n    if (gl.state.program !== handle) {\n      originalUseProgram(handle);\n      gl.state.program = handle;\n    }\n  };\n}\n\n// HELPER CLASS - GLState\n\n/* eslint-disable no-shadow */\nclass GLState {\n  constructor(\n    gl,\n    {\n      copyState = false, // Copy cache from params (slow) or initialize from WebGL defaults (fast)\n      log = () => {} // Logging function, called when gl parameter change calls are actually issued\n    } = {}\n  ) {\n    this.gl = gl;\n    this.program = null;\n    this.stateStack = [];\n    this.enable = true;\n    this.cache = copyState ? getParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);\n    this.log = log;\n\n    this._updateCache = this._updateCache.bind(this);\n    Object.seal(this);\n  }\n\n  push(values = {}) {\n    this.stateStack.push({});\n  }\n\n  pop() {\n    assert(this.stateStack.length > 0);\n    // Use the saved values in the state stack to restore parameters\n    const oldValues = this.stateStack[this.stateStack.length - 1];\n    setParameters(this.gl, oldValues);\n    // Don't pop until we have reset parameters (to make sure other \"stack frames\" are not affected)\n    this.stateStack.pop();\n  }\n\n  // interceptor for context set functions - update our cache and our stack\n  // values (Object) - the key values for this setter\n  _updateCache(values) {\n    let valueChanged = false;\n    let oldValue; // = undefined\n\n    const oldValues = this.stateStack.length > 0 && this.stateStack[this.stateStack.length - 1];\n\n    for (const key in values) {\n      assert(key !== undefined);\n      const value = values[key];\n      const cached = this.cache[key];\n      // Check that value hasn't already been shadowed\n      if (!deepArrayEqual(value, cached)) {\n        valueChanged = true;\n        oldValue = cached;\n\n        // First, save current value being shadowed\n        // If a state stack frame is active, save the current parameter values for pop\n        // but first check that value hasn't already been shadowed and saved\n        if (oldValues && !(key in oldValues)) {\n          oldValues[key] = cached;\n        }\n\n        // Save current value being shadowed\n        this.cache[key] = value;\n      }\n    }\n\n    return {valueChanged, oldValue};\n  }\n}\n\n// PUBLIC API\n\n/**\n * Initialize WebGL state caching on a context\n * @type {types['trackContextState']}\n */\n// After calling this function, context state will be cached\n// gl.state.push() and gl.state.pop() will be available for saving,\n// temporarily modifying, and then restoring state.\nexport function trackContextState(gl, options = {}) {\n  const {enable = true, copyState} = options;\n  assert(copyState !== undefined);\n  // @ts-ignore\n  if (!gl.state) {\n    const global_ = typeof global !== 'undefined' ? global : window;\n    // @ts-ignore\n    const {polyfillContext} = global_;\n    if (polyfillContext) {\n      polyfillContext(gl);\n    }\n\n    // Create a state cache\n    // @ts-ignore\n    gl.state = new GLState(gl, {copyState});\n\n    installProgramSpy(gl);\n\n    // intercept all setter functions in the table\n    for (const key in GL_HOOKED_SETTERS) {\n      const setter = GL_HOOKED_SETTERS[key];\n      installSetterSpy(gl, key, setter);\n    }\n\n    // intercept all getter functions in the table\n    installGetterOverride(gl, 'getParameter');\n    installGetterOverride(gl, 'isEnabled');\n  }\n\n  // @ts-ignore\n  gl.state.enable = enable;\n\n  return gl;\n}\n\n/**\n * Initialize WebGL state caching on a context\n * @type {types['pushContextState']}\n */\nexport function pushContextState(gl) {\n  // @ts-ignore\n  if (!gl.state) {\n    trackContextState(gl, {copyState: false});\n  }\n  // @ts-ignore\n  gl.state.push();\n}\n\n/**\n * Initialize WebGL state caching on a context\n * @type {types['popContextState']}\n */\nexport function popContextState(gl) {\n  // @ts-ignore\n  assert(gl.state);\n  // @ts-ignore\n  gl.state.pop();\n}\n","// Returns true if given object is empty, false otherwise.\nexport function isObjectEmpty(object) {\n  for (const key in object) {\n    return false;\n  }\n  return true;\n}\n\nexport function deepArrayEqual(x, y) {\n  if (x === y) {\n    return true;\n  }\n  const isArrayX = Array.isArray(x) || ArrayBuffer.isView(x);\n  const isArrayY = Array.isArray(y) || ArrayBuffer.isView(y);\n  if (isArrayX && isArrayY && x.length === y.length) {\n    for (let i = 0; i < x.length; ++i) {\n      if (x[i] !== y[i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n  return false;\n}\n","// WebGLRenderingContext related methods\n\n/** @typedef {import('./context')} types */\n\n/* eslint-disable quotes */\nimport GL from '@luma.gl/constants';\nimport {global, isBrowser as getIsBrowser} from 'probe.gl/env';\nimport {trackContextState} from '../state-tracker/track-context-state';\n\nimport {log} from '../utils/log';\nimport {assert} from '../utils/assert';\nimport {getDevicePixelRatio} from '../utils/device-pixels';\nimport {isWebGL2} from '../utils/webgl-checks';\n\nconst isBrowser = getIsBrowser();\nconst isPage = isBrowser && typeof document !== 'undefined';\n\nconst CONTEXT_DEFAULTS = {\n  // COMMON CONTEXT PARAMETERS\n  // Attempt to allocate WebGL2 context\n  webgl2: true, // Attempt to create a WebGL2 context (false to force webgl1)\n  webgl1: true, // Attempt to create a WebGL1 context (false to fail if webgl2 not available)\n  throwOnError: true,\n  manageState: true,\n  // BROWSER CONTEXT PARAMETERS\n  canvas: null, // A canvas element or a canvas string id\n  debug: false, // Instrument context (at the expense of performance)\n  // HEADLESS CONTEXT PARAMETERS\n  width: 800, // width are height are only used by headless gl\n  height: 600\n  // WEBGL/HEADLESS CONTEXT PARAMETERS\n  // Remaining options are passed through to context creator\n};\n\n/**\n * Creates a context giving access to the WebGL API\n * @type {types['createGLContext']}\n */\n/* eslint-disable complexity, max-statements */\nexport function createGLContext(options = {}) {\n  assert(\n    isBrowser,\n    \"createGLContext only available in the browser.\\nCreate your own headless context or use 'createHeadlessContext' from @luma.gl/test-utils\"\n  );\n\n  options = Object.assign({}, CONTEXT_DEFAULTS, options);\n  const {width, height} = options;\n\n  // Error reporting function, enables exceptions to be disabled\n  function onError(message) {\n    if (options.throwOnError) {\n      throw new Error(message);\n    }\n    // eslint-disable-next-line\n    console.error(message);\n    return null;\n  }\n  options.onError = onError;\n\n  let gl;\n  // Get or create a canvas\n  const {canvas} = options;\n  const targetCanvas = getCanvas({canvas, width, height, onError});\n  // Create a WebGL context in the canvas\n  gl = createBrowserContext(targetCanvas, options);\n\n  if (!gl) {\n    return null;\n  }\n\n  gl = instrumentGLContext(gl, options);\n\n  // Log some debug info about the newly created context\n  logInfo(gl);\n\n  // Add to seer integration\n  return gl;\n}\n\n/**\n * Creates a context giving access to the WebGL API\n * @type {types['instrumentGLContext']}\n */\nexport function instrumentGLContext(gl, options = {}) {\n  // Avoid multiple instrumentations\n  // @ts-ignore\n  if (!gl || gl._instrumented) {\n    return gl;\n  }\n\n  // @ts-ignore\n  gl._version = gl._version || getVersion(gl);\n\n  // Cache canvas size information to avoid setting it on every frame.\n  // @ts-ignore\n  gl.luma = gl.luma || {};\n  // @ts-ignore\n  gl.luma.canvasSizeInfo = gl.luma.canvasSizeInfo || {};\n\n  options = Object.assign({}, CONTEXT_DEFAULTS, options);\n  const {manageState, debug} = options;\n\n  // Install context state tracking\n  if (manageState) {\n    trackContextState(gl, {\n      copyState: false,\n      log: (...args) => log.log(1, ...args)()\n    });\n  }\n\n  // Add debug instrumentation to the context\n  if (isBrowser && debug) {\n    // @ts-ignore\n    if (!global.makeDebugContext) {\n      log.warn('WebGL debug mode not activated. import \"@luma.gl/debug\" to enable.')();\n    } else {\n      // @ts-ignore\n      gl = global.makeDebugContext(gl, options);\n      // Debug forces log level to at least 1\n      log.level = Math.max(log.level, 1);\n    }\n  }\n\n  // @ts-ignore\n  gl._instrumented = true;\n\n  return gl;\n}\n\n/**\n * Provides strings identifying the GPU vendor and driver.\n * @type {types['getContextDebugInfo']}\n */\nexport function getContextDebugInfo(gl) {\n  const vendorMasked = gl.getParameter(GL.VENDOR);\n  const rendererMasked = gl.getParameter(GL.RENDERER);\n  const ext = gl.getExtension('WEBGL_debug_renderer_info');\n  const vendorUnmasked = ext && gl.getParameter(ext.UNMASKED_VENDOR_WEBGL || GL.VENDOR);\n  const rendererUnmasked = ext && gl.getParameter(ext.UNMASKED_RENDERER_WEBGL || GL.RENDERER);\n  return {\n    vendor: vendorUnmasked || vendorMasked,\n    renderer: rendererUnmasked || rendererMasked,\n    vendorMasked,\n    rendererMasked,\n    version: gl.getParameter(GL.VERSION),\n    shadingLanguageVersion: gl.getParameter(GL.SHADING_LANGUAGE_VERSION)\n  };\n}\n\n/**\n * Resize the canvas' drawing buffer.\n * @type {types['resizeGLContext']}\n */\nexport function resizeGLContext(gl, options = {}) {\n  // Resize browser context\n  if (gl.canvas) {\n    const devicePixelRatio = getDevicePixelRatio(options.useDevicePixels);\n    setDevicePixelRatio(gl, devicePixelRatio, options);\n    return;\n  }\n\n  // Resize headless gl context\n  const ext = gl.getExtension('STACKGL_resize_drawingbuffer');\n  if (ext && `width` in options && `height` in options) {\n    ext.resize(options.width, options.height);\n  }\n}\n\n// HELPER METHODS\n\n/**\n * Create a WebGL context for a canvas\n * Note calling this multiple time on the same canvas does return the same context\n */\n\nfunction createBrowserContext(canvas, options) {\n  const {onError} = options;\n\n  // Try to extract any extra information about why context creation failed\n  let errorMessage = null;\n  const onCreateError = error => (errorMessage = error.statusMessage || errorMessage);\n  canvas.addEventListener('webglcontextcreationerror', onCreateError, false);\n\n  const {webgl1 = true, webgl2 = true} = options;\n  let gl = null;\n  // Prefer webgl2 over webgl1, prefer conformant over experimental\n  if (webgl2) {\n    gl = gl || canvas.getContext('webgl2', options);\n    gl = gl || canvas.getContext('experimental-webgl2', options);\n  }\n  if (webgl1) {\n    gl = gl || canvas.getContext('webgl', options);\n    gl = gl || canvas.getContext('experimental-webgl', options);\n  }\n\n  canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);\n\n  if (!gl) {\n    return onError(\n      `Failed to create ${webgl2 && !webgl1 ? 'WebGL2' : 'WebGL'} context: ${errorMessage ||\n        'Unknown error'}`\n    );\n  }\n\n  if (options.onContextLost) {\n    canvas.addEventListener('webglcontextlost', options.onContextLost, false);\n  }\n\n  if (options.onContextRestored) {\n    canvas.addEventListener('webglcontextrestored', options.onContextRestored, false);\n  }\n\n  return gl;\n}\n\nfunction getCanvas({canvas, width = 800, height = 600, onError}) {\n  let targetCanvas;\n  if (typeof canvas === 'string') {\n    const isPageLoaded = isPage && document.readyState === 'complete';\n    if (!isPageLoaded) {\n      onError(`createGLContext called on canvas '${canvas}' before page was loaded`);\n    }\n    targetCanvas = document.getElementById(canvas);\n  } else if (canvas) {\n    targetCanvas = canvas;\n  } else {\n    targetCanvas = document.createElement('canvas');\n    targetCanvas.id = 'lumagl-canvas';\n    targetCanvas.style.width = Number.isFinite(width) ? `${width}px` : '100%';\n    targetCanvas.style.height = Number.isFinite(height) ? `${height}px` : '100%';\n    document.body.insertBefore(targetCanvas, document.body.firstChild);\n  }\n\n  return targetCanvas;\n}\n\nfunction logInfo(gl) {\n  const webGL = isWebGL2(gl) ? 'WebGL2' : 'WebGL1';\n  const info = getContextDebugInfo(gl);\n  const driver = info ? `(${info.vendor},${info.renderer})` : '';\n  const debug = gl.debug ? ' debug' : '';\n  log.info(1, `${webGL}${debug} context ${driver}`)();\n}\n\nfunction getVersion(gl) {\n  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {\n    // WebGL2 context.\n    return 2;\n  }\n  // Must be a WebGL1 context.\n  return 1;\n}\n\n// use devicePixelRatio to set canvas width and height\nfunction setDevicePixelRatio(gl, devicePixelRatio, options) {\n  // NOTE: if options.width and options.height not used remove in v8\n  let clientWidth = 'width' in options ? options.width : gl.canvas.clientWidth;\n  let clientHeight = 'height' in options ? options.height : gl.canvas.clientHeight;\n\n  if (!clientWidth || !clientHeight) {\n    log.log(1, 'Canvas clientWidth/clientHeight is 0')();\n    // by forcing devicePixel ratio to 1, we do not scale gl.canvas.width and height in each frame.\n    devicePixelRatio = 1;\n    clientWidth = gl.canvas.width || 1;\n    clientHeight = gl.canvas.height || 1;\n  }\n\n  gl.luma = gl.luma || {};\n  gl.luma.canvasSizeInfo = gl.luma.canvasSizeInfo || {};\n  const cachedSize = gl.luma.canvasSizeInfo;\n  // Check if canvas needs to be resized\n  if (\n    cachedSize.clientWidth !== clientWidth ||\n    cachedSize.clientHeight !== clientHeight ||\n    cachedSize.devicePixelRatio !== devicePixelRatio\n  ) {\n    let clampedPixelRatio = devicePixelRatio;\n\n    const canvasWidth = Math.floor(clientWidth * clampedPixelRatio);\n    const canvasHeight = Math.floor(clientHeight * clampedPixelRatio);\n    gl.canvas.width = canvasWidth;\n    gl.canvas.height = canvasHeight;\n\n    // Note: when devicePixelRatio is too high, it is possible we might hit system limit for\n    // drawing buffer width and hight, in those cases they get clamped and resulting aspect ration may not be maintained\n    // for those cases, reduce devicePixelRatio.\n    if (gl.drawingBufferWidth !== canvasWidth || gl.drawingBufferHeight !== canvasHeight) {\n      log.warn(`Device pixel ratio clamped`)();\n      clampedPixelRatio = Math.min(\n        gl.drawingBufferWidth / clientWidth,\n        gl.drawingBufferHeight / clientHeight\n      );\n\n      gl.canvas.width = Math.floor(clientWidth * clampedPixelRatio);\n      gl.canvas.height = Math.floor(clientHeight * clampedPixelRatio);\n    }\n\n    Object.assign(gl.luma.canvasSizeInfo, {clientWidth, clientHeight, devicePixelRatio});\n  }\n}\n","/** @typedef {import('./device-pixels')} types */\n\n/**\n * Returns multiplier need to convert CSS size to Device size\n * @type {types['cssToDeviceRatio']}\n */\nexport function cssToDeviceRatio(gl) {\n  // @ts-ignore\n  const {luma} = gl;\n\n  if (gl.canvas && luma) {\n    // For headless gl we might have used custom width and height\n    // hence use cached clientWidth\n    const {clientWidth} = luma.canvasSizeInfo;\n    return clientWidth ? gl.drawingBufferWidth / clientWidth : 1;\n  }\n  // use default device pixel ratio\n  return 1;\n}\n\n/**\n * Maps CSS pixel position to device pixel position\n * @type {types['cssToDevicePixels']}\n */\nexport function cssToDevicePixels(gl, cssPixel, yInvert = true) {\n  const ratio = cssToDeviceRatio(gl);\n  const width = gl.drawingBufferWidth;\n  const height = gl.drawingBufferHeight;\n  return scalePixels(cssPixel, ratio, width, height, yInvert);\n}\n\n// HELPER METHOD\n\n/**\n * Calulates device pixel ratio, used during context creation\n * @type {types['getDevicePixelRatio']}\n */\nexport function getDevicePixelRatio(useDevicePixels) {\n  const windowRatio = typeof window === 'undefined' ? 1 : window.devicePixelRatio || 1;\n  if (Number.isFinite(useDevicePixels)) {\n    // @ts-ignore Can no longer be boolean after previous line\n    return useDevicePixels <= 0 ? 1 : useDevicePixels;\n  }\n  return useDevicePixels ? windowRatio : 1;\n}\n\n// PRIVATE\n\nfunction scalePixels(pixel, ratio, width, height, yInvert) {\n  const x = scaleX(pixel[0], ratio, width);\n  let y = scaleY(pixel[1], ratio, height, yInvert);\n\n  // Find boundaries of next pixel to provide valid range of device pixel locaitons\n\n  let t = scaleX(pixel[0] + 1, ratio, width);\n  // If next pixel's position is clamped to boundary, use it as is, otherwise subtract 1 for current pixel boundary\n  const xHigh = t === width - 1 ? t : t - 1;\n\n  t = scaleY(pixel[1] + 1, ratio, height, yInvert);\n  let yHigh;\n  if (yInvert) {\n    // If next pixel's position is clamped to boundary, use it as is, otherwise clamp it to valid range\n    t = t === 0 ? t : t + 1;\n    // swap y and yHigh\n    yHigh = y;\n    y = t;\n  } else {\n    // If next pixel's position is clamped to boundary, use it as is, otherwise clamp it to valid range\n    yHigh = t === height - 1 ? t : t - 1;\n    // y remains same\n  }\n  return {\n    x,\n    y,\n    // when ratio < 1, current css pixel and next css pixel may point to same device pixel, set width/height to 1 in those cases.\n    width: Math.max(xHigh - x + 1, 1),\n    height: Math.max(yHigh - y + 1, 1)\n  };\n}\n\nfunction scaleX(x, ratio, width) {\n  // since we are rounding to nearest, when ratio > 1, edge pixels may point to out of bounds value, clamp to the limit\n  const r = Math.min(Math.round(x * ratio), width - 1);\n  return r;\n}\n\nfunction scaleY(y, ratio, height, yInvert) {\n  // since we are rounding to nearest, when ratio > 1, edge pixels may point to out of bounds value, clamp to the limit\n  return yInvert\n    ? Math.max(0, height - 1 - Math.round(y * ratio))\n    : Math.min(Math.round(y * ratio), height - 1);\n}\n","// luma.gl Base WebGL wrapper library\n// Provides simple class/function wrappers around the low level webgl objects\n// These classes are intentionally close to the WebGL API\n// but make it easier to use.\n// Higher level abstractions can be built on these classes\n\n// Initialize any global state\nexport {lumaStats} from './init';\n\n// UTILS\nexport {requestAnimationFrame, cancelAnimationFrame} from './webgl-utils/request-animation-frame';\n\n// WebGL Functions\nexport {cloneTextureFrom} from './webgl-utils/texture-utils';\nexport {getKeyValue, getKey} from './webgl-utils/constants-to-keys';\nexport {getContextInfo, getGLContextInfo, getContextLimits} from './features/limits';\nexport {FEATURES} from './features/webgl-features-table';\nexport {hasFeature, hasFeatures, getFeatures} from './features/features';\nexport {default as canCompileGLGSExtension} from './features/check-glsl-extension';\n\n// WebGL Helper Classes\nexport {default as Accessor} from './classes/accessor';\n\n// WebGL1 classes\nexport {default as Buffer} from './classes/buffer';\nexport {Shader, VertexShader, FragmentShader} from './classes/shader';\nexport {default as Program} from './classes/program';\nexport {default as Framebuffer} from './classes/framebuffer';\nexport {default as Renderbuffer} from './classes/renderbuffer';\nexport {default as Texture2D} from './classes/texture-2d';\nexport {default as TextureCube} from './classes/texture-cube';\n\nexport {clear, clearBuffer} from './classes/clear';\n\n// Copy and Blit\nexport {\n  readPixelsToArray,\n  readPixelsToBuffer,\n  copyToDataUrl,\n  copyToImage,\n  copyToTexture,\n  blit\n} from './classes/copy-and-blit';\n\n// WebGL2 classes & Extensions\nexport {default as Query} from './classes/query';\nexport {default as Texture3D} from './classes/texture-3d';\nexport {default as TransformFeedback} from './classes/transform-feedback';\nexport {default as VertexArrayObject} from './classes/vertex-array-object';\nexport {default as VertexArray} from './classes/vertex-array';\nexport {default as UniformBufferLayout} from './classes/uniform-buffer-layout';\n\n// experimental WebGL exports\n\nexport {setPathPrefix, loadFile, loadImage} from './utils/load-file';\n\n// PARSE SHADER SOURCE\nexport {default as getShaderName} from './glsl-utils/get-shader-name';\nexport {default as getShaderVersion} from './glsl-utils/get-shader-version';\n\n// UTILS\nexport {log} from '@luma.gl/gltools';\nexport {assert} from './utils/assert';\nexport {uid, isObjectEmpty} from './utils/utils';\n\n// INTERNAL\nexport {parseUniformName, getUniformSetter} from './classes/uniforms';\nexport {getDebugTableForUniforms} from './debug/debug-uniforms';\nexport {getDebugTableForVertexArray} from './debug/debug-vertex-array';\nexport {getDebugTableForProgramConfiguration} from './debug/debug-program-configuration';\n","import {log} from '@luma.gl/gltools';\nimport {Stats} from 'probe.gl';\nimport {isBrowser, global} from 'probe.gl/env';\n\n// Version detection using babel plugin\n/* global __VERSION__ */\n// @ts-ignore\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'untranspiled source';\n\nconst STARTUP_MESSAGE = 'set luma.log.level=1 (or higher) to trace rendering';\n// Assign luma.log.level in console to control logging: \\\n// 0: none, 1: minimal, 2: verbose, 3: attribute/uniforms, 4: gl logs\n// luma.log.break[], set to gl funcs, luma.log.profile[] set to model names`;\n\nclass StatsManager {\n  constructor() {\n    this.stats = new Map();\n  }\n\n  get(name) {\n    if (!this.stats.has(name)) {\n      this.stats.set(name, new Stats({id: name}));\n    }\n\n    return this.stats.get(name);\n  }\n}\n\nconst lumaStats = new StatsManager();\n\nif (global.luma && global.luma.VERSION !== VERSION) {\n  throw new Error(`luma.gl - multiple VERSIONs detected: ${global.luma.VERSION} vs ${VERSION}`);\n}\n\nif (!global.luma) {\n  if (isBrowser()) {\n    log.log(1, `luma.gl ${VERSION} - ${STARTUP_MESSAGE}`)();\n  }\n\n  global.luma = global.luma || {\n    VERSION,\n    version: VERSION,\n    log,\n\n    // A global stats object that various components can add information to\n    // E.g. see webgl/resource.js\n    stats: lumaStats,\n\n    // Keep some luma globals in a sub-object\n    // This allows us to dynamically detect if certain modules have been\n    // included (such as IO and headless) and enable related functionality,\n    // without unconditionally requiring and thus bundling big dependencies\n    // into the app.\n    globals: {\n      modules: {},\n      nodeIO: {}\n    }\n  };\n}\n\nexport {lumaStats};\nexport default global.luma;\n","// Node.js polyfills for requestAnimationFrame and cancelAnimationFrame\n\nexport function requestAnimationFrame(callback) {\n  return typeof window !== 'undefined' && window.requestAnimationFrame\n    ? window.requestAnimationFrame(callback)\n    : setTimeout(callback, 1000 / 60);\n}\n\nexport function cancelAnimationFrame(timerId) {\n  return typeof window !== 'undefined' && window.cancelAnimationFrame\n    ? window.cancelAnimationFrame(timerId)\n    : clearTimeout(timerId);\n}\n","// TODO: Two subdirectories must not depend on each other (classes vs utils)!\nimport Texture2D from '../classes/texture-2d';\nimport TextureCube from '../classes/texture-cube';\nimport Texture3D from '../classes/texture-3d';\nimport Framebuffer from '../classes/framebuffer';\nimport GL from '@luma.gl/constants';\nimport {assert} from '../utils/assert';\n\n// Clone a new texture object from a reference texture object.\n/** @type {import('./texture-utils').cloneTextureFrom} */\nexport function cloneTextureFrom(refTexture, overrides) {\n  assert(\n    refTexture instanceof Texture2D ||\n      refTexture instanceof TextureCube ||\n      refTexture instanceof Texture3D\n  );\n\n  const TextureType = refTexture.constructor;\n\n  const {gl, width, height, format, type, dataFormat, border, mipmaps} = refTexture;\n\n  const textureOptions = Object.assign(\n    {\n      width,\n      height,\n      format,\n      type,\n      dataFormat,\n      border,\n      mipmaps\n    },\n    overrides\n  );\n\n  // TODO: move this to `Texture` class as instance method and use this.constructor\n  return new TextureType(gl, textureOptions);\n}\n\n// Wraps a given texture into a framebuffer object, that can be further used\n// to read data from the texture object.\n/** @type {import('./texture-utils').toFramebuffer} */\nexport function toFramebuffer(texture, opts) {\n  const {gl, width, height, id} = texture;\n  const framebuffer = new Framebuffer(\n    gl,\n    Object.assign({}, opts, {\n      id: `framebuffer-for-${id}`,\n      width,\n      height,\n      attachments: {\n        [GL.COLOR_ATTACHMENT0]: texture\n      }\n    })\n  );\n  return framebuffer;\n}\n","import GL from '@luma.gl/constants';\nimport {assertWebGLContext} from '@luma.gl/gltools';\nimport Texture from './texture';\nimport {loadImage} from '../utils/load-file';\n\nexport default class Texture2D extends Texture {\n  static isSupported(gl, opts) {\n    return Texture.isSupported(gl, opts);\n  }\n\n  constructor(gl, props = {}) {\n    assertWebGLContext(gl);\n\n    // Signature: new Texture2D(gl, url | Promise)\n    if (props instanceof Promise || typeof props === 'string') {\n      props = {data: props};\n    }\n\n    // Signature: new Texture2D(gl, {data: url})\n    if (typeof props.data === 'string') {\n      props = Object.assign({}, props, {data: loadImage(props.data)});\n    }\n\n    super(gl, Object.assign({}, props, {target: GL.TEXTURE_2D}));\n\n    this.initialize(props);\n\n    Object.seal(this);\n  }\n}\n","import GL from '@luma.gl/constants';\nimport {isWebGL2, assertWebGL2Context, withParameters, log} from '@luma.gl/gltools';\nimport {global} from 'probe.gl/env';\n\nimport Resource from './resource';\nimport Buffer from './buffer';\nimport {\n  TEXTURE_FORMATS,\n  DATA_FORMAT_CHANNELS,\n  TYPE_SIZES,\n  isFormatSupported,\n  isLinearFilteringSupported\n} from './texture-formats';\nimport {assert} from '../utils/assert';\nimport {uid, isPowerOfTwo} from '../utils/utils';\n\n// Supported min filters for NPOT texture.\nconst NPOT_MIN_FILTERS = [GL.LINEAR, GL.NEAREST];\n\n// Polyfill\n// Note (Tarek): Do we really need to support this API?\nconst WebGLBuffer = global.WebGLBuffer || function WebGLBuffer() {};\n\nexport default class Texture extends Resource {\n  static isSupported(gl, opts = {}) {\n    const {format, linearFiltering} = opts;\n    let supported = true;\n    if (format) {\n      supported = supported && isFormatSupported(gl, format);\n      supported = supported && (!linearFiltering || isLinearFilteringSupported(gl, format));\n    }\n    return supported;\n  }\n\n  // target cannot be modified by bind:\n  // textures are special because when you first bind them to a target,\n  // they get special information. When you first bind a texture as a\n  // GL_TEXTURE_2D, you are actually setting special state in the texture.\n  // You are saying that this texture is a 2D texture.\n  // And it will always be a 2D texture; this state cannot be changed ever.\n  // If you have a texture that was first bound as a GL_TEXTURE_2D,\n  // you must always bind it as a GL_TEXTURE_2D;\n  // attempting to bind it as GL_TEXTURE_1D will give rise to an error\n  // (while run-time).\n  constructor(gl, props) {\n    const {\n      id = uid('texture'),\n      handle,\n      target\n      // , magFilter, minFilter, wrapS, wrapT\n    } = props;\n\n    super(gl, {id, handle});\n\n    this.target = target;\n    this.textureUnit = undefined;\n\n    // Program.draw() checks the loaded flag of all textures to avoid\n    // Textures that are still loading from promises\n    // Set to true as soon as texture has been initialized with valid data\n    this.loaded = false;\n\n    this.width = undefined;\n    this.height = undefined;\n    this.depth = undefined;\n    this.format = undefined;\n    this.type = undefined;\n    this.dataFormat = undefined;\n    this.border = undefined;\n    this.textureUnit = undefined;\n    this.mipmaps = undefined;\n  }\n\n  toString() {\n    return `Texture(${this.id},${this.width}x${this.height})`;\n  }\n\n  /* eslint-disable max-len, max-statements */\n  initialize(props = {}) {\n    let data = props.data;\n\n    if (data instanceof Promise) {\n      data.then(resolvedImageData =>\n        this.initialize(\n          Object.assign({}, props, {\n            pixels: resolvedImageData,\n            data: resolvedImageData\n          })\n        )\n      );\n      return this;\n    }\n    const isVideo = typeof HTMLVideoElement !== 'undefined' && data instanceof HTMLVideoElement;\n    // @ts-ignore\n    if (isVideo && data.readyState < HTMLVideoElement.HAVE_METADATA) {\n      this._video = null; // Declare member before the object is sealed\n      data.addEventListener('loadeddata', () => this.initialize(props));\n      return this;\n    }\n\n    const {\n      pixels = null,\n      format = GL.RGBA,\n      border = 0,\n      recreate = false,\n      parameters = {},\n      pixelStore = {},\n      textureUnit = undefined\n    } = props;\n\n    // pixels variable is for API compatibility purpose\n    if (!data) {\n      // TODO - This looks backwards? Commenting out for now until we decide\n      // which prop to use\n      // log.deprecated('data', 'pixels')();\n      data = pixels;\n    }\n\n    let {width, height, dataFormat, type, compressed = false, mipmaps = true} = props;\n    const {depth = 0} = props;\n\n    // Deduce width and height\n    ({width, height, compressed, dataFormat, type} = this._deduceParameters({\n      format,\n      type,\n      dataFormat,\n      compressed,\n      data,\n      width,\n      height\n    }));\n\n    // Store opts for accessors\n    this.width = width;\n    this.height = height;\n    this.depth = depth;\n    this.format = format;\n    this.type = type;\n    this.dataFormat = dataFormat;\n    this.border = border;\n    this.textureUnit = textureUnit;\n\n    if (Number.isFinite(this.textureUnit)) {\n      this.gl.activeTexture(GL.TEXTURE0 + this.textureUnit);\n      this.gl.bindTexture(this.target, this.handle);\n    }\n\n    if (mipmaps && this._isNPOT()) {\n      log.warn(`texture: ${this} is Non-Power-Of-Two, disabling mipmaping`)();\n      mipmaps = false;\n\n      this._updateForNPOT(parameters);\n    }\n\n    this.mipmaps = mipmaps;\n\n    this.setImageData({\n      data,\n      width,\n      height,\n      depth,\n      format,\n      type,\n      dataFormat,\n      border,\n      mipmaps,\n      parameters: pixelStore,\n      compressed\n    });\n\n    if (mipmaps) {\n      this.generateMipmap();\n    }\n\n    // Set texture sampler parameters\n    this.setParameters(parameters);\n\n    // TODO - Store data to enable auto recreate on context loss\n    if (recreate) {\n      this.data = data;\n    }\n    if (isVideo) {\n      this._video = {\n        video: data,\n        parameters,\n        // @ts-ignore\n        lastTime: data.readyState >= HTMLVideoElement.HAVE_CURRENT_DATA ? data.currentTime : -1\n      };\n    }\n\n    return this;\n  }\n\n  update() {\n    if (this._video) {\n      const {video, parameters, lastTime} = this._video;\n      // @ts-ignore\n      if (lastTime === video.currentTime || video.readyState < HTMLVideoElement.HAVE_CURRENT_DATA) {\n        return;\n      }\n      this.setSubImageData({\n        data: video,\n        parameters\n      });\n      if (this.mipmaps) {\n        this.generateMipmap();\n      }\n      this._video.lastTime = video.currentTime;\n    }\n  }\n\n  // If size has changed, reinitializes with current format\n  // note clears image and mipmaps\n  resize({height, width, mipmaps = false}) {\n    if (width !== this.width || height !== this.height) {\n      return this.initialize({\n        width,\n        height,\n        format: this.format,\n        type: this.type,\n        dataFormat: this.dataFormat,\n        border: this.border,\n        mipmaps\n      });\n    }\n    return this;\n  }\n\n  // Call to regenerate mipmaps after modifying texture(s)\n  generateMipmap(params = {}) {\n    if (this._isNPOT()) {\n      log.warn(`texture: ${this} is Non-Power-Of-Two, disabling mipmaping`)();\n      return this;\n    }\n\n    this.mipmaps = true;\n\n    this.gl.bindTexture(this.target, this.handle);\n    withParameters(this.gl, params, () => {\n      this.gl.generateMipmap(this.target);\n    });\n    this.gl.bindTexture(this.target, null);\n    return this;\n  }\n\n  /*\n   * Allocates storage\n   * @param {*} pixels -\n   *  null - create empty texture of specified format\n   *  Typed array - init from image data in typed array\n   *  Buffer|WebGLBuffer - (WEBGL2) init from image data in WebGLBuffer\n   *  HTMLImageElement|Image - Inits with content of image. Auto width/height\n   *  HTMLCanvasElement - Inits with contents of canvas. Auto width/height\n   *  HTMLVideoElement - Creates video texture. Auto width/height\n   *\n   * @param {GLint} width -\n   * @param {GLint} height -\n   * @param {GLint} mipMapLevel -\n   * @param {GLenum} format - format of image data.\n   * @param {GLenum} type\n   *  - format of array (autodetect from type) or\n   *  - (WEBGL2) format of buffer\n   * @param {Number} offset - (WEBGL2) offset from start of buffer\n   * @param {GLint} border - must be 0.\n   * @parameters - temporary settings to be applied, can be used to supply pixel store settings.\n   */\n  /* eslint-disable max-len, max-statements, complexity */\n  setImageData(options) {\n    this._trackDeallocatedMemory('Texture');\n\n    const {\n      target = this.target,\n      pixels = null,\n      level = 0,\n      format = this.format,\n      border = this.border,\n      offset = 0,\n      parameters = {}\n    } = options;\n\n    let {\n      data = null,\n      type = this.type,\n      width = this.width,\n      height = this.height,\n      dataFormat = this.dataFormat,\n      compressed = false\n    } = options;\n\n    // pixels variable is  for API compatibility purpose\n    if (!data) {\n      data = pixels;\n    }\n\n    ({type, dataFormat, compressed, width, height} = this._deduceParameters({\n      format,\n      type,\n      dataFormat,\n      compressed,\n      data,\n      width,\n      height\n    }));\n\n    const {gl} = this;\n    gl.bindTexture(this.target, this.handle);\n\n    let dataType = null;\n    ({data, dataType} = this._getDataType({data, compressed}));\n\n    let gl2;\n\n    withParameters(this.gl, parameters, () => {\n      switch (dataType) {\n        case 'null':\n          gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data);\n          break;\n        case 'typed-array':\n          // Looks like this assert is not necessary, as offset is ignored under WebGL1\n          // assert((offset === 0 || isWebGL2(gl)), 'offset supported in WebGL2 only');\n          // @ts-ignore\n          gl.texImage2D(\n            target,\n            level,\n            format,\n            width,\n            height,\n            border,\n            dataFormat,\n            type,\n            data,\n            // @ts-ignore\n            offset\n          );\n          break;\n        case 'buffer':\n          // WebGL2 enables creating textures directly from a WebGL buffer\n          gl2 = assertWebGL2Context(gl);\n          gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle || data);\n          gl2.texImage2D(target, level, format, width, height, border, dataFormat, type, offset);\n          gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);\n          break;\n        case 'browser-object':\n          if (isWebGL2(gl)) {\n            gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data);\n          } else {\n            gl.texImage2D(target, level, format, dataFormat, type, data);\n          }\n          break;\n        case 'compressed':\n          for (const [levelIndex, levelData] of data.entries()) {\n            gl.compressedTexImage2D(\n              target,\n              levelIndex,\n              levelData.format,\n              levelData.width,\n              levelData.height,\n              border,\n              levelData.data\n            );\n          }\n\n          break;\n        default:\n          assert(false, 'Unknown image data type');\n      }\n    });\n\n    if (data && data.byteLength) {\n      this._trackAllocatedMemory(data.byteLength, 'Texture');\n    } else {\n      // NOTE(Tarek): Default to RGBA bytes\n      const channels = DATA_FORMAT_CHANNELS[this.dataFormat] || 4;\n      const channelSize = TYPE_SIZES[this.type] || 1;\n\n      this._trackAllocatedMemory(this.width * this.height * channels * channelSize, 'Texture');\n    }\n\n    this.loaded = true;\n\n    return this;\n  }\n  /* eslint-enable max-len, max-statements, complexity */\n\n  /**\n   * Redefines an area of an existing texture\n   * Note: does not allocate storage\n   */\n  /*\n   * Redefines an area of an existing texture\n   * @param {*} pixels, data -\n   *  null - create empty texture of specified format\n   *  Typed array - init from image data in typed array\n   *  Buffer|WebGLBuffer - (WEBGL2) init from image data in WebGLBuffer\n   *  HTMLImageElement|Image - Inits with content of image. Auto width/height\n   *  HTMLCanvasElement - Inits with contents of canvas. Auto width/height\n   *  HTMLVideoElement - Creates video texture. Auto width/height\n   *\n   * @param {GLint} x - xOffset from where texture to be updated\n   * @param {GLint} y - yOffset from where texture to be updated\n   * @param {GLint} width - width of the sub image to be updated\n   * @param {GLint} height - height of the sub image to be updated\n   * @param {GLint} level - mip level to be updated\n   * @param {GLenum} format - internal format of image data.\n   * @param {GLenum} type\n   *  - format of array (autodetect from type) or\n   *  - (WEBGL2) format of buffer or ArrayBufferView\n   * @param {GLenum} dataFormat - format of image data.\n   * @param {Number} offset - (WEBGL2) offset from start of buffer\n   * @param {GLint} border - must be 0.\n   * @parameters - temporary settings to be applied, can be used to supply pixel store settings.\n   */\n  setSubImageData({\n    target = this.target,\n    pixels = null,\n    data = null,\n    x = 0,\n    y = 0,\n    width = this.width,\n    height = this.height,\n    level = 0,\n    format = this.format,\n    type = this.type,\n    dataFormat = this.dataFormat,\n    compressed = false,\n    offset = 0,\n    border = this.border,\n    parameters = {}\n  }) {\n    ({type, dataFormat, compressed, width, height} = this._deduceParameters({\n      format,\n      type,\n      dataFormat,\n      compressed,\n      data,\n      width,\n      height\n    }));\n\n    assert(this.depth === 0, 'texSubImage not supported for 3D textures');\n\n    // pixels variable is  for API compatibility purpose\n    if (!data) {\n      data = pixels;\n    }\n\n    // Support ndarrays\n    if (data && data.data) {\n      const ndarray = data;\n      data = ndarray.data;\n      width = ndarray.shape[0];\n      height = ndarray.shape[1];\n    }\n\n    // Support buffers\n    if (data instanceof Buffer) {\n      data = data.handle;\n    }\n\n    this.gl.bindTexture(this.target, this.handle);\n\n    withParameters(this.gl, parameters, () => {\n      // TODO - x,y parameters\n      if (compressed) {\n        this.gl.compressedTexSubImage2D(target, level, x, y, width, height, format, data);\n      } else if (data === null) {\n        this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, null);\n      } else if (ArrayBuffer.isView(data)) {\n        // const gl2 = assertWebGL2Context(this.gl);\n        // @ts-ignore last offset parameter is ignored under WebGL1\n        this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset);\n      } else if (data instanceof WebGLBuffer) {\n        // WebGL2 allows us to create texture directly from a WebGL buffer\n        const gl2 = assertWebGL2Context(this.gl);\n        // This texImage2D signature uses currently bound GL.PIXEL_UNPACK_BUFFER\n        gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data);\n        gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);\n        gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);\n      } else if (isWebGL2(this.gl)) {\n        // Assume data is a browser supported object (ImageData, Canvas, ...)\n        const gl2 = assertWebGL2Context(this.gl);\n        gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);\n      } else {\n        this.gl.texSubImage2D(target, level, x, y, dataFormat, type, data);\n      }\n    });\n\n    this.gl.bindTexture(this.target, null);\n  }\n  /* eslint-enable max-len, max-statements, complexity */\n\n  /**\n   * Defines a two-dimensional texture image or cube-map texture image with\n   * pixels from the current framebuffer (rather than from client memory).\n   * (gl.copyTexImage2D wrapper)\n   *\n   * Note that binding a texture into a Framebuffer's color buffer and\n   * rendering can be faster.\n   */\n  copyFramebuffer(opts = {}) {\n    log.error(\n      'Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})'\n    )();\n    return null;\n  }\n\n  getActiveUnit() {\n    return this.gl.getParameter(GL.ACTIVE_TEXTURE) - GL.TEXTURE0;\n  }\n\n  // target cannot be modified by bind:\n  // textures are special because when you first bind them to a target,\n  // they get special information. When you first bind a texture as a\n  // GL_TEXTURE_2D, you are actually setting special state in the texture.\n  // You are saying that this texture is a 2D texture.\n  // And it will always be a 2D texture; this state cannot be changed ever.\n  // If you have a texture that was first bound as a GL_TEXTURE_2D,\n  // you must always bind it as a GL_TEXTURE_2D;\n  // attempting to bind it as GL_TEXTURE_1D will give rise to an error\n  // (while run-time).\n\n  bind(textureUnit = this.textureUnit) {\n    const {gl} = this;\n\n    if (textureUnit !== undefined) {\n      this.textureUnit = textureUnit;\n      gl.activeTexture(gl.TEXTURE0 + textureUnit);\n    }\n\n    gl.bindTexture(this.target, this.handle);\n    return textureUnit;\n  }\n\n  unbind(textureUnit = this.textureUnit) {\n    const {gl} = this;\n\n    if (textureUnit !== undefined) {\n      this.textureUnit = textureUnit;\n      gl.activeTexture(gl.TEXTURE0 + textureUnit);\n    }\n\n    gl.bindTexture(this.target, null);\n    return textureUnit;\n  }\n\n  // PRIVATE METHODS\n\n  _getDataType({data, compressed = false}) {\n    if (compressed) {\n      return {data, dataType: 'compressed'};\n    }\n    if (data === null) {\n      return {data, dataType: 'null'};\n    }\n    if (ArrayBuffer.isView(data)) {\n      return {data, dataType: 'typed-array'};\n    }\n    if (data instanceof Buffer) {\n      return {data: data.handle, dataType: 'buffer'};\n    }\n    if (data instanceof WebGLBuffer) {\n      return {data, dataType: 'buffer'};\n    }\n    // Assume data is a browser supported object (ImageData, Canvas, ...)\n    return {data, dataType: 'browser-object'};\n  }\n\n  /* Copied from texture-2d.js\n  // WebGL2\n  setPixels(opts = {}) {\n    const {\n      buffer,\n      width = null,\n      height = null,\n      mipmapLevel = 0,\n      format = GL.RGBA,\n      type = GL.UNSIGNED_BYTE,\n      border = 0\n    } = opts;\n\n    const {gl} = this;\n\n    // This signature of texImage2D uses currently bound GL.PIXEL_UNPACK_BUFFER\n    gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, buffer.target);\n    // And as always, we must also bind the texture itself\n    this.bind();\n\n    gl.texImage2D(gl.TEXTURE_2D,\n      mipmapLevel, format, width, height, border, format, type, buffer.target);\n\n    this.unbind();\n    gl.bindBuffer(GL.GL.PIXEL_UNPACK_BUFFER, null);\n    return this;\n  }\n\n  setImageDataFromCompressedBuffer(opts) {\n    const {\n      buffer,\n      // offset = 0,\n      width = null,\n      height = null,\n      mipmapLevel = 0,\n      internalFormat = GL.RGBA,\n      // format = GL.RGBA,\n      // type = GL.UNSIGNED_BYTE,\n      border = 0\n    } = opts;\n\n    const {gl} = this;\n    gl.compressedTexImage2D(this.target,\n      mipmapLevel, internalFormat, width, height, border, buffer);\n    // gl.compressedTexSubImage2D(target,\n    //   level, xoffset, yoffset, width, height, format, ArrayBufferView? pixels);\n    return this;\n  }\n\n  copySubImage(opts) {\n    const {\n      // pixels,\n      // offset = 0,\n      // x,\n      // y,\n      // width,\n      // height,\n      // mipmapLevel = 0,\n      // internalFormat = GL.RGBA,\n      // type = GL.UNSIGNED_BYTE,\n      // border = 0\n    } = opts;\n\n    // if (pixels instanceof ArrayBufferView) {\n    //   gl.texSubImage2D(target, level, x, y, width, height, format, type, pixels);\n    // }\n    // gl.texSubImage2D(target, level, x, y, format, type, ? pixels);\n    // gl.texSubImage2D(target, level, x, y, format, type, HTMLImageElement pixels);\n    // gl.texSubImage2D(target, level, x, y, format, type, HTMLCanvasElement pixels);\n    // gl.texSubImage2D(target, level, x, y, format, type, HTMLVideoElement pixels);\n    // // Additional signature in a WebGL 2 context:\n    // gl.texSubImage2D(target, level, x, y, format, type, GLintptr offset);\n  }\n  */\n\n  // HELPER METHODS\n\n  _deduceParameters(opts) {\n    const {format, data} = opts;\n    let {width, height, dataFormat, type, compressed} = opts;\n\n    // Deduce format and type from format\n    const textureFormat = TEXTURE_FORMATS[format];\n    dataFormat = dataFormat || (textureFormat && textureFormat.dataFormat);\n    type = type || (textureFormat && textureFormat.types[0]);\n\n    // Deduce compression from format\n    compressed = compressed || (textureFormat && textureFormat.compressed);\n\n    ({width, height} = this._deduceImageSize(data, width, height));\n\n    return {dataFormat, type, compressed, width, height, format, data};\n  }\n\n  // eslint-disable-next-line complexity\n  _deduceImageSize(data, width, height) {\n    let size;\n\n    if (typeof ImageData !== 'undefined' && data instanceof ImageData) {\n      size = {width: data.width, height: data.height};\n    } else if (typeof HTMLImageElement !== 'undefined' && data instanceof HTMLImageElement) {\n      size = {width: data.naturalWidth, height: data.naturalHeight};\n    } else if (typeof HTMLCanvasElement !== 'undefined' && data instanceof HTMLCanvasElement) {\n      size = {width: data.width, height: data.height};\n    } else if (typeof ImageBitmap !== 'undefined' && data instanceof ImageBitmap) {\n      size = {width: data.width, height: data.height};\n    } else if (typeof HTMLVideoElement !== 'undefined' && data instanceof HTMLVideoElement) {\n      size = {width: data.videoWidth, height: data.videoHeight};\n    } else if (!data) {\n      size = {width: width >= 0 ? width : 1, height: height >= 0 ? height : 1};\n    } else {\n      size = {width, height};\n    }\n\n    assert(size, 'Could not deduced texture size');\n    assert(\n      width === undefined || size.width === width,\n      'Deduced texture width does not match supplied width'\n    );\n    assert(\n      height === undefined || size.height === height,\n      'Deduced texture height does not match supplied height'\n    );\n\n    return size;\n  }\n\n  // RESOURCE METHODS\n\n  _createHandle() {\n    return this.gl.createTexture();\n  }\n\n  _deleteHandle() {\n    this.gl.deleteTexture(this.handle);\n    this._trackDeallocatedMemory('Texture');\n  }\n\n  _getParameter(pname) {\n    switch (pname) {\n      case GL.TEXTURE_WIDTH:\n        return this.width;\n      case GL.TEXTURE_HEIGHT:\n        return this.height;\n      default:\n        this.gl.bindTexture(this.target, this.handle);\n        const value = this.gl.getTexParameter(this.target, pname);\n        this.gl.bindTexture(this.target, null);\n        return value;\n    }\n  }\n\n  _setParameter(pname, param) {\n    this.gl.bindTexture(this.target, this.handle);\n\n    // NOTE: Apply NPOT workaround\n    param = this._getNPOTParam(pname, param);\n\n    // Apparently there are some integer/float conversion rules that made\n    // the WebGL committe expose two parameter setting functions in JavaScript.\n    // For now, pick the float version for parameters specified as GLfloat.\n    switch (pname) {\n      case GL.TEXTURE_MIN_LOD:\n      case GL.TEXTURE_MAX_LOD:\n        this.gl.texParameterf(this.handle, pname, param);\n        break;\n\n      case GL.TEXTURE_WIDTH:\n      case GL.TEXTURE_HEIGHT:\n        assert(false);\n        break;\n\n      default:\n        this.gl.texParameteri(this.target, pname, param);\n        break;\n    }\n\n    this.gl.bindTexture(this.target, null);\n    return this;\n  }\n\n  _isNPOT() {\n    if (isWebGL2(this.gl)) {\n      // NPOT restriction is only for WebGL1\n      return false;\n    }\n    // Width and height not available, consider it is not NPOT texture\n    if (!this.width || !this.height) {\n      return false;\n    }\n    return !isPowerOfTwo(this.width) || !isPowerOfTwo(this.height);\n  }\n\n  // Update default settings which are not supported by NPOT textures.\n  _updateForNPOT(parameters) {\n    if (parameters[this.gl.TEXTURE_MIN_FILTER] === undefined) {\n      // log.warn(`texture: ${this} is Non-Power-Of-Two, forcing TEXTURE_MIN_FILTER to LINEAR`)();\n      parameters[this.gl.TEXTURE_MIN_FILTER] = this.gl.LINEAR;\n    }\n    if (parameters[this.gl.TEXTURE_WRAP_S] === undefined) {\n      // log.warn(`texture: ${this} is Non-Power-Of-Two, forcing TEXTURE_WRAP_S to CLAMP_TO_EDGE`)();\n      parameters[this.gl.TEXTURE_WRAP_S] = this.gl.CLAMP_TO_EDGE;\n    }\n    if (parameters[this.gl.TEXTURE_WRAP_T] === undefined) {\n      // log.warn(`texture: ${this} is Non-Power-Of-Two, forcing TEXTURE_WRAP_T to CLAMP_TO_EDGE`)();\n      parameters[this.gl.TEXTURE_WRAP_T] = this.gl.CLAMP_TO_EDGE;\n    }\n  }\n\n  _getNPOTParam(pname, param) {\n    if (this._isNPOT()) {\n      switch (pname) {\n        case GL.TEXTURE_MIN_FILTER:\n          if (NPOT_MIN_FILTERS.indexOf(param) === -1) {\n            // log.warn(`texture: ${this} is Non-Power-Of-Two, forcing TEXTURE_MIN_FILTER to LINEAR`)();\n            param = GL.LINEAR;\n          }\n          break;\n        case GL.TEXTURE_WRAP_S:\n        case GL.TEXTURE_WRAP_T:\n          if (param !== GL.CLAMP_TO_EDGE) {\n            // log.warn(`texture: ${this} is Non-Power-Of-Two, ${getKey(this.gl, pname)} to CLAMP_TO_EDGE`)();\n            param = GL.CLAMP_TO_EDGE;\n          }\n          break;\n        default:\n          break;\n      }\n    }\n    return param;\n  }\n}\n","import {isWebGL2, assertWebGLContext} from '@luma.gl/gltools';\nimport {lumaStats} from '../init';\nimport {getKey, getKeyValue} from '../webgl-utils/constants-to-keys';\nimport {assert} from '../utils/assert';\nimport {uid} from '../utils/utils';\nimport {stubRemovedMethods} from '../utils/stub-methods';\n\nconst ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual methods';\n\n// TODO - Handle context loss\n// function glGetContextLossCount(gl) {\n//   return (gl.luma && gl.luma.glCount) || 0;\n// }\n\nexport default class Resource {\n  constructor(gl, opts = {}) {\n    assertWebGLContext(gl);\n\n    const {id, userData = {}} = opts;\n    this.gl = gl;\n    // @ts-ignore\n    this.gl2 = gl;\n    // this.ext = polyfillContext(gl);\n    this.id = id || uid(this.constructor.name);\n    this.userData = userData;\n    this._bound = false;\n\n    // Set the handle\n    // If handle was provided, use it, otherwise create a new handle\n\n    // TODO - Stores the handle with context loss information\n    // this.glCount = glGetContextLossCount(this.gl);\n\n    // Default VertexArray needs to be created with null handle, so compare against undefined\n    this._handle = opts.handle;\n    if (this._handle === undefined) {\n      this._handle = this._createHandle();\n    }\n\n    // Only meaningful for resources that allocate GPU memory\n    this.byteLength = 0;\n\n    this._addStats();\n  }\n\n  toString() {\n    return `${this.constructor.name}(${this.id})`;\n  }\n\n  get handle() {\n    // TODO - Add context loss handling\n    // Will regenerate and reinitialize the handle if necessary\n    // const glCount = glGetContextLossCount(this.gl);\n    // if (this.glCount !== glCount) {\n    //   this._handle = this._createHandle(this.opts);\n    //   this._glCount = glCount;\n    //   // Reinitialize object\n    //   this.initialize(this.opts);\n    // }\n    return this._handle;\n  }\n\n  delete({deleteChildren = false} = {}) {\n    // Delete this object, and get refs to any children\n    // @ts-ignore\n    const children = this._handle && this._deleteHandle(this._handle);\n    if (this._handle) {\n      this._removeStats();\n    }\n    this._handle = null;\n\n    // Optionally, recursively delete the children\n    // @ts-ignore\n    if (children && deleteChildren) {\n      // @ts-ignore\n      children.filter(Boolean).forEach(child => child.delete());\n    }\n\n    return this;\n  }\n\n  bind(funcOrHandle = this.handle) {\n    if (typeof funcOrHandle !== 'function') {\n      this._bindHandle(funcOrHandle);\n      return this;\n    }\n\n    let value;\n\n    if (!this._bound) {\n      this._bindHandle(this.handle);\n      this._bound = true;\n\n      value = funcOrHandle();\n\n      this._bound = false;\n      this._bindHandle(null);\n    } else {\n      value = funcOrHandle();\n    }\n\n    return value;\n  }\n\n  unbind() {\n    this.bind(null);\n  }\n\n  /**\n   * Query a Resource parameter\n   *\n   * @param {GLenum} pname\n   * @return {GLint|GLfloat|GLenum} param\n   */\n  getParameter(pname, opts = {}) {\n    pname = getKeyValue(this.gl, pname);\n    assert(pname);\n\n    // @ts-ignore\n    const parameters = this.constructor.PARAMETERS || {};\n\n    // Use parameter definitions to handle unsupported parameters\n    const parameter = parameters[pname];\n    if (parameter) {\n      const isWebgl2 = isWebGL2(this.gl);\n\n      // Check if we can query for this parameter\n      const parameterAvailable =\n        (!('webgl2' in parameter) || isWebgl2) &&\n        (!('extension' in parameter) || this.gl.getExtension(parameter.extension));\n\n      if (!parameterAvailable) {\n        const webgl1Default = parameter.webgl1;\n        const webgl2Default = 'webgl2' in parameter ? parameter.webgl2 : parameter.webgl1;\n        const defaultValue = isWebgl2 ? webgl2Default : webgl1Default;\n        return defaultValue;\n      }\n    }\n\n    // If unknown parameter - Could be a valid parameter not covered by PARAMS\n    // Attempt to query for it and let WebGL report errors\n    return this._getParameter(pname, opts);\n  }\n\n  // Many resources support a getParameter call -\n  // getParameters will get all parameters - slow but useful for debugging\n  // eslint-disable-next-line complexity\n  getParameters(options = {}) {\n    const {parameters, keys} = options;\n\n    // Get parameter definitions for this Resource\n    // @ts-ignore\n    const PARAMETERS = this.constructor.PARAMETERS || {};\n\n    const isWebgl2 = isWebGL2(this.gl);\n\n    const values = {};\n\n    // Query all parameters if no list provided\n    const parameterKeys = parameters || Object.keys(PARAMETERS);\n\n    // WEBGL limits\n    for (const pname of parameterKeys) {\n      const parameter = PARAMETERS[pname];\n\n      // Check if this parameter is available on this platform\n      const parameterAvailable =\n        parameter &&\n        (!('webgl2' in parameter) || isWebgl2) &&\n        (!('extension' in parameter) || this.gl.getExtension(parameter.extension));\n\n      if (parameterAvailable) {\n        const key = keys ? getKey(this.gl, pname) : pname;\n        values[key] = this.getParameter(pname, options);\n        if (keys && parameter.type === 'GLenum') {\n          values[key] = getKey(this.gl, values[key]);\n        }\n      }\n    }\n\n    return values;\n  }\n\n  /**\n   * Update a Resource setting\n   *\n   * @todo - cache parameter to avoid issuing WebGL calls?\n   *\n   * @param {string} pname - parameter (GL constant, value or key)\n   * @param {GLint|GLfloat|GLenum} value\n   * @return {Resource} returns self to enable chaining\n   */\n  setParameter(pname, value) {\n    pname = getKeyValue(this.gl, pname);\n    assert(pname);\n\n    // @ts-ignore\n    const parameters = this.constructor.PARAMETERS || {};\n\n    const parameter = parameters[pname];\n    if (parameter) {\n      const isWebgl2 = isWebGL2(this.gl);\n\n      // Check if this parameter is available on this platform\n      const parameterAvailable =\n        (!('webgl2' in parameter) || isWebgl2) &&\n        (!('extension' in parameter) || this.gl.getExtension(parameter.extension));\n\n      if (!parameterAvailable) {\n        throw new Error('Parameter not available on this platform');\n      }\n\n      // Handle string keys\n      if (parameter.type === 'GLenum') {\n        value = getKeyValue(value);\n      }\n    }\n\n    // If unknown parameter - Could be a valid parameter not covered by PARAMS\n    // attempt to set it and let WebGL report errors\n    this._setParameter(pname, value);\n    return this;\n  }\n\n  /*\n   * Batch update resource parameters\n   * Assumes the subclass supports a setParameter call\n   */\n  setParameters(parameters) {\n    for (const pname in parameters) {\n      this.setParameter(pname, parameters[pname]);\n    }\n    return this;\n  }\n\n  // Install stubs for removed methods\n  stubRemovedMethods(className, version, methodNames) {\n    return stubRemovedMethods(this, className, version, methodNames);\n  }\n\n  // PUBLIC VIRTUAL METHODS\n  initialize(opts) {}\n\n  // PROTECTED METHODS - These must be overridden by subclass\n  _createHandle() {\n    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);\n  }\n\n  _deleteHandle() {\n    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);\n  }\n\n  _bindHandle(handle) {\n    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);\n  }\n\n  _getOptsFromHandle() {\n    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);\n  }\n\n  /** @returns {number} */\n  _getParameter(pname, opts) {\n    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);\n  }\n\n  _setParameter(pname, value) {\n    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);\n  }\n\n  // PRIVATE METHODS\n\n  _context() {\n    this.gl.luma = this.gl.luma || {};\n    return this.gl.luma;\n  }\n\n  _addStats() {\n    const name = this.constructor.name;\n    const stats = lumaStats.get('Resource Counts');\n\n    stats.get('Resources Created').incrementCount();\n    stats.get(`${name}s Created`).incrementCount();\n    stats.get(`${name}s Active`).incrementCount();\n  }\n\n  _removeStats() {\n    const name = this.constructor.name;\n    const stats = lumaStats.get('Resource Counts');\n\n    stats.get(`${name}s Active`).decrementCount();\n  }\n\n  _trackAllocatedMemory(bytes, name = this.constructor.name) {\n    const stats = lumaStats.get('Memory Usage');\n\n    stats.get('GPU Memory').addCount(bytes);\n    stats.get(`${name} Memory`).addCount(bytes);\n    this.byteLength = bytes;\n  }\n\n  _trackDeallocatedMemory(name = this.constructor.name) {\n    const stats = lumaStats.get('Memory Usage');\n\n    stats.get('GPU Memory').subtractCount(this.byteLength);\n    stats.get(`${name} Memory`).subtractCount(this.byteLength);\n    this.byteLength = 0;\n  }\n}\n","import {assert} from '../utils/assert';\n\n// Resolve a WebGL enumeration name (returns itself if already a number)\nexport function getKeyValue(gl, name) {\n  // If not a string, return (assume number)\n  if (typeof name !== 'string') {\n    return name;\n  }\n\n  // If string converts to number, return number\n  const number = Number(name);\n  if (!isNaN(number)) {\n    return number;\n  }\n\n  // Look up string, after removing any 'GL.' or 'gl.' prefix\n  name = name.replace(/^.*\\./, '');\n  const value = gl[name];\n  assert(value !== undefined, `Accessing undefined constant GL.${name}`);\n  return value;\n}\n\nexport function getKey(gl, value) {\n  value = Number(value);\n  for (const key in gl) {\n    if (gl[key] === value) {\n      return `GL.${key}`;\n    }\n  }\n  return String(value);\n}\n\nexport function getKeyType(gl, value) {\n  assert(value !== undefined, 'undefined key');\n  value = Number(value);\n  for (const key in gl) {\n    if (gl[key] === value) {\n      return `GL.${key}`;\n    }\n  }\n  return String(value);\n}\n","// Recommendation is to ignore message but current test suite checks agains the\n// message so keep it for now.\nexport function assert(condition, message) {\n  if (!condition) {\n    throw new Error(message || 'luma.gl: assertion failed.');\n  }\n}\n","import {assert} from './assert';\n\nconst uidCounters = {};\n\n/**\n * Returns a UID.\n * @param {string} id= - Identifier base name\n * @return {string} uid\n **/\nexport function uid(id = 'id') {\n  uidCounters[id] = uidCounters[id] || 1;\n  const count = uidCounters[id]++;\n  return `${id}-${count}`;\n}\n\n/**\n * Verifies if a given number is power of two or not.\n * @param {object} n - The number to check.\n * @return {boolean} Returns true if the given number is power of 2, false otherwise.\n **/\nexport function isPowerOfTwo(n) {\n  assert(typeof n === 'number', 'Input must be a number');\n  return n && (n & (n - 1)) === 0;\n}\n\n// Returns true if given object is empty, false otherwise.\nexport function isObjectEmpty(obj) {\n  let isEmpty = true;\n  /* eslint-disable no-unused-vars  */\n  for (const key in obj) {\n    isEmpty = false;\n    break;\n  }\n  /* eslint-enable no-unused-vars  */\n  return isEmpty;\n}\n","import {log} from '@luma.gl/gltools';\n\n// Install stubs for removed methods\nexport function stubRemovedMethods(instance, className, version, methodNames) {\n  const upgradeMessage = `See luma.gl ${version} Upgrade Guide at \\\nhttps://luma.gl/docs/upgrade-guide`;\n\n  const prototype = Object.getPrototypeOf(instance);\n\n  methodNames.forEach(methodName => {\n    if (prototype.methodName) {\n      return;\n    }\n\n    prototype[methodName] = () => {\n      log.removed(`Calling removed method ${className}.${methodName}: `, upgradeMessage)();\n      throw new Error(methodName);\n    };\n  });\n}\n","import GL from '@luma.gl/constants';\nimport Resource from './resource';\nimport Accessor from './accessor';\nimport {getGLTypeFromTypedArray, getTypedArrayFromGLType} from '../webgl-utils/typed-array-utils';\nimport {assertWebGL2Context, log} from '@luma.gl/gltools';\nimport {assert} from '../utils/assert';\nimport {checkProps} from '../utils/check-props';\n\nconst DEBUG_DATA_LENGTH = 10;\n\n// Shared prop checks for constructor and setProps\nconst DEPRECATED_PROPS = {\n  offset: 'accessor.offset',\n  stride: 'accessor.stride',\n  type: 'accessor.type',\n  size: 'accessor.size',\n  divisor: 'accessor.divisor',\n  normalized: 'accessor.normalized',\n  integer: 'accessor.integer',\n  instanced: 'accessor.divisor',\n  isInstanced: 'accessor.divisor'\n};\n\n// Prop checks for constructor\nconst PROP_CHECKS_INITIALIZE = {\n  removedProps: {},\n  replacedProps: {\n    bytes: 'byteLength'\n  },\n  // new Buffer() with individual accessor props is still used in apps, emit warnings\n  deprecatedProps: DEPRECATED_PROPS\n};\n\n// Prop checks for setProps\nconst PROP_CHECKS_SET_PROPS = {\n  // Buffer.setProps() with individual accessor props is rare => emit errors\n  removedProps: DEPRECATED_PROPS\n};\n\nexport default class Buffer extends Resource {\n  constructor(gl, props = {}) {\n    super(gl, props);\n\n    this.stubRemovedMethods('Buffer', 'v6.0', ['layout', 'setLayout', 'getIndexedParameter']);\n    // this.stubRemovedMethods('Buffer', 'v7.0', ['updateAccessor']);\n\n    // In WebGL1, need to make sure we use GL.ELEMENT_ARRAY_BUFFER when initializing element buffers\n    // otherwise buffer type will lock to generic (non-element) buffer\n    // In WebGL2, we can use GL.COPY_READ_BUFFER which avoids locking the type here\n    this.target = props.target || (this.gl.webgl2 ? GL.COPY_READ_BUFFER : GL.ARRAY_BUFFER);\n\n    this.initialize(props);\n\n    Object.seal(this);\n  }\n\n  // returns number of elements in the buffer (assuming that the full buffer is used)\n  getElementCount(accessor = this.accessor) {\n    return Math.round(this.byteLength / Accessor.getBytesPerElement(accessor));\n  }\n\n  // returns number of vertices in the buffer (assuming that the full buffer is used)\n  getVertexCount(accessor = this.accessor) {\n    return Math.round(this.byteLength / Accessor.getBytesPerVertex(accessor));\n  }\n\n  // Creates and initializes the buffer object's data store.\n  // Signature: `new Buffer(gl, {data: new Float32Array(...)})`\n  // Signature: `new Buffer(gl, new Float32Array(...))`\n  // Signature: `new Buffer(gl, 100)`\n  initialize(props = {}) {\n    // Signature `new Buffer(gl, new Float32Array(...)`\n    if (ArrayBuffer.isView(props)) {\n      props = {data: props};\n    }\n\n    // Signature: `new Buffer(gl, 100)`\n    if (Number.isFinite(props)) {\n      props = {byteLength: props};\n    }\n\n    props = checkProps('Buffer', props, PROP_CHECKS_INITIALIZE);\n\n    // Initialize member fields\n    this.usage = props.usage || GL.STATIC_DRAW;\n    this.debugData = null;\n\n    // Deprecated: Merge main props and accessor\n    this.setAccessor(Object.assign({}, props, props.accessor));\n\n    // Set data: (re)initializes the buffer\n    if (props.data) {\n      this._setData(props.data, props.offset, props.byteLength);\n    } else {\n      this._setByteLength(props.byteLength || 0);\n    }\n\n    return this;\n  }\n\n  setProps(props) {\n    props = checkProps('Buffer', props, PROP_CHECKS_SET_PROPS);\n\n    if ('accessor' in props) {\n      this.setAccessor(props.accessor);\n    }\n\n    return this;\n  }\n\n  // Optionally stores an accessor with the buffer, makes it easier to use it as an attribute later\n  // {type, size = 1, offset = 0, stride = 0, normalized = false, integer = false, divisor = 0}\n  setAccessor(accessor) {\n    // NOTE: From luma.gl v7.0, Accessors have an optional `buffer `field\n    // (mainly to support \"interleaving\")\n    // To avoid confusion, ensure `buffer.accessor` does not have a `buffer.accessor.buffer` field:\n    accessor = Object.assign({}, accessor);\n    delete accessor.buffer;\n\n    // This new statement ensures that an \"accessor object\" is re-packaged as an Accessor instance\n    this.accessor = new Accessor(accessor);\n    return this;\n  }\n\n  // Allocate a bigger GPU buffer (if the current buffer is not big enough).\n  // If a reallocation is triggered it clears the buffer\n  // Returns:\n  //  `true`: buffer was reallocated, data was cleared\n  //  `false`: buffer was big enough, data is intact\n  reallocate(byteLength) {\n    if (byteLength > this.byteLength) {\n      this._setByteLength(byteLength);\n      return true;\n    }\n    this.bytesUsed = byteLength;\n    return false;\n  }\n\n  // Update with new data. Reinitializes the buffer\n  setData(props) {\n    return this.initialize(props);\n  }\n\n  // Updates a subset of a buffer object's data store.\n  // Data (Typed Array or ArrayBuffer), length is inferred unless provided\n  // Offset into buffer\n  // WebGL2 only: Offset into srcData\n  // WebGL2 only: Number of bytes to be copied\n  subData(props) {\n    // Signature: buffer.subData(new Float32Array([...]))\n    if (ArrayBuffer.isView(props)) {\n      props = {data: props};\n    }\n\n    const {data, offset = 0, srcOffset = 0} = props;\n    const byteLength = props.byteLength || props.length;\n\n    assert(data);\n\n    // Create the buffer - binding it here for the first time locks the type\n    // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type\n    const target = this.gl.webgl2 ? GL.COPY_WRITE_BUFFER : this.target;\n    this.gl.bindBuffer(target, this.handle);\n    // WebGL2: subData supports additional srcOffset and length parameters\n    if (srcOffset !== 0 || byteLength !== undefined) {\n      assertWebGL2Context(this.gl);\n      this.gl.bufferSubData(this.target, offset, data, srcOffset, byteLength);\n    } else {\n      this.gl.bufferSubData(target, offset, data);\n    }\n    this.gl.bindBuffer(target, null);\n\n    // TODO - update local `data` if offsets are right\n    this.debugData = null;\n\n    this._inferType(data);\n\n    return this;\n  }\n\n  // WEBGL2 ONLY: Copies part of the data of another buffer into this buffer\n  copyData({sourceBuffer, readOffset = 0, writeOffset = 0, size}) {\n    const {gl} = this;\n    assertWebGL2Context(gl);\n\n    // Use GL.COPY_READ_BUFFER+GL.COPY_WRITE_BUFFER avoid disturbing other targets and locking type\n    gl.bindBuffer(GL.COPY_READ_BUFFER, sourceBuffer.handle);\n    gl.bindBuffer(GL.COPY_WRITE_BUFFER, this.handle);\n    gl.copyBufferSubData(GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);\n    gl.bindBuffer(GL.COPY_READ_BUFFER, null);\n    gl.bindBuffer(GL.COPY_WRITE_BUFFER, null);\n\n    // TODO - update local `data` if offsets are 0\n    this.debugData = null;\n\n    return this;\n  }\n\n  // WEBGL2 ONLY: Reads data from buffer into an ArrayBufferView or SharedArrayBuffer.\n  getData({dstData = null, srcByteOffset = 0, dstOffset = 0, length = 0} = {}) {\n    assertWebGL2Context(this.gl);\n\n    const ArrayType = getTypedArrayFromGLType(this.accessor.type || GL.FLOAT, {clamped: false});\n    const sourceAvailableElementCount = this._getAvailableElementCount(srcByteOffset);\n\n    const dstElementOffset = dstOffset;\n\n    let dstAvailableElementCount;\n    let dstElementCount;\n    if (dstData) {\n      dstElementCount = dstData.length;\n      dstAvailableElementCount = dstElementCount - dstElementOffset;\n    } else {\n      // Allocate ArrayBufferView with enough size to copy all eligible data.\n      dstAvailableElementCount = Math.min(\n        sourceAvailableElementCount,\n        length || sourceAvailableElementCount\n      );\n      dstElementCount = dstElementOffset + dstAvailableElementCount;\n    }\n\n    const copyElementCount = Math.min(sourceAvailableElementCount, dstAvailableElementCount);\n    length = length || copyElementCount;\n    assert(length <= copyElementCount);\n    dstData = dstData || new ArrayType(dstElementCount);\n\n    // Use GL.COPY_READ_BUFFER to avoid disturbing other targets and locking type\n    this.gl.bindBuffer(GL.COPY_READ_BUFFER, this.handle);\n    this.gl.getBufferSubData(GL.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);\n    this.gl.bindBuffer(GL.COPY_READ_BUFFER, null);\n\n    // TODO - update local `data` if offsets are 0\n    return dstData;\n  }\n\n  /**\n   * Binds a buffer to a given binding point (target).\n   *   GL.TRANSFORM_FEEDBACK_BUFFER and GL.UNIFORM_BUFFER take an index, and optionally a range.\n   *   - GL.TRANSFORM_FEEDBACK_BUFFER and GL.UNIFORM_BUFFER need an index to affect state\n   *   - GL.UNIFORM_BUFFER: `offset` must be aligned to GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT.\n   *   - GL.UNIFORM_BUFFER: `size` must be a minimum of GL.UNIFORM_BLOCK_SIZE_DATA.\n   */\n  bind({\n    target = this.target, // target for the bind operation\n    index = this.accessor && this.accessor.index, // index = index of target (indexed bind point)\n    offset = 0,\n    size\n  } = {}) {\n    // NOTE: While GL.TRANSFORM_FEEDBACK_BUFFER and GL.UNIFORM_BUFFER could\n    // be used as direct binding points, they will not affect transform feedback or\n    // uniform buffer state. Instead indexed bindings need to be made.\n    if (target === GL.UNIFORM_BUFFER || target === GL.TRANSFORM_FEEDBACK_BUFFER) {\n      if (size !== undefined) {\n        this.gl.bindBufferRange(target, index, this.handle, offset, size);\n      } else {\n        assert(offset === 0); // Make sure offset wasn't supplied\n        this.gl.bindBufferBase(target, index, this.handle);\n      }\n    } else {\n      this.gl.bindBuffer(target, this.handle);\n    }\n\n    return this;\n  }\n\n  unbind({target = this.target, index = this.accessor && this.accessor.index} = {}) {\n    const isIndexedBuffer = target === GL.UNIFORM_BUFFER || target === GL.TRANSFORM_FEEDBACK_BUFFER;\n    if (isIndexedBuffer) {\n      this.gl.bindBufferBase(target, index, null);\n    } else {\n      this.gl.bindBuffer(target, null);\n    }\n    return this;\n  }\n\n  // PROTECTED METHODS (INTENDED FOR USE BY OTHER FRAMEWORK CODE ONLY)\n\n  // Returns a short initial data array\n  getDebugData() {\n    if (!this.debugData) {\n      this.debugData = this.getData({length: Math.min(DEBUG_DATA_LENGTH, this.byteLength)});\n      return {data: this.debugData, changed: true};\n    }\n    return {data: this.debugData, changed: false};\n  }\n\n  invalidateDebugData() {\n    this.debugData = null;\n  }\n\n  // PRIVATE METHODS\n\n  // Allocate a new buffer and initialize to contents of typed array\n  _setData(data, offset = 0, byteLength = data.byteLength + offset) {\n    assert(ArrayBuffer.isView(data));\n\n    this._trackDeallocatedMemory();\n\n    const target = this._getTarget();\n    this.gl.bindBuffer(target, this.handle);\n    this.gl.bufferData(target, byteLength, this.usage);\n    this.gl.bufferSubData(target, offset, data);\n    this.gl.bindBuffer(target, null);\n\n    this.debugData = data.slice(0, DEBUG_DATA_LENGTH);\n    this.bytesUsed = byteLength;\n\n    this._trackAllocatedMemory(byteLength);\n\n    // infer GL type from supplied typed array\n    const type = getGLTypeFromTypedArray(data);\n    assert(type);\n    this.setAccessor(new Accessor(this.accessor, {type}));\n    return this;\n  }\n\n  // Allocate a GPU buffer of specified size.\n  _setByteLength(byteLength, usage = this.usage) {\n    assert(byteLength >= 0);\n\n    this._trackDeallocatedMemory();\n\n    // Workaround needed for Safari (#291):\n    // gl.bufferData with size equal to 0 crashes. Instead create zero sized array.\n    let data = byteLength;\n    if (byteLength === 0) {\n      data = new Float32Array(0);\n    }\n\n    const target = this._getTarget();\n    this.gl.bindBuffer(target, this.handle);\n    this.gl.bufferData(target, data, usage);\n    this.gl.bindBuffer(target, null);\n\n    this.usage = usage;\n    this.debugData = null;\n    this.bytesUsed = byteLength;\n\n    this._trackAllocatedMemory(byteLength);\n\n    return this;\n  }\n\n  // Binding a buffer for the first time locks the type\n  // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type\n  _getTarget() {\n    return this.gl.webgl2 ? GL.COPY_WRITE_BUFFER : this.target;\n  }\n\n  _getAvailableElementCount(srcByteOffset) {\n    const ArrayType = getTypedArrayFromGLType(this.accessor.type || GL.FLOAT, {clamped: false});\n    const sourceElementOffset = srcByteOffset / ArrayType.BYTES_PER_ELEMENT;\n    return this.getElementCount() - sourceElementOffset;\n  }\n\n  // Automatically infers type from typed array passed to setData\n  // Note: No longer that useful, since type is now autodeduced from the compiled shaders\n  _inferType(data) {\n    if (!this.accessor.type) {\n      this.setAccessor(new Accessor(this.accessor, {type: getGLTypeFromTypedArray(data)}));\n    }\n  }\n\n  // RESOURCE METHODS\n\n  _createHandle() {\n    return this.gl.createBuffer();\n  }\n\n  _deleteHandle() {\n    this.gl.deleteBuffer(this.handle);\n    this._trackDeallocatedMemory();\n  }\n\n  _getParameter(pname) {\n    this.gl.bindBuffer(this.target, this.handle);\n    const value = this.gl.getBufferParameter(this.target, pname);\n    this.gl.bindBuffer(this.target, null);\n    return value;\n  }\n\n  // DEPRECATIONS - v7.0\n  get type() {\n    log.deprecated('Buffer.type', 'Buffer.accessor.type')();\n    return this.accessor.type;\n  }\n\n  get bytes() {\n    log.deprecated('Buffer.bytes', 'Buffer.byteLength')();\n    return this.byteLength;\n  }\n\n  // DEPRECATIONS - v6.0\n  // Deprecated in v6.x, but not warnings not properly implemented\n  setByteLength(byteLength) {\n    log.deprecated('setByteLength', 'reallocate')();\n    return this.reallocate(byteLength);\n  }\n\n  // Deprecated in v6.x, but not warnings not properly implemented\n  updateAccessor(opts) {\n    log.deprecated('updateAccessor(...)', 'setAccessor(new Accessor(buffer.accessor, ...)')();\n    this.accessor = new Accessor(this.accessor, opts);\n    return this;\n  }\n}\n","import GL from '@luma.gl/constants';\nimport {getTypedArrayFromGLType} from '../webgl-utils/typed-array-utils';\nimport {assert} from '../utils/assert';\nimport {checkProps} from '../utils/check-props';\n\nconst DEFAULT_ACCESSOR_VALUES = {\n  offset: 0,\n  stride: 0,\n  type: GL.FLOAT,\n  size: 1,\n  divisor: 0,\n  normalized: false,\n  integer: false\n};\n\nconst PROP_CHECKS = {\n  deprecatedProps: {\n    instanced: 'divisor',\n    isInstanced: 'divisor'\n  }\n};\n\nexport default class Accessor {\n  static getBytesPerElement(accessor) {\n    // TODO: using `FLOAT` when type is not specified,\n    // ensure this assumption is valid or force API to specify type.\n    const ArrayType = getTypedArrayFromGLType(accessor.type || GL.FLOAT);\n    return ArrayType.BYTES_PER_ELEMENT;\n  }\n\n  static getBytesPerVertex(accessor) {\n    assert(accessor.size);\n    // TODO: using `FLOAT` when type is not specified,\n    // ensure this assumption is valid or force API to specify type.\n    const ArrayType = getTypedArrayFromGLType(accessor.type || GL.FLOAT);\n    return ArrayType.BYTES_PER_ELEMENT * accessor.size;\n  }\n\n  // Combines (merges) a list of accessors. On top of default values\n  // Usually [programAccessor, bufferAccessor, appAccessor]\n  // All props will be set in the returned object.\n  // TODO check for conflicts between values in the supplied accessors\n  static resolve(...accessors) {\n    return new Accessor(...[DEFAULT_ACCESSOR_VALUES, ...accessors]); // Default values\n  }\n\n  constructor(...accessors) {\n    accessors.forEach(accessor => this._assign(accessor)); // Merge in sequence\n    Object.freeze(this);\n  }\n\n  toString() {\n    return JSON.stringify(this);\n  }\n\n  // ACCESSORS\n\n  // TODO - remove>\n  get BYTES_PER_ELEMENT() {\n    return Accessor.getBytesPerElement(this);\n  }\n\n  get BYTES_PER_VERTEX() {\n    return Accessor.getBytesPerVertex(this);\n  }\n\n  // PRIVATE\n\n  // eslint-disable-next-line complexity, max-statements\n  _assign(props = {}) {\n    props = checkProps('Accessor', props, PROP_CHECKS);\n\n    if (props.type !== undefined) {\n      this.type = props.type;\n\n      // Auto-deduce integer type?\n      if (props.type === GL.INT || props.type === GL.UNSIGNED_INT) {\n        this.integer = true;\n      }\n    }\n    if (props.size !== undefined) {\n      this.size = props.size;\n    }\n    if (props.offset !== undefined) {\n      this.offset = props.offset;\n    }\n    if (props.stride !== undefined) {\n      this.stride = props.stride;\n    }\n    if (props.normalized !== undefined) {\n      this.normalized = props.normalized;\n    }\n    if (props.integer !== undefined) {\n      this.integer = props.integer;\n    }\n\n    // INSTANCE DIVISOR\n    if (props.divisor !== undefined) {\n      this.divisor = props.divisor;\n    }\n\n    // Buffer is optional\n    if (props.buffer !== undefined) {\n      this.buffer = props.buffer;\n    }\n\n    // The binding index (for binding e.g. Transform feedbacks and Uniform buffers)\n    // TODO - should this be part of accessor?\n    if (props.index !== undefined) {\n      if (typeof props.index === 'boolean') {\n        this.index = props.index ? 1 : 0;\n      } else {\n        this.index = props.index;\n      }\n    }\n\n    // DEPRECATED\n    if (props.instanced !== undefined) {\n      this.divisor = props.instanced ? 1 : 0;\n    }\n    if (props.isInstanced !== undefined) {\n      this.divisor = props.isInstanced ? 1 : 0;\n    }\n\n    return this;\n  }\n}\n\n// TEST EXPORTS\nexport {DEFAULT_ACCESSOR_VALUES};\n","import GL from '@luma.gl/constants';\n\nconst ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';\n\n// Converts TYPED ARRAYS to corresponding GL constant\n// Used to auto deduce gl parameter types\nexport function getGLTypeFromTypedArray(arrayOrType) {\n  // If typed array, look up constructor\n  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;\n  switch (type) {\n    case Float32Array:\n      return GL.FLOAT;\n    case Uint16Array:\n      return GL.UNSIGNED_SHORT;\n    case Uint32Array:\n      return GL.UNSIGNED_INT;\n    case Uint8Array:\n      return GL.UNSIGNED_BYTE;\n    case Uint8ClampedArray:\n      return GL.UNSIGNED_BYTE;\n    case Int8Array:\n      return GL.BYTE;\n    case Int16Array:\n      return GL.SHORT;\n    case Int32Array:\n      return GL.INT;\n    default:\n      throw new Error(ERR_TYPE_DEDUCTION);\n  }\n}\n\n// Converts GL constant to corresponding TYPED ARRAY\n// Used to auto deduce gl parameter types\n\n/* eslint-disable complexity */\nexport function getTypedArrayFromGLType(glType, {clamped = true} = {}) {\n  // Sorted in some order of likelihood to reduce amount of comparisons\n  switch (glType) {\n    case GL.FLOAT:\n      return Float32Array;\n    case GL.UNSIGNED_SHORT:\n    case GL.UNSIGNED_SHORT_5_6_5:\n    case GL.UNSIGNED_SHORT_4_4_4_4:\n    case GL.UNSIGNED_SHORT_5_5_5_1:\n      return Uint16Array;\n    case GL.UNSIGNED_INT:\n      return Uint32Array;\n    case GL.UNSIGNED_BYTE:\n      return clamped ? Uint8ClampedArray : Uint8Array;\n    case GL.BYTE:\n      return Int8Array;\n    case GL.SHORT:\n      return Int16Array;\n    case GL.INT:\n      return Int32Array;\n    default:\n      throw new Error('Failed to deduce typed array type from GL constant');\n  }\n}\n/* eslint-enable complexity */\n\n// Flip rows (can be used on arrays returned from `Framebuffer.readPixels`)\n// https://stackoverflow.com/questions/41969562/\n// how-can-i-flip-the-result-of-webglrenderingcontext-readpixels\nexport function flipRows({data, width, height, bytesPerPixel = 4, temp}) {\n  const bytesPerRow = width * bytesPerPixel;\n\n  // make a temp buffer to hold one row\n  temp = temp || new Uint8Array(bytesPerRow);\n  for (let y = 0; y < height / 2; ++y) {\n    const topOffset = y * bytesPerRow;\n    const bottomOffset = (height - y - 1) * bytesPerRow;\n    // make copy of a row on the top half\n    temp.set(data.subarray(topOffset, topOffset + bytesPerRow));\n    // copy a row from the bottom half to the top\n    data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);\n    // copy the copy of the top half row to the bottom half\n    data.set(temp, bottomOffset);\n  }\n}\n\nexport function scalePixels({data, width, height}) {\n  const newWidth = Math.round(width / 2);\n  const newHeight = Math.round(height / 2);\n  const newData = new Uint8Array(newWidth * newHeight * 4);\n  for (let y = 0; y < newHeight; y++) {\n    for (let x = 0; x < newWidth; x++) {\n      for (let c = 0; c < 4; c++) {\n        newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];\n      }\n    }\n  }\n  return {data: newData, width: newWidth, height: newHeight};\n}\n","/* Use as\nimport {checkProps} from '../util/check-props;'\n\nconst PROP_CHECKS = {\n  // Removed props no longer supported, print error and link to upgrade guide\n  removedProps: {\n  },\n  // Deprecated props\n  deprecatedProps: {\n    offset: 'accessor',\n    stride: 'accessor',\n    type: 'accessor',\n    size: 'accessor',\n    divisor: 'accessor',\n    normalized: 'accessor',\n    integer: 'accessor'\n  },\n  // Deprecated props that can be autosubstituted, print warning and return updated props object\n  replacedProps: {\n    bytes: 'byteLength'\n  }\n}\n\nclass Buffer {\n  setProps(props) {\n    checkProps('Buffer', props, PROP_CHECKS);\n  }\n}\n*/\nimport {log} from '@luma.gl/gltools';\n\nexport function checkProps(className, props, propChecks) {\n  const {removedProps = {}, deprecatedProps = {}, replacedProps = {}} = propChecks;\n\n  // removedProps: Removed props no longer supported\n  // print error and link to upgrade guide\n  for (const propName in removedProps) {\n    if (propName in props) {\n      const replacementProp = removedProps[propName];\n      const replacement = replacementProp ? `${className}.${removedProps[propName]}` : 'N/A';\n      log.removed(`${className}.${propName}`, replacement)();\n    }\n  }\n\n  // deprecatedProps: Deprecated props that can not be autosubstituted\n  // print warning and rely on caller to substitute\n  for (const propName in deprecatedProps) {\n    if (propName in props) {\n      const replacementProp = deprecatedProps[propName];\n      log.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)();\n    }\n  }\n\n  // replacedProps: Deprecated props that can be autosubstituted\n  // print warning and return updated props object\n  let newProps = null;\n  for (const propName in replacedProps) {\n    if (propName in props) {\n      const replacementProp = replacedProps[propName];\n      log.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)();\n      newProps = newProps || Object.assign({}, props);\n      newProps[replacementProp] = props[propName];\n      delete newProps[propName];\n    }\n  }\n\n  return newProps || props;\n}\n","import GL from '@luma.gl/constants';\nimport {isWebGL2} from '@luma.gl/gltools';\n\n// const S3TC = 'WEBGL_compressed_texture_s3tc';\n// const PVRTC = 'WEBGL_compressed_texture_pvrtc';\n// const ES3 = 'WEBGL_compressed_texture_es3';\n// const ETC1 = 'WEBGL_compressed_texture_etc1';\n// const SRGB = 'EXT_sRGB';\n// const DEPTH = 'WEBGL_depth_texture';\n\n// Legal combinations for internalFormat, format and type\nexport const TEXTURE_FORMATS = {\n  // Unsized texture format - more performance\n  [GL.RGB]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_5_6_5]},\n  // TODO: format: GL.RGBA type: GL.FLOAT is supported in WebGL1 when 'OES_texure_float' is suported\n  // we need to update this table structure to specify extensions (gl1: 'OES_texure_float', gl2: false) for each type.\n  [GL.RGBA]: {\n    dataFormat: GL.RGBA,\n    types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_4_4_4_4, GL.UNSIGNED_SHORT_5_5_5_1]\n  },\n  [GL.ALPHA]: {dataFormat: GL.ALPHA, types: [GL.UNSIGNED_BYTE]},\n  [GL.LUMINANCE]: {dataFormat: GL.LUMINANCE, types: [GL.UNSIGNED_BYTE]},\n  [GL.LUMINANCE_ALPHA]: {dataFormat: GL.LUMINANCE_ALPHA, types: [GL.UNSIGNED_BYTE]},\n\n  // 32 bit floats\n  [GL.R32F]: {dataFormat: GL.RED, types: [GL.FLOAT], gl2: true},\n  [GL.RG32F]: {dataFormat: GL.RG, types: [GL.FLOAT], gl2: true},\n  [GL.RGB32F]: {dataFormat: GL.RGB, types: [GL.FLOAT], gl2: true},\n  [GL.RGBA32F]: {dataFormat: GL.RGBA, types: [GL.FLOAT], gl2: true}\n\n  // [GL.DEPTH_COMPONENT]: {types: [GL.UNSIGNED_SHORT, GL.UNSIGNED_INT, GL.UNSIGNED_INT_24_8], gl1: DEPTH},\n  // [GL.DEPTH_STENCIL]: {gl1: DEPTH},\n\n  // Sized texture format - more performance\n  // R\n  // [GL.R8]: {dataFormat: GL.RED, types: [GL.UNSIGNED_BYTE], gl2: true},\n  // [GL.R16F]: {dataFormat: GL.RED, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},\n  // [GL.R8UI]: {dataFormat: GL.RED_INTEGER, types: [GL.UNSIGNED_BYTE], gl2: true},\n  // // RG\n  // [GL.RG8]: {dataFormat: GL.RG, types: [GL.UNSIGNED_BYTE], gl2: true},\n  // [GL.RG16F]: {dataFormat: GL.RG, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},\n  // [GL.RG8UI]: {dataFormat: GL.RG_INTEGER, types: [GL.UNSIGNED_BYTE], gl2: true},\n  // // RGB\n  // [GL.RGB8]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_BYTE], gl2: true, gl1: SRGB},\n  // [GL.SRGB8]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_BYTE], gl2: true, gl1: SRGB},\n  // [GL.RGB565]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_5_6_5], gl2: true},\n  // [GL.R11F_G11F_B10F]: {dataFormat: GL.RGB, types: [GL.UNSIGNED_INT_10F_11F_11F_REV, GL.HALF_FLOAT, GL.FLOAT], gl2: true},\n  // [GL.RGB9_E5]: {dataFormat: GL.RGB, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true, gl1: 'WEBGL_color_buffer_half_float'},\n  // [GL.RGB16F]: {dataFormat: GL.RGB, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true, gl1: 'WEBGL_color_buffer_float'},\n  // [GL.RGB8UI]: {dataFormat: GL.RGB_INTEGER, types: [GL.UNSIGNED_BYTE], gl2: true},\n  // // RGBA\n  // [GL.RGBA8]: {dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE], gl2: true, gl1: SRGB},\n  // [GL.SRGB8_ALPHA8]: {dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE], gl2: true, gl1: SRGB},\n  // [GL.RGB5_A1]: {dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_5_5_5_1], gl2: true},\n  // [GL.RGBA4]: {dataFormat: GL.RGBA, types: [GL.UNSIGNED_BYTE, GL.UNSIGNED_SHORT_4_4_4_4], gl2: true},\n  // [GL.RGBA16F]: {dataFormat: GL.RGBA, types: [GL.HALF_FLOAT, GL.FLOAT], gl2: true},\n  // [GL.RGBA8UI]: {dataFormat: GL.RGBA_INTEGER, types: [GL.UNSIGNED_BYTE], gl2: true}\n\n  // Compressed formats\n\n  // WEBGL_compressed_texture_s3tc\n\n  // [GL.COMPRESSED_RGB_S3TC_DXT1_EXT]: {compressed: true, gl1: S3TC},\n  // [GL.COMPRESSED_RGBA_S3TC_DXT1_EXT]: {compressed: true, gl1: S3TC},\n  // [GL.COMPRESSED_RGBA_S3TC_DXT3_EXT]: {compressed: true, gl1: S3TC},\n  // [GL.COMPRESSED_RGBA_S3TC_DXT5_EXT]: {compressed: true, gl1: S3TC},\n\n  // WEBGL_compressed_texture_es3\n\n  // [GL.COMPRESSED_R11_EAC]: {compressed: true, gl1: ES3}, // RED\n  // [GL.COMPRESSED_SIGNED_R11_EAC]: {compressed: true, gl1: ES3}, // RED\n  // [GL.COMPRESSED_RG11_EAC]: {compressed: true, gl1: ES3}, // RG\n  // [GL.COMPRESSED_SIGNED_RG11_EAC]: {compressed: true, gl1: ES3}, // RG\n  // [GL.COMPRESSED_RGB8_ETC2]: {compressed: true, gl1: ES3}, // RGB\n  // [GL.COMPRESSED_RGBA8_ETC2_EAC]: {compressed: true, gl1: ES3}, // RBG\n  // [GL.COMPRESSED_SRGB8_ETC2]: {compressed: true, gl1: ES3}, // RGB\n  // [GL.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC]: {compressed: true, gl1: ES3}, // RGBA\n  // [GL.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2]: {compressed: true, gl1: ES3}, // RGBA\n  // [GL.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2]: {compressed: true, gl1: ES3}, // RGBA\n  /* WebGL2 guaranteed availability compressed formats?\n  COMPRESSED_R11_EAC RED\n  COMPRESSED_SIGNED_R11_EAC RED\n  COMPRESSED_RG11_EAC RG\n  COMPRESSED_SIGNED_RG11_EAC RG\n  COMPRESSED_RGB8_ETC2 RGB\n  COMPRESSED_SRGB8_ETC2 RGB\n  COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 RGBA\n  COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 RGBA\n  COMPRESSED_RGBA8_ETC2_EAC RGBA\n  COMPRESSED_SRGB8_ALPHA8_ETC2_EAC\n  */\n\n  // WEBGL_compressed_texture_pvrtc\n\n  // [GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG]: {compressed: true, gl1: PVRTC},\n  // [GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG]: {compressed: true, gl1: PVRTC},\n  // [GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG]: {compressed: true, gl1: PVRTC},\n  // [GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG]: {compressed: true, gl1: PVRTC},\n\n  // WEBGL_compressed_texture_etc1\n\n  // [GL.COMPRESSED_RGB_ETC1_WEBGL]: {compressed: true, gl1: ETC1},\n\n  // WEBGL_compressed_texture_atc\n\n  // [GL.COMPRESSED_RGB_ATC_WEBGL]: {compressed: true, gl1: ETC1},\n  // [GL.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL]: {compressed: true, gl1: ETC1},\n  // [GL.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL]: {compressed: true, gl1: ETC1}\n};\n\nexport const DATA_FORMAT_CHANNELS = {\n  [GL.RED]: 1,\n  [GL.RED_INTEGER]: 1,\n  [GL.RG]: 2,\n  [GL.RG_INTEGER]: 2,\n  [GL.RGB]: 3,\n  [GL.RGB_INTEGER]: 3,\n  [GL.RGBA]: 4,\n  [GL.RGBA_INTEGER]: 4,\n  [GL.DEPTH_COMPONENT]: 1,\n  [GL.DEPTH_STENCIL]: 1,\n  [GL.ALPHA]: 1,\n  [GL.LUMINANCE]: 1,\n  [GL.LUMINANCE_ALPHA]: 2\n};\n\nexport const TYPE_SIZES = {\n  [GL.FLOAT]: 4,\n  [GL.UNSIGNED_INT]: 4,\n  [GL.INT]: 4,\n  [GL.UNSIGNED_SHORT]: 2,\n  [GL.SHORT]: 2,\n  [GL.HALF_FLOAT]: 2,\n  [GL.BYTE]: 1,\n  [GL.UNSIGNED_BYTE]: 1\n};\n\nexport function isFormatSupported(gl, format) {\n  const info = TEXTURE_FORMATS[format];\n  if (!info) {\n    return false;\n  }\n  if (info.gl1 === undefined && info.gl2 === undefined) {\n    // No info - always supported\n    return true;\n  }\n  const value = isWebGL2(gl) ? info.gl2 || info.gl1 : info.gl1;\n  return typeof value === 'string' ? gl.getExtension(value) : value;\n}\n\nexport function isLinearFilteringSupported(gl, format) {\n  const info = TEXTURE_FORMATS[format];\n  switch (info && info.types[0]) {\n    // Both WebGL1 and WebGL2?\n    case GL.FLOAT:\n      return gl.getExtension('OES_texture_float_linear');\n    // Not in WebGL2?\n    case GL.HALF_FLOAT:\n      return gl.getExtension('OES_texture_half_float_linear');\n    default:\n      return true;\n  }\n}\n","import {assert} from '../utils/assert';\n\nlet pathPrefix = '';\n\n/*\n * Set a relative path prefix\n */\nexport function setPathPrefix(prefix) {\n  pathPrefix = prefix;\n}\n\n// Reads raw file data from:\nexport function loadFile(url, options = {}) {\n  assert(typeof url === 'string');\n  url = pathPrefix + url;\n  const dataType = options.dataType || 'text';\n  return fetch(url, options).then(res => res[dataType]());\n}\n\n/*\n * Loads images asynchronously\n * image.crossOrigin can be set via opts.crossOrigin, default to 'anonymous'\n * returns a promise tracking the load\n */\nexport function loadImage(url, opts) {\n  assert(typeof url === 'string');\n  url = pathPrefix + url;\n  return new Promise((resolve, reject) => {\n    try {\n      const image = new Image();\n      image.onload = () => resolve(image);\n      image.onerror = () => reject(new Error(`Could not load image ${url}.`));\n      image.crossOrigin = (opts && opts.crossOrigin) || 'anonymous';\n      image.src = url;\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n","import GL from '@luma.gl/constants';\nimport {log, assertWebGLContext} from '@luma.gl/gltools';\nimport Texture from './texture';\n\nconst FACES = [\n  GL.TEXTURE_CUBE_MAP_POSITIVE_X,\n  GL.TEXTURE_CUBE_MAP_NEGATIVE_X,\n  GL.TEXTURE_CUBE_MAP_POSITIVE_Y,\n  GL.TEXTURE_CUBE_MAP_NEGATIVE_Y,\n  GL.TEXTURE_CUBE_MAP_POSITIVE_Z,\n  GL.TEXTURE_CUBE_MAP_NEGATIVE_Z\n];\n\nexport default class TextureCube extends Texture {\n  constructor(gl, props = {}) {\n    assertWebGLContext(gl);\n\n    super(gl, Object.assign({}, props, {target: GL.TEXTURE_CUBE_MAP}));\n\n    this.initialize(props);\n\n    Object.seal(this);\n  }\n\n  initialize(props = {}) {\n    const {mipmaps = true, parameters = {}} = props;\n\n    // Store props for accessors\n    this.opts = props;\n\n    // @ts-ignore\n    this.setCubeMapImageData(props).then(() => {\n      this.loaded = true;\n\n      // TODO - should genMipmap() be called on the cubemap or on the faces?\n      // TODO - without generateMipmap() cube textures do not work at all!!! Why?\n      if (mipmaps) {\n        this.generateMipmap(props);\n      }\n\n      this.setParameters(parameters);\n    });\n    return this;\n  }\n\n  subImage({face, data, x = 0, y = 0, mipmapLevel = 0}) {\n    // @ts-ignore TODO - is this a bug?\n    return this._subImage({target: face, data, x, y, mipmapLevel});\n  }\n\n  /* eslint-disable max-statements, max-len */\n  async setCubeMapImageData({\n    width,\n    height,\n    pixels,\n    data,\n    border = 0,\n    format = GL.RGBA,\n    type = GL.UNSIGNED_BYTE\n  }) {\n    const {gl} = this;\n    const imageDataMap = pixels || data;\n\n    // pixel data (imageDataMap) is an Object from Face to Image or Promise.\n    // For example:\n    // {\n    // GL.TEXTURE_CUBE_MAP_POSITIVE_X : Image-or-Promise,\n    // GL.TEXTURE_CUBE_MAP_NEGATIVE_X : Image-or-Promise,\n    // ... }\n    // To provide multiple level-of-details (LODs) this can be Face to Array\n    // of Image or Promise, like this\n    // {\n    // GL.TEXTURE_CUBE_MAP_POSITIVE_X : [Image-or-Promise-LOD-0, Image-or-Promise-LOD-1],\n    // GL.TEXTURE_CUBE_MAP_NEGATIVE_X : [Image-or-Promise-LOD-0, Image-or-Promise-LOD-1],\n    // ... }\n\n    const resolvedFaces = await Promise.all(\n      FACES.map(face => {\n        const facePixels = imageDataMap[face];\n        return Promise.all(Array.isArray(facePixels) ? facePixels : [facePixels]);\n      })\n    );\n\n    this.bind();\n\n    FACES.forEach((face, index) => {\n      if (resolvedFaces[index].length > 1 && this.opts.mipmaps !== false) {\n        // If the user provides multiple LODs, then automatic mipmap\n        // generation generateMipmap() should be disabled to avoid overwritting them.\n        log.warn(`${this.id} has mipmap and multiple LODs.`)();\n      }\n      resolvedFaces[index].forEach((image, lodLevel) => {\n        // TODO: adjust width & height for LOD!\n        if (width && height) {\n          gl.texImage2D(face, lodLevel, format, width, height, border, format, type, image);\n        } else {\n          gl.texImage2D(face, lodLevel, format, format, type, image);\n        }\n      });\n    });\n\n    this.unbind();\n  }\n\n  // TODO: update this method to accept LODs\n  setImageDataForFace(options) {\n    const {\n      face,\n      width,\n      height,\n      pixels,\n      data,\n      border = 0,\n      format = GL.RGBA,\n      type = GL.UNSIGNED_BYTE\n      // generateMipmap = false // TODO\n    } = options;\n\n    const {gl} = this;\n\n    const imageData = pixels || data;\n\n    this.bind();\n    if (imageData instanceof Promise) {\n      imageData.then(resolvedImageData =>\n        this.setImageDataForFace(\n          Object.assign({}, options, {\n            face,\n            data: resolvedImageData,\n            pixels: resolvedImageData\n          })\n        )\n      );\n    } else if (this.width || this.height) {\n      gl.texImage2D(face, 0, format, width, height, border, format, type, imageData);\n    } else {\n      gl.texImage2D(face, 0, format, format, type, imageData);\n    }\n\n    return this;\n  }\n}\n\nTextureCube.FACES = FACES;\n","import GL from '@luma.gl/constants';\nimport {isWebGL2, assertWebGL2Context, withParameters} from '@luma.gl/gltools';\nimport Texture from './texture';\nimport {DATA_FORMAT_CHANNELS, TYPE_SIZES} from './texture-formats';\nimport Buffer from './buffer';\n\nexport default class Texture3D extends Texture {\n  static isSupported(gl) {\n    return isWebGL2(gl);\n  }\n\n  constructor(gl, props = {}) {\n    assertWebGL2Context(gl);\n    props = Object.assign({depth: 1}, props, {target: GL.TEXTURE_3D, unpackFlipY: false});\n    super(gl, props);\n    this.initialize(props);\n\n    Object.seal(this);\n  }\n\n  // Image 3D copies from Typed Array or WebGLBuffer\n  setImageData({\n    level = 0,\n    dataFormat = GL.RGBA,\n    width,\n    height,\n    depth = 1,\n    border = 0,\n    format,\n    type = GL.UNSIGNED_BYTE,\n    offset = 0,\n    data,\n    parameters = {}\n  }) {\n    this._trackDeallocatedMemory('Texture');\n\n    this.gl.bindTexture(this.target, this.handle);\n\n    withParameters(this.gl, parameters, () => {\n      if (ArrayBuffer.isView(data)) {\n        // @ts-ignore\n        this.gl.texImage3D(\n          this.target,\n          level,\n          dataFormat,\n          width,\n          height,\n          depth,\n          border,\n          format,\n          type,\n          data\n        );\n      }\n\n      if (data instanceof Buffer) {\n        this.gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle);\n        // @ts-ignore\n        this.gl.texImage3D(\n          this.target,\n          level,\n          dataFormat,\n          width,\n          height,\n          depth,\n          border,\n          format,\n          type,\n          offset\n        );\n      }\n    });\n\n    if (data && data.byteLength) {\n      this._trackAllocatedMemory(data.byteLength, 'Texture');\n    } else {\n      // NOTE(Tarek): Default to RGBA bytes\n      // @ts-ignore\n      const channels = DATA_FORMAT_CHANNELS[this.dataFormat] || 4;\n      // @ts-ignore\n      const channelSize = TYPE_SIZES[this.type] || 1;\n\n      this._trackAllocatedMemory(\n        this.width * this.height * this.depth * channels * channelSize,\n        'Texture'\n      );\n    }\n\n    this.loaded = true;\n\n    return this;\n  }\n}\n","import GL from '@luma.gl/constants';\nimport {getWebGL2Context, assertWebGL2Context, log} from '@luma.gl/gltools';\nimport Resource from './resource';\nimport Texture2D from './texture-2d';\nimport Renderbuffer from './renderbuffer';\nimport {clear, clearBuffer} from './clear';\nimport {copyToDataUrl} from './copy-and-blit.js';\n\nimport {getFeatures} from '../features';\nimport {getKey} from '../webgl-utils/constants-to-keys';\nimport {assert} from '../utils/assert';\n\nconst ERR_MULTIPLE_RENDERTARGETS = 'Multiple render targets not supported';\n\nexport default class Framebuffer extends Resource {\n  static isSupported(gl, options = {}) {\n    const {\n      colorBufferFloat, // Whether floating point textures can be rendered and read\n      colorBufferHalfFloat // Whether half float textures can be rendered and read\n    } = options;\n    let supported = true;\n\n    if (colorBufferFloat) {\n      supported = Boolean(\n        // WebGL 2\n        gl.getExtension('EXT_color_buffer_float') ||\n          // WebGL 1, not exposed on all platforms\n          gl.getExtension('WEBGL_color_buffer_float') ||\n          // WebGL 1, implicitly enables float render targets https://www.khronos.org/registry/webgl/extensions/OES_texture_float/\n          gl.getExtension('OES_texture_float')\n      );\n    }\n\n    if (colorBufferHalfFloat) {\n      supported =\n        supported &&\n        Boolean(\n          // WebGL 2\n          gl.getExtension('EXT_color_buffer_float') ||\n            // WebGL 1\n            gl.getExtension('EXT_color_buffer_half_float')\n        );\n    }\n\n    return supported;\n  }\n\n  // Create a Framebuffer wrapper for the default framebuffer (target === null)\n  static getDefaultFramebuffer(gl) {\n    gl.luma = gl.luma || {};\n    gl.luma.defaultFramebuffer =\n      gl.luma.defaultFramebuffer ||\n      new Framebuffer(gl, {\n        id: 'default-framebuffer',\n        handle: null,\n        attachments: {}\n      });\n    // TODO - can we query for and get a handle to the GL.FRONT renderbuffer?\n    return gl.luma.defaultFramebuffer;\n  }\n\n  get MAX_COLOR_ATTACHMENTS() {\n    const gl2 = assertWebGL2Context(this.gl);\n    return gl2.getParameter(gl2.MAX_COLOR_ATTACHMENTS);\n  }\n\n  get MAX_DRAW_BUFFERS() {\n    const gl2 = assertWebGL2Context(this.gl);\n    return gl2.getParameter(gl2.MAX_DRAW_BUFFERS);\n  }\n\n  constructor(gl, opts = {}) {\n    super(gl, opts);\n\n    // Public members\n    this.width = null;\n    this.height = null;\n    this.attachments = {};\n    this.readBuffer = GL.COLOR_ATTACHMENT0;\n    this.drawBuffers = [GL.COLOR_ATTACHMENT0];\n    this.ownResources = [];\n    this.initialize(opts);\n\n    Object.seal(this);\n  }\n\n  get color() {\n    return this.attachments[GL.COLOR_ATTACHMENT0] || null;\n  }\n\n  get texture() {\n    return this.attachments[GL.COLOR_ATTACHMENT0] || null;\n  }\n\n  get depth() {\n    return (\n      this.attachments[GL.DEPTH_ATTACHMENT] || this.attachments[GL.DEPTH_STENCIL_ATTACHMENT] || null\n    );\n  }\n\n  get stencil() {\n    return (\n      this.attachments[GL.STENCIL_ATTACHMENT] ||\n      this.attachments[GL.DEPTH_STENCIL_ATTACHMENT] ||\n      null\n    );\n  }\n\n  initialize({\n    width = 1,\n    height = 1,\n    attachments = null,\n    color = true,\n    depth = true,\n    stencil = false,\n    check = true,\n    readBuffer = undefined,\n    drawBuffers = undefined\n  }) {\n    assert(width >= 0 && height >= 0, 'Width and height need to be integers');\n\n    // Store actual width and height for diffing\n    this.width = width;\n    this.height = height;\n\n    // Resize any provided attachments - note that resize only resizes if needed\n    // Note: A framebuffer has no separate size, it is defined by its attachments (which must agree)\n    if (attachments) {\n      for (const attachment in attachments) {\n        const target = attachments[attachment];\n        const object = Array.isArray(target) ? target[0] : target;\n        object.resize({width, height});\n      }\n    } else {\n      // Create any requested default attachments\n      attachments = this._createDefaultAttachments(color, depth, stencil, width, height);\n    }\n\n    this.update({clearAttachments: true, attachments, readBuffer, drawBuffers});\n\n    // Checks that framebuffer was properly set up, if not, throws an explanatory error\n    if (attachments && check) {\n      this.checkStatus();\n    }\n  }\n\n  delete() {\n    for (const resource of this.ownResources) {\n      resource.delete();\n    }\n    super.delete();\n    return this;\n  }\n\n  update({\n    attachments = {},\n    readBuffer,\n    drawBuffers,\n    clearAttachments = false,\n    resizeAttachments = true\n  }) {\n    this.attach(attachments, {clearAttachments, resizeAttachments});\n\n    const {gl} = this;\n    // Multiple render target support, set read buffer and draw buffers\n    const prevHandle = gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);\n    if (readBuffer) {\n      this._setReadBuffer(readBuffer);\n    }\n    if (drawBuffers) {\n      this._setDrawBuffers(drawBuffers);\n    }\n    // @ts-ignore\n    gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);\n\n    return this;\n  }\n\n  // Attachment resize is expected to be a noop if size is same\n  resize(options = {}) {\n    let {width, height} = options;\n    // for default framebuffer, just update the stored size\n    if (this.handle === null) {\n      assert(width === undefined && height === undefined);\n      this.width = this.gl.drawingBufferWidth;\n      this.height = this.gl.drawingBufferHeight;\n      return this;\n    }\n\n    if (width === undefined) {\n      width = this.gl.drawingBufferWidth;\n    }\n    if (height === undefined) {\n      height = this.gl.drawingBufferHeight;\n    }\n\n    if (width !== this.width && height !== this.height) {\n      log.log(2, `Resizing framebuffer ${this.id} to ${width}x${height}`)();\n    }\n    for (const attachmentPoint in this.attachments) {\n      this.attachments[attachmentPoint].resize({width, height});\n    }\n    this.width = width;\n    this.height = height;\n    return this;\n  }\n\n  // Attach from a map of attachments\n  attach(attachments, {clearAttachments = false, resizeAttachments = true} = {}) {\n    const newAttachments = {};\n\n    // Any current attachments need to be removed, add null values to map\n    if (clearAttachments) {\n      Object.keys(this.attachments).forEach(key => {\n        newAttachments[key] = null;\n      });\n    }\n\n    // Overlay the new attachments\n    Object.assign(newAttachments, attachments);\n\n    const prevHandle = this.gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);\n\n    // Walk the attachments\n    for (const key in newAttachments) {\n      // Ensure key is not undefined\n      assert(key !== undefined, 'Misspelled framebuffer binding point?');\n\n      const attachment = Number(key);\n\n      const descriptor = newAttachments[attachment];\n      let object = descriptor;\n      if (!object) {\n        this._unattach(attachment);\n      } else if (object instanceof Renderbuffer) {\n        this._attachRenderbuffer({attachment, renderbuffer: object});\n      } else if (Array.isArray(descriptor)) {\n        const [texture, layer = 0, level = 0] = descriptor;\n        object = texture;\n        this._attachTexture({attachment, texture, layer, level});\n      } else {\n        this._attachTexture({attachment, texture: object, layer: 0, level: 0});\n      }\n\n      // Resize objects\n      if (resizeAttachments && object) {\n        object.resize({width: this.width, height: this.height});\n      }\n    }\n\n    // @ts-ignore\n    this.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);\n\n    // Assign to attachments and remove any nulls to get a clean attachment map\n    Object.assign(this.attachments, attachments);\n    Object.keys(this.attachments)\n      .filter(key => !this.attachments[key])\n      .forEach(key => {\n        delete this.attachments[key];\n      });\n  }\n\n  checkStatus() {\n    const {gl} = this;\n    const status = this.getStatus();\n    if (status !== gl.FRAMEBUFFER_COMPLETE) {\n      throw new Error(_getFrameBufferStatus(status));\n    }\n    return this;\n  }\n\n  getStatus() {\n    const {gl} = this;\n    const prevHandle = gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);\n    const status = gl.checkFramebufferStatus(GL.FRAMEBUFFER);\n    // @ts-ignore\n    gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);\n    return status;\n  }\n\n  clear(options = {}) {\n    const {color, depth, stencil, drawBuffers = []} = options;\n\n    // Bind framebuffer and delegate to global clear functions\n    const prevHandle = this.gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);\n\n    if (color || depth || stencil) {\n      clear(this.gl, {color, depth, stencil});\n    }\n\n    drawBuffers.forEach((value, drawBuffer) => {\n      clearBuffer(this.gl, {drawBuffer, value});\n    });\n\n    // @ts-ignore\n    this.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);\n\n    return this;\n  }\n\n  // NOTE: Slow requires roundtrip to GPU\n  // App can provide pixelArray or have it auto allocated by this method\n  // @returns {Uint8Array|Uint16Array|FloatArray} - pixel array,\n  //  newly allocated by this method unless provided by app.\n  readPixels(opts = {}) {\n    log.error(\n      'Framebuffer.readPixels() is no logner supported, use readPixelsToArray(framebuffer)'\n    )();\n    return null;\n  }\n\n  // Reads data into provided buffer object asynchronously\n  // This function doesn't wait for copy to be complete, it programs GPU to perform a DMA transffer.\n  readPixelsToBuffer(opts = {}) {\n    log.error(\n      'Framebuffer.readPixelsToBuffer()is no logner supported, use readPixelsToBuffer(framebuffer)'\n    )();\n    return null;\n  }\n\n  // Reads pixels as a dataUrl\n  copyToDataUrl(opts = {}) {\n    log.error(\n      'Framebuffer.copyToDataUrl() is no logner supported, use copyToDataUrl(framebuffer)'\n    )();\n    return null;\n  }\n\n  // Reads pixels into an HTML Image\n  copyToImage(opts = {}) {\n    log.error('Framebuffer.copyToImage() is no logner supported, use copyToImage(framebuffer)')();\n    return null;\n  }\n\n  // copyToFramebuffer({width, height}) {\n  //   const scaleX = width / this.width;\n  //   const scaleY = height / this.height;\n  //   const scale = Math.min(scaleX, scaleY);\n  //   width = width * scale;\n  //   height = height * scale;\n  //   const scaledFramebuffer = new Framebuffer(this.gl, {width, height});\n  //   this.blit();\n  // }\n\n  // Copy a rectangle from a framebuffer attachment into a texture (at an offset)\n  // NOTE: assumes texture has enough storage allocated\n  // eslint-disable-next-line complexity\n  copyToTexture(opts = {}) {\n    log.error(\n      'Framebuffer.copyToTexture({...}) is no logner supported, use copyToTexture(source, target, opts})'\n    )();\n    return null;\n  }\n\n  // WEBGL2 INTERFACE\n\n  // Copies a rectangle of pixels between framebuffers\n  // eslint-disable-next-line complexity\n  blit(opts = {}) {\n    log.error('Framebuffer.blit({...}) is no logner supported, use blit(source, target, opts)')();\n    return null;\n  }\n\n  // signals to the GL that it need not preserve all pixels of a specified region of the framebuffer\n  invalidate({attachments = [], x = 0, y = 0, width, height}) {\n    const gl2 = assertWebGL2Context(this.gl);\n    const prevHandle = gl2.bindFramebuffer(GL.READ_FRAMEBUFFER, this.handle);\n    const invalidateAll = x === 0 && y === 0 && width === undefined && height === undefined;\n    if (invalidateAll) {\n      gl2.invalidateFramebuffer(GL.READ_FRAMEBUFFER, attachments);\n    } else {\n      // TODO - why does type checking fail on this line\n      // @ts-ignore\n      gl2.invalidateFramebuffer(GL.READ_FRAMEBUFFER, attachments, x, y, width, height);\n    }\n    // @ts-ignore\n    gl2.bindFramebuffer(GL.READ_FRAMEBUFFER, prevHandle);\n    return this;\n  }\n\n  // Return the value for `pname` of the specified attachment.\n  // The type returned is the type of the requested pname\n  getAttachmentParameter(attachment, pname, keys) {\n    let value = this._getAttachmentParameterFallback(pname);\n    if (value === null) {\n      this.gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);\n      value = this.gl.getFramebufferAttachmentParameter(GL.FRAMEBUFFER, attachment, pname);\n      this.gl.bindFramebuffer(GL.FRAMEBUFFER, null);\n    }\n    if (keys && value > 1000) {\n      // @ts-ignore\n      value = getKey(this.gl, value);\n    }\n    return value;\n  }\n\n  getAttachmentParameters(\n    attachment = GL.COLOR_ATTACHMENT0,\n    keys,\n    // @ts-ignore\n    parameters = this.constructor.ATTACHMENT_PARAMETERS || []\n  ) {\n    const values = {};\n    for (const pname of parameters) {\n      const key = keys ? getKey(this.gl, pname) : pname;\n      values[key] = this.getAttachmentParameter(attachment, pname, keys);\n    }\n    return values;\n  }\n\n  getParameters(keys = true) {\n    const attachments = Object.keys(this.attachments);\n    // if (this === this.gl.luma.defaultFramebuffer) {\n    //   attachments = [GL.COLOR_ATTACHMENT0, GL.DEPTH_STENCIL_ATTACHMENT];\n    // }\n    const parameters = {};\n    for (const attachmentName of attachments) {\n      const attachment = Number(attachmentName);\n      const key = keys ? getKey(this.gl, attachment) : attachment;\n      parameters[key] = this.getAttachmentParameters(attachment, keys);\n    }\n    return parameters;\n  }\n\n  // DEBUG\n\n  // Note: Will only work when called in an event handler\n  show() {\n    if (typeof window !== 'undefined') {\n      window.open(copyToDataUrl(this), 'luma-debug-texture');\n    }\n    return this;\n  }\n\n  log(logLevel = 0, message = '') {\n    if (logLevel > log.level || typeof window === 'undefined') {\n      return this;\n    }\n    message = message || `Framebuffer ${this.id}`;\n    const image = copyToDataUrl(this, {targetMaxHeight: 100});\n    log.image({logLevel, message, image}, message)();\n    return this;\n  }\n\n  // WEBGL INTERFACE\n  bind({target = GL.FRAMEBUFFER} = {}) {\n    this.gl.bindFramebuffer(target, this.handle);\n    return this;\n  }\n\n  unbind({target = GL.FRAMEBUFFER} = {}) {\n    this.gl.bindFramebuffer(target, null);\n    return this;\n  }\n\n  // PRIVATE METHODS\n\n  _createDefaultAttachments(color, depth, stencil, width, height) {\n    let defaultAttachments = null;\n\n    // Add a color buffer if requested and not supplied\n    if (color) {\n      defaultAttachments = defaultAttachments || {};\n      defaultAttachments[GL.COLOR_ATTACHMENT0] = new Texture2D(this.gl, {\n        id: `${this.id}-color0`,\n        pixels: null, // reserves texture memory, but texels are undefined\n        format: GL.RGBA,\n        type: GL.UNSIGNED_BYTE,\n        width,\n        height,\n        // Note: Mipmapping can be disabled by texture resource when we resize the texture\n        // to a non-power-of-two dimenstion (NPOT texture) under WebGL1. To have consistant\n        // behavior we always disable mipmaps.\n        mipmaps: false,\n        // Set MIN and MAG filtering parameters so mipmaps are not used in sampling.\n        // Use LINEAR so subpixel algos like fxaa work.\n        // Set WRAP modes that support NPOT textures too.\n        parameters: {\n          [GL.TEXTURE_MIN_FILTER]: GL.LINEAR,\n          [GL.TEXTURE_MAG_FILTER]: GL.LINEAR,\n          [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,\n          [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE\n        }\n      });\n      // track to delete later\n      this.ownResources.push(defaultAttachments[GL.COLOR_ATTACHMENT0]);\n    }\n\n    if (depth && stencil) {\n      // TODO - handle separate stencil\n      defaultAttachments = defaultAttachments || {};\n      defaultAttachments[GL.DEPTH_STENCIL_ATTACHMENT] = new Renderbuffer(this.gl, {\n        id: `${this.id}-depth-stencil`,\n        format: GL.DEPTH24_STENCIL8,\n        width,\n        height: 111\n      });\n      // track to delete later\n      this.ownResources.push(defaultAttachments[GL.DEPTH_STENCIL_ATTACHMENT]);\n      // TODO - optional texture\n      // new Texture2D(this.gl, {\n      //   id: `${this.id}-depth-stencil`,\n      //   format: GL.DEPTH24_STENCIL8,\n      //   dataFormat: GL.DEPTH_STENCIL,\n      //   type: GL.UNSIGNED_INT_24_8,\n      //   width,\n      //   height,\n      //   mipmaps: false\n      // });\n    } else if (depth) {\n      // Add a depth buffer if requested and not supplied\n      defaultAttachments = defaultAttachments || {};\n      defaultAttachments[GL.DEPTH_ATTACHMENT] = new Renderbuffer(this.gl, {\n        id: `${this.id}-depth`,\n        format: GL.DEPTH_COMPONENT16,\n        width,\n        height\n      });\n      // track to delete later\n      this.ownResources.push(defaultAttachments[GL.DEPTH_ATTACHMENT]);\n    } else if (stencil) {\n      // TODO - handle separate stencil\n      assert(false);\n    }\n\n    return defaultAttachments;\n  }\n\n  _unattach(attachment) {\n    const oldAttachment = this.attachments[attachment];\n    if (!oldAttachment) {\n      return;\n    }\n    if (oldAttachment instanceof Renderbuffer) {\n      // render buffer\n      this.gl.framebufferRenderbuffer(GL.FRAMEBUFFER, attachment, GL.RENDERBUFFER, null);\n    } else {\n      // Must be a texture attachment\n      this.gl.framebufferTexture2D(GL.FRAMEBUFFER, attachment, GL.TEXTURE_2D, null, 0);\n    }\n    delete this.attachments[attachment];\n  }\n\n  _attachRenderbuffer({attachment = GL.COLOR_ATTACHMENT0, renderbuffer}) {\n    const {gl} = this;\n    // TODO - is the bind needed?\n    // gl.bindRenderbuffer(GL.RENDERBUFFER, renderbuffer.handle);\n    gl.framebufferRenderbuffer(GL.FRAMEBUFFER, attachment, GL.RENDERBUFFER, renderbuffer.handle);\n    // TODO - is the unbind needed?\n    // gl.bindRenderbuffer(GL.RENDERBUFFER, null);\n\n    this.attachments[attachment] = renderbuffer;\n  }\n\n  // layer = 0 - index into Texture2DArray and Texture3D or face for `TextureCubeMap`\n  // level = 0 - mipmapLevel (must be 0 in WebGL1)\n  _attachTexture({attachment = GL.COLOR_ATTACHMENT0, texture, layer, level}) {\n    const {gl} = this;\n    gl.bindTexture(texture.target, texture.handle);\n\n    switch (texture.target) {\n      case GL.TEXTURE_2D_ARRAY:\n      case GL.TEXTURE_3D:\n        const gl2 = assertWebGL2Context(gl);\n        gl2.framebufferTextureLayer(GL.FRAMEBUFFER, attachment, texture.target, level, layer);\n        break;\n\n      case GL.TEXTURE_CUBE_MAP:\n        // layer must be a cubemap face (or if index, converted to cube map face)\n        const face = mapIndexToCubeMapFace(layer);\n        gl.framebufferTexture2D(GL.FRAMEBUFFER, attachment, face, texture.handle, level);\n        break;\n\n      case GL.TEXTURE_2D:\n        gl.framebufferTexture2D(GL.FRAMEBUFFER, attachment, GL.TEXTURE_2D, texture.handle, level);\n        break;\n\n      default:\n        assert(false, 'Illegal texture type');\n    }\n\n    gl.bindTexture(texture.target, null);\n    this.attachments[attachment] = texture;\n  }\n\n  // Expects framebuffer to be bound\n  _setReadBuffer(readBuffer) {\n    const gl2 = getWebGL2Context(this.gl);\n    if (gl2) {\n      gl2.readBuffer(readBuffer);\n    } else {\n      // Setting to color attachment 0 is a noop, so allow it in WebGL1\n      assert(\n        readBuffer === GL.COLOR_ATTACHMENT0 || readBuffer === GL.BACK,\n        ERR_MULTIPLE_RENDERTARGETS\n      );\n    }\n    this.readBuffer = readBuffer;\n  }\n\n  // Expects framebuffer to be bound\n  _setDrawBuffers(drawBuffers) {\n    const {gl} = this;\n    const gl2 = assertWebGL2Context(gl);\n    if (gl2) {\n      gl2.drawBuffers(drawBuffers);\n    } else {\n      // TODO - is this not handled by polyfills?\n      const ext = gl.getExtension('WEBGL_draw_buffers');\n      if (ext) {\n        ext.drawBuffersWEBGL(drawBuffers);\n      } else {\n        // Setting a single draw buffer to color attachment 0 is a noop, allow in WebGL1\n        assert(\n          drawBuffers.length === 1 &&\n            (drawBuffers[0] === GL.COLOR_ATTACHMENT0 || drawBuffers[0] === GL.BACK),\n          ERR_MULTIPLE_RENDERTARGETS\n        );\n      }\n    }\n    this.drawBuffers = drawBuffers;\n  }\n\n  // Attempt to provide workable defaults for WebGL2 symbols under WebGL1\n  // null means OK to query\n  // TODO - move to webgl1 polyfills\n  /* eslint-disable complexity */\n  _getAttachmentParameterFallback(pname) {\n    const caps = getFeatures(this.gl);\n\n    switch (pname) {\n      case GL.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: // GLint\n        return !caps.WEBGL2 ? 0 : null;\n      case GL.FRAMEBUFFER_ATTACHMENT_RED_SIZE: // GLint\n      case GL.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: // GLint\n      case GL.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: // GLint\n      case GL.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: // GLint\n      case GL.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: // GLint\n      case GL.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: // GLint\n        return !caps.WEBGL2 ? 8 : null;\n      case GL.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: // GLenum\n        return !caps.WEBGL2 ? GL.UNSIGNED_INT : null;\n      case GL.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:\n        return !caps.WEBGL2 && !caps.EXT_sRGB ? GL.LINEAR : null;\n      default:\n        return null;\n    }\n  }\n  /* eslint-enable complexity */\n\n  // RESOURCE METHODS\n\n  _createHandle() {\n    return this.gl.createFramebuffer();\n  }\n\n  _deleteHandle() {\n    this.gl.deleteFramebuffer(this.handle);\n  }\n\n  _bindHandle(handle) {\n    return this.gl.bindFramebuffer(GL.FRAMEBUFFER, handle);\n  }\n}\n\n// PUBLIC METHODS\n\n// Map an index to a cube map face constant\nfunction mapIndexToCubeMapFace(layer) {\n  // TEXTURE_CUBE_MAP_POSITIVE_X is a big value (0x8515)\n  // if smaller assume layer is index, otherwise assume it is already a cube map face constant\n  return layer < GL.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + GL.TEXTURE_CUBE_MAP_POSITIVE_X : layer;\n}\n\n// Helper METHODS\n// Get a string describing the framebuffer error if installed\nfunction _getFrameBufferStatus(status) {\n  // Use error mapping if installed\n  // @ts-ignore\n  const STATUS = Framebuffer.STATUS || {};\n  return STATUS[status] || `Framebuffer error ${status}`;\n}\n\nexport const FRAMEBUFFER_ATTACHMENT_PARAMETERS = [\n  GL.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, // WebGLRenderbuffer or WebGLTexture\n  GL.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, // GL.RENDERBUFFER, GL.TEXTURE, GL.NONE\n  // GL.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE, // GL.TEXTURE_CUBE_MAP_POSITIVE_X, etc.\n  // GL.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, // GLint\n  // EXT_sRGB or WebGL2\n  GL.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, // GL.LINEAR, GL.SRBG\n  // WebGL2\n  // GL.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER, // GLint\n  GL.FRAMEBUFFER_ATTACHMENT_RED_SIZE, // GLint\n  GL.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, // GLint\n  GL.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, // GLint\n  GL.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, // GLint\n  GL.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, // GLint\n  GL.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE // GLint\n  // GL.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE\n  // GL.FLOAT, GL.INT, GL.UNSIGNED_INT, GL.SIGNED_NORMALIZED, OR GL.UNSIGNED_NORMALIZED.\n];\n\nFramebuffer.ATTACHMENT_PARAMETERS = FRAMEBUFFER_ATTACHMENT_PARAMETERS;\n","/* eslint-disable no-inline-comments */\nimport GL from '@luma.gl/constants';\nimport Resource from './resource';\nimport RENDERBUFFER_FORMATS from './renderbuffer-formats';\nimport {isWebGL2} from '@luma.gl/gltools';\nimport {assert} from '../utils/assert';\n\nfunction isFormatSupported(gl, format, formats) {\n  const info = formats[format];\n  if (!info) {\n    return false;\n  }\n  const value = isWebGL2(gl) ? info.gl2 || info.gl1 : info.gl1;\n  if (typeof value === 'string') {\n    return gl.getExtension(value);\n  }\n  return value;\n}\n\nexport default class Renderbuffer extends Resource {\n  static isSupported(gl, {format} = {format: null}) {\n    return !format || isFormatSupported(gl, format, RENDERBUFFER_FORMATS);\n  }\n\n  static getSamplesForFormat(gl, {format}) {\n    // Polyfilled to return [0] under WebGL1\n    return gl.getInternalformatParameter(GL.RENDERBUFFER, format, GL.SAMPLES);\n  }\n\n  constructor(gl, opts = {}) {\n    super(gl, opts);\n\n    // @ts-ignore\n    this.initialize(opts);\n\n    Object.seal(this);\n  }\n\n  // Creates and initializes a renderbuffer object's data store\n  initialize({format, width = 1, height = 1, samples = 0}) {\n    assert(format, 'Needs format');\n\n    this._trackDeallocatedMemory();\n\n    this.gl.bindRenderbuffer(GL.RENDERBUFFER, this.handle);\n\n    if (samples !== 0 && isWebGL2(this.gl)) {\n      // @ts-ignore\n      this.gl.renderbufferStorageMultisample(GL.RENDERBUFFER, samples, format, width, height);\n    } else {\n      this.gl.renderbufferStorage(GL.RENDERBUFFER, format, width, height);\n    }\n\n    // this.gl.bindRenderbuffer(GL.RENDERBUFFER, null);\n\n    this.format = format;\n    this.width = width;\n    this.height = height;\n    this.samples = samples;\n\n    this._trackAllocatedMemory(\n      this.width * this.height * (this.samples || 1) * RENDERBUFFER_FORMATS[this.format].bpp\n    );\n\n    return this;\n  }\n\n  resize({width, height}) {\n    // Don't resize if width/height haven't changed\n    if (width !== this.width || height !== this.height) {\n      return this.initialize({width, height, format: this.format, samples: this.samples});\n    }\n    return this;\n  }\n\n  // PRIVATE METHODS\n  _createHandle() {\n    return this.gl.createRenderbuffer();\n  }\n\n  _deleteHandle() {\n    this.gl.deleteRenderbuffer(this.handle);\n    this._trackDeallocatedMemory();\n  }\n\n  _bindHandle(handle) {\n    this.gl.bindRenderbuffer(GL.RENDERBUFFER, handle);\n  }\n\n  _syncHandle(handle) {\n    this.format = this.getParameter(GL.RENDERBUFFER_INTERNAL_FORMAT);\n    this.width = this.getParameter(GL.RENDERBUFFER_WIDTH);\n    this.height = this.getParameter(GL.RENDERBUFFER_HEIGHT);\n    this.samples = this.getParameter(GL.RENDERBUFFER_SAMPLES);\n  }\n\n  // @param {Boolean} opt.autobind=true - method call will bind/unbind object\n  // @returns {GLenum|GLint} - depends on pname\n  _getParameter(pname) {\n    this.gl.bindRenderbuffer(GL.RENDERBUFFER, this.handle);\n    const value = this.gl.getRenderbufferParameter(GL.RENDERBUFFER, pname);\n    // this.gl.bindRenderbuffer(GL.RENDERBUFFER, null);\n    return value;\n  }\n}\n","import GL from '@luma.gl/constants';\n\n// Define local extension strings to optimize minification\n// const SRGB = 'EXT_sRGB';\n// const EXT_FLOAT_WEBGL1 = 'WEBGL_color_buffer_float';\nconst EXT_FLOAT_WEBGL2 = 'EXT_color_buffer_float';\n// const EXT_HALF_FLOAT_WEBGL1 = 'EXT_color_buffer_half_float';\n\n// NOTE(Tarek): bpp === \"bytes per pixel\", used for\n// memory usage calculations.\nexport default {\n  [GL.DEPTH_COMPONENT16]: {bpp: 2}, // 16 depth bits.\n  [GL.DEPTH_COMPONENT24]: {gl2: true, bpp: 3},\n  [GL.DEPTH_COMPONENT32F]: {gl2: true, bpp: 4},\n\n  [GL.STENCIL_INDEX8]: {bpp: 1}, // 8 stencil bits.\n\n  [GL.DEPTH_STENCIL]: {bpp: 4},\n  [GL.DEPTH24_STENCIL8]: {gl2: true, bpp: 4},\n  [GL.DEPTH32F_STENCIL8]: {gl2: true, bpp: 5},\n\n  // When using a WebGL 1 context, color renderbuffer formats are limited\n  [GL.RGBA4]: {bpp: 2},\n  [GL.RGB565]: {bpp: 2},\n  [GL.RGB5_A1]: {bpp: 2},\n\n  // When using a WebGL 2 context, the following values are available additionally:\n  [GL.R8]: {gl2: true, bpp: 1},\n  [GL.R8UI]: {gl2: true, bpp: 1},\n  [GL.R8I]: {gl2: true, bpp: 1},\n  [GL.R16UI]: {gl2: true, bpp: 2},\n  [GL.R16I]: {gl2: true, bpp: 2},\n  [GL.R32UI]: {gl2: true, bpp: 4},\n  [GL.R32I]: {gl2: true, bpp: 4},\n  [GL.RG8]: {gl2: true, bpp: 2},\n  [GL.RG8UI]: {gl2: true, bpp: 2},\n  [GL.RG8I]: {gl2: true, bpp: 2},\n  [GL.RG16UI]: {gl2: true, bpp: 4},\n  [GL.RG16I]: {gl2: true, bpp: 4},\n  [GL.RG32UI]: {gl2: true, bpp: 8},\n  [GL.RG32I]: {gl2: true, bpp: 8},\n  [GL.RGB8]: {gl2: true, bpp: 3},\n  [GL.RGBA8]: {gl2: true, bpp: 4},\n  // [GL.SRGB8_ALPHA8]: {gl2: true, gl1: SRGB}, // When using the EXT_sRGB WebGL1 extension\n  [GL.RGB10_A2]: {gl2: true, bpp: 4},\n  [GL.RGBA8UI]: {gl2: true, bpp: 4},\n  [GL.RGBA8I]: {gl2: true, bpp: 4},\n  [GL.RGB10_A2UI]: {gl2: true, bpp: 4},\n  [GL.RGBA16UI]: {gl2: true, bpp: 8},\n  [GL.RGBA16I]: {gl2: true, bpp: 8},\n  [GL.RGBA32I]: {gl2: true, bpp: 16},\n  [GL.RGBA32UI]: {gl2: true, bpp: 16},\n\n  // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension\n  [GL.R16F]: {gl2: EXT_FLOAT_WEBGL2, bpp: 2},\n  [GL.RG16F]: {gl2: EXT_FLOAT_WEBGL2, bpp: 4},\n  [GL.RGBA16F]: {gl2: EXT_FLOAT_WEBGL2, bpp: 8},\n  [GL.R32F]: {gl2: EXT_FLOAT_WEBGL2, bpp: 4},\n  [GL.RG32F]: {gl2: EXT_FLOAT_WEBGL2, bpp: 8},\n  // TODO - can't get WEBGL_color_buffer_float to work on renderbuffers\n  [GL.RGBA32F]: {gl2: EXT_FLOAT_WEBGL2, bpp: 16},\n  // [GL.RGBA32F]: {gl2: EXT_FLOAT_WEBGL2, gl1: EXT_FLOAT_WEBGL1},\n  [GL.R11F_G11F_B10F]: {gl2: EXT_FLOAT_WEBGL2, bpp: 4}\n};\n","import {assertWebGL2Context, withParameters} from '@luma.gl/gltools';\nimport {assert} from '../utils/assert';\n\n// Should collapse during minification\nconst GL_DEPTH_BUFFER_BIT = 0x00000100;\nconst GL_STENCIL_BUFFER_BIT = 0x00000400;\nconst GL_COLOR_BUFFER_BIT = 0x00004000;\n\nconst GL_COLOR = 0x1800;\nconst GL_DEPTH = 0x1801;\nconst GL_STENCIL = 0x1802;\nconst GL_DEPTH_STENCIL = 0x84f9;\n\n// Should disappear if asserts are removed\nconst ERR_ARGUMENTS = 'clear: bad arguments';\n\n// Optionally clears depth, color and stencil buffers\n/** @type {import('./clear').clear} */\nexport function clear(gl, {framebuffer = null, color = null, depth = null, stencil = null} = {}) {\n  const parameters = {};\n\n  if (framebuffer) {\n    parameters.framebuffer = framebuffer;\n  }\n\n  let clearFlags = 0;\n\n  if (color) {\n    clearFlags |= GL_COLOR_BUFFER_BIT;\n    if (color !== true) {\n      parameters.clearColor = color;\n    }\n  }\n\n  if (depth) {\n    clearFlags |= GL_DEPTH_BUFFER_BIT;\n    if (depth !== true) {\n      parameters.clearDepth = depth;\n    }\n  }\n\n  if (stencil) {\n    clearFlags |= GL_STENCIL_BUFFER_BIT;\n    if (depth !== true) {\n      parameters.clearStencil = depth;\n    }\n  }\n\n  assert(clearFlags !== 0, ERR_ARGUMENTS);\n\n  // Temporarily set any clear \"colors\" and call clear\n  withParameters(gl, parameters, () => {\n    gl.clear(clearFlags);\n  });\n}\n\n// WebGL2 - clear a specific drawing buffer\n/** @type {import('./clear').clearBuffer} */\nexport function clearBuffer(\n  gl,\n  {framebuffer = null, buffer = GL_COLOR, drawBuffer = 0, value = [0, 0, 0, 0]} = {}\n) {\n  assertWebGL2Context(gl);\n\n  withParameters(gl, {framebuffer}, () => {\n    // Method selection per OpenGL ES 3 docs\n    switch (buffer) {\n      case GL_COLOR:\n        switch (value.constructor) {\n          case Int32Array:\n            gl.clearBufferiv(buffer, drawBuffer, value);\n            break;\n          case Uint32Array:\n            gl.clearBufferuiv(buffer, drawBuffer, value);\n            break;\n          case Float32Array:\n          default:\n            gl.clearBufferfv(buffer, drawBuffer, value);\n        }\n        break;\n\n      case GL_DEPTH:\n        gl.clearBufferfv(GL_DEPTH, 0, [value]);\n        break;\n\n      case GL_STENCIL:\n        gl.clearBufferiv(GL_STENCIL, 0, [value]);\n        break;\n\n      case GL_DEPTH_STENCIL:\n        const [depth, stencil] = value;\n        gl.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil);\n        break;\n\n      default:\n        assert(false, ERR_ARGUMENTS);\n    }\n  });\n}\n","import GL from '@luma.gl/constants';\nimport Buffer from './buffer';\nimport Framebuffer from './framebuffer';\nimport Texture from './texture';\nimport {assertWebGL2Context, withParameters, log} from '@luma.gl/gltools';\nimport {flipRows, scalePixels} from '../webgl-utils/typed-array-utils';\nimport {getTypedArrayFromGLType, getGLTypeFromTypedArray} from '../webgl-utils/typed-array-utils';\nimport {glFormatToComponents, glTypeToBytes} from '../webgl-utils/format-utils';\nimport {toFramebuffer} from '../webgl-utils/texture-utils';\nimport {assert} from '../utils/assert';\n\n// NOTE: Slow requires roundtrip to GPU\n// Copies data from a Framebuffer or a Texture object into ArrayBuffer object.\n// App can provide targetPixelArray or have it auto allocated by this method\n// @returns {Uint8Array|Uint16Array|FloatArray} - pixel array,\n//  newly allocated by this method unless provided by app.\nexport function readPixelsToArray(source, options = {}) {\n  const {sourceX = 0, sourceY = 0, sourceFormat = GL.RGBA} = options;\n  let {\n    sourceAttachment = GL.COLOR_ATTACHMENT0, // TODO - support gl.readBuffer\n    target = null,\n    // following parameters are auto deduced if not provided\n    sourceWidth,\n    sourceHeight,\n    sourceType\n  } = options;\n\n  const {framebuffer, deleteFramebuffer} = getFramebuffer(source);\n  assert(framebuffer);\n  const {gl, handle, attachments} = framebuffer;\n  sourceWidth = sourceWidth || framebuffer.width;\n  sourceHeight = sourceHeight || framebuffer.height;\n\n  // TODO - Set and unset gl.readBuffer\n  if (sourceAttachment === GL.COLOR_ATTACHMENT0 && handle === null) {\n    sourceAttachment = GL.FRONT;\n  }\n\n  assert(attachments[sourceAttachment]);\n\n  // Deduce the type from color attachment if not provided.\n  sourceType = sourceType || attachments[sourceAttachment].type;\n\n  // Deduce type and allocated pixelArray if needed\n  target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);\n\n  // Pixel array available, if necessary, deduce type from it.\n  sourceType = sourceType || getGLTypeFromTypedArray(target);\n\n  const prevHandle = gl.bindFramebuffer(GL.FRAMEBUFFER, handle);\n  gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);\n  // @ts-ignore\n  gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);\n  if (deleteFramebuffer) {\n    framebuffer.delete();\n  }\n  return target;\n}\n\n// NOTE: doesn't wait for copy to be complete, it programs GPU to perform a DMA transffer.\n// Copies data from a Framebuffer or a Texture object into a Buffer object.\nexport function readPixelsToBuffer(\n  source,\n  {\n    sourceX = 0,\n    sourceY = 0,\n    sourceFormat = GL.RGBA,\n    target = null, // A new Buffer object is created when not provided.\n    targetByteOffset = 0, // byte offset in buffer object\n    // following parameters are auto deduced if not provided\n    sourceWidth,\n    sourceHeight,\n    sourceType\n  }\n) {\n  const {framebuffer, deleteFramebuffer} = getFramebuffer(source);\n  assert(framebuffer);\n  sourceWidth = sourceWidth || framebuffer.width;\n  sourceHeight = sourceHeight || framebuffer.height;\n\n  // Asynchronus read (PIXEL_PACK_BUFFER) is WebGL2 only feature\n  const gl2 = assertWebGL2Context(framebuffer.gl);\n\n  // deduce type if not available.\n  sourceType = sourceType || (target ? target.type : GL.UNSIGNED_BYTE);\n\n  if (!target) {\n    // Create new buffer with enough size\n    const components = glFormatToComponents(sourceFormat);\n    const byteCount = glTypeToBytes(sourceType);\n    const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;\n    target = new Buffer(gl2, {byteLength, accessor: {type: sourceType, size: components}});\n  }\n\n  target.bind({target: GL.PIXEL_PACK_BUFFER});\n  withParameters(gl2, {framebuffer}, () => {\n    gl2.readPixels(\n      sourceX,\n      sourceY,\n      sourceWidth,\n      sourceHeight,\n      sourceFormat,\n      sourceType,\n      targetByteOffset\n    );\n  });\n  target.unbind({target: GL.PIXEL_PACK_BUFFER});\n  if (deleteFramebuffer) {\n    framebuffer.delete();\n  }\n\n  return target;\n}\n\n// Reads pixels from a Framebuffer or Texture object to a dataUrl\nexport function copyToDataUrl(\n  source,\n  {\n    sourceAttachment = GL.COLOR_ATTACHMENT0, // TODO - support gl.readBuffer\n    targetMaxHeight = Number.MAX_SAFE_INTEGER\n  } = {}\n) {\n  let data = readPixelsToArray(source, {sourceAttachment});\n\n  // Scale down\n  let {width, height} = source;\n  while (height > targetMaxHeight) {\n    ({data, width, height} = scalePixels({data, width, height}));\n  }\n\n  // Flip to top down coordinate system\n  flipRows({data, width, height});\n\n  const canvas = document.createElement('canvas');\n  canvas.width = width;\n  canvas.height = height;\n  const context = canvas.getContext('2d');\n\n  // Copy the pixels to a 2D canvas\n  const imageData = context.createImageData(width, height);\n  imageData.data.set(data);\n  context.putImageData(imageData, 0, 0);\n\n  return canvas.toDataURL();\n}\n\n// Reads pixels from a Framebuffer or Texture object into an HTML Image\nexport function copyToImage(\n  source,\n  {\n    sourceAttachment = GL.COLOR_ATTACHMENT0, // TODO - support gl.readBuffer\n    targetImage = null\n  } = {}\n) {\n  const dataUrl = copyToDataUrl(source, {sourceAttachment});\n  targetImage = targetImage || new Image();\n  targetImage.src = dataUrl;\n  return targetImage;\n}\n\n// Copy a rectangle from a Framebuffer or Texture object into a texture (at an offset)\n// eslint-disable-next-line complexity, max-statements\nexport function copyToTexture(source, target, options = {}) {\n  const {\n    sourceX = 0,\n    sourceY = 0,\n    // attachment = GL.COLOR_ATTACHMENT0, // TODO - support gl.readBuffer\n    targetMipmaplevel = 0,\n    targetInternalFormat = GL.RGBA\n  } = options;\n  let {\n    targetX,\n    targetY,\n    targetZ,\n    width, // defaults to target width\n    height // defaults to target height\n  } = options;\n\n  const {framebuffer, deleteFramebuffer} = getFramebuffer(source);\n  assert(framebuffer);\n  const {gl, handle} = framebuffer;\n  const isSubCopy =\n    typeof targetX !== 'undefined' ||\n    typeof targetY !== 'undefined' ||\n    typeof targetZ !== 'undefined';\n  targetX = targetX || 0;\n  targetY = targetY || 0;\n  targetZ = targetZ || 0;\n  const prevHandle = gl.bindFramebuffer(GL.FRAMEBUFFER, handle);\n  // TODO - support gl.readBuffer (WebGL2 only)\n  // const prevBuffer = gl.readBuffer(attachment);\n  assert(target);\n  let texture = null;\n  if (target instanceof Texture) {\n    texture = target;\n    width = Number.isFinite(width) ? width : texture.width;\n    height = Number.isFinite(height) ? height : texture.height;\n    texture.bind(0);\n    target = texture.target;\n  }\n\n  if (!isSubCopy) {\n    gl.copyTexImage2D(\n      target,\n      targetMipmaplevel,\n      targetInternalFormat,\n      sourceX,\n      sourceY,\n      width,\n      height,\n      0 /* border must be 0 */\n    );\n  } else {\n    switch (target) {\n      case GL.TEXTURE_2D:\n      case GL.TEXTURE_CUBE_MAP:\n        gl.copyTexSubImage2D(\n          target,\n          targetMipmaplevel,\n          targetX,\n          targetY,\n          sourceX,\n          sourceY,\n          width,\n          height\n        );\n        break;\n      case GL.TEXTURE_2D_ARRAY:\n      case GL.TEXTURE_3D:\n        const gl2 = assertWebGL2Context(gl);\n        gl2.copyTexSubImage3D(\n          target,\n          targetMipmaplevel,\n          targetX,\n          targetY,\n          targetZ,\n          sourceX,\n          sourceY,\n          width,\n          height\n        );\n        break;\n      default:\n    }\n  }\n  if (texture) {\n    texture.unbind();\n  }\n  // @ts-ignore\n  gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);\n  if (deleteFramebuffer) {\n    framebuffer.delete();\n  }\n  return texture;\n}\n\n// NOTE: WEBLG2 only\n// Copies a rectangle of pixels between Framebuffer or Texture objects\n// eslint-disable-next-line max-statements, complexity\nexport function blit(source, target, options = {}) {\n  const {\n    sourceX0 = 0,\n    sourceY0 = 0,\n    targetX0 = 0,\n    targetY0 = 0,\n    color = true,\n    depth = false,\n    stencil = false,\n    filter = GL.NEAREST\n  } = options;\n\n  let {\n    sourceX1,\n    sourceY1,\n    targetX1,\n    targetY1,\n    sourceAttachment = GL.COLOR_ATTACHMENT0,\n    mask = 0\n  } = options;\n\n  const {framebuffer: srcFramebuffer, deleteFramebuffer: deleteSrcFramebuffer} = getFramebuffer(\n    source\n  );\n  const {framebuffer: dstFramebuffer, deleteFramebuffer: deleteDstFramebuffer} = getFramebuffer(\n    target\n  );\n\n  assert(srcFramebuffer);\n  assert(dstFramebuffer);\n  // @ts-ignore\n  const {gl, handle, width, height, readBuffer} = dstFramebuffer;\n  const gl2 = assertWebGL2Context(gl);\n\n  if (!srcFramebuffer.handle && sourceAttachment === GL.COLOR_ATTACHMENT0) {\n    sourceAttachment = GL.FRONT;\n  }\n\n  if (color) {\n    mask |= GL.COLOR_BUFFER_BIT;\n  }\n  if (depth) {\n    mask |= GL.DEPTH_BUFFER_BIT;\n  }\n  if (stencil) {\n    mask |= GL.STENCIL_BUFFER_BIT;\n  }\n\n  if (deleteSrcFramebuffer || deleteDstFramebuffer) {\n    // Either source or destiantion was a texture object, which is wrapped in a Framebuffer objecgt as color attachment.\n    // Overwrite the mask to `COLOR_BUFFER_BIT`\n    if (mask & (GL.DEPTH_BUFFER_BIT | GL.STENCIL_BUFFER_BIT)) {\n      mask = GL.COLOR_BUFFER_BIT;\n      log.warn('Blitting from or into a Texture object, forcing mask to GL.COLOR_BUFFER_BIT')();\n    }\n  }\n  assert(mask);\n\n  sourceX1 = sourceX1 === undefined ? srcFramebuffer.width : sourceX1;\n  sourceY1 = sourceY1 === undefined ? srcFramebuffer.height : sourceY1;\n  targetX1 = targetX1 === undefined ? width : targetX1;\n  targetY1 = targetY1 === undefined ? height : targetY1;\n\n  const prevDrawHandle = gl.bindFramebuffer(GL.DRAW_FRAMEBUFFER, handle);\n  const prevReadHandle = gl.bindFramebuffer(GL.READ_FRAMEBUFFER, srcFramebuffer.handle);\n  gl2.readBuffer(sourceAttachment);\n  gl2.blitFramebuffer(\n    sourceX0,\n    sourceY0,\n    sourceX1,\n    sourceY1,\n    targetX0,\n    targetY0,\n    targetX1,\n    targetY1,\n    mask,\n    filter\n  );\n  gl2.readBuffer(readBuffer);\n  // @ts-ignore\n  gl2.bindFramebuffer(GL.READ_FRAMEBUFFER, prevReadHandle || null);\n  // @ts-ignore\n  gl2.bindFramebuffer(GL.DRAW_FRAMEBUFFER, prevDrawHandle || null);\n  if (deleteSrcFramebuffer) {\n    srcFramebuffer.delete();\n  }\n  if (deleteDstFramebuffer) {\n    dstFramebuffer.delete();\n  }\n\n  return dstFramebuffer;\n}\n\n// Helper methods\n\nfunction getFramebuffer(source) {\n  if (!(source instanceof Framebuffer)) {\n    return {framebuffer: toFramebuffer(source), deleteFramebuffer: true};\n  }\n  return {framebuffer: source, deleteFramebuffer: false};\n}\n\nfunction getPixelArray(pixelArray, type, format, width, height) {\n  if (pixelArray) {\n    return pixelArray;\n  }\n  // Allocate pixel array if not already available, using supplied type\n  type = type || GL.UNSIGNED_BYTE;\n  const ArrayType = getTypedArrayFromGLType(type, {clamped: false});\n  const components = glFormatToComponents(format);\n  // TODO - check for composite type (components = 1).\n  return new ArrayType(width * height * components);\n}\n","import GL from '@luma.gl/constants';\nimport {assert} from '../utils/assert';\n\n// Returns number of components in a specific readPixels WebGL format\nexport function glFormatToComponents(format) {\n  switch (format) {\n    case GL.ALPHA:\n    case GL.R32F:\n    case GL.RED:\n      return 1;\n    case GL.RG32F:\n    case GL.RG:\n      return 2;\n    case GL.RGB:\n    case GL.RGB32F:\n      return 3;\n    case GL.RGBA:\n    case GL.RGBA32F:\n      return 4;\n    // TODO: Add support for additional WebGL2 formats\n    default:\n      assert(false);\n      return 0;\n  }\n}\n\n// Return byte count for given readPixels WebGL type\nexport function glTypeToBytes(type) {\n  switch (type) {\n    case GL.UNSIGNED_BYTE:\n      return 1;\n    case GL.UNSIGNED_SHORT_5_6_5:\n    case GL.UNSIGNED_SHORT_4_4_4_4:\n    case GL.UNSIGNED_SHORT_5_5_5_1:\n      return 2;\n    case GL.FLOAT:\n      return 4;\n    // TODO: Add support for additional WebGL2 types\n    default:\n      assert(false);\n      return 0;\n  }\n}\n","export {getContextInfo, getGLContextInfo, getContextLimits} from './limits';\nexport {FEATURES} from './webgl-features-table';\nexport {hasFeature, hasFeatures, getFeatures} from './features';\n\nexport {default as canCompileGLGSExtension} from './check-glsl-extension';\n","import GL from '@luma.gl/constants';\n\nimport WEBGL_LIMITS from './webgl-limits-table';\nimport {isWebGL2, getContextDebugInfo} from '@luma.gl/gltools';\n\nexport function getContextLimits(gl) {\n  gl.luma = gl.luma || {};\n\n  if (!gl.luma.limits) {\n    gl.luma.limits = {};\n    gl.luma.webgl1MinLimits = {};\n    gl.luma.webgl2MinLimits = {};\n\n    const isWebgl2 = isWebGL2(gl);\n\n    // WEBGL limits\n    for (const parameter in WEBGL_LIMITS) {\n      const limit = WEBGL_LIMITS[parameter];\n\n      const webgl1MinLimit = limit.gl1;\n      const webgl2MinLimit = 'gl2' in limit ? limit.gl2 : limit.gl1;\n      const minLimit = isWebgl2 ? webgl2MinLimit : webgl1MinLimit;\n\n      // Check if we can query for this limit\n      const limitNotAvailable =\n        ('gl2' in limit && !isWebgl2) ||\n        // @ts-ignore\n        ('extension' in limit && !gl.getExtension(limit.extension));\n\n      const value = limitNotAvailable ? minLimit : gl.getParameter(parameter);\n      gl.luma.limits[parameter] = value;\n      gl.luma.webgl1MinLimits[parameter] = webgl1MinLimit;\n      gl.luma.webgl2MinLimits[parameter] = webgl2MinLimit;\n    }\n  }\n\n  return gl.luma.limits;\n}\n\nexport function getGLContextInfo(gl) {\n  gl.luma = gl.luma || {};\n\n  const info = getContextDebugInfo(gl);\n  if (!gl.luma.info) {\n    gl.luma.info = {\n      [GL.UNMASKED_VENDOR_WEBGL]: info.vendor,\n      [GL.UNMASKED_RENDERER_WEBGL]: info.renderer,\n      [GL.VENDOR]: info.vendorMasked,\n      [GL.RENDERER]: info.rendererMasked,\n      [GL.VERSION]: info.version,\n      [GL.SHADING_LANGUAGE_VERSION]: info.shadingLanguageVersion\n    };\n  }\n\n  return gl.luma.info;\n}\n\nexport function getContextInfo(gl) {\n  return Object.assign(getContextDebugInfo(gl), {\n    limits: getContextLimits(gl),\n    info: getGLContextInfo(gl),\n    webgl1MinLimits: gl.luma.webgl1MinLimits,\n    webgl2MinLimits: gl.luma.webgl2MinLimits\n  });\n}\n","import GL from '@luma.gl/constants';\n\nexport default {\n  [GL.ALIASED_LINE_WIDTH_RANGE]: {gl1: new Float32Array([1, 1])},\n  [GL.ALIASED_POINT_SIZE_RANGE]: {gl1: new Float32Array([1, 1])},\n  [GL.MAX_TEXTURE_SIZE]: {gl1: 64, gl2: 2048}, // GLint\n  [GL.MAX_CUBE_MAP_TEXTURE_SIZE]: {gl1: 16}, // GLint\n  [GL.MAX_TEXTURE_IMAGE_UNITS]: {gl1: 8}, // GLint\n  [GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: {gl1: 8}, // GLint\n  [GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: {gl1: 0}, // GLint\n  [GL.MAX_RENDERBUFFER_SIZE]: {gl1: 1}, // GLint\n  [GL.MAX_VARYING_VECTORS]: {gl1: 8}, // GLint\n  [GL.MAX_VERTEX_ATTRIBS]: {gl1: 8}, // GLint\n  [GL.MAX_VERTEX_UNIFORM_VECTORS]: {gl1: 128}, // GLint\n  [GL.MAX_FRAGMENT_UNIFORM_VECTORS]: {gl1: 16}, // GLint\n  [GL.MAX_VIEWPORT_DIMS]: {gl1: new Int32Array([0, 0])},\n\n  // Extensions\n  // [GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: {gl1: 1.0, extension: 'EXT_texture_filter_anisotropic'},\n\n  // WebGL2 Limits\n  [GL.MAX_3D_TEXTURE_SIZE]: {gl1: 0, gl2: 256}, //  GLint\n  [GL.MAX_ARRAY_TEXTURE_LAYERS]: {gl1: 0, gl2: 256}, // GLint\n  [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: {gl1: 0, gl2: 0}, //  GLint64\n  [GL.MAX_COLOR_ATTACHMENTS]: {gl1: 0, gl2: 4}, //  GLint\n  [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: {gl1: 0, gl2: 0}, // GLint64\n  [GL.MAX_COMBINED_UNIFORM_BLOCKS]: {gl1: 0, gl2: 0}, //  GLint\n  [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: {gl1: 0, gl2: 0}, // GLint64\n  [GL.MAX_DRAW_BUFFERS]: {gl1: 0, gl2: 4}, // GLint\n  [GL.MAX_ELEMENT_INDEX]: {gl1: 0, gl2: 0}, //  GLint64\n  [GL.MAX_ELEMENTS_INDICES]: {gl1: 0, gl2: 0}, // GLint\n  [GL.MAX_ELEMENTS_VERTICES]: {gl1: 0, gl2: 0}, //  GLint\n  [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: {gl1: 0, gl2: 0}, //  GLint\n  [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: {gl1: 0, gl2: 0}, //  GLint\n  [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: {gl1: 0, gl2: 0}, //  GLint\n  [GL.MAX_SAMPLES]: {gl1: 0, gl2: 0}, //  GLint\n  [GL.MAX_SERVER_WAIT_TIMEOUT]: {gl1: 0, gl2: 0}, //  GLint64\n  [GL.MAX_TEXTURE_LOD_BIAS]: {gl1: 0, gl2: 0}, // GLfloat\n  [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: {gl1: 0, gl2: 0}, //  GLint\n  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: {gl1: 0, gl2: 0}, //  GLint\n  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: {gl1: 0, gl2: 0}, // GLint\n  [GL.MAX_UNIFORM_BLOCK_SIZE]: {gl1: 0, gl2: 0}, // GLint64\n  [GL.MAX_UNIFORM_BUFFER_BINDINGS]: {gl1: 0, gl2: 0}, //  GLint\n  [GL.MAX_VARYING_COMPONENTS]: {gl1: 0, gl2: 0}, // GLint\n  [GL.MAX_VERTEX_OUTPUT_COMPONENTS]: {gl1: 0, gl2: 0}, // GLint\n  [GL.MAX_VERTEX_UNIFORM_BLOCKS]: {gl1: 0, gl2: 0}, //  GLint\n  [GL.MAX_VERTEX_UNIFORM_COMPONENTS]: {gl1: 0, gl2: 0}, //  GLint\n  [GL.MIN_PROGRAM_TEXEL_OFFSET]: {gl1: 0, gl2: -8, negative: true}, // GLint\n  [GL.MAX_PROGRAM_TEXEL_OFFSET]: {gl1: 0, gl2: 7}, // GLint\n  [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: {gl1: 0, gl2: 0} // GLint\n};\n","import Framebuffer from '../classes/framebuffer';\nimport Texture2D from '../classes/texture-2d';\n// TODO - this should be the default export, test cases need updating\nexport const FEATURES = {\n  WEBGL2: 'WEBGL2',\n\n  // API SUPPORT\n  VERTEX_ARRAY_OBJECT: 'VERTEX_ARRAY_OBJECT',\n  TIMER_QUERY: 'TIMER_QUERY',\n  INSTANCED_RENDERING: 'INSTANCED_RENDERING',\n  MULTIPLE_RENDER_TARGETS: 'MULTIPLE_RENDER_TARGETS',\n\n  // FEATURES\n  ELEMENT_INDEX_UINT32: 'ELEMENT_INDEX_UINT32',\n\n  // BLENDING\n  BLEND_EQUATION_MINMAX: 'BLEND_EQUATION_MINMAX',\n  FLOAT_BLEND: 'FLOAT_BLEND',\n\n  // TEXTURES: '// TEXTURES', RENDERBUFFERS\n  COLOR_ENCODING_SRGB: 'COLOR_ENCODING_SRGB',\n\n  // TEXTURES\n  TEXTURE_DEPTH: 'TEXTURE_DEPTH',\n  TEXTURE_FLOAT: 'TEXTURE_FLOAT',\n  TEXTURE_HALF_FLOAT: 'TEXTURE_HALF_FLOAT',\n\n  TEXTURE_FILTER_LINEAR_FLOAT: 'TEXTURE_FILTER_LINEAR_FLOAT',\n  TEXTURE_FILTER_LINEAR_HALF_FLOAT: 'TEXTURE_FILTER_LINEAR_HALF_FLOAT',\n  TEXTURE_FILTER_ANISOTROPIC: 'TEXTURE_FILTER_ANISOTROPIC',\n\n  // FRAMEBUFFERS: '// FRAMEBUFFERS', TEXTURES AND RENDERBUFFERS\n  COLOR_ATTACHMENT_RGBA32F: 'COLOR_ATTACHMENT_RGBA32F',\n  COLOR_ATTACHMENT_FLOAT: 'COLOR_ATTACHMENT_FLOAT',\n  COLOR_ATTACHMENT_HALF_FLOAT: 'COLOR_ATTACHMENT_HALF_FLOAT',\n\n  // GLSL extensions\n  GLSL_FRAG_DATA: 'GLSL_FRAG_DATA',\n  GLSL_FRAG_DEPTH: 'GLSL_FRAG_DEPTH',\n  GLSL_DERIVATIVES: 'GLSL_DERIVATIVES',\n  GLSL_TEXTURE_LOD: 'GLSL_TEXTURE_LOD'\n};\n\n// function to test if Float 32 bit format texture can be bound as color attachment\nfunction checkFloat32ColorAttachment(gl) {\n  const testTexture = new Texture2D(gl, {\n    format: gl.RGBA,\n    type: gl.FLOAT,\n    dataFormat: gl.RGBA\n  });\n  const testFb = new Framebuffer(gl, {\n    id: `test-framebuffer`,\n    check: false,\n    attachments: {\n      [gl.COLOR_ATTACHMENT0]: testTexture\n    }\n  });\n  const status = testFb.getStatus();\n  testTexture.delete();\n  testFb.delete();\n  return status === gl.FRAMEBUFFER_COMPLETE;\n}\n\n// Defines luma.gl \"feature\" names and semantics\n// Format: 'feature-name: [WebGL1 support, WebGL2 support] / [WebGL1 and WebGL2 support]', when support is 'string' it is the name of the extension\nexport default {\n  [FEATURES.WEBGL2]: [false, true],\n\n  // API SUPPORT\n  [FEATURES.VERTEX_ARRAY_OBJECT]: ['OES_vertex_array_object', true],\n  [FEATURES.TIMER_QUERY]: ['EXT_disjoint_timer_query', 'EXT_disjoint_timer_query_webgl2'],\n  [FEATURES.INSTANCED_RENDERING]: ['ANGLE_instanced_arrays', true],\n  [FEATURES.MULTIPLE_RENDER_TARGETS]: ['WEBGL_draw_buffers', true],\n\n  // FEATURES\n  [FEATURES.ELEMENT_INDEX_UINT32]: ['OES_element_index_uint', true],\n\n  // BLENDING\n  [FEATURES.BLEND_EQUATION_MINMAX]: ['EXT_blend_minmax', true],\n  [FEATURES.FLOAT_BLEND]: ['EXT_float_blend'],\n\n  // TEXTURES, RENDERBUFFERS\n  [FEATURES.COLOR_ENCODING_SRGB]: ['EXT_sRGB', true],\n\n  // TEXTURES\n  [FEATURES.TEXTURE_DEPTH]: ['WEBGL_depth_texture', true],\n  [FEATURES.TEXTURE_FLOAT]: ['OES_texture_float', true],\n  [FEATURES.TEXTURE_HALF_FLOAT]: ['OES_texture_half_float', true],\n\n  [FEATURES.TEXTURE_FILTER_LINEAR_FLOAT]: ['OES_texture_float_linear'],\n  [FEATURES.TEXTURE_FILTER_LINEAR_HALF_FLOAT]: ['OES_texture_half_float_linear'],\n  [FEATURES.TEXTURE_FILTER_ANISOTROPIC]: ['EXT_texture_filter_anisotropic'],\n\n  // FRAMEBUFFERS, TEXTURES AND RENDERBUFFERS\n  [FEATURES.COLOR_ATTACHMENT_RGBA32F]: [checkFloat32ColorAttachment, 'EXT_color_buffer_float'],\n  [FEATURES.COLOR_ATTACHMENT_FLOAT]: [false, 'EXT_color_buffer_float'],\n  [FEATURES.COLOR_ATTACHMENT_HALF_FLOAT]: ['EXT_color_buffer_half_float'],\n\n  // GLSL extensions\n  [FEATURES.GLSL_FRAG_DATA]: ['WEBGL_draw_buffers', true],\n  [FEATURES.GLSL_FRAG_DEPTH]: ['EXT_frag_depth', true],\n  [FEATURES.GLSL_DERIVATIVES]: ['OES_standard_derivatives', true],\n  [FEATURES.GLSL_TEXTURE_LOD]: ['EXT_shader_texture_lod', true]\n};\n","// Feature detection for WebGL\n//\n// Provides a function that enables simple checking of which WebGL features are\n// available in an WebGL1 or WebGL2 environment.\n\nimport WEBGL_FEATURES from './webgl-features-table';\nimport {isWebGL2, log} from '@luma.gl/gltools';\nimport {assert} from '../utils/assert';\n\nconst LOG_UNSUPPORTED_FEATURE = 2;\n\n// Check one feature\nexport function hasFeature(gl, feature) {\n  return hasFeatures(gl, feature);\n}\n\n// Check one or more features\nexport function hasFeatures(gl, features) {\n  features = Array.isArray(features) ? features : [features];\n  return features.every(feature => {\n    return isFeatureSupported(gl, feature);\n  });\n}\n\n// Return a list of supported features\nexport function getFeatures(gl) {\n  gl.luma = gl.luma || {};\n  gl.luma.caps = gl.luma.caps || {};\n  for (const cap in WEBGL_FEATURES) {\n    if (gl.luma.caps[cap] === undefined) {\n      gl.luma.caps[cap] = isFeatureSupported(gl, cap);\n    }\n  }\n  return gl.luma.caps;\n}\n\n// TODO - cache the value\nfunction isFeatureSupported(gl, cap) {\n  gl.luma = gl.luma || {};\n  gl.luma.caps = gl.luma.caps || {};\n\n  if (gl.luma.caps[cap] === undefined) {\n    gl.luma.caps[cap] = queryFeature(gl, cap);\n  }\n\n  if (!gl.luma.caps[cap]) {\n    log.log(LOG_UNSUPPORTED_FEATURE, `Feature: ${cap} not supported`)();\n  }\n\n  return gl.luma.caps[cap];\n}\n\nfunction queryFeature(gl, cap) {\n  const feature = WEBGL_FEATURES[cap];\n  assert(feature, cap);\n\n  let isSupported;\n\n  // Get extension name from table\n  const featureDefinition = isWebGL2(gl) ? feature[1] || feature[0] : feature[0];\n\n  // Check if the value is dependent on checking one or more extensions\n  if (typeof featureDefinition === 'function') {\n    isSupported = featureDefinition(gl);\n  } else if (Array.isArray(featureDefinition)) {\n    isSupported = true;\n    for (const extension of featureDefinition) {\n      isSupported = isSupported && Boolean(gl.getExtension(extension));\n    }\n  } else if (typeof featureDefinition === 'string') {\n    isSupported = Boolean(gl.getExtension(featureDefinition));\n  } else if (typeof featureDefinition === 'boolean') {\n    isSupported = featureDefinition;\n  } else {\n    assert(false);\n  }\n\n  return isSupported;\n}\n","import isOldIE from './check-old-ie';\nimport WEBGL_FEATURES from './webgl-features-table';\nimport {assert} from '../utils/assert';\n\n// Enables feature detection in IE11 due to a bug where gl.getExtension may return true\n// but fail to compile when the extension is enabled in the shader. Specifically,\n// the OES_standard_derivatives extension fails to compile in IE11 even though its included\n// in the list of supported extensions.\nconst compiledGlslExtensions = {};\n\n// options allows user agent to be overridden for testing\nexport default function canCompileGLGSExtension(gl, cap, options = {}) {\n  const feature = WEBGL_FEATURES[cap];\n  assert(feature, cap);\n\n  if (!isOldIE(options)) {\n    return true;\n  }\n\n  if (cap in compiledGlslExtensions) {\n    return compiledGlslExtensions[cap];\n  }\n\n  const extensionName = feature[0];\n  const source = `#extension GL_${extensionName} : enable\\nvoid main(void) {}`;\n\n  const shader = gl.createShader(gl.VERTEX_SHADER);\n  gl.shaderSource(shader, source);\n  gl.compileShader(shader);\n  const canCompile = gl.getShaderParameter(shader, gl.COMPILE_STATUS);\n  gl.deleteShader(shader);\n  compiledGlslExtensions[cap] = canCompile;\n  return canCompile;\n}\n","// opts allows user agent to be overridden for testing\nexport default function isOldIE(opts = {}) {\n  const navigator = (typeof window !== 'undefined' && window.navigator) || {};\n  // @ts-ignore\n  const userAgent = opts.userAgent || navigator.userAgent || '';\n  // We only care about older versions of IE (IE 11 and below). Newer versions of IE (Edge)\n  // have much better web standards support.\n  const isMSIE = userAgent.indexOf('MSIE ') !== -1;\n  const isTrident = userAgent.indexOf('Trident/') !== -1;\n  return isMSIE || isTrident;\n}\n","import GL from '@luma.gl/constants';\nimport {assertWebGLContext, log} from '@luma.gl/gltools';\nimport {parseGLSLCompilerError, getShaderName} from '../glsl-utils';\nimport {assert} from '../utils/assert';\nimport {uid} from '../utils/utils';\nimport Resource from './resource';\n\nconst ERR_SOURCE = 'Shader: GLSL source code must be a JavaScript string';\n\n// For now this is an internal class\nexport class Shader extends Resource {\n  static getTypeName(shaderType) {\n    switch (shaderType) {\n      case GL.VERTEX_SHADER:\n        return 'vertex-shader';\n      case GL.FRAGMENT_SHADER:\n        return 'fragment-shader';\n      default:\n        assert(false);\n        return 'unknown';\n    }\n  }\n\n  /* eslint-disable max-statements */\n  constructor(gl, props) {\n    assertWebGLContext(gl);\n\n    // Validate arguments\n    assert(typeof props.source === 'string', ERR_SOURCE);\n\n    // Deduce an id, from shader source, or supplied id, or shader type\n    const id =\n      getShaderName(props.source, null) ||\n      props.id ||\n      uid(`unnamed ${Shader.getTypeName(props.shaderType)}`);\n\n    super(gl, {id});\n\n    this.shaderType = props.shaderType;\n    this.source = props.source;\n\n    this.initialize(props);\n  }\n\n  initialize({source}) {\n    const shaderName = getShaderName(source, null);\n    if (shaderName) {\n      this.id = uid(shaderName);\n    }\n    this._compile(source);\n  }\n\n  // Accessors\n\n  getParameter(pname) {\n    return this.gl.getShaderParameter(this.handle, pname);\n  }\n\n  toString() {\n    return `${Shader.getTypeName(this.shaderType)}:${this.id}`;\n  }\n\n  getName() {\n    return getShaderName(this.source) || 'unnamed-shader';\n  }\n\n  getSource() {\n    return this.gl.getShaderSource(this.handle);\n  }\n\n  // Debug method - Returns translated source if available\n  getTranslatedSource() {\n    const extension = this.gl.getExtension('WEBGL_debug_shaders');\n    return extension\n      ? extension.getTranslatedShaderSource(this.handle)\n      : 'No translated source available. WEBGL_debug_shaders not implemented';\n  }\n\n  // PRIVATE METHODS\n  _compile(source = this.source) {\n    if (!source.startsWith('#version ')) {\n      source = `#version 100\\n${source}`;\n    }\n    this.source = source;\n    this.gl.shaderSource(this.handle, this.source);\n    this.gl.compileShader(this.handle);\n\n    // TODO - For performance reasons, avoid checking shader compilation errors on production?\n    // TODO - Load log even when no error reported, to catch warnings?\n    // https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings\n    const compileStatus = this.getParameter(GL.COMPILE_STATUS);\n    if (!compileStatus) {\n      const infoLog = this.gl.getShaderInfoLog(this.handle);\n      const {shaderName, errors, warnings} = parseGLSLCompilerError(\n        infoLog,\n        this.source,\n        this.shaderType,\n        this.id\n      );\n      log.error(`GLSL compilation errors in ${shaderName}\\n${errors}`)();\n      log.warn(`GLSL compilation warnings in ${shaderName}\\n${warnings}`)();\n      throw new Error(`GLSL compilation errors in ${shaderName}`);\n    }\n  }\n\n  _deleteHandle() {\n    this.gl.deleteShader(this.handle);\n  }\n\n  _getOptsFromHandle() {\n    return {\n      type: this.getParameter(GL.SHADER_TYPE),\n      source: this.getSource()\n    };\n  }\n}\n\nexport class VertexShader extends Shader {\n  constructor(gl, props) {\n    // Signature: new VertexShader(gl, source)\n    if (typeof props === 'string') {\n      props = {source: props};\n    }\n    super(gl, Object.assign({}, props, {shaderType: GL.VERTEX_SHADER}));\n  }\n\n  // PRIVATE METHODS\n  _createHandle() {\n    return this.gl.createShader(GL.VERTEX_SHADER);\n  }\n}\n\nexport class FragmentShader extends Shader {\n  constructor(gl, props) {\n    // Signature: new FragmentShader(gl, source)\n    if (typeof props === 'string') {\n      props = {source: props};\n    }\n\n    super(gl, Object.assign({}, props, {shaderType: GL.FRAGMENT_SHADER}));\n  }\n\n  // PRIVATE METHODS\n  _createHandle() {\n    return this.gl.createShader(GL.FRAGMENT_SHADER);\n  }\n}\n","// PARSE SHADER ERRORS\nexport {default as formatGLSLCompilerError, parseGLSLCompilerError} from './format-glsl-error';\n\n// PARSE SHADER SOURCE\nexport {default as getShaderName} from './get-shader-name';\nexport {default as getShaderVersion} from './get-shader-version';\n\nexport {default as getShaderTypeName} from './get-shader-type-name';\n","// TODO - formatGLSLCompilerError should not depend on this\nimport getShaderName from './get-shader-name';\nimport getShaderTypeName from './get-shader-type-name';\n\n// Formats GLSL compiler error log into single string\nexport default function formatGLSLCompilerError(errLog, src, shaderType) {\n  const {shaderName, errors, warnings} = parseGLSLCompilerError(errLog, src, shaderType);\n  return `GLSL compilation error in ${shaderName}\\n\\n${errors}\\n${warnings}`;\n}\n\n/**\n * Parse a GLSL compiler error log into a string showing the source code around each error.\n * Based on https://github.com/wwwtyro/gl-format-compiler-error (public domain)\n */\n/* eslint-disable no-continue, max-statements */\nexport function parseGLSLCompilerError(errLog, src, shaderType, shaderName) {\n  const errorStrings = errLog.split(/\\r?\\n/);\n  const errors = {};\n  const warnings = {};\n\n  // Patch the shader name\n  const name = shaderName || getShaderName(src) || '(unnamed)';\n  const shaderDescription = `${getShaderTypeName(shaderType)} shader ${name}`;\n\n  // Parse the error - note: browser and driver dependent\n  for (let i = 0; i < errorStrings.length; i++) {\n    const errorString = errorStrings[i];\n    if (errorString.length <= 1) {\n      continue;\n    }\n    const segments = errorString.split(':');\n    const type = segments[0];\n    const line = parseInt(segments[2], 10);\n    if (isNaN(line)) {\n      throw new Error(`GLSL compilation error in ${shaderDescription}: ${errLog}`);\n    }\n    if (type !== 'WARNING') {\n      errors[line] = errorString;\n    } else {\n      warnings[line] = errorString;\n    }\n  }\n\n  // Format the error inline with the code\n  const lines = addLineNumbers(src);\n\n  return {\n    shaderName: shaderDescription,\n    errors: formatErrors(errors, lines),\n    warnings: formatErrors(warnings, lines)\n  };\n}\n\n// helper function, outputs annotated errors or warnings\nfunction formatErrors(errors, lines) {\n  let message = '';\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i];\n    if (!errors[i + 3] && !errors[i + 2] && !errors[i + 1]) {\n      continue;\n    }\n    message += `${line}\\n`;\n    if (errors[i + 1]) {\n      const error = errors[i + 1];\n      const segments = error.split(':', 3);\n      const type = segments[0];\n      const column = parseInt(segments[1], 10) || 0;\n      const err = error.substring(segments.join(':').length + 1).trim();\n      message += padLeft(`^^^ ${type}: ${err}\\n\\n`, column);\n    }\n  }\n  return message;\n}\n\n/**\n * Prepends line numbers to each line of a string.\n * The line numbers will be left-padded with spaces to ensure an\n * aligned layout when rendered using monospace fonts.\n * @param {String} string - multi-line string to add line numbers to\n * @param {Number} start=1 - number of spaces to add\n * @param {String} delim =': ' - injected between line number and original line\n * @return {String[]} strings - array of string, one per line, with line numbers added\n */\nfunction addLineNumbers(string, start = 1, delim = ': ') {\n  const lines = string.split(/\\r?\\n/);\n  const maxDigits = String(lines.length + start - 1).length;\n  return lines.map((line, i) => {\n    const lineNumber = String(i + start);\n    const digits = lineNumber.length;\n    const prefix = padLeft(lineNumber, maxDigits - digits);\n    return prefix + delim + line;\n  });\n}\n\n/**\n * Pads a string with a number of spaces (space characters) to the left\n * @param {String} string - string to pad\n * @param {Number} digits - number of spaces to add\n * @return {String} string - The padded string\n */\nfunction padLeft(string, digits) {\n  let result = '';\n  for (let i = 0; i < digits; ++i) {\n    result += ' ';\n  }\n  return `${result}${string}`;\n}\n","// Supports GLSLIFY style naming of shaders\n// #define SHADER_NAME ...\nexport default function getShaderName(shader, defaultName = 'unnamed') {\n  const SHADER_NAME_REGEXP = /#define[\\s*]SHADER_NAME[\\s*]([A-Za-z0-9_-]+)[\\s*]/;\n  const match = shader.match(SHADER_NAME_REGEXP);\n  return match ? match[1] : defaultName;\n}\n","const GL_FRAGMENT_SHADER = 0x8b30;\nconst GL_VERTEX_SHADER = 0x8b31;\n\nexport default function getShaderTypeName(type) {\n  switch (type) {\n    case GL_FRAGMENT_SHADER:\n      return 'fragment';\n    case GL_VERTEX_SHADER:\n      return 'vertex';\n    default:\n      return 'unknown type';\n  }\n}\n","// returns GLSL shader version of given shader string\nexport default function getShaderVersion(source) {\n  let version = 100;\n  const words = source.match(/[^\\s]+/g);\n  if (words.length >= 2 && words[0] === '#version') {\n    const v = parseInt(words[1], 10);\n    if (Number.isFinite(v)) {\n      version = v;\n    }\n  }\n  return version;\n}\n","import GL from '@luma.gl/constants';\n\nimport Resource from './resource';\nimport Texture from './texture';\nimport Framebuffer from './framebuffer';\nimport {parseUniformName, getUniformSetter} from './uniforms';\nimport {VertexShader, FragmentShader} from './shader';\nimport ProgramConfiguration from './program-configuration';\nimport {copyUniform, checkUniformValues} from './uniforms';\n\nimport {isWebGL2, assertWebGL2Context, withParameters, log} from '@luma.gl/gltools';\nimport {getKey} from '../webgl-utils/constants-to-keys';\nimport {getPrimitiveDrawMode} from '../webgl-utils/attribute-utils';\nimport {assert} from '../utils/assert';\nimport {uid} from '../utils/utils';\n\nconst LOG_PROGRAM_PERF_PRIORITY = 4;\n\nconst GL_SEPARATE_ATTRIBS = 0x8c8d;\n\nconst V6_DEPRECATED_METHODS = [\n  'setVertexArray',\n  'setAttributes',\n  'setBuffers',\n  'unsetBuffers',\n\n  'use',\n  'getUniformCount',\n  'getUniformInfo',\n  'getUniformLocation',\n  'getUniformValue',\n\n  'getVarying',\n  'getFragDataLocation',\n  'getAttachedShaders',\n  'getAttributeCount',\n  'getAttributeLocation',\n  'getAttributeInfo'\n];\n\nexport default class Program extends Resource {\n  constructor(gl, props = {}) {\n    super(gl, props);\n\n    this.stubRemovedMethods('Program', 'v6.0', V6_DEPRECATED_METHODS);\n\n    // Experimental flag to avoid deleting Program object while it is cached\n    this._isCached = false;\n\n    this.initialize(props);\n\n    Object.seal(this);\n\n    this._setId(props.id);\n  }\n\n  initialize(props = {}) {\n    const {hash, vs, fs, varyings, bufferMode = GL_SEPARATE_ATTRIBS} = props;\n\n    this.hash = hash || ''; // Used by ProgramManager\n\n    // Create shaders if needed\n    this.vs =\n      typeof vs === 'string' ? new VertexShader(this.gl, {id: `${props.id}-vs`, source: vs}) : vs;\n    this.fs =\n      typeof fs === 'string' ? new FragmentShader(this.gl, {id: `${props.id}-fs`, source: fs}) : fs;\n    assert(this.vs instanceof VertexShader);\n    assert(this.fs instanceof FragmentShader);\n\n    // uniforms\n    this.uniforms = {};\n\n    this._textureUniforms = {};\n\n    // Setup varyings if supplied\n    if (varyings && varyings.length > 0) {\n      assertWebGL2Context(this.gl);\n      this.varyings = varyings;\n      this.gl2.transformFeedbackVaryings(this.handle, varyings, bufferMode);\n    }\n\n    this._compileAndLink();\n    this._readUniformLocationsFromLinkedProgram();\n    this.configuration = new ProgramConfiguration(this);\n\n    return this.setProps(props);\n  }\n\n  delete(options = {}) {\n    if (this._isCached) {\n      // This object is cached, do not delete\n      return this;\n    }\n    return super.delete(options);\n  }\n\n  setProps(props) {\n    if ('uniforms' in props) {\n      this.setUniforms(props.uniforms);\n    }\n    return this;\n  }\n\n  // A good thing about the WebGL API is that there are so many ways to draw things ;)\n  // This function unifies those ways into a single call using common parameters with sane defaults\n  draw({\n    logPriority, // Probe log priority, enables Model to do more integrated logging\n\n    drawMode = GL.TRIANGLES,\n    vertexCount,\n    offset = 0,\n    start,\n    end,\n    isIndexed = false,\n    indexType = GL.UNSIGNED_SHORT,\n    instanceCount = 0,\n    isInstanced = instanceCount > 0,\n\n    vertexArray = null,\n    transformFeedback,\n    framebuffer,\n    parameters = {},\n\n    // Deprecated\n    uniforms,\n    samplers\n  }) {\n    if (uniforms || samplers) {\n      // DEPRECATED: v7.0 (deprecated earlier but warning not properly implemented)\n      log.deprecated('Program.draw({uniforms})', 'Program.setUniforms(uniforms)')();\n      this.setUniforms(uniforms || {});\n    }\n\n    if (log.priority >= logPriority) {\n      const fb = framebuffer ? framebuffer.id : 'default';\n      const message =\n        `mode=${getKey(this.gl, drawMode)} verts=${vertexCount} ` +\n        `instances=${instanceCount} indexType=${getKey(this.gl, indexType)} ` +\n        `isInstanced=${isInstanced} isIndexed=${isIndexed} ` +\n        `Framebuffer=${fb}`;\n      log.log(logPriority, message)();\n    }\n\n    // TODO - move vertex array binding and transform feedback binding to withParameters?\n    assert(vertexArray);\n\n    this.gl.useProgram(this.handle);\n\n    if (\n      // Note: async textures set as uniforms might still be loading.\n      // Now that all uniforms have been updated, check if any texture\n      // in the uniforms is not yet initialized, then we don't draw\n      !this._areTexturesRenderable() ||\n      // Avoid WebGL draw call when not rendering any data\n      vertexCount === 0 ||\n      (isInstanced && instanceCount === 0)\n    ) {\n      return false;\n    }\n\n    vertexArray.bindForDraw(vertexCount, instanceCount, () => {\n      if (framebuffer !== undefined) {\n        parameters = Object.assign({}, parameters, {framebuffer});\n      }\n\n      if (transformFeedback) {\n        const primitiveMode = getPrimitiveDrawMode(drawMode);\n        transformFeedback.begin(primitiveMode);\n      }\n\n      this._bindTextures();\n\n      withParameters(this.gl, parameters, () => {\n        // TODO - Use polyfilled WebGL2RenderingContext instead of ANGLE extension\n        if (isIndexed && isInstanced) {\n          this.gl2.drawElementsInstanced(drawMode, vertexCount, indexType, offset, instanceCount);\n        } else if (isIndexed && isWebGL2(this.gl) && !isNaN(start) && !isNaN(end)) {\n          this.gl2.drawRangeElements(drawMode, start, end, vertexCount, indexType, offset);\n        } else if (isIndexed) {\n          this.gl.drawElements(drawMode, vertexCount, indexType, offset);\n        } else if (isInstanced) {\n          this.gl2.drawArraysInstanced(drawMode, offset, vertexCount, instanceCount);\n        } else {\n          this.gl.drawArrays(drawMode, offset, vertexCount);\n        }\n      });\n\n      if (transformFeedback) {\n        transformFeedback.end();\n      }\n    });\n\n    return true;\n  }\n\n  setUniforms(uniforms = {}) {\n    if (log.priority >= 2) {\n      checkUniformValues(uniforms, this.id, this._uniformSetters);\n    }\n\n    this.gl.useProgram(this.handle);\n\n    for (const uniformName in uniforms) {\n      const uniform = uniforms[uniformName];\n      const uniformSetter = this._uniformSetters[uniformName];\n\n      if (uniformSetter) {\n        let value = uniform;\n        let textureUpdate = false;\n\n        if (value instanceof Framebuffer) {\n          value = value.texture;\n        }\n        if (value instanceof Texture) {\n          textureUpdate = this.uniforms[uniformName] !== uniform;\n\n          if (textureUpdate) {\n            // eslint-disable-next-line max-depth\n            if (uniformSetter.textureIndex === undefined) {\n              uniformSetter.textureIndex = this._textureIndexCounter++;\n            }\n\n            // Bind texture to index\n            const texture = value;\n            const {textureIndex} = uniformSetter;\n\n            texture.bind(textureIndex);\n            value = textureIndex;\n\n            this._textureUniforms[uniformName] = texture;\n          } else {\n            value = uniformSetter.textureIndex;\n          }\n        } else if (this._textureUniforms[uniformName]) {\n          delete this._textureUniforms[uniformName];\n        }\n\n        // NOTE(Tarek): uniformSetter returns whether\n        //   value had to be updated or not.\n        if (uniformSetter(value) || textureUpdate) {\n          copyUniform(this.uniforms, uniformName, uniform);\n        }\n      }\n    }\n\n    return this;\n  }\n\n  // PRIVATE METHODS\n\n  // Checks if all texture-values uniforms are renderable (i.e. loaded)\n  // Update a texture if needed (e.g. from video)\n  // Note: This is currently done before every draw call\n  _areTexturesRenderable() {\n    let texturesRenderable = true;\n\n    for (const uniformName in this._textureUniforms) {\n      const texture = this._textureUniforms[uniformName];\n      texture.update();\n      texturesRenderable = texturesRenderable && texture.loaded;\n    }\n\n    return texturesRenderable;\n  }\n\n  // Binds textures\n  // Note: This is currently done before every draw call\n  _bindTextures() {\n    for (const uniformName in this._textureUniforms) {\n      const textureIndex = this._uniformSetters[uniformName].textureIndex;\n      this._textureUniforms[uniformName].bind(textureIndex);\n    }\n  }\n\n  // RESOURCE METHODS\n\n  _createHandle() {\n    return this.gl.createProgram();\n  }\n\n  _deleteHandle() {\n    this.gl.deleteProgram(this.handle);\n  }\n\n  // Extract opts needed to initialize a `Program` from an independently created WebGLProgram handle\n  _getOptionsFromHandle(handle) {\n    const shaderHandles = this.gl.getAttachedShaders(handle);\n    const opts = {};\n    for (const shaderHandle of shaderHandles) {\n      const type = this.gl.getShaderParameter(this.handle, GL.SHADER_TYPE);\n      switch (type) {\n        case GL.VERTEX_SHADER:\n          // @ts-ignore\n          opts.vs = new VertexShader({handle: shaderHandle});\n          break;\n        case GL.FRAGMENT_SHADER:\n          // @ts-ignore\n          opts.fs = new FragmentShader({handle: shaderHandle});\n          break;\n        default:\n      }\n    }\n    return opts;\n  }\n\n  _getParameter(pname) {\n    return this.gl.getProgramParameter(this.handle, pname);\n  }\n\n  // If program is not named, name it after shader names\n  // TODO - this.id will already have been initialized\n  _setId(id) {\n    if (!id) {\n      const programName = this._getName();\n      this.id = uid(programName);\n    }\n  }\n\n  // Generate a default name for the program based on names of the shaders\n  _getName() {\n    let programName = this.vs.getName() || this.fs.getName();\n    programName = programName.replace(/shader/i, '');\n    programName = programName ? `${programName}-program` : 'program';\n    return programName;\n  }\n\n  _compileAndLink() {\n    const {gl} = this;\n    gl.attachShader(this.handle, this.vs.handle);\n    gl.attachShader(this.handle, this.fs.handle);\n    log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this._getName()}`)();\n    gl.linkProgram(this.handle);\n    log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this._getName()}`)();\n\n    // Avoid checking program linking error in production\n    // @ts-ignore\n    if (gl.debug || log.level > 0) {\n      const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);\n      if (!linked) {\n        throw new Error(`Error linking: ${gl.getProgramInfoLog(this.handle)}`);\n      }\n\n      gl.validateProgram(this.handle);\n      const validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);\n      if (!validated) {\n        throw new Error(`Error validating: ${gl.getProgramInfoLog(this.handle)}`);\n      }\n    }\n  }\n\n  // query uniform locations and build name to setter map.\n  // TODO - This overlaps with ProgramConfiguration?\n  _readUniformLocationsFromLinkedProgram() {\n    const {gl} = this;\n    this._uniformSetters = {};\n    this._uniformCount = this._getParameter(GL.ACTIVE_UNIFORMS);\n    for (let i = 0; i < this._uniformCount; i++) {\n      const info = this.gl.getActiveUniform(this.handle, i);\n      const {name} = parseUniformName(info.name);\n      let location = gl.getUniformLocation(this.handle, name);\n      this._uniformSetters[name] = getUniformSetter(gl, location, info);\n      if (info.size > 1) {\n        for (let l = 0; l < info.size; l++) {\n          location = gl.getUniformLocation(this.handle, `${name}[${l}]`);\n          this._uniformSetters[`${name}[${l}]`] = getUniformSetter(gl, location, info);\n        }\n      }\n    }\n    this._textureIndexCounter = 0;\n  }\n\n  // TO BE REMOVED in v7?\n\n  // Rretrieves information about active uniforms identifed by their indices (`uniformIndices`)\n  // https://\n  // developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext/getActiveUniforms\n  getActiveUniforms(uniformIndices, pname) {\n    return this.gl2.getActiveUniforms(this.handle, uniformIndices, pname);\n  }\n\n  // Retrieves the index of a uniform block\n  getUniformBlockIndex(blockName) {\n    return this.gl2.getUniformBlockIndex(this.handle, blockName);\n  }\n\n  // Retrieves information about an active uniform block (`blockIndex`)\n  // https://\n  // developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext/getActiveUniformBlockParameter\n  getActiveUniformBlockParameter(blockIndex, pname) {\n    return this.gl2.getActiveUniformBlockParameter(this.handle, blockIndex, pname);\n  }\n\n  // Binds a uniform block (`blockIndex`) to a specific binding point (`blockBinding`)\n  uniformBlockBinding(blockIndex, blockBinding) {\n    this.gl2.uniformBlockBinding(this.handle, blockIndex, blockBinding);\n  }\n}\n","/** @typedef {import('./uniforms')} types */\n\nimport GL from '@luma.gl/constants';\nimport {log} from '@luma.gl/gltools';\n\nimport Framebuffer from './framebuffer';\nimport Renderbuffer from './renderbuffer';\nimport Texture from './texture';\nimport {assert} from '../utils/assert';\n\nconst UNIFORM_SETTERS = {\n  // WEBGL1\n\n  /* eslint-disable max-len */\n  [GL.FLOAT]: getArraySetter.bind(null, 'uniform1fv', toFloatArray, 1, setVectorUniform),\n  [GL.FLOAT_VEC2]: getArraySetter.bind(null, 'uniform2fv', toFloatArray, 2, setVectorUniform),\n  [GL.FLOAT_VEC3]: getArraySetter.bind(null, 'uniform3fv', toFloatArray, 3, setVectorUniform),\n  [GL.FLOAT_VEC4]: getArraySetter.bind(null, 'uniform4fv', toFloatArray, 4, setVectorUniform),\n\n  [GL.INT]: getArraySetter.bind(null, 'uniform1iv', toIntArray, 1, setVectorUniform),\n  [GL.INT_VEC2]: getArraySetter.bind(null, 'uniform2iv', toIntArray, 2, setVectorUniform),\n  [GL.INT_VEC3]: getArraySetter.bind(null, 'uniform3iv', toIntArray, 3, setVectorUniform),\n  [GL.INT_VEC4]: getArraySetter.bind(null, 'uniform4iv', toIntArray, 4, setVectorUniform),\n\n  [GL.BOOL]: getArraySetter.bind(null, 'uniform1iv', toIntArray, 1, setVectorUniform),\n  [GL.BOOL_VEC2]: getArraySetter.bind(null, 'uniform2iv', toIntArray, 2, setVectorUniform),\n  [GL.BOOL_VEC3]: getArraySetter.bind(null, 'uniform3iv', toIntArray, 3, setVectorUniform),\n  [GL.BOOL_VEC4]: getArraySetter.bind(null, 'uniform4iv', toIntArray, 4, setVectorUniform),\n\n  // uniformMatrix(false): don't transpose the matrix\n  [GL.FLOAT_MAT2]: getArraySetter.bind(null, 'uniformMatrix2fv', toFloatArray, 4, setMatrixUniform),\n  [GL.FLOAT_MAT3]: getArraySetter.bind(null, 'uniformMatrix3fv', toFloatArray, 9, setMatrixUniform),\n  [GL.FLOAT_MAT4]: getArraySetter.bind(\n    null,\n    'uniformMatrix4fv',\n    toFloatArray,\n    16,\n    setMatrixUniform\n  ),\n\n  [GL.SAMPLER_2D]: getSamplerSetter,\n  [GL.SAMPLER_CUBE]: getSamplerSetter,\n\n  // WEBGL2 - unsigned integers, irregular matrices, additional texture samplers\n\n  [GL.UNSIGNED_INT]: getArraySetter.bind(null, 'uniform1uiv', toUIntArray, 1, setVectorUniform),\n  [GL.UNSIGNED_INT_VEC2]: getArraySetter.bind(\n    null,\n    'uniform2uiv',\n    toUIntArray,\n    2,\n    setVectorUniform\n  ),\n  [GL.UNSIGNED_INT_VEC3]: getArraySetter.bind(\n    null,\n    'uniform3uiv',\n    toUIntArray,\n    3,\n    setVectorUniform\n  ),\n  [GL.UNSIGNED_INT_VEC4]: getArraySetter.bind(\n    null,\n    'uniform4uiv',\n    toUIntArray,\n    4,\n    setVectorUniform\n  ),\n\n  // uniformMatrix(false): don't transpose the matrix\n  [GL.FLOAT_MAT2x3]: getArraySetter.bind(\n    null,\n    'uniformMatrix2x3fv',\n    toFloatArray,\n    6,\n    setMatrixUniform\n  ),\n  [GL.FLOAT_MAT2x4]: getArraySetter.bind(\n    null,\n    'uniformMatrix2x4fv',\n    toFloatArray,\n    8,\n    setMatrixUniform\n  ),\n  [GL.FLOAT_MAT3x2]: getArraySetter.bind(\n    null,\n    'uniformMatrix3x2fv',\n    toFloatArray,\n    6,\n    setMatrixUniform\n  ),\n  [GL.FLOAT_MAT3x4]: getArraySetter.bind(\n    null,\n    'uniformMatrix3x4fv',\n    toFloatArray,\n    12,\n    setMatrixUniform\n  ),\n  [GL.FLOAT_MAT4x2]: getArraySetter.bind(\n    null,\n    'uniformMatrix4x2fv',\n    toFloatArray,\n    8,\n    setMatrixUniform\n  ),\n  [GL.FLOAT_MAT4x3]: getArraySetter.bind(\n    null,\n    'uniformMatrix4x3fv',\n    toFloatArray,\n    12,\n    setMatrixUniform\n  ),\n\n  [GL.SAMPLER_2D]: getSamplerSetter,\n  [GL.SAMPLER_CUBE]: getSamplerSetter,\n\n  [GL.SAMPLER_3D]: getSamplerSetter,\n  [GL.SAMPLER_2D_SHADOW]: getSamplerSetter,\n  [GL.SAMPLER_2D_ARRAY]: getSamplerSetter,\n  [GL.SAMPLER_2D_ARRAY_SHADOW]: getSamplerSetter,\n  [GL.SAMPLER_CUBE_SHADOW]: getSamplerSetter,\n  [GL.INT_SAMPLER_2D]: getSamplerSetter,\n  [GL.INT_SAMPLER_3D]: getSamplerSetter,\n  [GL.INT_SAMPLER_CUBE]: getSamplerSetter,\n  [GL.INT_SAMPLER_2D_ARRAY]: getSamplerSetter,\n  [GL.UNSIGNED_INT_SAMPLER_2D]: getSamplerSetter,\n  [GL.UNSIGNED_INT_SAMPLER_3D]: getSamplerSetter,\n  [GL.UNSIGNED_INT_SAMPLER_CUBE]: getSamplerSetter,\n  [GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: getSamplerSetter\n  /* eslint-enable max-len */\n};\n\n// Pre-allocated typed arrays for temporary conversion\nconst FLOAT_ARRAY = {};\nconst INT_ARRAY = {};\nconst UINT_ARRAY = {};\n\nconst array1 = [0];\n\n// Functions to ensure the type of uniform values\n// This is done because uniform*v functions\n// are extremely slow when consuming JS arrays directly.\nfunction toTypedArray(value, uniformLength, Type, cache) {\n  // convert boolean uniforms to Number\n  if (uniformLength === 1 && typeof value === 'boolean') {\n    value = value ? 1 : 0;\n  }\n  if (Number.isFinite(value)) {\n    array1[0] = value;\n    value = array1;\n  }\n  const length = value.length;\n  if (length % uniformLength) {\n    log.warn(`Uniform size should be multiples of ${uniformLength}`, value)();\n  }\n\n  if (value instanceof Type) {\n    return value;\n  }\n  let result = cache[length];\n  if (!result) {\n    result = new Type(length);\n    cache[length] = result;\n  }\n  for (let i = 0; i < length; i++) {\n    result[i] = value[i];\n  }\n  return result;\n}\n\nfunction toFloatArray(value, uniformLength) {\n  return toTypedArray(value, uniformLength, Float32Array, FLOAT_ARRAY);\n}\n\nfunction toIntArray(value, uniformLength) {\n  return toTypedArray(value, uniformLength, Int32Array, INT_ARRAY);\n}\n\nfunction toUIntArray(value, uniformLength) {\n  return toTypedArray(value, uniformLength, Uint32Array, UINT_ARRAY);\n} // Returns a Magic Uniform Setter\n\n// PUBLIC API\n\n/** @type {types['getUniformSetter']} */ export function getUniformSetter(gl, location, info) {\n  const setter = UNIFORM_SETTERS[info.type];\n  if (!setter) {\n    throw new Error(`Unknown GLSL uniform type ${info.type}`);\n  }\n\n  // NOTE(Tarek): This construction is the ensure\n  // separate caches for all setters.\n  return setter().bind(null, gl, location);\n}\n\n/** @type {types['parseUniformName']} */\nexport function parseUniformName(name) {\n  // Shortcut to avoid redundant or bad matches\n  if (name[name.length - 1] !== ']') {\n    return {\n      name,\n      length: 1,\n      isArray: false\n    };\n  }\n\n  // if array name then clean the array brackets\n  const UNIFORM_NAME_REGEXP = /([^[]*)(\\[[0-9]+\\])?/;\n  const matches = name.match(UNIFORM_NAME_REGEXP);\n  if (!matches || matches.length < 2) {\n    throw new Error(`Failed to parse GLSL uniform name ${name}`);\n  }\n\n  return {\n    name: matches[1],\n    length: matches[2] || 1,\n    isArray: Boolean(matches[2])\n  };\n} // To facilitate early detection of e.g. undefined values in JavaScript\n\n// Basic checks of uniform values (with or without knowledge of program)\n\n/** @type {types['checkUniformValues']} */\nexport function checkUniformValues(uniforms, source, uniformMap) {\n  for (const uniformName in uniforms) {\n    const value = uniforms[uniformName];\n    const shouldCheck = !uniformMap || Boolean(uniformMap[uniformName]);\n    if (shouldCheck && !checkUniformValue(value)) {\n      // Add space to source\n      source = source ? `${source} ` : '';\n      // Value could be unprintable so write the object on console\n      console.error(`${source} Bad uniform ${uniformName}`, value); // eslint-disable-line\n      /* eslint-enable no-console */\n      throw new Error(`${source} Bad uniform ${uniformName}`);\n    }\n  }\n  return true;\n}\n\n// TODO use type information during validation\nfunction checkUniformValue(value) {\n  if (Array.isArray(value) || ArrayBuffer.isView(value)) {\n    return checkUniformArray(value);\n  }\n\n  // Check if single value is a number\n  if (isFinite(value)) {\n    return true;\n  } else if (value === true || value === false) {\n    return true;\n  } else if (value instanceof Texture) {\n    return true;\n  } else if (value instanceof Renderbuffer) {\n    return true;\n  } else if (value instanceof Framebuffer) {\n    return Boolean(value.texture);\n  }\n  return false;\n}\n\n/** @type {types['copyUniform']} */\nexport function copyUniform(uniforms, key, value) {\n  if (Array.isArray(value) || ArrayBuffer.isView(value)) {\n    if (uniforms[key]) {\n      const dest = uniforms[key];\n      // @ts-ignore\n      for (let i = 0, len = value.length; i < len; ++i) {\n        dest[i] = value[i];\n      }\n    } else {\n      // @ts-ignore\n      uniforms[key] = value.slice();\n    }\n  } else {\n    uniforms[key] = value;\n  }\n}\n\n// HELPERS\n\nfunction checkUniformArray(value) {\n  // Check that every element in array is a number, and at least 1 element\n  if (value.length === 0) {\n    return false;\n  }\n\n  const checkLength = Math.min(value.length, 16);\n\n  for (let i = 0; i < checkLength; ++i) {\n    if (!Number.isFinite(value[i])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n// NOTE(Tarek): Setters maintain a cache\n// of the previously set value, and\n// avoid resetting it if it's the same.\nfunction getSamplerSetter() {\n  let cache = null;\n  return (gl, location, value) => {\n    const update = cache !== value;\n    if (update) {\n      gl.uniform1i(location, value);\n      cache = value;\n    }\n\n    return update;\n  };\n}\n\nfunction getArraySetter(functionName, toArray, size, uniformSetter) {\n  let cache = null;\n  let cacheLength = null;\n  return (gl, location, value) => {\n    const arrayValue = toArray(value, size);\n    const length = arrayValue.length;\n    let update = false;\n    if (cache === null) {\n      cache = new Float32Array(length);\n      cacheLength = length;\n      update = true;\n    } else {\n      assert(cacheLength === length, 'Uniform length cannot change.');\n      for (let i = 0; i < length; ++i) {\n        if (arrayValue[i] !== cache[i]) {\n          update = true;\n          break;\n        }\n      }\n    }\n    if (update) {\n      uniformSetter(gl, functionName, location, arrayValue);\n      cache.set(arrayValue);\n    }\n\n    return update;\n  };\n}\n\nfunction setVectorUniform(gl, functionName, location, value) {\n  gl[functionName](location, value);\n}\n\nfunction setMatrixUniform(gl, functionName, location, value) {\n  gl[functionName](location, false, value);\n}\n","// Contains metadata describing attribute configurations for a program's shaders\n// Much of this is automatically extracted from shaders after program linking\nimport Accessor from './accessor';\nimport {isWebGL2} from '@luma.gl/gltools';\nimport {decomposeCompositeGLType} from '../webgl-utils/attribute-utils';\n\nexport default class ProgramConfiguration {\n  constructor(program) {\n    this.id = program.id;\n    this.attributeInfos = [];\n    this.attributeInfosByName = {};\n\n    // Locations may not be contiguous the case of matrix attributes\n    // so keep a separate location->attribute map.\n    this.attributeInfosByLocation = [];\n    this.varyingInfos = [];\n    this.varyingInfosByName = {};\n    Object.seal(this);\n    this._readAttributesFromProgram(program);\n    this._readVaryingsFromProgram(program);\n  }\n\n  getAttributeInfo(locationOrName) {\n    const location = Number(locationOrName);\n    if (Number.isFinite(location)) {\n      return this.attributeInfosByLocation[location];\n    }\n    return this.attributeInfosByName[locationOrName] || null;\n  }\n\n  // Resolves an attribute name or index to an index\n  getAttributeLocation(locationOrName) {\n    const attributeInfo = this.getAttributeInfo(locationOrName);\n    return attributeInfo ? attributeInfo.location : -1;\n  }\n\n  getAttributeAccessor(locationOrName) {\n    const attributeInfo = this.getAttributeInfo(locationOrName);\n    return attributeInfo ? attributeInfo.accessor : null;\n  }\n\n  getVaryingInfo(locationOrName) {\n    const location = Number(locationOrName);\n    if (Number.isFinite(location)) {\n      return this.varyingInfos[location];\n    }\n    return this.varyingInfosByName[locationOrName] || null;\n  }\n\n  getVaryingIndex(locationOrName) {\n    const varying = this.getVaryingInfo();\n    return varying ? varying.location : -1;\n  }\n\n  getVaryingAccessor(locationOrName) {\n    const varying = this.getVaryingInfo();\n    return varying ? varying.accessor : null;\n  }\n\n  // PRIVATE METHODS\n\n  // linkProgram needs to have been called, although linking does not need to have been successful\n  _readAttributesFromProgram(program) {\n    const {gl} = program;\n    const count = gl.getProgramParameter(program.handle, gl.ACTIVE_ATTRIBUTES);\n\n    for (let index = 0; index < count; index++) {\n      const {name, type, size} = gl.getActiveAttrib(program.handle, index);\n      const location = gl.getAttribLocation(program.handle, name);\n      // Add only user provided attributes, for built-in attributes like\n      // `gl_InstanceID` locaiton will be < 0\n      if (location >= 0) {\n        this._addAttribute(location, name, type, size);\n      }\n    }\n\n    this.attributeInfos.sort((a, b) => a.location - b.location);\n  }\n\n  // linkProgram needs to have been called, although linking does not need to have been successful\n  _readVaryingsFromProgram(program) {\n    const {gl} = program;\n    if (!isWebGL2(gl)) {\n      return;\n    }\n\n    const count = gl.getProgramParameter(program.handle, gl.TRANSFORM_FEEDBACK_VARYINGS);\n    for (let location = 0; location < count; location++) {\n      const {name, type, size} = gl.getTransformFeedbackVarying(program.handle, location);\n      this._addVarying(location, name, type, size);\n    }\n\n    this.varyingInfos.sort((a, b) => a.location - b.location);\n  }\n\n  _addAttribute(location, name, compositeType, size) {\n    const {type, components} = decomposeCompositeGLType(compositeType);\n    const accessor = {type, size: size * components};\n    this._inferProperties(location, name, accessor);\n\n    const attributeInfo = {location, name, accessor: new Accessor(accessor)}; // Base values\n    this.attributeInfos.push(attributeInfo);\n    this.attributeInfosByLocation[location] = attributeInfo; // For quick location based lookup\n    this.attributeInfosByName[attributeInfo.name] = attributeInfo; // For quick name based lookup\n  }\n\n  // Extract additional attribute metadata from shader names (based on attribute naming conventions)\n  _inferProperties(location, name, accessor) {\n    if (/instance/i.test(name)) {\n      // Any attribute containing the word \"instance\" will be assumed to be instanced\n      accessor.divisor = 1;\n    }\n  }\n\n  _addVarying(location, name, compositeType, size) {\n    const {type, components} = decomposeCompositeGLType(compositeType);\n    const accessor = new Accessor({type, size: size * components});\n\n    const varying = {location, name, accessor}; // Base values\n    this.varyingInfos.push(varying);\n    this.varyingInfosByName[varying.name] = varying; // For quick name based lookup\n  }\n}\n","/* eslint-disable camelcase */\nimport {assert} from '../utils/assert';\n\nconst GL_BYTE = 0x1400;\nconst GL_UNSIGNED_BYTE = 0x1401;\nconst GL_SHORT = 0x1402;\nconst GL_UNSIGNED_SHORT = 0x1403;\n\nconst GL_POINTS = 0x0;\nconst GL_LINES = 0x1;\nconst GL_LINE_LOOP = 0x2;\nconst GL_LINE_STRIP = 0x3;\nconst GL_TRIANGLES = 0x4;\nconst GL_TRIANGLE_STRIP = 0x5;\nconst GL_TRIANGLE_FAN = 0x6;\n\n// Local constants - these will \"collapse\" during minification\nconst GL_FLOAT = 0x1406;\nconst GL_FLOAT_VEC2 = 0x8b50;\nconst GL_FLOAT_VEC3 = 0x8b51;\nconst GL_FLOAT_VEC4 = 0x8b52;\n\nconst GL_INT = 0x1404;\nconst GL_INT_VEC2 = 0x8b53;\nconst GL_INT_VEC3 = 0x8b54;\nconst GL_INT_VEC4 = 0x8b55;\n\nconst GL_UNSIGNED_INT = 0x1405;\nconst GL_UNSIGNED_INT_VEC2 = 0x8dc6;\nconst GL_UNSIGNED_INT_VEC3 = 0x8dc7;\nconst GL_UNSIGNED_INT_VEC4 = 0x8dc8;\n\nconst GL_BOOL = 0x8b56;\nconst GL_BOOL_VEC2 = 0x8b57;\nconst GL_BOOL_VEC3 = 0x8b58;\nconst GL_BOOL_VEC4 = 0x8b59;\n\nconst GL_FLOAT_MAT2 = 0x8b5a;\nconst GL_FLOAT_MAT3 = 0x8b5b;\nconst GL_FLOAT_MAT4 = 0x8b5c;\n\nconst GL_FLOAT_MAT2x3 = 0x8b65;\nconst GL_FLOAT_MAT2x4 = 0x8b66;\nconst GL_FLOAT_MAT3x2 = 0x8b67;\nconst GL_FLOAT_MAT3x4 = 0x8b68;\nconst GL_FLOAT_MAT4x2 = 0x8b69;\nconst GL_FLOAT_MAT4x3 = 0x8b6a;\n\n// Composite types table\nconst COMPOSITE_GL_TYPES = {\n  [GL_FLOAT]: [GL_FLOAT, 1, 'float'],\n  [GL_FLOAT_VEC2]: [GL_FLOAT, 2, 'vec2'],\n  [GL_FLOAT_VEC3]: [GL_FLOAT, 3, 'vec3'],\n  [GL_FLOAT_VEC4]: [GL_FLOAT, 4, 'vec4'],\n\n  [GL_INT]: [GL_INT, 1, 'int'],\n  [GL_INT_VEC2]: [GL_INT, 2, 'ivec2'],\n  [GL_INT_VEC3]: [GL_INT, 3, 'ivec3'],\n  [GL_INT_VEC4]: [GL_INT, 4, 'ivec4'],\n\n  [GL_UNSIGNED_INT]: [GL_UNSIGNED_INT, 1, 'uint'],\n  [GL_UNSIGNED_INT_VEC2]: [GL_UNSIGNED_INT, 2, 'uvec2'],\n  [GL_UNSIGNED_INT_VEC3]: [GL_UNSIGNED_INT, 3, 'uvec3'],\n  [GL_UNSIGNED_INT_VEC4]: [GL_UNSIGNED_INT, 4, 'uvec4'],\n\n  [GL_BOOL]: [GL_FLOAT, 1, 'bool'],\n  [GL_BOOL_VEC2]: [GL_FLOAT, 2, 'bvec2'],\n  [GL_BOOL_VEC3]: [GL_FLOAT, 3, 'bvec3'],\n  [GL_BOOL_VEC4]: [GL_FLOAT, 4, 'bvec4'],\n\n  [GL_FLOAT_MAT2]: [GL_FLOAT, 8, 'mat2'], // 4\n  [GL_FLOAT_MAT2x3]: [GL_FLOAT, 8, 'mat2x3'], // 6\n  [GL_FLOAT_MAT2x4]: [GL_FLOAT, 8, 'mat2x4'], // 8\n\n  [GL_FLOAT_MAT3]: [GL_FLOAT, 12, 'mat3'], // 9\n  [GL_FLOAT_MAT3x2]: [GL_FLOAT, 12, 'mat3x2'], // 6\n  [GL_FLOAT_MAT3x4]: [GL_FLOAT, 12, 'mat3x4'], // 12\n\n  [GL_FLOAT_MAT4]: [GL_FLOAT, 16, 'mat4'], // 16\n  [GL_FLOAT_MAT4x2]: [GL_FLOAT, 16, 'mat4x2'], // 8\n  [GL_FLOAT_MAT4x3]: [GL_FLOAT, 16, 'mat4x3'] // 12\n};\n\n// Counts the number of complete primitives given a number of vertices and a drawMode\nexport function getPrimitiveDrawMode(drawMode) {\n  switch (drawMode) {\n    case GL_POINTS:\n      return GL_POINTS;\n    case GL_LINES:\n      return GL_LINES;\n    case GL_LINE_STRIP:\n      return GL_LINES;\n    case GL_LINE_LOOP:\n      return GL_LINES;\n    case GL_TRIANGLES:\n      return GL_TRIANGLES;\n    case GL_TRIANGLE_STRIP:\n      return GL_TRIANGLES;\n    case GL_TRIANGLE_FAN:\n      return GL_TRIANGLES;\n    default:\n      assert(false);\n      return 0;\n  }\n}\n\n// Counts the number of complete \"primitives\" given a number of vertices and a drawMode\nexport function getPrimitiveCount({drawMode, vertexCount}) {\n  switch (drawMode) {\n    case GL_POINTS:\n    case GL_LINE_LOOP:\n      return vertexCount;\n    case GL_LINES:\n      return vertexCount / 2;\n    case GL_LINE_STRIP:\n      return vertexCount - 1;\n    case GL_TRIANGLES:\n      return vertexCount / 3;\n    case GL_TRIANGLE_STRIP:\n    case GL_TRIANGLE_FAN:\n      return vertexCount - 2;\n    default:\n      assert(false);\n      return 0;\n  }\n}\n\n// Counts the number of vertices after splitting the vertex stream into separate \"primitives\"\nexport function getVertexCount({drawMode, vertexCount}) {\n  const primitiveCount = getPrimitiveCount({drawMode, vertexCount});\n  switch (getPrimitiveDrawMode(drawMode)) {\n    case GL_POINTS:\n      return primitiveCount;\n    case GL_LINES:\n      return primitiveCount * 2;\n    case GL_TRIANGLES:\n      return primitiveCount * 3;\n    default:\n      assert(false);\n      return 0;\n  }\n}\n\n// Decomposes a composite type GL.VEC3 into a basic type (GL.FLOAT) and components (3)\nexport function decomposeCompositeGLType(compositeGLType) {\n  const typeAndSize = COMPOSITE_GL_TYPES[compositeGLType];\n  if (!typeAndSize) {\n    return null;\n  }\n  const [type, components] = typeAndSize;\n  return {type, components};\n}\n\nexport function getCompositeGLType(type, components) {\n  switch (type) {\n    case GL_BYTE:\n    case GL_UNSIGNED_BYTE:\n    case GL_SHORT:\n    case GL_UNSIGNED_SHORT:\n      type = GL_FLOAT;\n      break;\n    default:\n  }\n\n  for (const glType in COMPOSITE_GL_TYPES) {\n    const [compType, compComponents, name] = COMPOSITE_GL_TYPES[glType];\n    if (compType === type && compComponents === components) {\n      return {glType, name};\n    }\n  }\n  return null;\n}\n","// WebGL2 Query (also handles disjoint timer extensions)\nimport Resource from './resource';\nimport {FEATURES, hasFeatures} from '../features';\nimport {isWebGL2} from '@luma.gl/gltools';\nimport {assert} from '../utils/assert';\n\nconst GL_QUERY_RESULT = 0x8866; // Returns a GLuint containing the query result.\nconst GL_QUERY_RESULT_AVAILABLE = 0x8867; // whether query result is available.\n\nconst GL_TIME_ELAPSED_EXT = 0x88bf; // Elapsed time (in nanoseconds).\nconst GL_GPU_DISJOINT_EXT = 0x8fbb; // Whether GPU performed any disjoint operation.\n\nconst GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8c88; // #primitives written to feedback buffers\nconst GL_ANY_SAMPLES_PASSED = 0x8c2f; // Occlusion query (if drawing passed depth test)\nconst GL_ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8d6a; // Occlusion query less accurate/faster version\n\nexport default class Query extends Resource {\n  // Returns true if Query is supported by the WebGL implementation\n  // Can also check whether timestamp queries are available.\n  static isSupported(gl, opts = []) {\n    const webgl2 = isWebGL2(gl);\n\n    // Initial value\n    const hasTimerQuery = hasFeatures(gl, FEATURES.TIMER_QUERY);\n    let supported = webgl2 || hasTimerQuery;\n\n    for (const key of opts) {\n      switch (key) {\n        case 'queries':\n          supported = supported && webgl2;\n          break;\n        case 'timers':\n          supported = supported && hasTimerQuery;\n          break;\n        default:\n          assert(false);\n      }\n    }\n\n    return supported;\n  }\n\n  // Create a query class\n  constructor(gl, opts = {}) {\n    super(gl, opts);\n\n    this.target = null;\n    this._queryPending = false;\n    this._pollingPromise = null;\n\n    Object.seal(this);\n  }\n\n  // Shortcut for timer query (dependent on extension in both WebGL1 and 2)\n  // Measures GPU time delta between this call and a matching `end` call in the\n  // GPU instruction stream.\n  beginTimeElapsedQuery() {\n    return this.begin(GL_TIME_ELAPSED_EXT);\n  }\n\n  // Shortcut for occlusion queries\n  beginOcclusionQuery({conservative = false} = {}) {\n    return this.begin(conservative ? GL_ANY_SAMPLES_PASSED_CONSERVATIVE : GL_ANY_SAMPLES_PASSED);\n  }\n\n  // Shortcut for transformFeedbackQuery\n  beginTransformFeedbackQuery() {\n    return this.begin(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);\n  }\n\n  // Due to OpenGL API limitations, after calling `begin()` on one Query\n  // instance, `end()` must be called on that same instance before\n  // calling `begin()` on another query. While there can be multiple\n  // outstanding queries representing disjoint `begin()`/`end()` intervals.\n  // It is not possible to interleave or overlap `begin` and `end` calls.\n  begin(target) {\n    // Don't start a new query if one is already active.\n    if (this._queryPending) {\n      return this;\n    }\n\n    this.target = target;\n    this.gl2.beginQuery(this.target, this.handle);\n\n    return this;\n  }\n\n  // ends the current query\n  end() {\n    // Can't end a new query if the last one hasn't been resolved.\n    if (this._queryPending) {\n      return this;\n    }\n\n    if (this.target) {\n      this.gl2.endQuery(this.target);\n      this.target = null;\n      this._queryPending = true;\n    }\n    return this;\n  }\n\n  // Returns true if the query result is available\n  isResultAvailable() {\n    if (!this._queryPending) {\n      return false;\n    }\n\n    const resultAvailable = this.gl2.getQueryParameter(this.handle, GL_QUERY_RESULT_AVAILABLE);\n    if (resultAvailable) {\n      this._queryPending = false;\n    }\n    return resultAvailable;\n  }\n\n  // Timing query is disjoint, i.e. results are invalid\n  isTimerDisjoint() {\n    return this.gl2.getParameter(GL_GPU_DISJOINT_EXT);\n  }\n\n  // Returns query result.\n  getResult() {\n    return this.gl2.getQueryParameter(this.handle, GL_QUERY_RESULT);\n  }\n\n  // Returns the query result, converted to milliseconds to match JavaScript conventions.\n  getTimerMilliseconds() {\n    return this.getResult() / 1e6;\n  }\n\n  // Polls the query\n  createPoll(limit = Number.POSITIVE_INFINITY) {\n    if (this._pollingPromise) {\n      return this._pollingPromise;\n    }\n\n    let counter = 0;\n\n    this._pollingPromise = new Promise((resolve, reject) => {\n      const poll = () => {\n        if (this.isResultAvailable()) {\n          resolve(this.getResult());\n          this._pollingPromise = null;\n        } else if (counter++ > limit) {\n          reject('Timed out');\n          this._pollingPromise = null;\n        } else {\n          requestAnimationFrame(poll);\n        }\n      };\n\n      requestAnimationFrame(poll);\n    });\n\n    return this._pollingPromise;\n  }\n\n  _createHandle() {\n    return Query.isSupported(this.gl) ? this.gl2.createQuery() : null;\n  }\n\n  _deleteHandle() {\n    this.gl2.deleteQuery(this.handle);\n  }\n}\n","import GL from '@luma.gl/constants';\nimport {isWebGL2, assertWebGL2Context, log} from '@luma.gl/gltools';\nimport Resource from './resource';\nimport Buffer from './buffer';\nimport {isObjectEmpty} from '../utils/utils';\n\n// NOTE: The `bindOnUse` flag is a major workaround:\n// See https://github.com/KhronosGroup/WebGL/issues/2346\n\nexport default class TransformFeedback extends Resource {\n  static isSupported(gl) {\n    return isWebGL2(gl);\n  }\n\n  constructor(gl, props = {}) {\n    assertWebGL2Context(gl);\n    super(gl, props);\n\n    this.initialize(props);\n    this.stubRemovedMethods('TransformFeedback', 'v6.0', ['pause', 'resume']);\n    Object.seal(this);\n  }\n\n  initialize(props = {}) {\n    this.buffers = {};\n    this.unused = {};\n    this.configuration = null;\n    this.bindOnUse = true;\n\n    // Unbind any currently bound buffers\n    if (!isObjectEmpty(this.buffers)) {\n      this.bind(() => this._unbindBuffers());\n    }\n\n    this.setProps(props);\n    return this;\n  }\n\n  setProps(props) {\n    if ('program' in props) {\n      this.configuration = props.program && props.program.configuration;\n    }\n    if ('configuration' in props) {\n      this.configuration = props.configuration;\n    }\n    if ('bindOnUse' in props) {\n      props = props.bindOnUse;\n    }\n    if ('buffers' in props) {\n      this.setBuffers(props.buffers);\n    }\n  }\n\n  setBuffers(buffers = {}) {\n    this.bind(() => {\n      for (const bufferName in buffers) {\n        this.setBuffer(bufferName, buffers[bufferName]);\n      }\n    });\n    return this;\n  }\n\n  setBuffer(locationOrName, bufferOrParams) {\n    const location = this._getVaryingIndex(locationOrName);\n    const {buffer, byteSize, byteOffset} = this._getBufferParams(bufferOrParams);\n\n    if (location < 0) {\n      this.unused[locationOrName] = buffer;\n      log.warn(() => `${this.id} unused varying buffer ${locationOrName}`)();\n      return this;\n    }\n\n    this.buffers[location] = bufferOrParams;\n\n    // Need to avoid chrome bug where buffer that is already bound to a different target\n    // cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.\n    if (!this.bindOnUse) {\n      this._bindBuffer(location, buffer, byteOffset, byteSize);\n    }\n\n    return this;\n  }\n\n  begin(primitiveMode = GL.POINTS) {\n    // @ts-ignore\n    this.gl.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, this.handle);\n    this._bindBuffers();\n    // @ts-ignore\n    this.gl.beginTransformFeedback(primitiveMode);\n    return this;\n  }\n\n  end() {\n    // @ts-ignore\n    this.gl.endTransformFeedback();\n    this._unbindBuffers();\n    // @ts-ignore\n    this.gl.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, null);\n    return this;\n  }\n\n  // PRIVATE METHODS\n\n  _getBufferParams(bufferOrParams) {\n    let byteOffset;\n    let byteSize;\n    let buffer;\n    if (bufferOrParams instanceof Buffer === false) {\n      buffer = bufferOrParams.buffer;\n      byteSize = bufferOrParams.byteSize;\n      byteOffset = bufferOrParams.byteOffset;\n    } else {\n      buffer = bufferOrParams;\n    }\n    // to use bindBufferRange, either offset or size must be specified, use default value for the other.\n    if (byteOffset !== undefined || byteSize !== undefined) {\n      byteOffset = byteOffset || 0;\n      byteSize = byteSize || buffer.byteLength - byteOffset;\n    }\n    return {buffer, byteOffset, byteSize};\n  }\n\n  _getVaryingInfo(locationOrName) {\n    return this.configuration && this.configuration.getVaryingInfo(locationOrName);\n  }\n\n  _getVaryingIndex(locationOrName) {\n    if (this.configuration) {\n      return this.configuration.getVaryingInfo(locationOrName).location;\n    }\n    const location = Number(locationOrName);\n    return Number.isFinite(location) ? location : -1;\n  }\n\n  // Need to avoid chrome bug where buffer that is already bound to a different target\n  // cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.\n  _bindBuffers() {\n    if (this.bindOnUse) {\n      for (const bufferIndex in this.buffers) {\n        const {buffer, byteSize, byteOffset} = this._getBufferParams(this.buffers[bufferIndex]);\n        this._bindBuffer(bufferIndex, buffer, byteOffset, byteSize);\n      }\n    }\n  }\n\n  _unbindBuffers() {\n    if (this.bindOnUse) {\n      for (const bufferIndex in this.buffers) {\n        this._bindBuffer(bufferIndex, null);\n      }\n    }\n  }\n\n  _bindBuffer(index, buffer, byteOffset = 0, byteSize) {\n    const handle = buffer && buffer.handle;\n    if (!handle || byteSize === undefined) {\n      // @ts-ignore\n      this.gl.bindBufferBase(GL.TRANSFORM_FEEDBACK_BUFFER, index, handle);\n    } else {\n      // @ts-ignore\n      this.gl.bindBufferRange(GL.TRANSFORM_FEEDBACK_BUFFER, index, handle, byteOffset, byteSize);\n    }\n    return this;\n  }\n\n  // RESOURCE METHODS\n\n  _createHandle() {\n    // @ts-ignore\n    return this.gl.createTransformFeedback();\n  }\n\n  _deleteHandle() {\n    // @ts-ignore\n    this.gl.deleteTransformFeedback(this.handle);\n  }\n\n  _bindHandle(handle) {\n    // @ts-ignore\n    this.gl.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, this.handle);\n  }\n}\n","import GL from '@luma.gl/constants';\nimport Resource from './resource';\nimport Buffer from './buffer';\nimport {isWebGL2} from '@luma.gl/gltools';\nimport {getScratchArray, fillArray} from '../utils/array-utils-flat';\nimport {assert} from '../utils/assert';\nimport {getBrowser} from 'probe.gl';\n\nconst ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';\n\nexport default class VertexArrayObject extends Resource {\n  static isSupported(gl, options = {}) {\n    // Attribute 0 can not be disable on most desktop OpenGL based browsers\n    // and on iOS Safari browser.\n    if (options.constantAttributeZero) {\n      return isWebGL2(gl) || getBrowser() === 'Chrome';\n    }\n\n    // Whether additional objects can be created\n    return true;\n  }\n\n  // Returns the global (null) vertex array object. Exists even when no extension available\n  // TODO(Tarek): VAOs are now polyfilled. Deprecate this in 9.0\n  static getDefaultArray(gl) {\n    gl.luma = gl.luma || {};\n    if (!gl.luma.defaultVertexArray) {\n      gl.luma.defaultVertexArray = new VertexArrayObject(gl, {handle: null, isDefaultArray: true});\n    }\n    return gl.luma.defaultVertexArray;\n  }\n\n  static getMaxAttributes(gl) {\n    // TODO - should be cached per context\n    // @ts-ignore\n    VertexArrayObject.MAX_ATTRIBUTES =\n      // @ts-ignore\n      VertexArrayObject.MAX_ATTRIBUTES || gl.getParameter(gl.MAX_VERTEX_ATTRIBS);\n    // @ts-ignore\n    return VertexArrayObject.MAX_ATTRIBUTES;\n  }\n\n  // Note: Constants are stored globally on the WebGL context, not the VAO\n  // So they need to be updated before every render\n  // TODO - use known type (in configuration or passed in) to allow non-typed arrays?\n  // TODO - remember/cache values to avoid setting them unnecessarily?\n  static setConstant(gl, location, array) {\n    switch (array.constructor) {\n      case Float32Array:\n        VertexArrayObject._setConstantFloatArray(gl, location, array);\n        break;\n      case Int32Array:\n        VertexArrayObject._setConstantIntArray(gl, location, array);\n        break;\n      case Uint32Array:\n        VertexArrayObject._setConstantUintArray(gl, location, array);\n        break;\n      default:\n        assert(false);\n    }\n  }\n\n  // Create a VertexArray\n  constructor(gl, opts = {}) {\n    // Use program's id if program but no id is supplied\n    const id = opts.id || (opts.program && opts.program.id);\n    super(gl, Object.assign({}, opts, {id}));\n\n    this.buffer = null;\n    this.bufferValue = null;\n    this.isDefaultArray = opts.isDefaultArray || false;\n\n    /** @type {WebGL2RenderingContext} */\n    this.gl2 = gl;\n\n    this.initialize(opts);\n\n    Object.seal(this);\n  }\n\n  delete() {\n    super.delete();\n    if (this.buffer) {\n      this.buffer.delete();\n    }\n    return this;\n  }\n\n  get MAX_ATTRIBUTES() {\n    return VertexArrayObject.getMaxAttributes(this.gl);\n  }\n\n  initialize(props = {}) {\n    return this.setProps(props);\n  }\n\n  setProps(props) {\n    // TODO: decide which props should be supported\n    return this;\n  }\n\n  // Set (bind) an elements buffer, for indexed rendering.\n  // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported\n  setElementBuffer(elementBuffer = null, opts = {}) {\n    assert(!elementBuffer || elementBuffer.target === GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);\n\n    // The GL.ELEMENT_ARRAY_BUFFER_BINDING is stored on the VertexArrayObject...\n    this.bind(() => {\n      this.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);\n    });\n\n    return this;\n  }\n\n  // Set a location in vertex attributes array to a bufferk, enables the location, sets divisor\n  setBuffer(location, buffer, accessor) {\n    // Check target\n    if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {\n      return this.setElementBuffer(buffer, accessor);\n    }\n\n    const {size, type, stride, offset, normalized, integer, divisor} = accessor;\n\n    const {gl, gl2} = this;\n    location = Number(location);\n\n    this.bind(() => {\n      // A non-zero buffer object must be bound to the GL_ARRAY_BUFFER target\n      gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);\n\n      // WebGL2 supports *integer* data formats, i.e. GPU will see integer values\n      if (integer) {\n        assert(isWebGL2(gl));\n        gl2.vertexAttribIPointer(location, size, type, stride, offset);\n      } else {\n        // Attaches ARRAY_BUFFER with specified buffer format to location\n        gl.vertexAttribPointer(location, size, type, normalized, stride, offset);\n      }\n      gl.enableVertexAttribArray(location);\n      gl2.vertexAttribDivisor(location, divisor || 0);\n\n      // NOTE We don't unbind buffer here, typically another buffer will be bound just after\n    });\n\n    return this;\n  }\n\n  // Enabling an attribute location makes it reference the currently bound buffer\n  // Disabling an attribute location makes it reference the global constant value\n  // TODO - handle single values for size 1 attributes?\n  // TODO - convert classic arrays based on known type?\n  enable(location, enable = true) {\n    // Attribute 0 cannot be disabled in most desktop OpenGL based browsers\n    const disablingAttributeZero =\n      !enable &&\n      location === 0 &&\n      !VertexArrayObject.isSupported(this.gl, {constantAttributeZero: true});\n\n    if (!disablingAttributeZero) {\n      location = Number(location);\n      this.bind(\n        () =>\n          enable\n            ? this.gl.enableVertexAttribArray(location)\n            : this.gl.disableVertexAttribArray(location)\n      );\n    }\n    return this;\n  }\n\n  // Provide a means to create a buffer that is equivalent to a constant.\n  // NOTE: Desktop OpenGL cannot disable attribute 0.\n  // https://stackoverflow.com/questions/20305231/webgl-warning-attribute-0-is-disabled-\n  // this-has-significant-performance-penalt\n  getConstantBuffer(elementCount, value) {\n    // Create buffer only when needed, and reuse it (avoids inflating buffer creation statistics)\n\n    const constantValue = this._normalizeConstantArrayValue(value);\n\n    const byteLength = constantValue.byteLength * elementCount;\n    const length = constantValue.length * elementCount;\n\n    let updateNeeded = !this.buffer;\n\n    this.buffer = this.buffer || new Buffer(this.gl, byteLength);\n    updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);\n\n    // Reallocate and update contents if needed\n    updateNeeded =\n      updateNeeded || !this._compareConstantArrayValues(constantValue, this.bufferValue);\n\n    if (updateNeeded) {\n      // Create a typed array that is big enough, and fill it with the required data\n      const typedArray = getScratchArray(value.constructor, length);\n      fillArray({target: typedArray, source: constantValue, start: 0, count: length});\n      this.buffer.subData(typedArray);\n      this.bufferValue = value;\n    }\n\n    return this.buffer;\n  }\n\n  // PRIVATE\n\n  // TODO - convert Arrays based on known type? (read type from accessor, don't assume Float32Array)\n  // TODO - handle single values for size 1 attributes?\n  _normalizeConstantArrayValue(arrayValue) {\n    if (Array.isArray(arrayValue)) {\n      return new Float32Array(arrayValue);\n    }\n    return arrayValue;\n  }\n\n  _compareConstantArrayValues(v1, v2) {\n    if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {\n      return false;\n    }\n    for (let i = 0; i < v1.length; ++i) {\n      if (v1[i] !== v2[i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  static _setConstantFloatArray(gl, location, array) {\n    switch (array.length) {\n      case 1:\n        gl.vertexAttrib1fv(location, array);\n        break;\n      case 2:\n        gl.vertexAttrib2fv(location, array);\n        break;\n      case 3:\n        gl.vertexAttrib3fv(location, array);\n        break;\n      case 4:\n        gl.vertexAttrib4fv(location, array);\n        break;\n      default:\n        assert(false);\n    }\n  }\n\n  static _setConstantIntArray(gl, location, array) {\n    assert(isWebGL2(gl));\n    switch (array.length) {\n      case 1:\n        gl.vertexAttribI1iv(location, array);\n        break;\n      case 2:\n        gl.vertexAttribI2iv(location, array);\n        break;\n      case 3:\n        gl.vertexAttribI3iv(location, array);\n        break;\n      case 4:\n        gl.vertexAttribI4iv(location, array);\n        break;\n      default:\n        assert(false);\n    }\n  }\n\n  static _setConstantUintArray(gl, location, array) {\n    assert(isWebGL2(gl));\n    switch (array.length) {\n      case 1:\n        gl.vertexAttribI1uiv(location, array);\n        break;\n      case 2:\n        gl.vertexAttribI2uiv(location, array);\n        break;\n      case 3:\n        gl.vertexAttribI3uiv(location, array);\n        break;\n      case 4:\n        gl.vertexAttribI4uiv(location, array);\n        break;\n      default:\n        assert(false);\n    }\n  }\n\n  // RESOURCE IMPLEMENTATION\n\n  _createHandle() {\n    /** @type {WebGL2RenderingContext} */\n    // @ts-ignore\n    const gl2 = this.gl;\n    return gl2.createVertexArray();\n  }\n\n  _deleteHandle(handle) {\n    this.gl2.deleteVertexArray(handle);\n    // @ts-ignore\n    return [this.elements];\n    // return [this.elements, ...this.buffers];\n  }\n\n  _bindHandle(handle) {\n    this.gl2.bindVertexArray(handle);\n  }\n\n  // Generic getter for information about a vertex attribute at a given position\n  _getParameter(pname, {location}) {\n    assert(Number.isFinite(location));\n    return this.bind(() => {\n      switch (pname) {\n        case GL.VERTEX_ATTRIB_ARRAY_POINTER:\n          return this.gl.getVertexAttribOffset(location, pname);\n        default:\n          return this.gl.getVertexAttrib(location, pname);\n      }\n    });\n  }\n}\n","let arrayBuffer = null;\n\nexport function getScratchArrayBuffer(byteLength) {\n  if (!arrayBuffer || arrayBuffer.byteLength < byteLength) {\n    arrayBuffer = new ArrayBuffer(byteLength);\n  }\n  return arrayBuffer;\n}\n\nexport function getScratchArray(Type, length) {\n  const scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length);\n  return new Type(scratchArrayBuffer, 0, length); // arrayBuffer, byteOffset, length (in elements)\n}\n\n// Uses copyWithin to significantly speed up typed array value filling\nexport function fillArray({target, source, start = 0, count = 1}) {\n  const length = source.length;\n  const total = count * length;\n  let copied = 0;\n  for (let i = start; copied < length; copied++) {\n    target[i++] = source[copied];\n  }\n\n  while (copied < total) {\n    // If we have copied less than half, copy everything we got\n    // else copy remaining in one operation\n    if (copied < total - copied) {\n      target.copyWithin(start + copied, start, start + copied);\n      copied *= 2;\n    } else {\n      target.copyWithin(start + copied, start, start + total - copied);\n      copied = total;\n    }\n  }\n\n  return target;\n}\n\n/*\n\n// Creates a new Uint8Array based on two different ArrayBuffers\n// @private\n// @param {ArrayBuffers} buffer1 The first buffer.\n// @param {ArrayBuffers} buffer2 The second buffer.\n// @return {ArrayBuffers} The new ArrayBuffer created out of the two.\n//\nexport function copyArrayBuffer(\n  targetBuffer, sourceBuffer, byteOffset, byteLength = sourceBuffer.byteLength\n) {\n  const targetArray = new Uint8Array(targetBuffer, byteOffset, byteLength);\n  const sourceArray = new Uint8Array(sourceBuffer);\n  targetArray.set(sourceArray);\n  return targetBuffer;\n}\n\n*/\n","import GL from '@luma.gl/constants';\nimport {log} from '@luma.gl/gltools';\nimport Accessor from './accessor';\nimport Buffer from './buffer';\nimport VertexArrayObject from './vertex-array-object';\nimport {assert} from '../utils/assert';\nimport {stubRemovedMethods} from '../utils/stub-methods';\n\nconst ERR_ATTRIBUTE_TYPE =\n  'VertexArray: attributes must be Buffers or constants (i.e. typed array)';\n\n// This is done to support mat type attributes.\n// See section \"Notes about setting mat type attributes\"\n// in vertex-array.md\nconst MULTI_LOCATION_ATTRIBUTE_REGEXP = /^(.+)__LOCATION_([0-9]+)$/;\n\nconst DEPRECATIONS_V6 = [\n  'setBuffers',\n  'setGeneric',\n  'clearBindings',\n  'setLocations',\n  'setGenericValues',\n  'setDivisor',\n  'enable',\n  'disable'\n];\n\nexport default class VertexArray {\n  constructor(gl, opts = {}) {\n    // Use program's id if program is supplied but no id is supplied\n    const id = opts.id || (opts.program && opts.program.id);\n    // super(gl, Object.assign({}, opts, {id}));\n\n    this.id = id;\n    this.gl = gl;\n    this.configuration = null;\n\n    // Extracted information\n    this.elements = null;\n    this.elementsAccessor = null;\n    this.values = null;\n    this.accessors = null;\n    this.unused = null;\n    this.drawParams = null;\n    this.buffer = null; // For attribute 0 on desktops, and created when unbinding buffers\n\n    this.attributes = {};\n\n    this.vertexArrayObject = new VertexArrayObject(gl);\n\n    // Issue errors when using removed methods\n    stubRemovedMethods(this, 'VertexArray', 'v6.0', DEPRECATIONS_V6);\n\n    this.initialize(opts);\n    Object.seal(this);\n  }\n\n  delete() {\n    if (this.buffer) {\n      this.buffer.delete();\n    }\n\n    this.vertexArrayObject.delete();\n  }\n\n  initialize(props = {}) {\n    this.reset();\n    this.configuration = null;\n    this.bindOnUse = false;\n    return this.setProps(props);\n  }\n\n  // Resets all attributes (to default valued constants)\n  reset() {\n    // this.vertexArrayObject.reset();\n\n    this.elements = null;\n    this.elementsAccessor = null;\n    const {MAX_ATTRIBUTES} = this.vertexArrayObject;\n    this.values = new Array(MAX_ATTRIBUTES).fill(null);\n    this.accessors = new Array(MAX_ATTRIBUTES).fill(null);\n    this.unused = {};\n\n    // Auto detects draw params\n    this.drawParams = null;\n\n    return this;\n  }\n\n  setProps(props) {\n    if ('program' in props) {\n      this.configuration = props.program && props.program.configuration;\n    }\n    if ('configuration' in props) {\n      this.configuration = props.configuration;\n    }\n    if ('attributes' in props) {\n      this.setAttributes(props.attributes);\n    }\n    if ('elements' in props) {\n      this.setElementBuffer(props.elements);\n    }\n    if ('bindOnUse' in props) {\n      props = props.bindOnUse;\n    }\n    return this;\n  }\n\n  // Automatically called if buffers changed through VertexArray API\n  clearDrawParams() {\n    this.drawParams = null;\n  }\n\n  getDrawParams() {\n    // Auto deduced draw parameters\n    this.drawParams = this.drawParams || this._updateDrawParams();\n\n    return this.drawParams;\n  }\n\n  // Set (bind) an array or map of vertex array buffers, either in numbered or named locations.\n  // For names that are not present in `location`, the supplied buffers will be ignored.\n  // if a single buffer of type GL.ELEMENT_ARRAY_BUFFER is present, it will be set as elements\n  //   Signatures:\n  //     {attributeName: buffer}\n  //     {attributeName: [buffer, accessor]}\n  //     {attributeName: (typed) array} => constant\n  setAttributes(attributes) {\n    Object.assign(this.attributes, attributes);\n    this.vertexArrayObject.bind(() => {\n      for (const locationOrName in attributes) {\n        const value = attributes[locationOrName];\n        this._setAttribute(locationOrName, value);\n      }\n      // Make sure we don't leave any bindings\n      this.gl.bindBuffer(GL.ARRAY_BUFFER, null);\n    });\n\n    return this;\n  }\n\n  // Set (bind) an elements buffer, for indexed rendering.\n  // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported\n  setElementBuffer(elementBuffer = null, accessor = {}) {\n    this.elements = elementBuffer; // Save value for debugging\n    this.elementsAccessor = accessor;\n    this.clearDrawParams();\n    this.vertexArrayObject.setElementBuffer(elementBuffer, accessor);\n\n    return this;\n  }\n\n  // Set a location in vertex attributes array to a buffer\n  setBuffer(locationOrName, buffer, appAccessor = {}) {\n    // Check target\n    if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {\n      return this.setElementBuffer(buffer, appAccessor);\n    }\n\n    const {location, accessor} = this._resolveLocationAndAccessor(\n      locationOrName,\n      buffer,\n      buffer.accessor,\n      appAccessor\n    );\n\n    if (location >= 0) {\n      this.values[location] = buffer;\n      this.accessors[location] = accessor;\n      this.clearDrawParams();\n      this.vertexArrayObject.setBuffer(location, buffer, accessor);\n    }\n\n    return this;\n  }\n\n  // Set attribute to constant value (small typed array corresponding to one vertex' worth of data)\n  setConstant(locationOrName, arrayValue, appAccessor = {}) {\n    const {location, accessor} = this._resolveLocationAndAccessor(\n      locationOrName,\n      arrayValue,\n      // Ensure that size isn't taken from program for multi-column\n      // attributes\n      Object.assign({size: arrayValue.length}, appAccessor)\n    );\n\n    if (location >= 0) {\n      arrayValue = this.vertexArrayObject._normalizeConstantArrayValue(arrayValue);\n\n      this.values[location] = arrayValue;\n      this.accessors[location] = accessor;\n      this.clearDrawParams();\n\n      // NOTE: We set the actual constant value later on bind. We can't set the value now since\n      // constants are global and affect all other VertexArrays that have disabled attributes\n      // in the same location.\n      // We do disable the attribute which makes it use the global constant value at that location\n      this.vertexArrayObject.enable(location, false);\n    }\n\n    return this;\n  }\n\n  // Workaround for Chrome TransformFeedback binding issue\n  // If required, unbind temporarily to avoid conflicting with TransformFeedback\n  unbindBuffers() {\n    this.vertexArrayObject.bind(() => {\n      if (this.elements) {\n        this.vertexArrayObject.setElementBuffer(null);\n      }\n\n      // Chrome does not like buffers that are bound to several binding points,\n      // so we need to offer and unbind facility\n      // WebGL offers disabling, but no clear way to set a VertexArray buffer to `null`\n      // So we just bind all the attributes to the dummy \"attribute zero\" buffer\n      this.buffer = this.buffer || new Buffer(this.gl, {accessor: {size: 4}});\n\n      for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {\n        if (this.values[location] instanceof Buffer) {\n          this.gl.disableVertexAttribArray(location);\n          this.gl.bindBuffer(GL.ARRAY_BUFFER, this.buffer.handle);\n          this.gl.vertexAttribPointer(location, 1, GL.FLOAT, false, 0, 0);\n        }\n      }\n    });\n    return this;\n  }\n\n  // Workaround for Chrome TransformFeedback binding issue\n  // If required, rebind rebind after temporary unbind\n  bindBuffers() {\n    this.vertexArrayObject.bind(() => {\n      if (this.elements) {\n        this.setElementBuffer(this.elements);\n      }\n\n      for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {\n        const buffer = this.values[location];\n        if (buffer instanceof Buffer) {\n          this.setBuffer(location, buffer);\n        }\n      }\n    });\n    return this;\n  }\n\n  // Bind for use\n  // When a vertex array is about to be used, we must:\n  // - Set constant attributes (since these are stored on the context and reset on bind)\n  // - Check if we need to initialize the buffer\n  bindForDraw(vertexCount, instanceCount, func) {\n    let value;\n\n    this.vertexArrayObject.bind(() => {\n      // Make sure that any constant attributes are updated (stored on the context, not the VAO)\n      // Also handles attribute 0\n      this._setConstantAttributes(vertexCount, instanceCount);\n\n      value = func();\n    });\n\n    return value;\n  }\n\n  // PRIVATE\n\n  // Resolve locations and accessors\n  _resolveLocationAndAccessor(locationOrName, value, valueAccessor, appAccessor) {\n    const INVALID_RESULT = {\n      location: -1,\n      accessor: null\n    };\n\n    const {location, name} = this._getAttributeIndex(locationOrName);\n    if (!Number.isFinite(location) || location < 0) {\n      this.unused[locationOrName] = value;\n      log.once(3, () => `unused value ${locationOrName} in ${this.id}`)();\n      return INVALID_RESULT;\n    }\n\n    const accessInfo = this._getAttributeInfo(name || location);\n\n    // Attribute location wasn't directly found.\n    // Likely due to multi-location attributes (e.g. matrix)\n    if (!accessInfo) {\n      return INVALID_RESULT;\n    }\n\n    // Resolve the partial accessors into a final accessor\n    const currentAccessor = this.accessors[location] || {};\n    const accessor = Accessor.resolve(\n      accessInfo.accessor,\n      currentAccessor,\n      valueAccessor,\n      appAccessor\n    );\n\n    const {size, type} = accessor;\n    assert(Number.isFinite(size) && Number.isFinite(type));\n\n    return {location, accessor};\n  }\n\n  _getAttributeInfo(attributeName) {\n    return this.configuration && this.configuration.getAttributeInfo(attributeName);\n  }\n\n  _getAttributeIndex(locationOrName) {\n    const location = Number(locationOrName);\n    if (Number.isFinite(location)) {\n      return {location};\n    }\n\n    const multiLocation = MULTI_LOCATION_ATTRIBUTE_REGEXP.exec(locationOrName);\n    const name = multiLocation ? multiLocation[1] : locationOrName;\n    const locationOffset = multiLocation ? Number(multiLocation[2]) : 0;\n\n    if (this.configuration) {\n      return {\n        location: this.configuration.getAttributeLocation(name) + locationOffset,\n        name\n      };\n    }\n\n    return {location: -1};\n  }\n\n  _setAttribute(locationOrName, value) {\n    if (value instanceof Buffer) {\n      //  Signature: {attributeName: Buffer}\n      this.setBuffer(locationOrName, value);\n    } else if (Array.isArray(value) && value.length && value[0] instanceof Buffer) {\n      // Signature: {attributeName: [buffer, accessor]}\n      const buffer = value[0];\n      const accessor = value[1];\n      this.setBuffer(locationOrName, buffer, accessor);\n    } else if (ArrayBuffer.isView(value) || Array.isArray(value)) {\n      // Signature: {attributeName: constant}, constant == short (typed) array\n      const constant = value;\n      this.setConstant(locationOrName, constant);\n    } else if (value.buffer instanceof Buffer) {\n      // luma.gl v7: Support accessor objects with 'buffer' field\n      // for interleaved data\n      // Signature: {attributeName: {...accessor, buffer}}\n      const accessor = value;\n      this.setBuffer(locationOrName, accessor.buffer, accessor);\n    } else {\n      throw new Error(ERR_ATTRIBUTE_TYPE);\n    }\n  }\n\n  // Updates all constant attribute values (constants are used when vertex attributes are disabled).\n  // This needs to be done repeatedly since in contrast to buffer bindings,\n  // constants are stored on the WebGL context, not the VAO\n  _setConstantAttributes(vertexCount, instanceCount) {\n    // TODO - use accessor to determine what length to use\n    const elementCount = Math.max(vertexCount | 0, instanceCount | 0);\n    let constant = this.values[0];\n    if (ArrayBuffer.isView(constant)) {\n      this._setConstantAttributeZero(constant, elementCount);\n    }\n\n    for (let location = 1; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {\n      constant = this.values[location];\n      if (ArrayBuffer.isView(constant)) {\n        this._setConstantAttribute(location, constant);\n      }\n    }\n  }\n\n  _setConstantAttributeZero(constant, elementCount) {\n    if (VertexArrayObject.isSupported(this.gl, {constantAttributeZero: true})) {\n      this._setConstantAttribute(0, constant);\n      return;\n    }\n\n    // Get a dummy buffer populated with repeated constants\n    const buffer = this.vertexArrayObject.getConstantBuffer(elementCount, constant);\n\n    // Set the buffer on location 0\n    this.vertexArrayObject.setBuffer(0, buffer, this.accessors[0]);\n  }\n\n  _setConstantAttribute(location, constant) {\n    VertexArrayObject.setConstant(this.gl, location, constant);\n  }\n\n  // Walks the buffers and updates draw parameters\n  _updateDrawParams() {\n    const drawParams = {\n      isIndexed: false,\n      isInstanced: false,\n      indexCount: Infinity,\n      vertexCount: Infinity,\n      instanceCount: Infinity\n    };\n\n    for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {\n      this._updateDrawParamsForLocation(drawParams, location);\n    }\n\n    if (this.elements) {\n      // indexing is autodetected - buffer with target GL.ELEMENT_ARRAY_BUFFER\n      // index type is saved for drawElement calls\n      drawParams.elementCount = this.elements.getElementCount(this.elements.accessor);\n      drawParams.isIndexed = true;\n      drawParams.indexType = this.elementsAccessor.type || this.elements.accessor.type;\n      drawParams.indexOffset = this.elementsAccessor.offset || 0;\n    }\n\n    // Post-calculation checks\n    if (drawParams.indexCount === Infinity) {\n      drawParams.indexCount = 0;\n    }\n    if (drawParams.vertexCount === Infinity) {\n      drawParams.vertexCount = 0;\n    }\n    if (drawParams.instanceCount === Infinity) {\n      drawParams.instanceCount = 0;\n    }\n\n    return drawParams;\n  }\n\n  _updateDrawParamsForLocation(drawParams, location) {\n    const value = this.values[location];\n    const accessor = this.accessors[location];\n\n    if (!value) {\n      return;\n    }\n\n    // Check if instanced (whether buffer or constant)\n    const {divisor} = accessor;\n    const isInstanced = divisor > 0;\n    drawParams.isInstanced = drawParams.isInstanced || isInstanced;\n\n    if (value instanceof Buffer) {\n      const buffer = value;\n\n      if (isInstanced) {\n        // instance attribute\n        const instanceCount = buffer.getVertexCount(accessor);\n        drawParams.instanceCount = Math.min(drawParams.instanceCount, instanceCount);\n      } else {\n        // normal attribute\n        const vertexCount = buffer.getVertexCount(accessor);\n        drawParams.vertexCount = Math.min(drawParams.vertexCount, vertexCount);\n      }\n    }\n  }\n\n  // DEPRECATED in v6.x - but not warnings not properly implemented\n\n  setElements(elementBuffer = null, accessor = {}) {\n    log.deprecated('setElements', 'setElementBuffer')();\n    return this.setElementBuffer(elementBuffer, accessor);\n  }\n}\n","// @ts-nocheck\n\n/* eslint-disable camelcase */\nimport {decomposeCompositeGLType} from '../webgl-utils/attribute-utils';\nimport {assert} from '../utils/assert';\n\nconst ERR_ARGUMENT = 'UniformBufferLayout illegal argument';\n\n// Local constants - these will \"collapse\" during minification\nconst GL_FLOAT = 0x1406;\nconst GL_INT = 0x1404;\nconst GL_UNSIGNED_INT = 0x1405;\n\n// Std140 layout for uniforms\nexport default class UniformBufferLayout {\n  constructor(layout) {\n    this.layout = {};\n    this.size = 0;\n\n    // Add layout (type, size and offset) definitions for each uniform in the layout\n    for (const key in layout) {\n      this._addUniform(key, layout[key]);\n    }\n\n    this.size += (4 - (this.size % 4)) % 4;\n\n    // Allocate three typed arrays pointing at same memory\n    const data = new Float32Array(this.size);\n    this.typedArray = {\n      [GL_FLOAT]: data,\n      [GL_INT]: new Int32Array(data.buffer),\n      [GL_UNSIGNED_INT]: new Uint32Array(data.buffer)\n    };\n  }\n\n  // Get number of bytes needed for buffer allocation\n  getBytes() {\n    return this.size * 4;\n  }\n\n  // Get the current data as Float32Array, for bufferSubData\n  getData() {\n    return this.typedArray[GL_FLOAT];\n  }\n\n  // Get offset and data for one object (for bufferSubData)\n  getSubData(index) {\n    let data;\n    let offset;\n    if (index === undefined) {\n      data = this.data;\n      offset = 0;\n    } else {\n      const begin = this.offsets[index];\n      const end = begin + this.sizes[index];\n      data = this.data.subarray(begin, end);\n      offset = begin * 4;\n    }\n    return {data, offset};\n  }\n\n  // Set a map of values\n  setUniforms(values) {\n    for (const key in values) {\n      this._setValue(key, values[key]);\n    }\n    return this;\n  }\n\n  _setValue(key, value) {\n    const layout = this.layout[key];\n    assert(layout, 'UniformLayoutStd140 illegal argument');\n    const typedArray = this.typedArray[layout.type];\n    if (layout.size === 1) {\n      // single value -> just set it\n      typedArray[layout.offset] = value;\n    } else {\n      // vector/matrix -> copy the supplied (typed) array, starting from offset\n      typedArray.set(value, layout.offset);\n    }\n  }\n\n  _addUniform(key, uniformType) {\n    const typeAndComponents = decomposeCompositeGLType(uniformType);\n    assert(typeAndComponents, ERR_ARGUMENT);\n    const {type, components: count} = typeAndComponents;\n\n    // First, align (bump) current offset to an even multiple of current object (1, 2, 4)\n    this.size = this._alignTo(this.size, count);\n    // Use the aligned size as the offset of the current uniform.\n    const offset = this.size;\n    // Then, add our object's padded size ((1, 2, multiple of 4) to the current offset\n    this.size += count;\n\n    this.layout[key] = {type, size: count, offset};\n  }\n\n  // Align offset to 1, 2 or 4 elements (4, 8 or 16 bytes)\n  _alignTo(size, count) {\n    switch (count) {\n      case 1:\n        return size; // Pad upwards to even multiple of 2\n      case 2:\n        return size + (size % 2); // Pad upwards to even multiple of 2\n      default:\n        return size + ((4 - (size % 4)) % 4); // Pad upwards to even multiple of 4\n    }\n  }\n}\n","import {assert} from '../utils/assert';\nimport {formatValue} from '../utils/format-value';\n\n// Prepares a table suitable for console.table\n/* eslint-disable max-statements, complexity */\nexport function getDebugTableForUniforms({\n  header = 'Uniforms',\n  program,\n  uniforms,\n  undefinedOnly = false\n}) {\n  assert(program);\n\n  const SHADER_MODULE_UNIFORM_REGEXP = '.*_.*';\n  const PROJECT_MODULE_UNIFORM_REGEXP = '.*Matrix'; // TODO - Use explicit list\n\n  const uniformLocations = program._uniformSetters;\n  const table = {}; // {[header]: {}};\n\n  // Add program's provided uniforms (in alphabetical order)\n  const uniformNames = Object.keys(uniformLocations).sort();\n\n  let count = 0;\n\n  // First add non-underscored uniforms (assumed not coming from shader modules)\n  for (const uniformName of uniformNames) {\n    if (\n      !uniformName.match(SHADER_MODULE_UNIFORM_REGEXP) &&\n      !uniformName.match(PROJECT_MODULE_UNIFORM_REGEXP)\n    ) {\n      if (addUniformToTable({table, header, uniforms, uniformName, undefinedOnly})) {\n        count++;\n      }\n    }\n  }\n\n  // add underscored uniforms (assumed from shader modules)\n  for (const uniformName of uniformNames) {\n    if (uniformName.match(PROJECT_MODULE_UNIFORM_REGEXP)) {\n      if (addUniformToTable({table, header, uniforms, uniformName, undefinedOnly})) {\n        count++;\n      }\n    }\n  }\n\n  for (const uniformName of uniformNames) {\n    if (!table[uniformName]) {\n      if (addUniformToTable({table, header, uniforms, uniformName, undefinedOnly})) {\n        count++;\n      }\n    }\n  }\n\n  // Create a table of unused uniforms\n  let unusedCount = 0;\n  const unusedTable = {};\n  if (!undefinedOnly) {\n    for (const uniformName in uniforms) {\n      const uniform = uniforms[uniformName];\n      if (!table[uniformName]) {\n        unusedCount++;\n        unusedTable[uniformName] = {\n          Type: `NOT USED: ${uniform}`,\n          [header]: formatValue(uniform)\n        };\n      }\n    }\n  }\n\n  return {table, count, unusedTable, unusedCount};\n}\n\n// Helper\nfunction addUniformToTable({table, header, uniforms, uniformName, undefinedOnly}) {\n  const value = uniforms[uniformName];\n  const isDefined = isUniformDefined(value);\n  if (!undefinedOnly || !isDefined) {\n    table[uniformName] = {\n      // Add program's unprovided uniforms\n      [header]: isDefined ? formatValue(value) : 'N/A',\n      'Uniform Type': isDefined ? value : 'NOT PROVIDED'\n    };\n    return true;\n  }\n  return false;\n}\n\nfunction isUniformDefined(value) {\n  return value !== undefined && value !== null;\n}\n","// TODO / DEPRECATED - delete when confident that probe.gl logging implements all opts\n/* eslint-disable no-console */\nfunction formatArrayValue(v, opts) {\n  const {maxElts = 16, size = 1} = opts;\n  let string = '[';\n  for (let i = 0; i < v.length && i < maxElts; ++i) {\n    if (i > 0) {\n      string += `,${i % size === 0 ? ' ' : ''}`;\n    }\n    string += formatValue(v[i], opts);\n  }\n  const terminator = v.length > maxElts ? '...' : ']';\n  return `${string}${terminator}`;\n}\n\nexport function formatValue(v, opts = {}) {\n  const EPSILON = 1e-16;\n  const {isInteger = false} = opts;\n  if (Array.isArray(v) || ArrayBuffer.isView(v)) {\n    return formatArrayValue(v, opts);\n  }\n  if (!Number.isFinite(v)) {\n    return String(v);\n  }\n  if (Math.abs(v) < EPSILON) {\n    return isInteger ? '0' : '0.';\n  }\n  if (isInteger) {\n    return v.toFixed(0);\n  }\n  if (Math.abs(v) > 100 && Math.abs(v) < 10000) {\n    return v.toFixed(0);\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","import Buffer from '../classes/buffer';\nimport {getKey} from '../webgl-utils/constants-to-keys';\nimport {getCompositeGLType} from '../webgl-utils/attribute-utils';\nimport {formatValue} from '../utils/format-value';\n\n// Creates object suitable as input for console.table\nexport function getDebugTableForVertexArray({vertexArray, header = 'Attributes'}) {\n  if (!vertexArray.configuration) {\n    return {};\n  }\n\n  const table = {}; // {[header]: {}};\n\n  // Add index (elements) if available\n  if (vertexArray.elements) {\n    // const elements = Object.assign({size: 1}, vertexArray.elements);\n    table.ELEMENT_ARRAY_BUFFER = getDebugTableRow(vertexArray, vertexArray.elements, null, header);\n  }\n\n  // Add used attributes\n  const attributes = vertexArray.values;\n\n  for (const attributeLocation in attributes) {\n    const info = vertexArray._getAttributeInfo(attributeLocation);\n    if (info) {\n      let rowHeader = `${attributeLocation}: ${info.name}`;\n      const accessor = vertexArray.accessors[info.location];\n      if (accessor) {\n        rowHeader = `${attributeLocation}: ${getGLSLDeclaration(info.name, accessor)}`;\n      }\n      table[rowHeader] = getDebugTableRow(\n        vertexArray,\n        attributes[attributeLocation],\n        accessor,\n        header\n      );\n    }\n  }\n\n  return table;\n}\n\n/* eslint-disable max-statements */\nfunction getDebugTableRow(vertexArray, attribute, accessor, header) {\n  const {gl} = vertexArray;\n\n  if (!attribute) {\n    return {\n      [header]: 'null',\n      'Format ': 'N/A'\n    };\n  }\n\n  let type = 'NOT PROVIDED';\n  let size = 1;\n  let verts = 0;\n  let bytes = 0;\n\n  let isInteger;\n  let marker;\n  let value;\n\n  if (accessor) {\n    type = accessor.type;\n    size = accessor.size;\n\n    // Generate a type name by dropping Array from Float32Array etc.\n    type = String(type).replace('Array', '');\n\n    // Look for 'nt' to detect integer types, e.g. Int32Array, Uint32Array\n    isInteger = type.indexOf('nt') !== -1;\n  }\n\n  if (attribute instanceof Buffer) {\n    const buffer = attribute;\n\n    const {data, changed} = buffer.getDebugData();\n    marker = changed ? '*' : '';\n\n    value = data;\n    // @ts-ignore\n    bytes = buffer.byteLength;\n    // @ts-ignore\n    verts = bytes / data.BYTES_PER_ELEMENT / size;\n\n    let format;\n\n    if (accessor) {\n      const instanced = accessor.divisor > 0;\n      format = `${instanced ? 'I ' : 'P '} ${verts} (x${size}=${bytes} bytes ${getKey(gl, type)})`;\n    } else {\n      // element buffer\n      isInteger = true;\n      format = `${bytes} bytes`;\n    }\n\n    return {\n      [header]: `${marker}${formatValue(value, {size, isInteger})}`,\n      'Format ': format\n    };\n  }\n\n  // CONSTANT VALUE\n  value = attribute;\n  size = attribute.length;\n  // Generate a type name by dropping Array from Float32Array etc.\n  type = String(attribute.constructor.name).replace('Array', '');\n  // Look for 'nt' to detect integer types, e.g. Int32Array, Uint32Array\n  isInteger = type.indexOf('nt') !== -1;\n\n  return {\n    [header]: `${formatValue(value, {size, isInteger})} (constant)`,\n    'Format ': `${size}x${type} (constant)`\n  };\n}\n/* eslint-ensable max-statements */\n\nfunction getGLSLDeclaration(name, accessor) {\n  const {type, size} = accessor;\n  const typeAndName = getCompositeGLType(type, size);\n  return typeAndName ? `${name} (${typeAndName.name})` : name;\n}\n","import {getCompositeGLType} from '../webgl-utils/attribute-utils';\n\nexport function getDebugTableForProgramConfiguration(config) {\n  const table = {};\n\n  const header = `Accessors for ${config.id}`;\n\n  for (const attributeInfo of config.attributeInfos) {\n    if (attributeInfo) {\n      const glslDeclaration = getGLSLDeclaration(attributeInfo);\n      table[`in ${glslDeclaration}`] = {[header]: JSON.stringify(attributeInfo.accessor)};\n    }\n  }\n\n  for (const varyingInfo of config.varyingInfos) {\n    if (varyingInfo) {\n      const glslDeclaration = getGLSLDeclaration(varyingInfo);\n      table[`out ${glslDeclaration}`] = {[header]: JSON.stringify(varyingInfo.accessor)};\n    }\n  }\n\n  return table;\n}\n\nfunction getGLSLDeclaration(attributeInfo) {\n  const {type, size} = attributeInfo.accessor;\n  const typeAndName = getCompositeGLType(type, size);\n  if (typeAndName) {\n    return `${typeAndName.name} ${attributeInfo.name}`;\n  }\n  return attributeInfo.name;\n}\n","// CORE\nexport {default as AnimationLoop} from './lib/animation-loop';\nexport {default as Model} from './lib/model';\nexport {default as ProgramManager} from './lib/program-manager';\nexport {default as Transform} from './transform/transform';\n\n// Geometries\nexport {default as Geometry} from './geometry/geometry';\nexport {default as ConeGeometry} from './geometries/cone-geometry';\nexport {default as CubeGeometry} from './geometries/cube-geometry';\nexport {default as CylinderGeometry} from './geometries/cylinder-geometry';\nexport {default as IcoSphereGeometry} from './geometries/ico-sphere-geometry';\nexport {default as PlaneGeometry} from './geometries/plane-geometry';\nexport {default as SphereGeometry} from './geometries/sphere-geometry';\nexport {default as TruncatedConeGeometry} from './geometries/truncated-cone-geometry';\n\n// Animation\nexport {Timeline} from './animation/timeline';\nexport {KeyFrames} from './animation/key-frames';\n\n// Utils\nexport {default as ClipSpace} from './utils/clip-space';\n","import {\n  isWebGL,\n  createGLContext,\n  instrumentGLContext,\n  resizeGLContext,\n  resetParameters\n} from '@luma.gl/gltools';\n\nimport {\n  requestAnimationFrame,\n  cancelAnimationFrame,\n  Query,\n  lumaStats,\n  // TODO - remove dependency on framebuffer (bundle size impact)\n  Framebuffer,\n  log,\n  assert\n} from '@luma.gl/webgl';\n\nimport {isBrowser} from 'probe.gl/env';\n\nconst isPage = isBrowser() && typeof document !== 'undefined';\n\nlet statIdCounter = 0;\n\nexport default class AnimationLoop {\n  /*\n   * @param {HTMLCanvasElement} canvas - if provided, width and height will be passed to context\n   */\n  constructor(props = {}) {\n    const {\n      onCreateContext = opts => createGLContext(opts),\n      onAddHTML = null,\n      onInitialize = () => {},\n      onRender = () => {},\n      onFinalize = () => {},\n      onError,\n\n      gl = null,\n      glOptions = {},\n      debug = false,\n\n      createFramebuffer = false,\n\n      // view parameters\n      autoResizeViewport = true,\n      autoResizeDrawingBuffer = true,\n      stats = lumaStats.get(`animation-loop-${statIdCounter++}`)\n    } = props;\n\n    let {useDevicePixels = true} = props;\n\n    if ('useDevicePixelRatio' in props) {\n      log.deprecated('useDevicePixelRatio', 'useDevicePixels')();\n      // @ts-ignore\n      useDevicePixels = props.useDevicePixelRatio;\n    }\n\n    this.props = {\n      onCreateContext,\n      onAddHTML,\n      onInitialize,\n      onRender,\n      onFinalize,\n      onError,\n\n      gl,\n      glOptions,\n      debug,\n      createFramebuffer\n    };\n\n    // state\n    this.gl = gl;\n    this.needsRedraw = null;\n    this.timeline = null;\n    this.stats = stats;\n    this.cpuTime = this.stats.get('CPU Time');\n    this.gpuTime = this.stats.get('GPU Time');\n    this.frameRate = this.stats.get('Frame Rate');\n\n    this._initialized = false;\n    this._running = false;\n    this._animationFrameId = null;\n    this._nextFramePromise = null;\n    this._resolveNextFrame = null;\n    this._cpuStartTime = 0;\n\n    this.setProps({\n      autoResizeViewport,\n      autoResizeDrawingBuffer,\n      useDevicePixels\n    });\n\n    // Bind methods\n    this.start = this.start.bind(this);\n    this.stop = this.stop.bind(this);\n\n    this._pageLoadPromise = null;\n\n    this._onMousemove = this._onMousemove.bind(this);\n    this._onMouseleave = this._onMouseleave.bind(this);\n  }\n\n  delete() {\n    this.stop();\n    this._setDisplay(null);\n  }\n\n  setNeedsRedraw(reason) {\n    assert(typeof reason === 'string');\n    this.needsRedraw = this.needsRedraw || reason;\n    return this;\n  }\n\n  setProps(props) {\n    if ('autoResizeViewport' in props) {\n      this.autoResizeViewport = props.autoResizeViewport;\n    }\n    if ('autoResizeDrawingBuffer' in props) {\n      this.autoResizeDrawingBuffer = props.autoResizeDrawingBuffer;\n    }\n    if ('useDevicePixels' in props) {\n      this.useDevicePixels = props.useDevicePixels;\n    }\n    return this;\n  }\n\n  // Starts a render loop if not already running\n  // @param {Object} context - contains frame specific info (E.g. tick, width, height, etc)\n  start(opts = {}) {\n    if (this._running) {\n      return this;\n    }\n    this._running = true;\n    // console.debug(`Starting ${this.constructor.name}`);\n    // Wait for start promise before rendering frame\n    const startPromise = this._getPageLoadPromise()\n      .then(() => {\n        if (!this._running || this._initialized) {\n          return null;\n        }\n\n        // Create the WebGL context\n        this._createWebGLContext(opts);\n        this._createFramebuffer();\n        this._startEventHandling();\n\n        // Initialize the callback data\n        this._initializeCallbackData();\n        this._updateCallbackData();\n\n        // Default viewport setup, in case onInitialize wants to render\n        this._resizeCanvasDrawingBuffer();\n        this._resizeViewport();\n\n        this._gpuTimeQuery = Query.isSupported(this.gl, ['timers']) ? new Query(this.gl) : null;\n\n        this._initialized = true;\n\n        // Note: onIntialize can return a promise (in case it needs to load resources)\n        return this.onInitialize(this.animationProps);\n      })\n      .then(appContext => {\n        if (this._running) {\n          this._addCallbackData(appContext || {});\n          if (appContext !== false) {\n            this._startLoop();\n          }\n        }\n      });\n\n    if (this.props.onError) {\n      startPromise.catch(this.props.onError);\n    }\n\n    return this;\n  }\n\n  // Redraw now\n  redraw() {\n    if (this.isContextLost()) {\n      return this;\n    }\n\n    this._beginTimers();\n\n    this._setupFrame();\n    this._updateCallbackData();\n\n    this._renderFrame(this.animationProps);\n\n    // clear needsRedraw flag\n    this._clearNeedsRedraw();\n\n    // https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/commit\n    // Chrome's offscreen canvas does not require gl.commit\n    if (this.offScreen && this.gl.commit) {\n      this.gl.commit();\n    }\n\n    if (this._resolveNextFrame) {\n      this._resolveNextFrame(this);\n      this._nextFramePromise = null;\n      this._resolveNextFrame = null;\n    }\n\n    this._endTimers();\n\n    return this;\n  }\n\n  // Stops a render loop if already running, finalizing\n  stop() {\n    // console.debug(`Stopping ${this.constructor.name}`);\n    if (this._running) {\n      this._finalizeCallbackData();\n      this._cancelAnimationFrame(this._animationFrameId);\n      this._nextFramePromise = null;\n      this._resolveNextFrame = null;\n      this._animationFrameId = null;\n      this._running = false;\n    }\n    return this;\n  }\n\n  attachTimeline(timeline) {\n    this.timeline = timeline;\n\n    return this.timeline;\n  }\n\n  detachTimeline() {\n    this.timeline = null;\n  }\n\n  waitForRender() {\n    this.setNeedsRedraw('waitForRender');\n\n    if (!this._nextFramePromise) {\n      this._nextFramePromise = new Promise(resolve => {\n        this._resolveNextFrame = resolve;\n      });\n    }\n    return this._nextFramePromise;\n  }\n\n  async toDataURL() {\n    this.setNeedsRedraw('toDataURL');\n\n    await this.waitForRender();\n\n    return this.gl.canvas.toDataURL();\n  }\n\n  isContextLost() {\n    return this.gl.isContextLost();\n  }\n\n  onCreateContext(...args) {\n    return this.props.onCreateContext(...args);\n  }\n\n  onInitialize(...args) {\n    return this.props.onInitialize(...args);\n  }\n\n  onRender(...args) {\n    return this.props.onRender(...args);\n  }\n\n  onFinalize(...args) {\n    return this.props.onFinalize(...args);\n  }\n\n  // DEPRECATED/REMOVED METHODS\n\n  getHTMLControlValue(id, defaultValue = 1) {\n    const element = document.getElementById(id);\n    // @ts-ignore Not all html elements have value\n    return element ? Number(element.value) : defaultValue;\n  }\n\n  // Update parameters\n  setViewParameters() {\n    log.removed('AnimationLoop.setViewParameters', 'AnimationLoop.setProps')();\n    return this;\n  }\n\n  // PRIVATE METHODS\n\n  _startLoop() {\n    const renderFrame = () => {\n      if (!this._running) {\n        return;\n      }\n      this.redraw();\n      this._animationFrameId = this._requestAnimationFrame(renderFrame);\n    };\n\n    // cancel any pending renders to ensure only one loop can ever run\n    this._cancelAnimationFrame(this._animationFrameId);\n    this._animationFrameId = this._requestAnimationFrame(renderFrame);\n  }\n\n  // PRIVATE METHODS\n\n  _getPageLoadPromise() {\n    if (!this._pageLoadPromise) {\n      this._pageLoadPromise = isPage\n        ? new Promise((resolve, reject) => {\n            if (isPage && document.readyState === 'complete') {\n              resolve(document);\n              return;\n            }\n            window.addEventListener('load', () => {\n              resolve(document);\n            });\n          })\n        : Promise.resolve({});\n    }\n    return this._pageLoadPromise;\n  }\n\n  _setDisplay(display) {\n    if (this.display) {\n      this.display.delete();\n      this.display.animationLoop = null;\n    }\n\n    // store animation loop on the display\n    if (display) {\n      display.animationLoop = this;\n    }\n\n    this.display = display;\n  }\n\n  _cancelAnimationFrame(animationFrameId) {\n    // E.g. VR display has a separate animation frame to sync with headset\n    if (this.display && this.display.cancelAnimationFrame) {\n      return this.display.cancelAnimationFrame(animationFrameId);\n    }\n\n    return cancelAnimationFrame(animationFrameId);\n  }\n\n  _requestAnimationFrame(renderFrameCallback) {\n    if (this._running) {\n      // E.g. VR display has a separate animation frame to sync with headset\n      if (this.display && this.display.requestAnimationFrame) {\n        return this.display.requestAnimationFrame(renderFrameCallback);\n      }\n\n      return requestAnimationFrame(renderFrameCallback);\n    }\n    return undefined;\n  }\n\n  // Called on each frame, can be overridden to call onRender multiple times\n  // to support e.g. stereoscopic rendering\n  _renderFrame(...args) {\n    // Allow e.g. VR display to render multiple frames.\n    if (this.display) {\n      this.display._renderFrame(...args);\n      return;\n    }\n\n    // call callback\n    this.onRender(...args);\n    // end callback\n  }\n\n  _clearNeedsRedraw() {\n    this.needsRedraw = null;\n  }\n\n  _setupFrame() {\n    this._resizeCanvasDrawingBuffer();\n    this._resizeViewport();\n    this._resizeFramebuffer();\n  }\n\n  // Initialize the  object that will be passed to app callbacks\n  _initializeCallbackData() {\n    this.animationProps = {\n      gl: this.gl,\n\n      stop: this.stop,\n      canvas: this.gl.canvas,\n      framebuffer: this.framebuffer,\n\n      // Initial values\n      useDevicePixels: this.useDevicePixels,\n      needsRedraw: null,\n\n      // Animation props\n      startTime: Date.now(),\n      engineTime: 0,\n      tick: 0,\n      tock: 0,\n\n      // Timeline time for back compatibility\n      time: 0,\n\n      // Experimental\n      _timeline: this.timeline,\n      _loop: this,\n      _animationLoop: this,\n      _mousePosition: null // Event props\n    };\n  }\n\n  // Update the context object that will be passed to app callbacks\n  _updateCallbackData() {\n    const {width, height, aspect} = this._getSizeAndAspect();\n    if (width !== this.animationProps.width || height !== this.animationProps.height) {\n      this.setNeedsRedraw('drawing buffer resized');\n    }\n    if (aspect !== this.animationProps.aspect) {\n      this.setNeedsRedraw('drawing buffer aspect changed');\n    }\n\n    this.animationProps.width = width;\n    this.animationProps.height = height;\n    this.animationProps.aspect = aspect;\n\n    this.animationProps.needsRedraw = this.needsRedraw;\n\n    // Update time properties\n    this.animationProps.engineTime = Date.now() - this.animationProps.startTime;\n\n    if (this.timeline) {\n      this.timeline.update(this.animationProps.engineTime);\n    }\n\n    this.animationProps.tick = Math.floor((this.animationProps.time / 1000) * 60);\n    this.animationProps.tock++;\n\n    // For back compatibility\n    this.animationProps.time = this.timeline\n      ? this.timeline.getTime()\n      : this.animationProps.engineTime;\n\n    // experimental\n    this.animationProps._offScreen = this.offScreen;\n  }\n\n  _finalizeCallbackData() {\n    // call callback\n    this.onFinalize(this.animationProps);\n    // end callback\n  }\n\n  // Add application's data to the app context object\n  _addCallbackData(appContext) {\n    if (typeof appContext === 'object' && appContext !== null) {\n      this.animationProps = Object.assign({}, this.animationProps, appContext);\n    }\n  }\n\n  // Either uses supplied or existing context, or calls provided callback to create one\n  _createWebGLContext(opts) {\n    this.offScreen =\n      opts.canvas &&\n      typeof OffscreenCanvas !== 'undefined' &&\n      opts.canvas instanceof OffscreenCanvas;\n\n    // Create the WebGL context if necessary\n    opts = Object.assign({}, opts, this.props.glOptions);\n    this.gl = this.props.gl ? instrumentGLContext(this.props.gl, opts) : this.onCreateContext(opts);\n\n    if (!isWebGL(this.gl)) {\n      throw new Error('AnimationLoop.onCreateContext - illegal context returned');\n    }\n\n    // Reset the WebGL context.\n    resetParameters(this.gl);\n\n    this._createInfoDiv();\n  }\n\n  _createInfoDiv() {\n    if (this.gl.canvas && this.props.onAddHTML) {\n      const wrapperDiv = document.createElement('div');\n      document.body.appendChild(wrapperDiv);\n      wrapperDiv.style.position = 'relative';\n      const div = document.createElement('div');\n      div.style.position = 'absolute';\n      div.style.left = '10px';\n      div.style.bottom = '10px';\n      div.style.width = '300px';\n      div.style.background = 'white';\n      wrapperDiv.appendChild(this.gl.canvas);\n      wrapperDiv.appendChild(div);\n      const html = this.props.onAddHTML(div);\n      if (html) {\n        div.innerHTML = html;\n      }\n    }\n  }\n\n  _getSizeAndAspect() {\n    // https://webglfundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html\n    const width = this.gl.drawingBufferWidth;\n    const height = this.gl.drawingBufferHeight;\n\n    // https://webglfundamentals.org/webgl/lessons/webgl-anti-patterns.html\n    let aspect = 1;\n    const {canvas} = this.gl;\n\n    if (canvas && canvas.clientHeight) {\n      aspect = canvas.clientWidth / canvas.clientHeight;\n    } else if (width > 0 && height > 0) {\n      aspect = width / height;\n    }\n\n    return {width, height, aspect};\n  }\n\n  // Default viewport setup\n  _resizeViewport() {\n    if (this.autoResizeViewport) {\n      this.gl.viewport(0, 0, this.gl.drawingBufferWidth, this.gl.drawingBufferHeight);\n    }\n  }\n\n  // Resize the render buffer of the canvas to match canvas client size\n  // Optionally multiplying with devicePixel ratio\n  _resizeCanvasDrawingBuffer() {\n    if (this.autoResizeDrawingBuffer) {\n      resizeGLContext(this.gl, {useDevicePixels: this.useDevicePixels});\n    }\n  }\n\n  // TBD - deprecated?\n  _createFramebuffer() {\n    // Setup default framebuffer\n    if (this.props.createFramebuffer) {\n      this.framebuffer = new Framebuffer(this.gl);\n    }\n  }\n\n  _resizeFramebuffer() {\n    if (this.framebuffer) {\n      this.framebuffer.resize({\n        width: this.gl.drawingBufferWidth,\n        height: this.gl.drawingBufferHeight\n      });\n    }\n  }\n\n  _beginTimers() {\n    this.frameRate.timeEnd();\n    this.frameRate.timeStart();\n\n    // Check if timer for last frame has completed.\n    // GPU timer results are never available in the same\n    // frame they are captured.\n    if (\n      this._gpuTimeQuery &&\n      this._gpuTimeQuery.isResultAvailable() &&\n      !this._gpuTimeQuery.isTimerDisjoint()\n    ) {\n      this.stats.get('GPU Time').addTime(this._gpuTimeQuery.getTimerMilliseconds());\n    }\n\n    if (this._gpuTimeQuery) {\n      // GPU time query start\n      this._gpuTimeQuery.beginTimeElapsedQuery();\n    }\n\n    this.cpuTime.timeStart();\n  }\n\n  _endTimers() {\n    this.cpuTime.timeEnd();\n\n    if (this._gpuTimeQuery) {\n      // GPU time query end. Results will be available on next frame.\n      this._gpuTimeQuery.end();\n    }\n  }\n\n  // Event handling\n\n  _startEventHandling() {\n    const {canvas} = this.gl;\n    if (canvas) {\n      canvas.addEventListener('mousemove', this._onMousemove);\n      canvas.addEventListener('mouseleave', this._onMouseleave);\n    }\n  }\n\n  _onMousemove(e) {\n    this.animationProps._mousePosition = [e.offsetX, e.offsetY];\n  }\n  _onMouseleave(e) {\n    this.animationProps._mousePosition = null;\n  }\n}\n","/* eslint-disable complexity */\n\nimport GL from '@luma.gl/constants';\nimport {isWebGL} from '@luma.gl/gltools';\nimport ProgramManager from './program-manager';\nimport {\n  Program,\n  VertexArray,\n  clear,\n  TransformFeedback,\n  Buffer,\n  log,\n  isObjectEmpty,\n  uid,\n  assert\n} from '@luma.gl/webgl';\nimport {\n  getDebugTableForUniforms,\n  getDebugTableForVertexArray,\n  getDebugTableForProgramConfiguration\n} from '@luma.gl/webgl';\nimport {getBuffersFromGeometry} from './model-utils';\n\nconst LOG_DRAW_PRIORITY = 2;\nconst LOG_DRAW_TIMEOUT = 10000;\n\nconst ERR_MODEL_PARAMS = 'Model needs drawMode and vertexCount';\n\nconst NOOP = () => {};\nconst DRAW_PARAMS = {};\n\nexport default class Model {\n  constructor(gl, props = {}) {\n    // Deduce a helpful id\n    const {id = uid('model')} = props;\n    assert(isWebGL(gl));\n    this.id = id;\n    this.gl = gl;\n    this.id = props.id || uid('Model');\n    this.lastLogTime = 0; // TODO - move to probe.gl\n    this.animated = false;\n    this.initialize(props);\n  }\n\n  initialize(props) {\n    this.props = {};\n\n    this.programManager = props.programManager || ProgramManager.getDefaultProgramManager(this.gl);\n    this._programManagerState = -1;\n    this._managedProgram = false;\n\n    const {\n      program = null,\n      vs,\n      fs,\n      modules,\n      defines,\n      inject,\n      varyings,\n      bufferMode,\n      transpileToGLSL100\n    } = props;\n\n    this.programProps = {\n      program,\n      vs,\n      fs,\n      modules,\n      defines,\n      inject,\n      varyings,\n      bufferMode,\n      transpileToGLSL100\n    };\n    this.program = null;\n    this.vertexArray = null;\n    this._programDirty = true;\n\n    // Initialize state\n    this.userData = {};\n    this.needsRedraw = true;\n\n    // Attributes and buffers\n    // Model manages auto Buffer creation from typed arrays\n    this._attributes = {}; // All attributes\n    this.attributes = {}; // User defined attributes\n\n    // Model manages uniform animation\n    this.uniforms = {};\n\n    // picking options\n    this.pickable = true;\n\n    this._checkProgram();\n\n    this.setUniforms(\n      Object.assign(\n        {},\n        this.getModuleUniforms(props.moduleSettings) // Get unforms for supplied parameters\n      )\n    );\n\n    this.drawMode = props.drawMode !== undefined ? props.drawMode : GL.TRIANGLES;\n    this.vertexCount = props.vertexCount || 0;\n\n    // Track buffers created by setGeometry\n    this.geometryBuffers = {};\n\n    // geometry might have set drawMode and vertexCount\n    this.isInstanced = props.isInstanced || props.instanced || props.instanceCount > 0;\n\n    this._setModelProps(props);\n\n    // TODO - just to unbreak deck.gl 7.0-beta, remove as soon as updated\n    this.geometry = {};\n\n    // assert(program || program instanceof Program);\n    assert(this.drawMode !== undefined && Number.isFinite(this.vertexCount), ERR_MODEL_PARAMS);\n  }\n\n  setProps(props) {\n    this._setModelProps(props);\n  }\n\n  delete() {\n    // delete all attributes created by this model\n    // TODO - should buffer deletes be handled by vertex array?\n    for (const key in this._attributes) {\n      if (this._attributes[key] !== this.attributes[key]) {\n        this._attributes[key].delete();\n      }\n    }\n\n    if (this._managedProgram) {\n      this.programManager.release(this.program);\n      this._managedProgram = false;\n    }\n\n    this.vertexArray.delete();\n\n    this._deleteGeometryBuffers();\n  }\n\n  // GETTERS\n\n  getDrawMode() {\n    return this.drawMode;\n  }\n\n  getVertexCount() {\n    return this.vertexCount;\n  }\n\n  getInstanceCount() {\n    return this.instanceCount;\n  }\n\n  getAttributes() {\n    return this.attributes;\n  }\n\n  getProgram() {\n    return this.program;\n  }\n\n  setProgram(props) {\n    const {\n      program,\n      vs,\n      fs,\n      modules,\n      defines,\n      inject,\n      varyings,\n      bufferMode,\n      transpileToGLSL100\n    } = props;\n    this.programProps = {\n      program,\n      vs,\n      fs,\n      modules,\n      defines,\n      inject,\n      varyings,\n      bufferMode,\n      transpileToGLSL100\n    };\n    this._programDirty = true;\n  }\n\n  getUniforms() {\n    return this.uniforms;\n  }\n\n  // SETTERS\n\n  setDrawMode(drawMode) {\n    this.drawMode = drawMode;\n    return this;\n  }\n\n  setVertexCount(vertexCount) {\n    assert(Number.isFinite(vertexCount));\n    this.vertexCount = vertexCount;\n    return this;\n  }\n\n  setInstanceCount(instanceCount) {\n    assert(Number.isFinite(instanceCount));\n    this.instanceCount = instanceCount;\n    return this;\n  }\n\n  setGeometry(geometry) {\n    this.drawMode = geometry.drawMode;\n    this.vertexCount = geometry.getVertexCount();\n\n    this._deleteGeometryBuffers();\n\n    this.geometryBuffers = getBuffersFromGeometry(this.gl, geometry);\n    this.vertexArray.setAttributes(this.geometryBuffers);\n    return this;\n  }\n\n  setAttributes(attributes = {}) {\n    // Avoid setting needsRedraw if no attributes\n    if (isObjectEmpty(attributes)) {\n      return this;\n    }\n\n    const normalizedAttributes = {};\n    for (const name in attributes) {\n      const attribute = attributes[name];\n      // The `getValue` call provides support for deck.gl `Attribute` class\n      // TODO - remove once deck refactoring completes\n      normalizedAttributes[name] = attribute.getValue ? attribute.getValue() : attribute;\n    }\n\n    this.vertexArray.setAttributes(normalizedAttributes);\n    return this;\n  }\n\n  // TODO - should actually set the uniforms\n  setUniforms(uniforms = {}) {\n    Object.assign(this.uniforms, uniforms);\n\n    return this;\n  }\n\n  getModuleUniforms(opts) {\n    this._checkProgram();\n\n    const getUniforms = this.programManager.getUniforms(this.program);\n\n    if (getUniforms) {\n      return getUniforms(opts);\n    }\n\n    return {};\n  }\n\n  updateModuleSettings(opts) {\n    const uniforms = this.getModuleUniforms(opts || {});\n    return this.setUniforms(uniforms);\n  }\n\n  // DRAW CALLS\n\n  clear(opts) {\n    clear(this.program.gl, opts);\n    return this;\n  }\n\n  draw(opts = {}) {\n    // Lazy update program and vertex array\n    this._checkProgram();\n\n    const {\n      moduleSettings = null,\n      framebuffer,\n      uniforms = {},\n      attributes = {},\n      transformFeedback = this.transformFeedback,\n      parameters = {},\n      vertexArray = this.vertexArray\n    } = opts;\n\n    // Update model with any just provided attributes, settings or uniforms\n    this.setAttributes(attributes);\n    this.updateModuleSettings(moduleSettings);\n    this.setUniforms(uniforms);\n\n    let logPriority;\n\n    if (log.priority >= LOG_DRAW_PRIORITY) {\n      logPriority = this._logDrawCallStart(LOG_DRAW_PRIORITY);\n    }\n\n    const drawParams = this.vertexArray.getDrawParams();\n    const {\n      isIndexed = drawParams.isIndexed,\n      indexType = drawParams.indexType,\n      indexOffset = drawParams.indexOffset,\n      vertexArrayInstanced = drawParams.isInstanced\n    } = this.props;\n\n    if (vertexArrayInstanced && !this.isInstanced) {\n      log.warn('Found instanced attributes on non-instanced model', this.id)();\n    }\n\n    const {isInstanced, instanceCount} = this;\n\n    const {onBeforeRender = NOOP, onAfterRender = NOOP} = this.props;\n\n    onBeforeRender();\n\n    this.program.setUniforms(this.uniforms);\n\n    const didDraw = this.program.draw(\n      Object.assign(DRAW_PARAMS, opts, {\n        logPriority,\n        uniforms: null, // Already set (may contain \"function values\" not understood by Program)\n        framebuffer,\n        parameters,\n        drawMode: this.getDrawMode(),\n        vertexCount: this.getVertexCount(),\n        vertexArray,\n        transformFeedback,\n        isIndexed,\n        indexType,\n        isInstanced,\n        instanceCount,\n        offset: isIndexed ? indexOffset : 0\n      })\n    );\n\n    onAfterRender();\n\n    if (log.priority >= LOG_DRAW_PRIORITY) {\n      this._logDrawCallEnd(logPriority, vertexArray, framebuffer);\n    }\n\n    return didDraw;\n  }\n\n  // Draw call for transform feedback\n  transform(opts = {}) {\n    const {discard = true, feedbackBuffers, unbindModels = []} = opts;\n\n    let {parameters} = opts;\n\n    if (feedbackBuffers) {\n      this._setFeedbackBuffers(feedbackBuffers);\n    }\n\n    if (discard) {\n      parameters = Object.assign({}, parameters, {[GL.RASTERIZER_DISCARD]: discard});\n    }\n\n    unbindModels.forEach(model => model.vertexArray.unbindBuffers());\n    try {\n      this.draw(Object.assign({}, opts, {parameters}));\n    } finally {\n      unbindModels.forEach(model => model.vertexArray.bindBuffers());\n    }\n\n    return this;\n  }\n\n  // DEPRECATED METHODS\n\n  render(uniforms = {}) {\n    log.warn('Model.render() is deprecated. Use Model.setUniforms() and Model.draw()')();\n    return this.setUniforms(uniforms).draw();\n  }\n\n  // PRIVATE METHODS\n\n  _setModelProps(props) {\n    Object.assign(this.props, props);\n\n    if ('uniforms' in props) {\n      this.setUniforms(props.uniforms);\n    }\n\n    if ('pickable' in props) {\n      this.pickable = props.pickable;\n    }\n\n    if ('instanceCount' in props) {\n      this.instanceCount = props.instanceCount;\n    }\n    if ('geometry' in props) {\n      this.setGeometry(props.geometry);\n    }\n\n    // webgl settings\n    if ('attributes' in props) {\n      this.setAttributes(props.attributes);\n    }\n    if ('_feedbackBuffers' in props) {\n      this._setFeedbackBuffers(props._feedbackBuffers);\n    }\n  }\n\n  _checkProgram() {\n    const needsUpdate =\n      this._programDirty || this.programManager.stateHash !== this._programManagerState;\n\n    if (!needsUpdate) {\n      return;\n    }\n\n    let {program} = this.programProps;\n\n    if (program) {\n      this._managedProgram = false;\n    } else {\n      const {\n        vs,\n        fs,\n        modules,\n        inject,\n        defines,\n        varyings,\n        bufferMode,\n        transpileToGLSL100\n      } = this.programProps;\n      program = this.programManager.get({\n        vs,\n        fs,\n        modules,\n        inject,\n        defines,\n        varyings,\n        bufferMode,\n        transpileToGLSL100\n      });\n      if (this.program && this._managedProgram) {\n        this.programManager.release(this.program);\n      }\n      this._programManagerState = this.programManager.stateHash;\n      this._managedProgram = true;\n    }\n\n    assert(program instanceof Program, 'Model needs a program');\n\n    this._programDirty = false;\n\n    if (program === this.program) {\n      return;\n    }\n\n    this.program = program;\n\n    if (this.vertexArray) {\n      // @ts-ignore TODO\n      this.vertexArray.setProps({program: this.program, attributes: this.vertexArray.attributes});\n    } else {\n      this.vertexArray = new VertexArray(this.gl, {program: this.program});\n    }\n\n    // Make sure we have some reasonable default uniforms in place\n    this.setUniforms(\n      Object.assign(\n        {},\n        this.getModuleUniforms() // Get all default uniforms,\n      )\n    );\n  }\n\n  _deleteGeometryBuffers() {\n    for (const name in this.geometryBuffers) {\n      // Buffer is raw value (for indices) or first element of [buffer, accessor] pair\n      const buffer = this.geometryBuffers[name][0] || this.geometryBuffers[name];\n      if (buffer instanceof Buffer) {\n        buffer.delete();\n      }\n    }\n  }\n\n  // Updates (evaluates) all function valued uniforms based on a new set of animationProps\n  // experimental\n  _setAnimationProps(animationProps) {\n    if (this.animated) {\n      assert(animationProps, 'Model.draw(): animated uniforms but no animationProps');\n      // const animatedUniforms = this._evaluateAnimateUniforms(animationProps);\n      // Object.assign(this.uniforms, animatedUniforms);\n    }\n  }\n\n  // Transform Feedback\n\n  _setFeedbackBuffers(feedbackBuffers = {}) {\n    // Avoid setting needsRedraw if no feedbackBuffers\n    if (isObjectEmpty(feedbackBuffers)) {\n      return this;\n    }\n\n    const {gl} = this.program;\n    this.transformFeedback =\n      this.transformFeedback ||\n      new TransformFeedback(gl, {\n        program: this.program\n      });\n\n    this.transformFeedback.setBuffers(feedbackBuffers);\n    return this;\n  }\n\n  _logDrawCallStart(logLevel) {\n    const logDrawTimeout = logLevel > 3 ? 0 : LOG_DRAW_TIMEOUT;\n    if (Date.now() - this.lastLogTime < logDrawTimeout) {\n      return undefined;\n    }\n\n    this.lastLogTime = Date.now();\n\n    log.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, {collapsed: log.level <= 2})();\n\n    return logLevel;\n  }\n\n  _logDrawCallEnd(logLevel, vertexArray, uniforms, framebuffer) {\n    // HACK: logLevel === undefined means logDrawCallStart didn't run\n    if (logLevel === undefined) {\n      return;\n    }\n\n    const attributeTable = getDebugTableForVertexArray({\n      vertexArray,\n      header: `${this.id} attributes`,\n      // @ts-ignore\n      attributes: this._attributes\n    });\n\n    const {table: uniformTable, unusedTable, unusedCount} = getDebugTableForUniforms({\n      header: `${this.id} uniforms`,\n      program: this.program,\n      uniforms: Object.assign({}, this.program.uniforms, uniforms)\n    });\n\n    // log missing uniforms\n    const {table: missingTable, count: missingCount} = getDebugTableForUniforms({\n      header: `${this.id} uniforms`,\n      program: this.program,\n      uniforms: Object.assign({}, this.program.uniforms, uniforms),\n      undefinedOnly: true\n    });\n\n    if (missingCount > 0) {\n      log.log('MISSING UNIFORMS', Object.keys(missingTable))();\n      // log.table(logLevel, missingTable)();\n    }\n    if (unusedCount > 0) {\n      log.log('UNUSED UNIFORMS', Object.keys(unusedTable))();\n      // log.log(logLevel, 'Unused uniforms ', unusedTable)();\n    }\n\n    const configTable = getDebugTableForProgramConfiguration(this.vertexArray.configuration);\n\n    log.table(logLevel, attributeTable)();\n\n    log.table(logLevel, uniformTable)();\n\n    log.table(logLevel + 1, configTable)();\n\n    if (framebuffer) {\n      framebuffer.log({logLevel: LOG_DRAW_PRIORITY, message: `Rendered to ${framebuffer.id}`});\n    }\n\n    log.groupEnd(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`)();\n  }\n}\n","import {assembleShaders} from '@luma.gl/shadertools';\nimport {Program} from '@luma.gl/webgl';\n\nexport default class ProgramManager {\n  static getDefaultProgramManager(gl) {\n    gl.luma = gl.luma || {};\n    gl.luma.defaultProgramManager = gl.luma.defaultProgramManager || new ProgramManager(gl);\n\n    return gl.luma.defaultProgramManager;\n  }\n\n  constructor(gl) {\n    this.gl = gl;\n\n    this._programCache = {};\n    this._getUniforms = {};\n    this._registeredModules = {}; // TODO: Remove? This isn't used anywhere in luma.gl\n    this._hookFunctions = [];\n    this._defaultModules = [];\n\n    this._hashes = {};\n    this._hashCounter = 0;\n    this.stateHash = 0; // Used change hashing if hooks are modified\n    this._useCounts = {};\n  }\n\n  addDefaultModule(module) {\n    if (!this._defaultModules.find(m => m.name === module.name)) {\n      this._defaultModules.push(module);\n    }\n\n    this.stateHash++;\n  }\n\n  removeDefaultModule(module) {\n    const moduleName = typeof module === 'string' ? module : module.name;\n    this._defaultModules = this._defaultModules.filter(m => m.name !== moduleName);\n    this.stateHash++;\n  }\n\n  addShaderHook(hook, opts) {\n    if (opts) {\n      hook = Object.assign(opts, {hook});\n    }\n\n    this._hookFunctions.push(hook);\n\n    this.stateHash++;\n  }\n\n  get(props = {}) {\n    const {\n      vs = '',\n      fs = '',\n      defines = {},\n      inject = {},\n      varyings = [],\n      bufferMode = 0x8c8d,\n      transpileToGLSL100 = false\n    } = props; // varyings/bufferMode for xform feedback, 0x8c8d = SEPARATE_ATTRIBS\n\n    const modules = this._getModuleList(props.modules); // Combine with default modules\n\n    const vsHash = this._getHash(vs);\n    const fsHash = this._getHash(fs);\n    const moduleHashes = modules.map(m => this._getHash(m.name)).sort();\n    const varyingHashes = varyings.map(v => this._getHash(v));\n\n    const defineKeys = Object.keys(defines).sort();\n    const injectKeys = Object.keys(inject).sort();\n    const defineHashes = [];\n    const injectHashes = [];\n\n    for (const key of defineKeys) {\n      defineHashes.push(this._getHash(key));\n      defineHashes.push(this._getHash(defines[key]));\n    }\n\n    for (const key of injectKeys) {\n      injectHashes.push(this._getHash(key));\n      injectHashes.push(this._getHash(inject[key]));\n    }\n\n    const hash = `${vsHash}/${fsHash}D${defineHashes.join('/')}M${moduleHashes.join(\n      '/'\n    )}I${injectHashes.join('/')}V${varyingHashes.join('/')}H${this.stateHash}B${bufferMode}${\n      transpileToGLSL100 ? 'T' : ''\n    }`;\n\n    if (!this._programCache[hash]) {\n      const assembled = assembleShaders(this.gl, {\n        vs,\n        fs,\n        modules,\n        inject,\n        defines,\n        hookFunctions: this._hookFunctions,\n        transpileToGLSL100\n      });\n\n      this._programCache[hash] = new Program(this.gl, {\n        hash,\n        vs: assembled.vs,\n        fs: assembled.fs,\n        varyings,\n        bufferMode\n      });\n\n      this._getUniforms[hash] = assembled.getUniforms || (x => {});\n      this._useCounts[hash] = 0;\n    }\n\n    this._useCounts[hash]++;\n\n    return this._programCache[hash];\n  }\n\n  getUniforms(program) {\n    return this._getUniforms[program.hash] || null;\n  }\n\n  release(program) {\n    const hash = program.hash;\n    this._useCounts[hash]--;\n\n    if (this._useCounts[hash] === 0) {\n      this._programCache[hash].delete();\n      delete this._programCache[hash];\n      delete this._getUniforms[hash];\n      delete this._useCounts[hash];\n    }\n  }\n\n  _getHash(key) {\n    if (this._hashes[key] === undefined) {\n      this._hashes[key] = this._hashCounter++;\n    }\n\n    return this._hashes[key];\n  }\n\n  // Dedup and combine with default modules\n  _getModuleList(appModules = []) {\n    const modules = new Array(this._defaultModules.length + appModules.length);\n    const seen = {};\n    let count = 0;\n\n    for (let i = 0, len = this._defaultModules.length; i < len; ++i) {\n      const module = this._defaultModules[i];\n      const name = module.name;\n      modules[count++] = module;\n      seen[name] = true;\n    }\n\n    for (let i = 0, len = appModules.length; i < len; ++i) {\n      const module = appModules[i];\n      const name = module.name;\n      if (!seen[name]) {\n        modules[count++] = module;\n        seen[name] = true;\n      }\n    }\n\n    modules.length = count;\n\n    return modules;\n  }\n}\n","// shadertools exports\n\n// DOCUMENTED APIS\nexport {assembleShaders} from './lib/assemble-shaders';\n\n// HELPERS\nexport {combineInjects} from './lib/inject-shader';\nexport {normalizeShaderModule} from './lib/shader-module';\n\n// UTILS\nexport {\n  getQualifierDetails,\n  getPassthroughFS,\n  typeToChannelSuffix,\n  typeToChannelCount,\n  convertToVec4\n} from './utils/shader-utils';\n\n// SHADER MODULES\nexport * from './modules';\n","import {VERTEX_SHADER, FRAGMENT_SHADER} from './constants';\nimport {resolveModules} from './resolve-modules';\nimport {getPlatformShaderDefines, getVersionDefines} from './platform-defines';\nimport injectShader, {DECLARATION_INJECT_MARKER} from './inject-shader';\nimport transpileShader from './transpile-shader';\nimport {assert} from '../utils';\n\nconst INJECT_SHADER_DECLARATIONS = `\\n\\n${DECLARATION_INJECT_MARKER}\\n\\n`;\n\nconst SHADER_TYPE = {\n  [VERTEX_SHADER]: 'vertex',\n  [FRAGMENT_SHADER]: 'fragment'\n};\n\n// Precision prologue to inject before functions are injected in shader\n// TODO - extract any existing prologue in the fragment source and move it up...\nconst FRAGMENT_SHADER_PROLOGUE = `\\\nprecision highp float;\n\n`;\n\n// Inject a list of modules\nexport function assembleShaders(gl, opts) {\n  const {vs, fs} = opts;\n  const modules = resolveModules(opts.modules || []);\n  return {\n    gl,\n    vs: assembleShader(gl, Object.assign({}, opts, {source: vs, type: VERTEX_SHADER, modules})),\n    fs: assembleShader(gl, Object.assign({}, opts, {source: fs, type: FRAGMENT_SHADER, modules})),\n    getUniforms: assembleGetUniforms(modules)\n  };\n}\n\n// Pulls together complete source code for either a vertex or a fragment shader\n// adding prologues, requested module chunks, and any final injections.\nfunction assembleShader(\n  gl,\n  {\n    id,\n    source,\n    type,\n    modules,\n    defines = {},\n    hookFunctions = [],\n    inject = {},\n    transpileToGLSL100 = false,\n    prologue = true,\n    log\n  }\n) {\n  assert(typeof source === 'string', 'shader source must be a string');\n\n  const isVertex = type === VERTEX_SHADER;\n\n  const sourceLines = source.split('\\n');\n  let glslVersion = 100;\n  let versionLine = '';\n  let coreSource = source;\n  // Extract any version directive string from source.\n  // TODO : keep all pre-processor statements at the begining of the shader.\n  if (sourceLines[0].indexOf('#version ') === 0) {\n    glslVersion = 300; // TODO - regexp that matches actual version number\n    versionLine = sourceLines[0];\n    coreSource = sourceLines.slice(1).join('\\n');\n  } else {\n    versionLine = `#version ${glslVersion}`;\n  }\n\n  // Combine Module and Application Defines\n  const allDefines = {};\n  modules.forEach(module => {\n    Object.assign(allDefines, module.getDefines());\n  });\n  Object.assign(allDefines, defines);\n\n  // Add platform defines (use these to work around platform-specific bugs and limitations)\n  // Add common defines (GLSL version compatibility, feature detection)\n  // Add precision declaration for fragment shaders\n  let assembledSource = prologue\n    ? `\\\n${versionLine}\n${getShaderName({id, source, type})}\n${getShaderType({type})}\n${getPlatformShaderDefines(gl)}\n${getVersionDefines(gl, glslVersion, !isVertex)}\n${getApplicationDefines(allDefines)}\n${isVertex ? '' : FRAGMENT_SHADER_PROLOGUE}\n`\n    : `${versionLine}\n`;\n\n  const hookFunctionMap = normalizeHookFunctions(hookFunctions);\n\n  // Add source of dependent modules in resolved order\n  const hookInjections = {};\n  const declInjections = {};\n  const mainInjections = {};\n\n  for (const key in inject) {\n    const injection =\n      typeof inject[key] === 'string' ? {injection: inject[key], order: 0} : inject[key];\n    const match = key.match(/^(v|f)s:(#)?([\\w-]+)$/);\n    if (match) {\n      const hash = match[2];\n      const name = match[3];\n      if (hash) {\n        if (name === 'decl') {\n          declInjections[key] = [injection];\n        } else {\n          mainInjections[key] = [injection];\n        }\n      } else {\n        hookInjections[key] = [injection];\n      }\n    } else {\n      // Regex injection\n      mainInjections[key] = [injection];\n    }\n  }\n\n  for (const module of modules) {\n    if (log) {\n      module.checkDeprecations(coreSource, log);\n    }\n    const moduleSource = module.getModuleSource(type, glslVersion);\n    // Add the module source, and a #define that declares it presence\n    assembledSource += moduleSource;\n\n    const injections = module.injections[type];\n    for (const key in injections) {\n      const match = key.match(/^(v|f)s:#([\\w-]+)$/);\n      if (match) {\n        const name = match[2];\n        const injectionType = name === 'decl' ? declInjections : mainInjections;\n        injectionType[key] = injectionType[key] || [];\n        injectionType[key].push(injections[key]);\n      } else {\n        hookInjections[key] = hookInjections[key] || [];\n        hookInjections[key].push(injections[key]);\n      }\n    }\n  }\n\n  // For injectShader\n  assembledSource += INJECT_SHADER_DECLARATIONS;\n\n  assembledSource = injectShader(assembledSource, type, declInjections);\n\n  assembledSource += getHookFunctions(hookFunctionMap[type], hookInjections);\n\n  // Add the version directive and actual source of this shader\n  assembledSource += coreSource;\n\n  // Apply any requested shader injections\n  assembledSource = injectShader(assembledSource, type, mainInjections);\n\n  assembledSource = transpileShader(\n    assembledSource,\n    transpileToGLSL100 ? 100 : glslVersion,\n    isVertex\n  );\n\n  return assembledSource;\n}\n\n// Returns a combined `getUniforms` covering the options for all the modules,\n// the created function will pass on options to the inidividual `getUniforms`\n// function of each shader module and combine the results into one object that\n// can be passed to setUniforms.\nfunction assembleGetUniforms(modules) {\n  return function getUniforms(opts) {\n    const uniforms = {};\n    for (const module of modules) {\n      // `modules` is already sorted by dependency level. This guarantees that\n      // modules have access to the uniforms that are generated by their dependencies.\n      const moduleUniforms = module.getUniforms(opts, uniforms);\n      Object.assign(uniforms, moduleUniforms);\n    }\n    return uniforms;\n  };\n}\n\nfunction getShaderType({type}) {\n  return `\n#define SHADER_TYPE_${SHADER_TYPE[type].toUpperCase()}\n`;\n}\n\n// Generate \"glslify-compatible\" SHADER_NAME defines\n// These are understood by the GLSL error parsing function\n// If id is provided and no SHADER_NAME constant is present in source, create one\nfunction getShaderName({id, source, type}) {\n  const injectShaderName = id && typeof id === 'string' && source.indexOf('SHADER_NAME') === -1;\n  return injectShaderName\n    ? `\n#define SHADER_NAME ${id}_${SHADER_TYPE[type]}\n\n`\n    : '';\n}\n\n// Generates application defines from an object\nfunction getApplicationDefines(defines = {}) {\n  let count = 0;\n  let sourceText = '';\n  for (const define in defines) {\n    if (count === 0) {\n      sourceText += '\\n// APPLICATION DEFINES\\n';\n    }\n    count++;\n\n    const value = defines[define];\n    if (value || Number.isFinite(value)) {\n      sourceText += `#define ${define.toUpperCase()} ${defines[define]}\\n`;\n    }\n  }\n  if (count === 0) {\n    sourceText += '\\n';\n  }\n  return sourceText;\n}\n\nfunction getHookFunctions(hookFunctions, hookInjections) {\n  let result = '';\n  for (const hookName in hookFunctions) {\n    const hookFunction = hookFunctions[hookName];\n    result += `void ${hookFunction.signature} {\\n`;\n    if (hookFunction.header) {\n      result += `  ${hookFunction.header}`;\n    }\n    if (hookInjections[hookName]) {\n      const injections = hookInjections[hookName];\n      injections.sort((a, b) => a.order - b.order);\n      for (const injection of injections) {\n        result += `  ${injection.injection}\\n`;\n      }\n    }\n    if (hookFunction.footer) {\n      result += `  ${hookFunction.footer}`;\n    }\n    result += '}\\n';\n  }\n\n  return result;\n}\n\nfunction normalizeHookFunctions(hookFunctions) {\n  const result = {\n    vs: {},\n    fs: {}\n  };\n\n  hookFunctions.forEach(hook => {\n    let opts;\n    if (typeof hook !== 'string') {\n      opts = hook;\n      hook = opts.hook;\n    } else {\n      opts = {};\n    }\n    hook = hook.trim();\n    const [stage, signature] = hook.split(':');\n    const name = hook.replace(/\\(.+/, '');\n    result[stage][name] = Object.assign(opts, {signature});\n  });\n\n  return result;\n}\n","export const VERTEX_SHADER = 'vs';\nexport const FRAGMENT_SHADER = 'fs';\n","import ShaderModule from './shader-module';\nimport {assert} from '../utils';\n\n// Instantiate shader modules and any dependencies resolve dependencies\nexport function resolveModules(modules) {\n  return getShaderDependencies(instantiateModules(modules));\n}\n\n/**\n * Takes a list of shader module names and returns a new list of\n * shader module names that includes all dependencies, sorted so\n * that modules that are dependencies of other modules come first.\n *\n * If the shader glsl code from the returned modules is concatenated\n * in the reverse order, it is guaranteed that all functions be resolved and\n * that all function and variable definitions come before use.\n *\n * @param {String[]} modules - Array of modules (inline modules or module names)\n * @return {String[]} - Array of modules\n */\nfunction getShaderDependencies(modules) {\n  const moduleMap = {};\n  const moduleDepth = {};\n  getDependencyGraph({modules, level: 0, moduleMap, moduleDepth});\n\n  // Return a reverse sort so that dependencies come before the modules that use them\n  return Object.keys(moduleDepth)\n    .sort((a, b) => moduleDepth[b] - moduleDepth[a])\n    .map(name => moduleMap[name]);\n}\n\n/**\n * Recursively checks module dpendencies to calculate dependency\n * level of each module.\n *\n * @param {object} options\n * @param {object[]} options.modules - Array of modules\n * @param {number} options.level - Current level\n * @param {object} options.moduleMap -\n * @param {object} options.moduleDepth - Current level\n * @return {object} - Map of module name to its level\n */\n// Adds another level of dependencies to the result map\nfunction getDependencyGraph({modules, level, moduleMap, moduleDepth}) {\n  if (level >= 5) {\n    throw new Error('Possible loop in shader dependency graph');\n  }\n\n  // Update level on all current modules\n  for (const module of modules) {\n    moduleMap[module.name] = module;\n    if (moduleDepth[module.name] === undefined || moduleDepth[module.name] < level) {\n      moduleDepth[module.name] = level;\n    }\n  }\n\n  // Recurse\n  for (const module of modules) {\n    if (module.dependencies) {\n      getDependencyGraph({modules: module.dependencies, level: level + 1, moduleMap, moduleDepth});\n    }\n  }\n}\n\nfunction instantiateModules(modules, seen) {\n  return modules.map(module => {\n    if (module instanceof ShaderModule) {\n      return module;\n    }\n\n    assert(\n      typeof module !== 'string',\n      `Shader module use by name is deprecated. Import shader module '${module}' and use it directly.`\n    );\n    assert(module.name, 'shader module has no name');\n\n    module = new ShaderModule(module);\n    module.dependencies = instantiateModules(module.dependencies);\n\n    return module;\n  });\n}\n\nexport const TEST_EXPORTS = {\n  getShaderDependencies,\n  getDependencyGraph\n};\n","import {assert} from '../utils';\nimport {parsePropTypes} from './filters/prop-types';\n\nconst VERTEX_SHADER = 'vs';\nconst FRAGMENT_SHADER = 'fs';\n\nexport default class ShaderModule {\n  constructor({\n    name,\n    vs,\n    fs,\n    dependencies = [],\n    uniforms,\n    getUniforms,\n    deprecations = [],\n    defines = {},\n    inject = {},\n    // DEPRECATED\n    vertexShader,\n    fragmentShader\n  }) {\n    assert(typeof name === 'string');\n    this.name = name;\n    this.vs = vs || vertexShader;\n    this.fs = fs || fragmentShader;\n    this.getModuleUniforms = getUniforms;\n    this.dependencies = dependencies;\n    this.deprecations = this._parseDeprecationDefinitions(deprecations);\n    this.defines = defines;\n    this.injections = normalizeInjections(inject);\n\n    if (uniforms) {\n      this.uniforms = parsePropTypes(uniforms);\n    }\n  }\n\n  // Extracts the source code chunk for the specified shader type from the named shader module\n  getModuleSource(type) {\n    let moduleSource;\n    switch (type) {\n      case VERTEX_SHADER:\n        moduleSource = this.vs || '';\n        break;\n      case FRAGMENT_SHADER:\n        moduleSource = this.fs || '';\n        break;\n      default:\n        assert(false);\n    }\n\n    return `\\\n#define MODULE_${this.name.toUpperCase().replace(/[^0-9a-z]/gi, '_')}\n${moduleSource}\\\n// END MODULE_${this.name}\n\n`;\n  }\n\n  getUniforms(opts, uniforms) {\n    if (this.getModuleUniforms) {\n      return this.getModuleUniforms(opts, uniforms);\n    }\n    // Build uniforms from the uniforms array\n    if (this.uniforms) {\n      return this._defaultGetUniforms(opts);\n    }\n    return {};\n  }\n\n  getDefines() {\n    return this.defines;\n  }\n\n  // Warn about deprecated uniforms or functions\n  checkDeprecations(shaderSource, log) {\n    this.deprecations.forEach(def => {\n      if (def.regex.test(shaderSource)) {\n        if (def.deprecated) {\n          log.deprecated(def.old, def.new)();\n        } else {\n          log.removed(def.old, def.new)();\n        }\n      }\n    });\n  }\n\n  _parseDeprecationDefinitions(deprecations) {\n    deprecations.forEach(def => {\n      switch (def.type) {\n        case 'function':\n          def.regex = new RegExp(`\\\\b${def.old}\\\\(`);\n          break;\n        default:\n          def.regex = new RegExp(`${def.type} ${def.old};`);\n      }\n    });\n\n    return deprecations;\n  }\n\n  _defaultGetUniforms(opts = {}) {\n    const uniforms = {};\n    const propTypes = this.uniforms;\n\n    for (const key in propTypes) {\n      const propDef = propTypes[key];\n      if (key in opts && !propDef.private) {\n        if (propDef.validate) {\n          assert(propDef.validate(opts[key], propDef), `${this.name}: invalid ${key}`);\n        }\n        uniforms[key] = opts[key];\n      } else {\n        uniforms[key] = propDef.value;\n      }\n    }\n\n    return uniforms;\n  }\n}\n\n// This utility mutates the original module\n// Keeping for backward compatibility\n// TODO - remove in v8\nexport function normalizeShaderModule(module) {\n  if (!module.normalized) {\n    module.normalized = true;\n    if (module.uniforms && !module.getUniforms) {\n      const shaderModule = new ShaderModule(module);\n      module.getUniforms = shaderModule.getUniforms.bind(shaderModule);\n    }\n  }\n  return module;\n}\n\nfunction normalizeInjections(injections) {\n  const result = {\n    vs: {},\n    fs: {}\n  };\n\n  for (const hook in injections) {\n    let injection = injections[hook];\n    const stage = hook.slice(0, 2);\n\n    if (typeof injection === 'string') {\n      injection = {\n        order: 0,\n        injection\n      };\n    }\n\n    result[stage][hook] = injection;\n  }\n\n  return result;\n}\n","export {default as assert} from './assert';\n","// Recommendation is to ignore message but current test suite checks agains the\n// message so keep it for now.\nexport default function assert(condition, message) {\n  if (!condition) {\n    throw new Error(message || 'shadertools: assertion failed.');\n  }\n}\n","const TYPE_DEFINITIONS = {\n  number: {\n    validate(value, propType) {\n      return (\n        Number.isFinite(value) &&\n        (!('max' in propType) || value <= propType.max) &&\n        (!('min' in propType) || value >= propType.min)\n      );\n    }\n  },\n  array: {\n    validate(value, propType) {\n      return Array.isArray(value) || ArrayBuffer.isView(value);\n    }\n  }\n};\n\nexport function parsePropTypes(propDefs) {\n  const propTypes = {};\n  for (const propName in propDefs) {\n    const propDef = propDefs[propName];\n    const propType = parsePropType(propDef);\n    propTypes[propName] = propType;\n  }\n  return propTypes;\n}\n\n// Parses one property definition entry. Either contains:\n// * a valid prop type object ({type, ...})\n// * or just a default value, in which case type and name inference is used\nfunction parsePropType(propDef) {\n  let type = getTypeOf(propDef);\n  if (type === 'object') {\n    if (!propDef) {\n      return {type: 'object', value: null};\n    }\n    if ('type' in propDef) {\n      return Object.assign({}, propDef, TYPE_DEFINITIONS[propDef.type]);\n    }\n    if (!('value' in propDef)) {\n      // If no type and value this object is likely the value\n      return {type: 'object', value: propDef};\n    }\n    type = getTypeOf(propDef.value);\n    return Object.assign({type}, propDef, TYPE_DEFINITIONS[type]);\n  }\n  return Object.assign({type, value: propDef}, TYPE_DEFINITIONS[type]);\n}\n\n// improved version of javascript typeof that can distinguish arrays and null values\nfunction getTypeOf(value) {\n  if (Array.isArray(value) || ArrayBuffer.isView(value)) {\n    return 'array';\n  }\n  return typeof value;\n}\n","import {getContextInfo, hasFeatures, canCompileGLGSExtension, FEATURES} from '../utils/webgl-info';\n\nexport function getPlatformShaderDefines(gl) {\n  const debugInfo = getContextInfo(gl);\n\n  switch (debugInfo.gpuVendor.toLowerCase()) {\n    case 'nvidia':\n      return `\\\n#define NVIDIA_GPU\n// Nvidia optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n`;\n\n    case 'intel':\n      return `\\\n#define INTEL_GPU\n// Intel optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Intel's built-in 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n\n    case 'amd':\n      // AMD Does not eliminate fp64 code\n      return `\\\n#define AMD_GPU\n`;\n\n    default:\n      // We don't know what GPU it is, could be that the GPU driver or\n      // browser is not implementing UNMASKED_RENDERER constant and not\n      // reporting a correct name\n      return `\\\n#define DEFAULT_GPU\n// Prevent driver from optimizing away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Intel's built-in 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n  }\n}\n\nexport function getVersionDefines(gl, glslVersion, isFragment) {\n  // Add shadertools defines to let shaders portably v1/v3 check for features\n  let versionDefines = `\\\n#if (__VERSION__ > 120)\n\n# define FEATURE_GLSL_DERIVATIVES\n# define FEATURE_GLSL_DRAW_BUFFERS\n# define FEATURE_GLSL_FRAG_DEPTH\n# define FEATURE_GLSL_TEXTURE_LOD\n\n// DEPRECATED FLAGS, remove in v9\n# define FRAG_DEPTH\n# define DERIVATIVES\n# define DRAW_BUFFERS\n# define TEXTURE_LOD\n\n#endif // __VERSION\n`;\n\n  if (hasFeatures(gl, FEATURES.GLSL_FRAG_DEPTH)) {\n    versionDefines += `\\\n\n// FRAG_DEPTH => gl_FragDepth is available\n#ifdef GL_EXT_frag_depth\n#extension GL_EXT_frag_depth : enable\n# define FEATURE_GLSL_FRAG_DEPTH\n# define FRAG_DEPTH\n# define gl_FragDepth gl_FragDepthEXT\n#endif\n`;\n  }\n  if (\n    hasFeatures(gl, FEATURES.GLSL_DERIVATIVES) &&\n    canCompileGLGSExtension(gl, FEATURES.GLSL_DERIVATIVES)\n  ) {\n    versionDefines += `\\\n\n// DERIVATIVES => dxdF, dxdY and fwidth are available\n#ifdef GL_OES_standard_derivatives\n#extension GL_OES_standard_derivatives : enable\n# define FEATURE_GLSL_DERIVATIVES\n# define DERIVATIVES\n#endif\n`;\n  }\n  if (\n    hasFeatures(gl, FEATURES.GLSL_FRAG_DATA) &&\n    canCompileGLGSExtension(gl, FEATURES.GLSL_FRAG_DATA, {behavior: 'require'})\n  ) {\n    versionDefines += `\\\n\n// DRAW_BUFFERS => gl_FragData[] is available\n#ifdef GL_EXT_draw_buffers\n#extension GL_EXT_draw_buffers : require\n#define FEATURE_GLSL_DRAW_BUFFERS\n#define DRAW_BUFFERS\n#endif\n`;\n  }\n  if (hasFeatures(gl, FEATURES.GLSL_TEXTURE_LOD)) {\n    versionDefines += `\\\n// TEXTURE_LOD => texture2DLod etc are available\n#ifdef GL_EXT_shader_texture_lod\n#extension GL_EXT_shader_texture_lod : enable\n\n# define FEATURE_GLSL_TEXTURE_LOD\n# define TEXTURE_LOD\n\n#endif\n`;\n  }\n  return versionDefines;\n}\n","// Feature detection for WebGL\n//\n// Provides a function that enables simple checking of which WebGL features are\n// available in an WebGL1 or WebGL2 environment.\n\n/* eslint-disable no-inline-comments, max-len */\nimport isOldIE from './is-old-ie';\nimport assert from './assert';\n\nconst GL_VENDOR = 0x1f00;\nconst GL_RENDERER = 0x1f01;\nconst GL_VERSION = 0x1f02;\nconst GL_SHADING_LANGUAGE_VERSION = 0x8b8c;\n\n// Defines luma.gl \"feature\" names and semantics\nconst WEBGL_FEATURES = {\n  // GLSL extensions\n  GLSL_FRAG_DATA: ['WEBGL_draw_buffers', true], // TODO - name makes no sense in GLSL 3.00\n  GLSL_FRAG_DEPTH: ['EXT_frag_depth', true],\n  GLSL_DERIVATIVES: ['OES_standard_derivatives', true],\n  GLSL_TEXTURE_LOD: ['EXT_shader_texture_lod', true]\n};\n\n// Create a key-mirrored FEATURES array\nconst FEATURES = {};\nObject.keys(WEBGL_FEATURES).forEach(key => {\n  FEATURES[key] = key;\n});\n\nexport {FEATURES};\n\nfunction isWebGL2(gl) {\n  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {\n    return true;\n  }\n  return Boolean(gl && gl._version === 2);\n}\n\nexport function getContextInfo(gl) {\n  const info = gl.getExtension('WEBGL_debug_renderer_info');\n  const vendor = gl.getParameter((info && info.UNMASKED_VENDOR_WEBGL) || GL_VENDOR);\n  const renderer = gl.getParameter((info && info.UNMASKED_RENDERER_WEBGL) || GL_RENDERER);\n  const gpuVendor = identifyGPUVendor(vendor, renderer);\n  const gpuInfo = {\n    gpuVendor,\n    vendor,\n    renderer,\n    version: gl.getParameter(GL_VERSION),\n    shadingLanguageVersion: gl.getParameter(GL_SHADING_LANGUAGE_VERSION)\n  };\n  return gpuInfo;\n}\n\nfunction identifyGPUVendor(vendor, renderer) {\n  if (vendor.match(/NVIDIA/i) || renderer.match(/NVIDIA/i)) {\n    return 'NVIDIA';\n  }\n  if (vendor.match(/INTEL/i) || renderer.match(/INTEL/i)) {\n    return 'INTEL';\n  }\n  if (\n    vendor.match(/AMD/i) ||\n    renderer.match(/AMD/i) ||\n    vendor.match(/ATI/i) ||\n    renderer.match(/ATI/i)\n  ) {\n    return 'AMD';\n  }\n  return 'UNKNOWN GPU';\n}\n\nconst compiledGlslExtensions = {};\n\n// Enables feature detection in IE11 due to a bug where gl.getExtension may return true\n// but fail to compile when the extension is enabled in the shader. Specifically,\n// the OES_standard_derivatives and WEBGL_draw_buffers extensions fails to compile in IE11 even though its included\n// in the list of supported extensions.\n// opts allows user agent to be overridden for testing\n/*\n* Inputs :\n*  gl : WebGL context\n*  cap : Key of WEBGL_FEATURES object identifying the extension\n*  opts :\n*   behavior : behavior of extension to be tested, by defualt `enable` is used\n* Returns : true, if shader is compiled successfully, false otherwise\n*/\nexport function canCompileGLGSExtension(gl, cap, opts = {}) {\n  const feature = WEBGL_FEATURES[cap];\n  assert(feature, cap);\n\n  if (!isOldIE(opts)) {\n    return true;\n  }\n\n  if (cap in compiledGlslExtensions) {\n    return compiledGlslExtensions[cap];\n  }\n\n  const extensionName = feature[0];\n  const behavior = opts.behavior || 'enable';\n  const source = `#extension GL_${extensionName} : ${behavior}\\nvoid main(void) {}`;\n\n  const shader = gl.createShader(gl.VERTEX_SHADER);\n  gl.shaderSource(shader, source);\n  gl.compileShader(shader);\n  const canCompile = gl.getShaderParameter(shader, gl.COMPILE_STATUS);\n  gl.deleteShader(shader);\n  compiledGlslExtensions[cap] = canCompile;\n  return canCompile;\n}\n\n// TODO - cache the value\nfunction getFeature(gl, cap) {\n  const feature = WEBGL_FEATURES[cap];\n  assert(feature, cap);\n\n  // Get extension name from table\n  const extensionName = isWebGL2(gl) ? feature[1] || feature[0] : feature[0];\n\n  // Check if the value is dependent on checking an extension\n  const value =\n    typeof extensionName === 'string' ? Boolean(gl.getExtension(extensionName)) : extensionName;\n\n  assert(value === false || value === true);\n\n  return value;\n}\n\nexport function hasFeatures(gl, features) {\n  features = Array.isArray(features) ? features : [features];\n  return features.every(feature => getFeature(gl, feature));\n}\n","// opts allows user agent to be overridden for testing\nexport default function isOldIE(opts = {}) {\n  const navigator = typeof window !== 'undefined' ? window.navigator || {} : {};\n  // @ts-ignore\n  const userAgent = opts.userAgent || navigator.userAgent || '';\n  // We only care about older versions of IE (IE 11 and below). Newer versions of IE (Edge)\n  // have much better web standards support.\n  const isMSIE = userAgent.indexOf('MSIE ') !== -1;\n  const isTrident = userAgent.indexOf('Trident/') !== -1;\n  return isMSIE || isTrident;\n}\n","import {MODULE_INJECTORS_VS, MODULE_INJECTORS_FS} from '../modules/module-injectors';\nimport {VERTEX_SHADER, FRAGMENT_SHADER} from './constants';\nimport {assert} from '../utils';\n\n// TODO - experimental\nconst MODULE_INJECTORS = {\n  [VERTEX_SHADER]: MODULE_INJECTORS_VS,\n  [FRAGMENT_SHADER]: MODULE_INJECTORS_FS\n};\n\nexport const DECLARATION_INJECT_MARKER = '__LUMA_INJECT_DECLARATIONS__'; // Uniform/attribute declarations\n\nconst REGEX_START_OF_MAIN = /void\\s+main\\s*\\([^)]*\\)\\s*\\{\\n?/; // Beginning of main\nconst REGEX_END_OF_MAIN = /}\\n?[^{}]*$/; // End of main, assumes main is last function\nconst fragments = [];\n\n// A minimal shader injection/templating system.\n// RFC: https://github.com/visgl/luma.gl/blob/7.0-release/dev-docs/RFCs/v6.0/shader-injection-rfc.md\n/* eslint-disable complexity */\nexport default function injectShader(source, type, inject, injectStandardStubs = false) {\n  const isVertex = type === VERTEX_SHADER;\n\n  for (const key in inject) {\n    const fragmentData = inject[key];\n    fragmentData.sort((a, b) => a.order - b.order);\n    fragments.length = fragmentData.length;\n    for (let i = 0, len = fragmentData.length; i < len; ++i) {\n      fragments[i] = fragmentData[i].injection;\n    }\n    const fragmentString = `${fragments.join('\\n')}\\n`;\n    switch (key) {\n      // declarations are injected before the main function\n      case 'vs:#decl':\n        if (isVertex) {\n          source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);\n        }\n        break;\n      // inject code at the beginning of the main function\n      case 'vs:#main-start':\n        if (isVertex) {\n          source = source.replace(REGEX_START_OF_MAIN, match => match + fragmentString);\n        }\n        break;\n      // inject code at the end of main function\n      case 'vs:#main-end':\n        if (isVertex) {\n          source = source.replace(REGEX_END_OF_MAIN, match => fragmentString + match);\n        }\n        break;\n      // declarations are injected before the main function\n      case 'fs:#decl':\n        if (!isVertex) {\n          source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);\n        }\n        break;\n      // inject code at the beginning of the main function\n      case 'fs:#main-start':\n        if (!isVertex) {\n          source = source.replace(REGEX_START_OF_MAIN, match => match + fragmentString);\n        }\n        break;\n      // inject code at the end of main function\n      case 'fs:#main-end':\n        if (!isVertex) {\n          source = source.replace(REGEX_END_OF_MAIN, match => fragmentString + match);\n        }\n        break;\n\n      default:\n        // TODO(Tarek): I think this usage should be deprecated.\n\n        // inject code after key, leaving key in place\n        source = source.replace(key, match => match + fragmentString);\n    }\n  }\n\n  // Remove if it hasn't already been replaced\n  source = source.replace(DECLARATION_INJECT_MARKER, '');\n\n  // Finally, if requested, insert an automatic module injector chunk\n  if (injectStandardStubs) {\n    source = source.replace(/\\}\\s*$/, match => match + MODULE_INJECTORS[type]);\n  }\n\n  return source;\n}\n\n/* eslint-enable complexity */\n\n// Takes an array of inject objects and combines them into one\nexport function combineInjects(injects) {\n  const result = {};\n  assert(Array.isArray(injects) && injects.length > 1);\n  injects.forEach(inject => {\n    for (const key in inject) {\n      result[key] = result[key] ? `${result[key]}\\n${inject[key]}` : inject[key];\n    }\n  });\n  return result;\n}\n","export const MODULE_INJECTORS_VS = `\\\n#ifdef MODULE_LOGDEPTH\n  logdepth_adjustPosition(gl_Position);\n#endif\n`;\n\nexport const MODULE_INJECTORS_FS = `\\\n#ifdef MODULE_MATERIAL\n  gl_FragColor = material_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_LIGHTING\n  gl_FragColor = lighting_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_FOG\n  gl_FragColor = fog_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_PICKING\n  gl_FragColor = picking_filterHighlightColor(gl_FragColor);\n  gl_FragColor = picking_filterPickingColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_LOGDEPTH\n  logdepth_setFragDepth();\n#endif\n`;\n","// TRANSPILATION TABLES\n\nfunction testVariable(qualifier) {\n  /*\n    should match:\n      in float weight;\n      out vec4 positions[2];\n    should not match:\n      void f(out float a, in float b) {}\n   */\n  return new RegExp(`\\\\b${qualifier}[ \\\\t]+(\\\\w+[ \\\\t]+\\\\w+(\\\\[\\\\w+\\\\])?;)`, 'g');\n}\n\n/** Simple regex replacements for GLSL ES 1.00 syntax that has changed in GLSL ES 3.00 */\nconst ES300_REPLACEMENTS = [\n  // Fix poorly formatted version directive\n  [/^(#version[ \\t]+(100|300[ \\t]+es))?[ \\t]*\\n/, '#version 300 es\\n'],\n  // The individual `texture...()` functions were replaced with `texture()` overloads\n  [/\\btexture(2D|2DProj|Cube)Lod(EXT)?\\(/g, 'textureLod('],\n  [/\\btexture(2D|2DProj|Cube)(EXT)?\\(/g, 'texture(']\n];\n\nconst ES300_VERTEX_REPLACEMENTS = [\n  ...ES300_REPLACEMENTS,\n  // `attribute` keyword replaced with `in`\n  [testVariable('attribute'), 'in $1'],\n  // `varying` keyword replaced with `out`\n  [testVariable('varying'), 'out $1']\n];\n\n/** Simple regex replacements for GLSL ES 1.00 syntax that has changed in GLSL ES 3.00 */\nconst ES300_FRAGMENT_REPLACEMENTS = [\n  ...ES300_REPLACEMENTS,\n  // `varying` keyword replaced with `in`\n  [testVariable('varying'), 'in $1']\n];\n\nconst ES100_REPLACEMENTS = [\n  [/^#version[ \\t]+300[ \\t]+es/, '#version 100'],\n\n  // In GLSL 1.00 ES these functions are provided by an extension\n  [/\\btexture(2D|2DProj|Cube)Lod\\(/g, 'texture$1LodEXT('],\n\n  // Overloads in GLSL 3.00 map to individual functions. Note that we cannot\n  // differentiate 2D,2DProj,Cube without type analysis so we choose the most common variant.\n  [/\\btexture\\(/g, 'texture2D('],\n  [/\\btextureLod\\(/g, 'texture2DLodEXT(']\n];\n\nconst ES100_VERTEX_REPLACEMENTS = [\n  ...ES100_REPLACEMENTS,\n  [testVariable('in'), 'attribute $1'],\n  [testVariable('out'), 'varying $1']\n];\n\nconst ES100_FRAGMENT_REPLACEMENTS = [\n  ...ES100_REPLACEMENTS,\n  // Replace `in` with `varying`\n  [testVariable('in'), 'varying $1']\n];\n\nconst ES100_FRAGMENT_OUTPUT_NAME = 'gl_FragColor';\nconst ES300_FRAGMENT_OUTPUT_REGEX = /\\bout[ \\t]+vec4[ \\t]+(\\w+)[ \\t]*;\\n?/;\n\nconst REGEX_START_OF_MAIN = /void\\s+main\\s*\\([^)]*\\)\\s*\\{\\n?/; // Beginning of main\n\n// Transpiles shader source code to target GLSL version\n// Note: We always run transpiler even if same version e.g. 3.00 => 3.00\n// RFC: https://github.com/visgl/luma.gl/blob/7.0-release/dev-docs/RFCs/v6.0/portable-glsl-300-rfc.md\nexport default function transpileShader(source, targetGLSLVersion, isVertex) {\n  switch (targetGLSLVersion) {\n    case 300:\n      return isVertex\n        ? convertShader(source, ES300_VERTEX_REPLACEMENTS)\n        : convertFragmentShaderTo300(source);\n    case 100:\n      return isVertex\n        ? convertShader(source, ES100_VERTEX_REPLACEMENTS)\n        : convertFragmentShaderTo100(source);\n    default:\n      throw new Error(`unknown GLSL version ${targetGLSLVersion}`);\n  }\n}\n\nfunction convertShader(source, replacements) {\n  for (const [pattern, replacement] of replacements) {\n    source = source.replace(pattern, replacement);\n  }\n  return source;\n}\n\nfunction convertFragmentShaderTo300(source) {\n  source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);\n\n  const outputMatch = source.match(ES300_FRAGMENT_OUTPUT_REGEX);\n  if (outputMatch) {\n    const outputName = outputMatch[1];\n    source = source.replace(new RegExp(`\\\\b${ES100_FRAGMENT_OUTPUT_NAME}\\\\b`, 'g'), outputName);\n  } else {\n    const outputName = 'fragmentColor';\n    source = source\n      .replace(REGEX_START_OF_MAIN, match => `out vec4 ${outputName};\\n${match}`)\n      .replace(new RegExp(`\\\\b${ES100_FRAGMENT_OUTPUT_NAME}\\\\b`, 'g'), outputName);\n  }\n\n  return source;\n}\n\nfunction convertFragmentShaderTo100(source) {\n  source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS);\n\n  const outputMatch = source.match(ES300_FRAGMENT_OUTPUT_REGEX);\n  if (outputMatch) {\n    const outputName = outputMatch[1];\n    source = source\n      .replace(ES300_FRAGMENT_OUTPUT_REGEX, '')\n      .replace(new RegExp(`\\\\b${outputName}\\\\b`, 'g'), ES100_FRAGMENT_OUTPUT_NAME);\n  }\n\n  return source;\n}\n","import {assert} from '../utils';\nconst FS100 = `void main() {gl_FragColor = vec4(0);}`;\nconst FS_GLES = `\\\nout vec4 transform_output;\nvoid main() {\n  transform_output = vec4(0);\n}`;\nconst FS300 = `#version 300 es\\n${FS_GLES}`;\n\n// Prase given glsl line and return qualifier details or null\nexport function getQualifierDetails(line, qualifiers) {\n  qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers];\n  const words = line.replace(/^\\s+/, '').split(/\\s+/);\n  // TODO add support for precession qualifiers (highp, mediump and lowp)\n  const [qualifier, type, definition] = words;\n  if (!qualifiers.includes(qualifier) || !type || !definition) {\n    return null;\n  }\n  const name = definition.split(';')[0];\n  return {qualifier, type, name};\n}\n\n// Given the shader version, input and output variable names,\n// builds and return a pass through fragment shader.\nexport function getPassthroughFS(options = {}) {\n  const {version = 100, input, inputType, output} = options;\n  if (!input) {\n    if (version === 300) {\n      // Fast-path for WebGL 2.0\n      return FS300;\n    } else if (version > 300) {\n      // Use the supplied version for OpenGL/ES 3.2+\n      return `#version ${version}\\n${FS_GLES}`;\n    }\n    // Fast-path for WebGL 1.0\n    return FS100;\n  }\n  const outputValue = convertToVec4(input, inputType);\n  if (version >= 300) {\n    // If version is 300, assume WebGL 2.0\n    return `\\\n#version ${version} ${version === 300 ? 'es' : ''}\nin ${inputType} ${input};\nout vec4 ${output};\nvoid main() {\n  ${output} = ${outputValue};\n}`;\n  }\n  // WebGL 1.0\n  return `\\\nvarying ${inputType} ${input};\nvoid main() {\n  gl_FragColor = ${outputValue};\n}`;\n}\n\n// convert glsl type to suffix\nexport function typeToChannelSuffix(type) {\n  switch (type) {\n    case 'float':\n      return 'x';\n    case 'vec2':\n      return 'xy';\n    case 'vec3':\n      return 'xyz';\n    case 'vec4':\n      return 'xyzw';\n    default:\n      assert(false);\n      return null;\n  }\n}\n\n// convert glsl type to channel count\nexport function typeToChannelCount(type) {\n  switch (type) {\n    case 'float':\n      return 1;\n    case 'vec2':\n      return 2;\n    case 'vec3':\n      return 3;\n    case 'vec4':\n      return 4;\n    default:\n      assert(false);\n      return null;\n  }\n}\n\n// Returns glsl instruction for converting to vec4\nexport function convertToVec4(variable, type) {\n  switch (type) {\n    case 'float':\n      return `vec4(${variable}, 0.0, 0.0, 1.0)`;\n    case 'vec2':\n      return `vec4(${variable}, 0.0, 1.0)`;\n    case 'vec3':\n      return `vec4(${variable}, 1.0)`;\n    case 'vec4':\n      return variable;\n    default:\n      assert(false);\n      return null;\n  }\n}\n","// utils\nexport {random} from './utils/random';\n\n// math libraries\nexport {fp32} from './fp32/fp32';\nexport {fp64, fp64arithmetic} from './fp64/fp64';\n\n// projection and lighting\nexport {project} from './project/project';\nexport {lights} from './lights/lights';\nexport {dirlight} from './dirlight/dirlight';\nexport {picking} from './picking/picking';\nexport {gouraudLighting, phongLighting} from './phong-lighting/phong-lighting';\nexport {pbr} from './pbr/pbr';\n\n// glfx BLUR shader modules\nexport {tiltShift} from './image-blur-filters/tiltshift';\nexport {triangleBlur} from './image-blur-filters/triangleblur';\nexport {zoomBlur} from './image-blur-filters/zoomblur';\n\n// glfx image adjustment shader modules\nexport {brightnessContrast} from './image-adjust-filters/brightnesscontrast';\nexport {denoise} from './image-adjust-filters/denoise';\nexport {hueSaturation} from './image-adjust-filters/huesaturation';\nexport {noise} from './image-adjust-filters/noise';\nexport {sepia} from './image-adjust-filters/sepia';\nexport {vibrance} from './image-adjust-filters/vibrance';\nexport {vignette} from './image-adjust-filters/vignette';\n\n// glfx FUN shader modules\nexport {colorHalftone} from './image-fun-filters/colorhalftone';\nexport {dotScreen} from './image-fun-filters/dotscreen';\nexport {edgeWork} from './image-fun-filters/edgework';\nexport {hexagonalPixelate} from './image-fun-filters/hexagonalpixelate';\nexport {ink} from './image-fun-filters/ink';\nexport {magnify} from './image-fun-filters/magnify';\n\n// glfx WARP shader modules\nexport {bulgePinch} from './image-warp-filters/bulgepinch';\nexport {swirl} from './image-warp-filters/swirl';\nexport {warp as _warp} from './image-warp-filters/warp';\n\n// Postprocessing\nexport {fxaa} from './fxaa/fxaa';\n\n// experimental\nexport {transform as _transform} from './transform/transform';\n","/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\nconst fs = `\\\nfloat random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n`;\n\nexport const random = {\n  name: 'random',\n  fs\n};\n","/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\nconst fp32shader = `\\\n#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\n\n// All these functions are for substituting tan() function from Intel GPU only\nconst float TWO_PI = 6.2831854820251465;\nconst float PI_2 = 1.5707963705062866;\nconst float PI_16 = 0.1963495463132858;\n\nconst float SIN_TABLE_0 = 0.19509032368659973;\nconst float SIN_TABLE_1 = 0.3826834261417389;\nconst float SIN_TABLE_2 = 0.5555702447891235;\nconst float SIN_TABLE_3 = 0.7071067690849304;\n\nconst float COS_TABLE_0 = 0.9807852506637573;\nconst float COS_TABLE_1 = 0.9238795042037964;\nconst float COS_TABLE_2 = 0.8314695954322815;\nconst float COS_TABLE_3 = 0.7071067690849304;\n\nconst float INVERSE_FACTORIAL_3 = 1.666666716337204e-01; // 1/3!\nconst float INVERSE_FACTORIAL_5 = 8.333333767950535e-03; // 1/5!\nconst float INVERSE_FACTORIAL_7 = 1.9841270113829523e-04; // 1/7!\nconst float INVERSE_FACTORIAL_9 = 2.75573188446287533e-06; // 1/9!\n\nfloat sin_taylor_fp32(float a) {\n  float r, s, t, x;\n\n  if (a == 0.0) {\n    return 0.0;\n  }\n\n  x = -a * a;\n  s = a;\n  r = a;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_3;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_5;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_7;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_9;\n  s = s + t;\n\n  return s;\n}\n\nvoid sincos_taylor_fp32(float a, out float sin_t, out float cos_t) {\n  if (a == 0.0) {\n    sin_t = 0.0;\n    cos_t = 1.0;\n  }\n  sin_t = sin_taylor_fp32(a);\n  cos_t = sqrt(1.0 - sin_t * sin_t);\n}\n\nfloat tan_taylor_fp32(float a) {\n    float sin_a;\n    float cos_a;\n\n    if (a == 0.0) {\n        return 0.0;\n    }\n\n    // 2pi range reduction\n    float z = floor(a / TWO_PI);\n    float r = a - TWO_PI * z;\n\n    float t;\n    float q = floor(r / PI_2 + 0.5);\n    int j = int(q);\n\n    if (j < -2 || j > 2) {\n        return 1.0 / 0.0;\n    }\n\n    t = r - PI_2 * q;\n\n    q = floor(t / PI_16 + 0.5);\n    int k = int(q);\n    int abs_k = int(abs(float(k)));\n\n    if (abs_k > 4) {\n        return 1.0 / 0.0;\n    } else {\n        t = t - PI_16 * q;\n    }\n\n    float u = 0.0;\n    float v = 0.0;\n\n    float sin_t, cos_t;\n    float s, c;\n    sincos_taylor_fp32(t, sin_t, cos_t);\n\n    if (k == 0) {\n        s = sin_t;\n        c = cos_t;\n    } else {\n        if (abs(float(abs_k) - 1.0) < 0.5) {\n            u = COS_TABLE_0;\n            v = SIN_TABLE_0;\n        } else if (abs(float(abs_k) - 2.0) < 0.5) {\n            u = COS_TABLE_1;\n            v = SIN_TABLE_1;\n        } else if (abs(float(abs_k) - 3.0) < 0.5) {\n            u = COS_TABLE_2;\n            v = SIN_TABLE_2;\n        } else if (abs(float(abs_k) - 4.0) < 0.5) {\n            u = COS_TABLE_3;\n            v = SIN_TABLE_3;\n        }\n        if (k > 0) {\n            s = u * sin_t + v * cos_t;\n            c = u * cos_t - v * sin_t;\n        } else {\n            s = u * sin_t - v * cos_t;\n            c = u * cos_t + v * sin_t;\n        }\n    }\n\n    if (j == 0) {\n        sin_a = s;\n        cos_a = c;\n    } else if (j == 1) {\n        sin_a = c;\n        cos_a = -s;\n    } else if (j == -1) {\n        sin_a = -c;\n        cos_a = s;\n    } else {\n        sin_a = -s;\n        cos_a = -c;\n    }\n    return sin_a / cos_a;\n}\n#endif\n\nfloat tan_fp32(float a) {\n#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\n  return tan_taylor_fp32(a);\n#else\n  return tan(a);\n#endif\n}\n`;\n\nexport const fp32 = {\n  name: 'fp32',\n  vs: fp32shader,\n  fs: null\n};\n","/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\nimport {fp64ify, fp64LowPart, fp64ifyMatrix4} from './fp64-utils';\n\nimport fp64arithmeticShader from './fp64-arithmetic.glsl';\nimport fp64functionShader from './fp64-functions.glsl';\n\nconst CONST_UNIFORMS = {\n  // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  ONE: 1.0\n};\nexport {fp64ify, fp64LowPart, fp64ifyMatrix4};\n\nfunction getUniforms() {\n  return CONST_UNIFORMS;\n}\n\n// Arithmetic only\nexport const fp64arithmetic = {\n  name: 'fp64-arithmetic',\n  vs: fp64arithmeticShader,\n  fs: null,\n  getUniforms,\n  fp64ify,\n  fp64LowPart,\n  fp64ifyMatrix4\n};\n\n// Full fp64 shader\nexport const fp64 = {\n  name: 'fp64',\n  vs: fp64functionShader,\n  fs: null,\n  dependencies: [fp64arithmetic],\n  fp64ify,\n  fp64LowPart,\n  fp64ifyMatrix4\n};\n","/** @typedef {import('./fp64-utils')} types */\n\n/**\n * Calculate WebGL 64 bit float\n * @type {types['fp64ify']}\n */\nexport function fp64ify(a, out = [], startIndex = 0) {\n  const hiPart = Math.fround(a);\n  const loPart = a - hiPart;\n  out[startIndex] = hiPart;\n  out[startIndex + 1] = loPart;\n  return out;\n}\n\n/** @type {types['fp64LowPart']} */\nexport function fp64LowPart(a) {\n  return a - Math.fround(a);\n}\n\n/**\n * Calculate WebGL 64 bit matrix (transposed \"Float64Array\")\n * @type {types['fp64ifyMatrix4']}\n * */\nexport function fp64ifyMatrix4(matrix) {\n  // Transpose the projection matrix to column major for GLSL.\n  const matrixFP64 = new Float32Array(32);\n  for (let i = 0; i < 4; ++i) {\n    for (let j = 0; j < 4; ++j) {\n      const index = i * 4 + j;\n      fp64ify(matrix[j * 4 + i], matrixFP64, index * 2);\n    }\n  }\n  return matrixFP64;\n}\n","/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\nimport {Matrix4} from '@math.gl/core';\n\nconst IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n\nconst DEFAULT_MODULE_OPTIONS = {\n  modelMatrix: IDENTITY_MATRIX,\n  viewMatrix: IDENTITY_MATRIX,\n  projectionMatrix: IDENTITY_MATRIX,\n  cameraPositionWorld: [0, 0, 0]\n};\n\nfunction getUniforms(opts = DEFAULT_MODULE_OPTIONS, prevUniforms = {}) {\n  // const viewProjectionInverse = viewProjection.invert();\n  // viewInverseMatrix: view.invert(),\n  // viewProjectionInverseMatrix: viewProjectionInverse\n\n  const uniforms = {};\n  if (opts.modelMatrix !== undefined) {\n    uniforms.modelMatrix = opts.modelMatrix;\n  }\n  if (opts.viewMatrix !== undefined) {\n    uniforms.viewMatrix = opts.viewMatrix;\n  }\n  if (opts.projectionMatrix !== undefined) {\n    uniforms.projectionMatrix = opts.projectionMatrix;\n  }\n  if (opts.cameraPositionWorld !== undefined) {\n    uniforms.cameraPositionWorld = opts.cameraPositionWorld;\n  }\n\n  // COMPOSITE UNIFORMS\n  if (opts.projectionMatrix !== undefined || opts.viewMatrix !== undefined) {\n    uniforms.viewProjectionMatrix = new Matrix4(opts.projectionMatrix).multiplyRight(\n      opts.viewMatrix\n    );\n  }\n\n  return uniforms;\n}\n\nconst common = `\\\nvarying vec4 project_vPositionWorld;\nvarying vec3 project_vNormalWorld;\n\nvec4 project_getPosition_World() {\n  return project_vPositionWorld;\n}\n\nvec3 project_getNormal_World() {\n  return project_vNormalWorld;\n}\n`;\n\nconst vs = `\\\n${common}\n\n// Unprefixed uniforms\nuniform mat4 modelMatrix;\nuniform mat4 viewMatrix;\nuniform mat4 projectionMatrix;\nuniform mat4 viewProjectionMatrix;\nuniform vec3 cameraPositionWorld;\n\nstruct World {\n  vec3 position;\n  vec3 normal;\n};\n\nWorld world;\n\nvoid project_setPosition(vec4 position) {\n  project_vPositionWorld = position;\n}\n\nvoid project_setNormal(vec3 normal) {\n  project_vNormalWorld = normal;\n}\n\nvoid project_setPositionAndNormal_World(vec3 position, vec3 normal) {\n  world.position = position;\n  world.normal = normal;\n}\n\nvoid project_setPositionAndNormal_Model(vec3 position, vec3 normal) {\n  world.position = (modelMatrix * vec4(position, 1.)).xyz;\n  world.normal = mat3(modelMatrix) * normal;\n}\n\nvec4 project_model_to_clipspace(vec4 position) {\n  return viewProjectionMatrix * modelMatrix * position;\n}\n\nvec4 project_model_to_clipspace(vec3 position) {\n  return viewProjectionMatrix * modelMatrix * vec4(position, 1.);\n}\n\nvec4 project_world_to_clipspace(vec3 position) {\n  return viewProjectionMatrix * vec4(position, 1.);\n}\n\nvec4 project_view_to_clipspace(vec3 position) {\n  return projectionMatrix * vec4(position, 1.);\n}\n\nvec4 project_to_clipspace(vec3 position) {\n  return viewProjectionMatrix * vec4(position, 1.);\n}\n`;\n\nconst fs = `\n${common}\\\n`;\n\n/** @type {ShaderModule} */\nexport const project = {\n  name: 'project',\n  getUniforms,\n  vs,\n  fs\n};\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {config} from './lib/common';\n\n// math.gl classes\nexport {default as Vector2} from './classes/vector2';\nexport {default as Vector3} from './classes/vector3';\nexport {default as Vector4} from './classes/vector4';\nexport {default as Matrix3} from './classes/matrix3';\nexport {default as Matrix4} from './classes/matrix4';\nexport {default as Quaternion} from './classes/quaternion';\n\nexport {\n  // math.gl global utility methods\n  config,\n  configure,\n  formatValue,\n  isArray,\n  clone,\n  equals,\n  exactEquals,\n  toRadians,\n  toDegrees,\n  // math.gl \"GLSL\"-style functions\n  radians,\n  degrees,\n  sin,\n  cos,\n  tan,\n  asin,\n  acos,\n  atan,\n  clamp,\n  lerp,\n  withEpsilon\n} from './lib/common';\n\nexport {checkNumber} from './lib/validators';\n\nexport {default as _MathUtils} from './lib/math-utils';\n\nexport {default as SphericalCoordinates} from './classes/spherical-coordinates';\nexport {default as Pose} from './classes/pose';\nexport {default as Euler} from './classes/euler';\n\nexport {default as assert} from './lib/assert';\n\nconst globals = {\n  // eslint-disable-next-line no-restricted-globals\n  self: typeof self !== 'undefined' && self,\n  window: typeof window !== 'undefined' && window,\n  global: typeof global !== 'undefined' && global\n};\n\nconst global_ = globals.global || globals.self || globals.window;\n\n// Make config avalable as global variable for access in debugger\n// TODO - integrate with probe.gl (as soft dependency) to persist across reloades\n\n// @ts-ignore error TS2339: Property 'mathgl' does not exist on type 'Window | Global\nglobal_.mathgl = {\n  config\n};\n\n// DEPRECATED\nexport {default as _SphericalCoordinates} from './classes/spherical-coordinates';\nexport {default as _Pose} from './classes/pose';\nexport {default as _Euler} from './classes/euler';\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport assert from './assert';\n\nconst RADIANS_TO_DEGREES = (1 / Math.PI) * 180;\nconst DEGREES_TO_RADIANS = (1 / 180) * Math.PI;\n\n// TODO - remove\n/* eslint-disable no-shadow */\nconst config = {};\nconfig.EPSILON = 1e-12;\nconfig.debug = false;\nconfig.precision = 4;\nconfig.printTypes = false;\nconfig.printDegrees = false;\nconfig.printRowMajor = true;\n\nexport {config};\n\nexport function configure(options = {}) {\n  // Only copy existing keys\n  for (const key in options) {\n    assert(key in config);\n    config[key] = options[key];\n  }\n  return config;\n}\n\nfunction round(value) {\n  return Math.round(value / config.EPSILON) * config.EPSILON;\n}\n\nexport function formatValue(value, {precision = config.precision || 4} = {}) {\n  value = round(value);\n  // get rid of trailing zeros\n  return `${parseFloat(value.toPrecision(precision))}`;\n}\n\n// Returns true if value is either an array or a typed array\n// Note: does not return true for ArrayBuffers and DataViews\nexport function isArray(value) {\n  return Array.isArray(value) || (ArrayBuffer.isView(value) && !(value instanceof DataView));\n}\n\n// If the array has a clone function, calls it, otherwise returns a copy\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\n// If the argument value is an array, applies the func element wise,\n// otherwise applies func to the argument value\nfunction map(value, func, result) {\n  if (isArray(value)) {\n    result = result || duplicateArray(value);\n    for (let i = 0; i < result.length && i < value.length; ++i) {\n      result[i] = func(value[i], i, result);\n    }\n    return result;\n  }\n  return func(value);\n}\n\nexport function toRadians(degrees) {\n  return radians(degrees);\n}\n\nexport function toDegrees(radians) {\n  return degrees(radians);\n}\n\n//\n// GLSL math function equivalents\n// Works on both single values and vectors\n//\n\nexport function radians(degrees, result) {\n  return map(degrees, (degrees) => degrees * DEGREES_TO_RADIANS, result);\n}\n\nexport function degrees(radians, result) {\n  return map(radians, (radians) => radians * RADIANS_TO_DEGREES, result);\n}\n\n// GLSL equivalent: Works on single values and vectors\nexport function sin(radians) {\n  return map(radians, (angle) => Math.sin(angle));\n}\n\n// GLSL equivalent: Works on single values and vectors\nexport function cos(radians) {\n  return map(radians, (angle) => Math.cos(angle));\n}\n\n// GLSL equivalent: Works on single values and vectors\nexport function tan(radians) {\n  return map(radians, (angle) => Math.tan(angle));\n}\n\n// GLSL equivalent: Works on single values and vectors\nexport function asin(radians) {\n  return map(radians, (angle) => Math.asin(angle));\n}\n\n// GLSL equivalent: Works on single values and vectors\nexport function acos(radians) {\n  return map(radians, (angle) => Math.acos(angle));\n}\n\n// GLSL equivalent: Works on single values and vectors\nexport function atan(radians) {\n  return map(radians, (angle) => Math.atan(angle));\n}\n\nexport function clamp(value, min, max) {\n  return map(value, (value) => Math.max(min, Math.min(max, value)));\n}\n\n// Interpolate between two numbers or two arrays\nexport function lerp(a, b, t) {\n  if (isArray(a)) {\n    return a.map((ai, i) => lerp(ai, b[i], t));\n  }\n  return t * b + (1 - t) * a;\n}\n\n// eslint-disable-next-line complexity\nexport function equals(a, b, epsilon) {\n  const oldEpsilon = config.EPSILON;\n  if (epsilon) {\n    config.EPSILON = epsilon;\n  }\n  try {\n    if (a === b) {\n      return true;\n    }\n    if (isArray(a) && isArray(b)) {\n      if (a.length !== b.length) {\n        return false;\n      }\n      for (let i = 0; i < a.length; ++i) {\n        // eslint-disable-next-line max-depth\n        if (!equals(a[i], b[i])) {\n          return false;\n        }\n      }\n      return true;\n    }\n    if (a && a.equals) {\n      return a.equals(b);\n    }\n    if (b && b.equals) {\n      return b.equals(a);\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    return false;\n  } finally {\n    config.EPSILON = oldEpsilon;\n  }\n}\n\n// eslint-disable-next-line complexity\nexport function exactEquals(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (a && typeof a === 'object' && b && typeof b === 'object') {\n    if (a.constructor !== b.constructor) {\n      return false;\n    }\n    if (a.exactEquals) {\n      return a.exactEquals(b);\n    }\n  }\n  if (isArray(a) && isArray(b)) {\n    if (a.length !== b.length) {\n      return false;\n    }\n    for (let i = 0; i < a.length; ++i) {\n      if (!exactEquals(a[i], b[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n  return false;\n}\n\nexport function withEpsilon(EPSILON, func) {\n  const oldPrecision = config.EPSILON;\n  config.EPSILON = EPSILON;\n  let value;\n  try {\n    value = func();\n  } finally {\n    config.EPSILON = oldPrecision;\n  }\n  return value;\n}\n","export default function assert(condition, message) {\n  if (!condition) {\n    throw new Error(`math.gl assertion ${message}`);\n  }\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport Vector from './base/vector';\nimport {config, isArray} from '../lib/common';\nimport {checkNumber} from '../lib/validators';\n\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as vec2 from 'gl-matrix/vec2';\n// eslint-disable-next-line camelcase\nimport {vec2_transformMat4AsVector} from '../lib/gl-matrix-extras';\n\nexport default class Vector2 extends Vector {\n  // Creates a new, empty vec2\n  constructor(x = 0, y = 0) {\n    // PERF NOTE: initialize elements as double precision numbers\n    super(2); // -0, -0);\n    if (isArray(x) && arguments.length === 1) {\n      this.copy(x);\n    } else {\n      if (config.debug) {\n        checkNumber(x);\n        checkNumber(y);\n      }\n      this[0] = x;\n      this[1] = y;\n    }\n  }\n\n  set(x, y) {\n    this[0] = x;\n    this[1] = y;\n    return this.check();\n  }\n\n  copy(array) {\n    this[0] = array[0];\n    this[1] = array[1];\n    return this.check();\n  }\n\n  fromObject(object) {\n    if (config.debug) {\n      checkNumber(object.x);\n      checkNumber(object.y);\n    }\n    this[0] = object.x;\n    this[1] = object.y;\n    return this.check();\n  }\n\n  toObject(object) {\n    object.x = this[0];\n    object.y = this[1];\n    return object;\n  }\n\n  // Getters/setters\n  get ELEMENTS() {\n    return 2;\n  }\n\n  // x,y inherited from Vector\n\n  horizontalAngle() {\n    return Math.atan2(this.y, this.x);\n  }\n\n  verticalAngle() {\n    return Math.atan2(this.x, this.y);\n  }\n\n  // Transforms\n\n  transform(matrix4) {\n    return this.transformAsPoint(matrix4);\n  }\n\n  // transforms as point (4th component is implicitly 1)\n  transformAsPoint(matrix4) {\n    vec2.transformMat4(this, this, matrix4);\n    return this.check();\n  }\n\n  // transforms as vector  (4th component is implicitly 0, ignores translation. slightly faster)\n  transformAsVector(matrix4) {\n    vec2_transformMat4AsVector(this, this, matrix4);\n    return this.check();\n  }\n\n  transformByMatrix3(matrix3) {\n    vec2.transformMat3(this, this, matrix3);\n    return this.check();\n  }\n\n  transformByMatrix2x3(matrix2x3) {\n    vec2.transformMat2d(this, this, matrix2x3);\n    return this.check();\n  }\n\n  transformByMatrix2(matrix2) {\n    vec2.transformMat2(this, this, matrix2);\n    return this.check();\n  }\n}\n","import MathArray from './math-array';\nimport {checkNumber} from '../../lib/validators';\nimport assert from '../../lib/assert';\n\nexport default class Vector extends MathArray {\n  get ELEMENTS() {\n    assert(false);\n    return 0;\n  }\n\n  // VIRTUAL METHODS\n  copy(vector) {\n    assert(false);\n    return this;\n  }\n\n  // ACCESSORS\n\n  get x() {\n    return this[0];\n  }\n  set x(value) {\n    this[0] = checkNumber(value);\n  }\n\n  get y() {\n    return this[1];\n  }\n  set y(value) {\n    this[1] = checkNumber(value);\n  }\n\n  // NOTE: `length` is a reserved word for Arrays, so we can't use `v.length()`\n  // Offer `len` and `magnitude`\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    for (let i = 0; i < this.ELEMENTS; ++i) {\n      length += this[i] * this[i];\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    for (let i = 0; i < this.ELEMENTS; ++i) {\n      const dist = this[i] - mathArray[i];\n      length += dist * dist;\n    }\n    return checkNumber(length);\n  }\n\n  dot(mathArray) {\n    let product = 0;\n    for (let i = 0; i < this.ELEMENTS; ++i) {\n      product += this[i] * mathArray[i];\n    }\n    return checkNumber(product);\n  }\n\n  // MODIFIERS\n\n  normalize() {\n    const length = this.magnitude();\n    if (length !== 0) {\n      for (let i = 0; i < this.ELEMENTS; ++i) {\n        this[i] /= length;\n      }\n    }\n    return this.check();\n  }\n\n  // negate() {\n  //   for (let i = 0; i < this.ELEMENTS; ++i) {\n  //     this[i] = -this[i];\n  //   }\n  //   return this.check();\n  // }\n\n  // inverse() {\n  //   for (let i = 0; i < this.ELEMENTS; ++i) {\n  //     this[i] = 1 / this[i];\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    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    return this.check();\n  }\n\n  // THREE.js compatibility\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    // @ts-ignore error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.\n    return this.add(new this.constructor(a).multiplyScalar(b));\n  }\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {config, formatValue, equals, isArray} from '../../lib/common';\nimport assert from '../../lib/assert';\n\nexport default class MathArray extends Array {\n  // Defined by derived class\n  get ELEMENTS() {\n    assert(false);\n    return 0;\n  }\n\n  clone() {\n    // @ts-ignore error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.\n    return new this.constructor().copy(this);\n  }\n\n  from(arrayOrObject) {\n    // @ts-ignore error TS2339: Property 'copy' does not exist on type 'MathArray'.\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    return this.check();\n  }\n\n  to(arrayOrObject) {\n    if (arrayOrObject === this) {\n      return this;\n    }\n    // @ts-ignore error TS2339: Property 'toObject' does not exist on type 'MathArray'.\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    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    for (let i = 0; i < this.ELEMENTS; ++i) {\n      string += (i > 0 ? ', ' : '') + formatValue(this[i], opts);\n    }\n    return `${opts.printTypes ? this.constructor.name : ''}[${string}]`;\n  }\n\n  equals(array) {\n    if (!array || this.length !== array.length) {\n      return false;\n    }\n    for (let i = 0; i < this.ELEMENTS; ++i) {\n      if (!equals(this[i], array[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  exactEquals(array) {\n    if (!array || this.length !== array.length) {\n      return false;\n    }\n    for (let i = 0; i < this.ELEMENTS; ++i) {\n      if (this[i] !== array[i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  // Modifiers\n\n  negate() {\n    for (let i = 0; i < this.ELEMENTS; ++i) {\n      this[i] = -this[i];\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; // eslint-disable-line\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    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    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    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    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    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    return this.check();\n  }\n\n  scale(scale) {\n    if (Array.isArray(scale)) {\n      // @ts-ignore error TS2339: Property 'multiply' does not exist on type 'MathArray'.\n      return this.multiply(scale);\n    }\n    for (let i = 0; i < this.ELEMENTS; ++i) {\n      this[i] *= scale;\n    }\n    return this.check();\n  }\n\n  // three.js compatibility\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    return this.check();\n  }\n\n  addScalar(a) {\n    for (let i = 0; i < this.ELEMENTS; ++i) {\n      this[i] += a;\n    }\n    return this.check();\n  }\n\n  subScalar(a) {\n    return this.addScalar(-a);\n  }\n\n  multiplyScalar(scalar) {\n    // Multiplies all elements\n    // `Matrix4.scale` only scales its 3x3 \"minor\"\n    for (let i = 0; i < this.ELEMENTS; ++i) {\n      this[i] *= scalar;\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    return this.check();\n  }\n\n  // Cesium compatibility\n\n  multiplyByScalar(scalar) {\n    return this.scale(scalar);\n  }\n\n  // THREE.js compatibility\n  get elements() {\n    return this;\n  }\n\n  // Debug checks\n\n  check() {\n    if (config.debug && !this.validate()) {\n      throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);\n    }\n    return this;\n  }\n\n  validate() {\n    let valid = this.length === this.ELEMENTS;\n    for (let i = 0; i < this.ELEMENTS; ++i) {\n      valid = valid && Number.isFinite(this[i]);\n    }\n    return valid;\n  }\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {config} from './common';\n\nexport function validateVector(v, length) {\n  if (v.length !== length) {\n    return false;\n  }\n  // Could be arguments \"array\" (v.every not availasble)\n  for (let i = 0; i < v.length; ++i) {\n    if (!Number.isFinite(v[i])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function checkNumber(value) {\n  if (!Number.isFinite(value)) {\n    throw new Error(`Invalid number ${value}`);\n  }\n  return value;\n}\n\nexport function checkVector(v, length, callerName = '') {\n  if (config.debug && !validateVector(v, length)) {\n    throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);\n  }\n  return v;\n}\n\nconst map = {};\n\nexport function deprecated(method, version) {\n  if (!map[method]) {\n    map[method] = true;\n    // eslint-disable-next-line\n    console.warn(\n      `${method} has been removed in version ${version}, see upgrade guide for more information`\n    );\n  }\n}\n","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}();","/**\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};","/* eslint-disable camelcase */\n// vec2 additions\n\nexport 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}\n\n// vec3 additions\n\n// Transform as vector, only uses 3x3 minor matrix\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}\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}\n\n// vec4 additions\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}\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","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport Vector from './base/vector';\nimport {config, isArray} from '../lib/common';\nimport {checkNumber} from '../lib/validators';\n\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as vec3 from 'gl-matrix/vec3';\n// eslint-disable-next-line camelcase\nimport {vec3_transformMat2, vec3_transformMat4AsVector} from '../lib/gl-matrix-extras';\n\nconst ORIGIN = [0, 0, 0];\nconst constants = {};\n\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  /**\n   * @class\n   * @param {Number | [Number, Number, Number]} x\n   * @param {Number} y - rotation around X (latitude)\n   * @param {Number} z - rotation around X (latitude)\n   */\n  constructor(x = 0, y = 0, z = 0) {\n    // PERF NOTE: initialize elements as double precision numbers\n    super(-0, -0, -0);\n    if (arguments.length === 1 && isArray(x)) {\n      this.copy(x);\n    } else {\n      // this.set(x, y, z);\n      if (config.debug) {\n        checkNumber(x);\n        checkNumber(y);\n        checkNumber(z);\n      }\n      // @ts-ignore TS2412: Property '0' of type 'number | [number, number, number]' is not assignable to numeric index type 'number'\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    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  // Getters/setters\n  /* eslint-disable no-multi-spaces, brace-style, no-return-assign */\n  get ELEMENTS() {\n    return 3;\n  }\n\n  // x,y inherited from Vector\n\n  get z() {\n    return this[2];\n  }\n  set z(value) {\n    this[2] = checkNumber(value);\n  }\n  /* eslint-enable no-multi-spaces, brace-style, no-return-assign */\n\n  angle(vector) {\n    return vec3.angle(this, vector);\n  }\n\n  // MODIFIERS\n\n  cross(vector) {\n    vec3.cross(this, this, vector);\n    return this.check();\n  }\n\n  rotateX({radians, origin = ORIGIN}) {\n    vec3.rotateX(this, this, origin, radians);\n    return this.check();\n  }\n\n  rotateY({radians, origin = ORIGIN}) {\n    vec3.rotateY(this, this, origin, radians);\n    return this.check();\n  }\n\n  rotateZ({radians, origin = ORIGIN}) {\n    vec3.rotateZ(this, this, origin, radians);\n    return this.check();\n  }\n\n  // Transforms\n\n  // transforms as point (4th component is implicitly 1)\n  transform(matrix4) {\n    return this.transformAsPoint(matrix4);\n  }\n\n  // transforms as point (4th component is implicitly 1)\n  transformAsPoint(matrix4) {\n    vec3.transformMat4(this, this, matrix4);\n    return this.check();\n  }\n\n  // transforms as vector  (4th component is implicitly 0, ignores translation. slightly faster)\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","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}();","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport Vector from './base/vector';\nimport {config, isArray} from '../lib/common';\nimport {checkNumber} from '../lib/validators';\n\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as vec4 from 'gl-matrix/vec3';\n// eslint-disable-next-line camelcase\nimport {vec4_transformMat2, vec4_transformMat3} from '../lib/gl-matrix-extras';\n\nconst constants = {};\n\nexport default class Vector4 extends Vector {\n  static get ZERO() {\n    return (constants.ZERO = constants.ZERO || Object.freeze(new Vector4(0, 0, 0, 0)));\n  }\n\n  constructor(x = 0, y = 0, z = 0, w = 0) {\n    // PERF NOTE: initialize elements as double precision numbers\n    super(-0, -0, -0, -0);\n    if (isArray(x) && arguments.length === 1) {\n      this.copy(x);\n    } else {\n      // this.set(x, y, z, w);\n      if (config.debug) {\n        checkNumber(x);\n        checkNumber(y);\n        checkNumber(z);\n        checkNumber(w);\n      }\n      this[0] = x;\n      this[1] = y;\n      this[2] = z;\n      this[3] = w;\n    }\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  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  fromObject(object) {\n    if (config.debug) {\n      checkNumber(object.x);\n      checkNumber(object.y);\n      checkNumber(object.z);\n      checkNumber(object.w);\n    }\n    this[0] = object.x;\n    this[1] = object.y;\n    this[2] = object.z;\n    this[3] = object.w;\n    return this;\n  }\n\n  toObject(object) {\n    object.x = this[0];\n    object.y = this[1];\n    object.z = this[2];\n    object.w = this[3];\n    return object;\n  }\n\n  // Getters/setters\n  /* eslint-disable no-multi-spaces, brace-style, no-return-assign */\n  get ELEMENTS() {\n    return 4;\n  }\n\n  // x,y inherited from Vector\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  /* eslint-enable no-multi-spaces, brace-style, no-return-assign */\n\n  transform(matrix4) {\n    vec4.transformMat4(this, this, matrix4);\n    return this.check();\n  }\n\n  transformByMatrix3(matrix3) {\n    vec4_transformMat3(this, this, matrix3);\n    return this.check();\n  }\n\n  transformByMatrix2(matrix2) {\n    vec4_transformMat2(this, this, matrix2);\n    return this.check();\n  }\n\n  transformByQuaternion(quaternion) {\n    vec4.transformQuat(this, this, quaternion);\n    return this.check();\n  }\n\n  // three.js compatibility\n  applyMatrix4(m) {\n    m.transform(this, this);\n    return this;\n  }\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport Matrix from './base/matrix';\nimport {checkVector, deprecated} from '../lib/validators';\n// eslint-disable-next-line camelcase\nimport {vec4_transformMat3} from '../lib/gl-matrix-extras';\n\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as mat3 from 'gl-matrix/mat3';\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as vec2 from 'gl-matrix/vec2';\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as vec3 from 'gl-matrix/vec3';\n\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]);\n\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});\n\nconst constants = {};\n\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    // PERF NOTE: initialize elements as double precision numbers\n    super(-0, -0, -0, -0, -0, -0, -0, -0, -0);\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  // accepts column major order, stores in column major order\n  // eslint-disable-next-line max-params\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  // accepts row major order, stores as column major\n  // eslint-disable-next-line max-params\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  // Accessors\n\n  determinant() {\n    return mat3.determinant(this);\n  }\n\n  // Constructors\n\n  identity() {\n    return this.copy(IDENTITY);\n  }\n\n  // Calculates a 3x3 matrix from the given quaternion\n  // q quat  Quaternion to create matrix from\n  fromQuaternion(q) {\n    mat3.fromQuat(this, q);\n    return this.check();\n  }\n\n  // Modifiers\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  // Operations\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  // Transforms\n\n  transform(vector, result) {\n    switch (vector.length) {\n      case 2:\n        result = vec2.transformMat3(result || [-0, -0], vector, this);\n        break;\n      case 3:\n        result = vec3.transformMat3(result || [-0, -0, -0], vector, this);\n        break;\n      case 4:\n        result = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this);\n        break;\n      default:\n        throw new Error('Illegal vector');\n    }\n    checkVector(result, vector.length);\n    return result;\n  }\n\n  // DEPRECATED IN 3.0\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","import MathArray from './math-array';\nimport {checkNumber} from '../../lib/validators';\nimport {config} from '../../lib/common';\nimport assert from '../../lib/assert';\n\nexport default class Matrix extends MathArray {\n  // Defined by derived class\n  get ELEMENTS() {\n    assert(false);\n    return 0;\n  }\n\n  get RANK() {\n    assert(false);\n    return 0;\n  }\n\n  // fromObject(object) {\n  //   const array = object.elements;\n  //   return this.fromRowMajor(array);\n  // }\n\n  // toObject(object) {\n  //   const array = object.elements;\n  //   this.toRowMajor(array);\n  //   return object;\n  // }\n\n  toString() {\n    let string = '[';\n    if (config.printRowMajor) {\n      string += 'row-major:';\n      for (let row = 0; row < this.RANK; ++row) {\n        for (let col = 0; col < this.RANK; ++col) {\n          string += ` ${this[col * this.RANK + row]}`;\n        }\n      }\n    } else {\n      string += 'column-major:';\n      for (let i = 0; i < this.ELEMENTS; ++i) {\n        string += ` ${this[i]}`;\n      }\n    }\n    string += ']';\n    return string;\n  }\n\n  getElementIndex(row, col) {\n    return col * this.RANK + row;\n  }\n\n  // By default assumes row major indices\n  getElement(row, col) {\n    return this[col * this.RANK + row];\n  }\n\n  // By default assumes row major indices\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    for (let i = 0; i < this.RANK; ++i) {\n      result[i] = this[firstIndex + i];\n    }\n    return result;\n  }\n\n  setColumn(columnIndex, columnVector) {\n    const firstIndex = columnIndex * this.RANK;\n    for (let i = 0; i < this.RANK; ++i) {\n      this[firstIndex + i] = columnVector[i];\n    }\n    return this;\n  }\n}\n","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;","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {checkVector, deprecated} from '../lib/validators';\nimport Matrix from './base/matrix';\n// eslint-disable-next-line camelcase\nimport {vec2_transformMat4AsVector, vec3_transformMat4AsVector} from '../lib/gl-matrix-extras';\n\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as mat4 from 'gl-matrix/mat4';\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as vec2 from 'gl-matrix/vec2';\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as vec3 from 'gl-matrix/vec3';\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as vec4 from 'gl-matrix/vec4';\n\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]);\n\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});\n\nconst constants = {};\n\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    // PERF NOTE: initialize elements as double precision numbers\n    super(-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0);\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  // eslint-disable-next-line max-params\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  // accepts row major order, stores as column major\n  // eslint-disable-next-line max-params\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  // Constructors\n\n  identity() {\n    return this.copy(IDENTITY);\n  }\n\n  // Calculates a 4x4 matrix from the given quaternion\n  // q quat  Quaternion to create matrix from\n  fromQuaternion(q) {\n    mat4.fromQuat(this, q);\n    return this.check();\n  }\n\n  // Generates a frustum matrix with the given bounds\n  // left  Number  Left bound of the frustum\n  // right Number  Right bound of the frustum\n  // bottom  Number  Bottom bound of the frustum\n  // top Number  Top bound of the frustum\n  // near  Number  Near bound of the frustum\n  // far Number  Far bound of the frustum\n  frustum({left, right, bottom, top, near, far}) {\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    return this.check();\n  }\n\n  // eslint-disable-next-line max-params\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\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  // Generates a look-at matrix with the given eye position, focal point,\n  // and up axis\n  // eye vec3  Position of the viewer\n  // center  vec3  Point the viewer is looking at\n  // up  vec3  vec3 pointing up\n  lookAt(eye, center, up) {\n    // Signature: lookAt({eye, center = [0, 0, 0], up = [0, 1, 0]}))\n    if (arguments.length === 1) {\n      ({eye, center, up} = eye);\n    }\n\n    center = center || [0, 0, 0];\n    up = up || [0, 1, 0];\n\n    mat4.lookAt(this, eye, center, up);\n    return this.check();\n  }\n\n  // Generates a orthogonal projection matrix with the given bounds\n  // from \"traditional\" view space parameters\n  // left  number  Left bound of the frustum\n  // right number  Right bound of the frustum\n  // bottom  number  Bottom bound of the frustum\n  // top number  Top bound of the frustum\n  // near  number  Near bound of the frustum\n  // far number  Far bound of the frustum\n  ortho({left, right, bottom, top, near = 0.1, far = 500}) {\n    mat4.ortho(this, left, right, bottom, top, near, far);\n    return this.check();\n  }\n\n  // Generates an orthogonal projection matrix with the same parameters\n  // as a perspective matrix (plus focalDistance)\n  // fovy  number  Vertical field of view in radians\n  // aspect  number  Aspect ratio. typically viewport width/height\n  // focalDistance distance in the view frustum used for extent calculations\n  // near  number  Near bound of the frustum\n  // far number  Far bound of the frustum\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    const halfY = fovy / 2;\n    const top = focalDistance * Math.tan(halfY); // focus_plane is the distance from the camera\n    const right = top * aspect;\n\n    return new Matrix4().ortho({\n      left: -right,\n      right,\n      bottom: -top,\n      top,\n      near,\n      far\n    });\n  }\n\n  // Generates a perspective projection matrix with the given bounds\n  // fovy  number  Vertical field of view in radians\n  // aspect  number  Aspect ratio. typically viewport width/height\n  // near  number  Near bound of the frustum\n  // far number  Far bound of the frustum\n  perspective({\n    fovy = undefined,\n    fov = (45 * Math.PI) / 180, // DEPRECATED\n    aspect = 1,\n    near = 0.1,\n    far = 500\n  } = {}) {\n    fovy = fovy || fov;\n    if (fovy > Math.PI * 2) {\n      throw Error('radians');\n    }\n    mat4.perspective(this, fovy, aspect, near, far);\n    return this.check();\n  }\n\n  // Accessors\n\n  determinant() {\n    return mat4.determinant(this);\n  }\n\n  // Extracts the non-uniform scale assuming the matrix is an affine transformation.\n  // The scales are the \"lengths\" of the column vectors in the upper-left 3x3 matrix.\n  getScale(result = [-0, -0, -0]) {\n    // explicit is faster than hypot...\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    // result[0] = Math.hypot(this[0], this[1], this[2]);\n    // result[1] = Math.hypot(this[4], this[5], this[6]);\n    // result[2] = Math.hypot(this[8], this[9], this[10]);\n    return result;\n  }\n\n  // Gets the translation portion, assuming the matrix is a affine transformation matrix.\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  // Gets upper left 3x3 pure rotation matrix (non-scaling), assume affine transformation matrix\n  getRotation(\n    result = [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0],\n    scaleResult = null\n  ) {\n    const scale = this.getScale(scaleResult || [-0, -0, -0]);\n\n    const inverseScale0 = 1 / scale[0];\n    const inverseScale1 = 1 / scale[1];\n    const inverseScale2 = 1 / scale[2];\n\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\n    const inverseScale0 = 1 / scale[0];\n    const inverseScale1 = 1 / scale[1];\n    const inverseScale2 = 1 / scale[2];\n\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  // Modifiers\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  // Operations\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  // Rotates a matrix by the given angle around the X axis\n  rotateX(radians) {\n    mat4.rotateX(this, this, radians);\n    // mat4.rotate(this, this, radians, [1, 0, 0]);\n    return this.check();\n  }\n\n  // Rotates a matrix by the given angle around the Y axis.\n  rotateY(radians) {\n    mat4.rotateY(this, this, radians);\n    // mat4.rotate(this, this, radians, [0, 1, 0]);\n    return this.check();\n  }\n\n  // Rotates a matrix by the given angle around the Z axis.\n  rotateZ(radians) {\n    mat4.rotateZ(this, this, radians);\n    // mat4.rotate(this, this, radians, [0, 0, 1]);\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  // Transforms\n\n  // Transforms any 2, 3 or 4 element vector. 2 and 3 elements are treated as points\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    return this.transformAsPoint(vector, result);\n  }\n\n  // Transforms any 2 or 3 element array as point (w implicitly 1)\n  transformAsPoint(vector, result) {\n    const {length} = vector;\n    switch (length) {\n      case 2:\n        result = vec2.transformMat4(result || [-0, -0], vector, this);\n        break;\n      case 3:\n        result = vec3.transformMat4(result || [-0, -0, -0], vector, this);\n        break;\n      default:\n        throw new Error('Illegal vector');\n    }\n    checkVector(result, vector.length);\n    return result;\n  }\n\n  // Transforms any 2 or 3 element array as vector (w implicitly 0)\n  transformAsVector(vector, result) {\n    switch (vector.length) {\n      case 2:\n        result = vec2_transformMat4AsVector(result || [-0, -0], vector, this);\n        break;\n      case 3:\n        result = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this);\n        break;\n      default:\n        throw new Error('Illegal vector');\n    }\n    checkVector(result, vector.length);\n    return result;\n  }\n\n  // three.js math API compatibility\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  // DEPRECATED in 3.0\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","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 * 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}();","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport MathArray from './base/math-array';\nimport {checkNumber, checkVector} from '../lib/validators';\nimport assert from '../lib/assert';\n\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as quat from 'gl-matrix/quat';\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as vec4 from 'gl-matrix/vec4';\n\nconst IDENTITY_QUATERNION = [0, 0, 0, 1];\n\nexport default class Quaternion extends MathArray {\n  constructor(x = 0, y = 0, z = 0, w = 1) {\n    // PERF NOTE: initialize elements as double precision numbers\n    super(-0, -0, -0, -0);\n    // eslint-disable-next-line prefer-rest-params\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  // Creates a quaternion from the given 3x3 rotation matrix.\n  // NOTE: The resultant quaternion is not normalized, so you should\n  // be sure to renormalize the quaternion yourself where necessary.\n  fromMatrix3(m) {\n    quat.fromMat3(this, m);\n    return this.check();\n  }\n\n  // Set a quat to the identity quaternion\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  // Set the components of a quat to the given values\n  // set(i, j, k, l) {\n  //   quat.set(this, i, j, k, l);\n  //   return this.check();\n  // }\n\n  // Sets a quat from the given angle and rotation axis, then returns it.\n  setAxisAngle(axis, rad) {\n    return this.fromAxisRotation(axis, rad);\n  }\n\n  // Getters/setters\n  /* eslint-disable no-multi-spaces, brace-style, no-return-assign */\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  /* eslint-enable no-multi-spaces, brace-style, no-return-assign */\n\n  // Calculates the length of a quat\n  len() {\n    return quat.length(this);\n  }\n\n  // Calculates the squared length of a quat\n  lengthSquared() {\n    return quat.squaredLength(this);\n  }\n\n  // Calculates the dot product of two quat's\n  // @return {Number}\n  dot(a, b) {\n    if (b !== undefined) {\n      throw new Error('Quaternion.dot only takes one argument');\n    }\n    return quat.dot(this, a);\n  }\n\n  // Gets the rotation axis and angle for a given quaternion.\n  // If a quaternion is created with setAxisAngle, this method will\n  // return the same values as providied in the original parameter\n  // list OR functionally equivalent values.\n  // Example: The quaternion formed by axis [0, 0, 1] and angle -90\n  // is the same as the quaternion formed by [0, 0, 1] and 270.\n  // This method favors the latter.\n  // @return {{[x,y,z], Number}}\n  // getAxisAngle() {\n  //   const axis = [];\n  //   const angle = quat.getAxisAngle(axis, this);\n  //   return {axis, angle};\n  // }\n\n  // MODIFIERS\n\n  // Sets a quaternion to represent the shortest rotation from one vector\n  // to another. Both vectors are assumed to be unit length.\n  rotationTo(vectorA, vectorB) {\n    quat.rotationTo(this, vectorA, vectorB);\n    return this.check();\n  }\n\n  // Sets the specified quaternion with values corresponding to the given axes.\n  // Each axis is a vec3 and is expected to be unit length and perpendicular\n  // to all other specified axes.\n  // setAxes() {\n  //   Number\n  // }\n\n  // Performs a spherical linear interpolation with two control points\n  // sqlerp() {\n  //   Number;\n  // }\n\n  // Adds two quat's\n  add(a, b) {\n    if (b !== undefined) {\n      throw new Error('Quaternion.add only takes one argument');\n    }\n    quat.add(this, this, a);\n    return this.check();\n  }\n\n  // Calculates the W component of a quat from the X, Y, and Z components.\n  // Any existing W component will be ignored.\n  calculateW() {\n    quat.calculateW(this, this);\n    return this.check();\n  }\n\n  // Calculates the conjugate of a quat If the quaternion is normalized,\n  // this function is faster than quat.inverse and produces the same result.\n  conjugate() {\n    quat.conjugate(this, this);\n    return this.check();\n  }\n\n  // Calculates the inverse of a quat\n  invert() {\n    quat.invert(this, this);\n    return this.check();\n  }\n\n  // Performs a linear interpolation between two quat's\n  lerp(a, b, t) {\n    quat.lerp(this, a, b, t);\n    return this.check();\n  }\n\n  // Multiplies two quat's\n  multiplyRight(a, b) {\n    assert(!b); // Quaternion.multiply only takes one argument\n    quat.multiply(this, this, a);\n    return this.check();\n  }\n\n  multiplyLeft(a, b) {\n    assert(!b); // Quaternion.multiply only takes one argument\n    quat.multiply(this, a, this);\n    return this.check();\n  }\n\n  // Normalize a quat\n  normalize() {\n    // Handle 0 case\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    // Set to [0, 0, 0, 1] if length is 0\n    if (length === 0) {\n      this[3] = 1;\n    }\n    return this.check();\n  }\n\n  // Rotates a quaternion by the given angle about the X axis\n  rotateX(rad) {\n    quat.rotateX(this, this, rad);\n    return this.check();\n  }\n\n  // Rotates a quaternion by the given angle about the Y axis\n  rotateY(rad) {\n    quat.rotateY(this, this, rad);\n    return this.check();\n  }\n\n  // Rotates a quaternion by the given angle about the Z axis\n  rotateZ(rad) {\n    quat.rotateZ(this, this, rad);\n    return this.check();\n  }\n\n  // Scales a quat by a scalar number\n  scale(b) {\n    quat.scale(this, this, b);\n    return this.check();\n  }\n\n  // Performs a spherical linear interpolation between two quat\n  slerp(start, target, ratio) {\n    // eslint-disable-next-line prefer-rest-params\n    switch (arguments.length) {\n      case 1: // Deprecated signature ({start, target, ratio})\n        // eslint-disable-next-line prefer-rest-params\n        ({start = IDENTITY_QUATERNION, target, ratio} = arguments[0]);\n        break;\n      case 2: // THREE.js compatibility signature (target, ration)\n        // eslint-disable-next-line prefer-rest-params\n        [target, ratio] = arguments;\n        start = this; // eslint-disable-line\n        break;\n      default: // Default signature: (start, target, ratio)\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  // THREE.js Math API compatibility\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","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}();","// NOTE: Added to make Cesium-derived test cases work\n// TODO: Determine if/how to keep\nexport 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\n  PI_OVER_TWO: Math.PI / 2,\n  PI_OVER_FOUR: Math.PI / 4,\n  PI_OVER_SIX: Math.PI / 6,\n\n  TWO_PI: Math.PI * 2\n};\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// Adaptation of THREE.js Spherical class, under MIT license\nimport {formatValue, equals, config} from '../lib/common';\nimport {degrees, radians, clamp} from '../lib/common';\nimport Vector3 from './vector3';\n\n// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.\nimport * as vec3 from 'gl-matrix/vec3';\n\n// TODO - import epsilon\nconst EPSILON = 0.000001;\n\nconst EARTH_RADIUS_METERS = 6.371e6;\n\n// Todo [rho, theta, phi] ?\nexport default class SphericalCoordinates {\n  // @ts-ignore TS2740: Type '{}' is missing the following properties from type\n  // eslint-disable-next-line complexity\n  constructor({\n    phi = 0,\n    theta = 0,\n    radius = 1,\n    bearing = undefined,\n    pitch = undefined,\n    altitude = undefined,\n    radiusScale = EARTH_RADIUS_METERS\n  } = {}) {\n    this.phi = phi;\n    this.theta = theta;\n    // TODO - silently accepts illegal 0\n    this.radius = radius || altitude || 1; // radial distance from center\n    this.radiusScale = radiusScale || 1; // Used by lngLatZ\n\n    if (bearing !== undefined) {\n      this.bearing = bearing; // up / down towards top and bottom pole\n    }\n    if (pitch !== undefined) {\n      this.pitch = pitch; // around the equator of the sphere\n    }\n    this.check();\n  }\n\n  toString() {\n    return this.formatString(config);\n  }\n\n  formatString({printTypes = false}) {\n    const f = formatValue;\n    return `${printTypes ? 'Spherical' : ''}\\\n[rho:${f(this.radius)},theta:${f(this.theta)},phi:${f(this.phi)}]`;\n  }\n\n  equals(other) {\n    return (\n      equals(this.radius, other.radius) &&\n      equals(this.theta, other.theta) &&\n      equals(this.phi, other.phi)\n    );\n  }\n\n  exactEquals(other) {\n    return this.radius === other.radius && this.theta === other.theta && this.phi === other.phi;\n  }\n\n  /* eslint-disable brace-style */\n  // Cartographic (bearing 0 north, pitch 0 look from above)\n  get bearing() {\n    return 180 - degrees(this.phi);\n  }\n  set bearing(v) {\n    this.phi = Math.PI - radians(v);\n  }\n  get pitch() {\n    return degrees(this.theta);\n  }\n  set pitch(v) {\n    this.theta = radians(v);\n  }\n  // get pitch() { return 90 - degrees(this.phi); }\n  // set pitch(v) { this.phi = radians(v) + Math.PI / 2; }\n  // get altitude() { return this.radius - 1; } // relative altitude\n\n  // lnglatZ coordinates\n  get longitude() {\n    return degrees(this.phi);\n  }\n  get latitude() {\n    return degrees(this.theta);\n  }\n  get lng() {\n    return degrees(this.phi);\n  }\n  get lat() {\n    return degrees(this.theta);\n  }\n  get z() {\n    return (this.radius - 1) * this.radiusScale;\n  }\n  /* eslint-enable brace-style */\n\n  set(radius, phi, theta) {\n    this.radius = radius;\n    this.phi = phi;\n    this.theta = theta;\n    return this.check();\n  }\n\n  clone() {\n    return new SphericalCoordinates().copy(this);\n  }\n\n  copy(other) {\n    this.radius = other.radius;\n    this.phi = other.phi;\n    this.theta = other.theta;\n    return this.check();\n  }\n\n  fromLngLatZ([lng, lat, z]) {\n    this.radius = 1 + z / this.radiusScale;\n    this.phi = radians(lat);\n    this.theta = radians(lng);\n  }\n\n  fromVector3(v) {\n    this.radius = vec3.length(v);\n    if (this.radius > 0) {\n      this.theta = Math.atan2(v[0], v[1]); // equator angle around y-up axis\n      this.phi = Math.acos(clamp(v[2] / this.radius, -1, 1)); // polar angle\n    }\n    return this.check();\n  }\n\n  toVector3() {\n    return new Vector3(0, 0, this.radius)\n      .rotateX({radians: this.theta})\n      .rotateZ({radians: this.phi});\n  }\n\n  // restrict phi to be betwee EPS and PI-EPS\n  makeSafe() {\n    this.phi = Math.max(EPSILON, Math.min(Math.PI - EPSILON, this.phi));\n    return this;\n  }\n\n  check() {\n    // this.makeSafe();\n    if (!Number.isFinite(this.phi) || !Number.isFinite(this.theta) || !(this.radius > 0)) {\n      throw new Error('SphericalCoordinates: some fields set to invalid numbers');\n    }\n    return this;\n  }\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\nimport Matrix4 from './matrix4';\nimport Vector3 from './vector3';\nimport Euler from './euler';\n\nexport default class Pose {\n  // @ts-ignore TS2740: Type '{}' is missing the following properties from type\n  constructor({\n    x = 0,\n    y = 0,\n    z = 0,\n    roll = 0,\n    pitch = 0,\n    yaw = 0,\n    position = undefined,\n    orientation = undefined\n  } = {}) {\n    if (Array.isArray(position) && position.length === 3) {\n      this.position = new Vector3(position);\n    } else {\n      this.position = new Vector3(x, y, z);\n    }\n    if (Array.isArray(orientation) && orientation.length === 4) {\n      this.orientation = new Euler(orientation, orientation[3]);\n    } else {\n      this.orientation = new Euler(roll, pitch, yaw, Euler.RollPitchYaw);\n    }\n  }\n\n  get x() {\n    return this.position.x;\n  }\n  set x(value) {\n    this.position.x = value;\n  }\n  get y() {\n    return this.position.y;\n  }\n  set y(value) {\n    this.position.y = value;\n  }\n  get z() {\n    return this.position.z;\n  }\n  set z(value) {\n    this.position.z = value;\n  }\n  get roll() {\n    return this.orientation.roll;\n  }\n  set roll(value) {\n    this.orientation.roll = value;\n  }\n  get pitch() {\n    return this.orientation.pitch;\n  }\n  set pitch(value) {\n    this.orientation.pitch = value;\n  }\n  get yaw() {\n    return this.orientation.yaw;\n  }\n  set yaw(value) {\n    this.orientation.yaw = value;\n  }\n\n  getPosition() {\n    return this.position;\n  }\n\n  getOrientation() {\n    return this.orientation;\n  }\n\n  equals(pose) {\n    if (!pose) {\n      return false;\n    }\n    return this.position.equals(pose.position) && this.orientation.equals(pose.orientation);\n  }\n\n  exactEquals(pose) {\n    if (!pose) {\n      return false;\n    }\n    return (\n      this.position.exactEquals(pose.position) && this.orientation.exactEquals(pose.orientation)\n    );\n  }\n\n  getTransformationMatrix() {\n    // setup precomputations for the sin/cos of the angles\n    const sr = Math.sin(this.roll);\n    const sp = Math.sin(this.pitch);\n    const sw = Math.sin(this.yaw);\n\n    const cr = Math.cos(this.roll);\n    const cp = Math.cos(this.pitch);\n    const cw = Math.cos(this.yaw);\n\n    const matrix = new Matrix4().setRowMajor(\n      cw * cp, // 0,0\n      -sw * cr + cw * sp * sr, // 0,1\n      sw * sr + cw * sp * cr, // 0,2\n      this.x, // 0,3\n\n      sw * cp, // 1,0\n      cw * cr + sw * sp * sr, // 1,1\n      -cw * sr + sw * sp * cr, // 1,2\n      this.y, // 1,3\n\n      -sp, // 2,0\n      cp * sr, // 2,1\n      cp * cr, // 2,2\n      this.z, // 2,3\n\n      0,\n      0,\n      0,\n      1\n    );\n\n    return matrix;\n  }\n\n  getTransformationMatrixFromPose(pose) {\n    return new Matrix4()\n      .multiplyRight(this.getTransformationMatrix())\n      .multiplyRight(pose.getTransformationMatrix().invert());\n  }\n\n  getTransformationMatrixToPose(pose) {\n    return new Matrix4()\n      .multiplyRight(pose.getTransformationMatrix())\n      .multiplyRight(this.getTransformationMatrix().invert());\n  }\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport MathArray from './base/math-array';\nimport {clamp} from '../lib/common';\nimport {checkNumber} from '../lib/validators';\nimport Quaternion from './quaternion';\n\n// Internal constants\nconst ERR_UNKNOWN_ORDER = 'Unknown Euler angle order';\nconst ALMOST_ONE = 0.99999;\n\nfunction validateOrder(value) {\n  return value >= 0 && value < 6;\n}\n\nfunction checkOrder(value) {\n  if (value < 0 && value >= 6) {\n    throw new Error(ERR_UNKNOWN_ORDER);\n  }\n  return value;\n}\n\nexport default class Euler extends MathArray {\n  // static XYZ = 0;\n  // static YZX = 1;\n  // static ZXY = 2;\n  // static XZY = 3;\n  // static YXZ = 4;\n  // static ZYX = 5;\n  // static RollPitchYaw = 0;\n  // static DefaultOrder = 0;\n\n  // Constants\n  /* eslint-disable no-multi-spaces, brace-style, no-return-assign */\n  static get ZYX() {\n    return 0;\n  }\n\n  static get YXZ() {\n    return 1;\n  }\n\n  static get XZY() {\n    return 2;\n  }\n\n  static get ZXY() {\n    return 3;\n  }\n\n  static get YZX() {\n    return 4;\n  }\n\n  static get XYZ() {\n    return 5;\n  }\n\n  static get RollPitchYaw() {\n    return 0;\n  }\n\n  static get DefaultOrder() {\n    return Euler.ZYX;\n  }\n\n  static get RotationOrders() {\n    return ['ZYX', 'YXZ', 'XZY', 'ZXY', 'YZX', 'XYZ'];\n  }\n\n  static rotationOrder(order) {\n    return Euler.RotationOrders[order];\n  }\n\n  get ELEMENTS() {\n    return 4;\n  }\n\n  /* eslint-enable no-multi-spaces, brace-style, no-return-assign */\n\n  /**\n   * @class\n   * @param {Number | Number[]} x\n   * @param {Number=} [y]\n   * @param {Number=} [z]\n   * @param {Number=} [order]\n   */\n  constructor(x = 0, y = 0, z = 0, order = Euler.DefaultOrder) {\n    // PERF NOTE: initialize elements as double precision numbers\n    super(-0, -0, -0, -0);\n    // eslint-disable-next-line prefer-rest-params\n    if (arguments.length > 0 && Array.isArray(arguments[0])) {\n      // eslint-disable-next-line prefer-rest-params\n      this.fromVector3(...arguments);\n    } else {\n      // @ts-ignore error TS2345: Argument of type 'number | [number, number, number, number]' not assignable to 'number'\n      this.set(x, y, z, order);\n    }\n  }\n\n  fromQuaternion(quaternion) {\n    const [x, y, z, w] = quaternion;\n    const ysqr = y * y;\n    const t0 = -2.0 * (ysqr + z * z) + 1.0;\n    const t1 = +2.0 * (x * y + w * z);\n    let t2 = -2.0 * (x * z - w * y);\n    const t3 = +2.0 * (y * z + w * x);\n    const t4 = -2.0 * (x * x + ysqr) + 1.0;\n\n    t2 = t2 > 1.0 ? 1.0 : t2;\n    t2 = t2 < -1.0 ? -1.0 : t2;\n\n    const roll = Math.atan2(t3, t4);\n    const pitch = Math.asin(t2);\n    const yaw = Math.atan2(t1, t0);\n\n    return new Euler(roll, pitch, yaw, Euler.RollPitchYaw);\n  }\n\n  // fromQuaternion(q, order) {\n  //   this._fromRotationMat[-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];\n  //   return this.check();\n  // }\n\n  // If copied array does contain fourth element, preserves currently set order\n  copy(array) {\n    this[0] = array[0];\n    this[1] = array[1];\n    this[2] = array[2];\n    this[3] = Number.isFinite(array[3]) || this.order;\n    return this.check();\n  }\n\n  // Sets the three angles, and optionally sets the rotation order\n  // If order is not specified, preserves currently set order\n  set(x = 0, y = 0, z = 0, order) {\n    this[0] = x;\n    this[1] = y;\n    this[2] = z;\n    this[3] = Number.isFinite(order) ? order : this[3];\n    return this.check();\n  }\n\n  validate() {\n    return (\n      validateOrder(this[3]) &&\n      Number.isFinite(this[0]) &&\n      Number.isFinite(this[1]) &&\n      Number.isFinite(this[2])\n    );\n  }\n\n  // Does not copy the orientation element\n  toArray(array = [], offset = 0) {\n    array[offset] = this[0];\n    array[offset + 1] = this[1];\n    array[offset + 2] = this[2];\n    return array;\n  }\n\n  // Copies the orientation element\n  toArray4(array = [], offset = 0) {\n    array[offset] = this[0];\n    array[offset + 1] = this[1];\n    array[offset + 2] = this[2];\n    array[offset + 3] = this[3];\n    return array;\n  }\n\n  toVector3(result = [-0, -0, -0]) {\n    result[0] = this[0];\n    result[1] = this[1];\n    result[2] = this[2];\n    return result;\n  }\n\n  /* eslint-disable no-multi-spaces, brace-style, no-return-assign */\n\n  // x, y, z angle notation (note: only corresponds to axis in XYZ orientation)\n  /** @type {number} */\n  get x() {\n    return this[0];\n  }\n\n  set x(value) {\n    this[0] = checkNumber(value);\n  }\n\n  /** @type {number} */\n  get y() {\n    return this[1];\n  }\n\n  set y(value) {\n    this[1] = checkNumber(value);\n  }\n\n  /** @type {number} */\n  get z() {\n    return this[2];\n  }\n\n  set z(value) {\n    this[2] = checkNumber(value);\n  }\n\n  // alpha, beta, gamma angle notation\n  get alpha() {\n    return this[0];\n  }\n\n  set alpha(value) {\n    this[0] = checkNumber(value);\n  }\n\n  get beta() {\n    return this[1];\n  }\n\n  set beta(value) {\n    this[1] = checkNumber(value);\n  }\n\n  get gamma() {\n    return this[2];\n  }\n\n  set gamma(value) {\n    this[2] = checkNumber(value);\n  }\n\n  // phi, theta, psi angle notation\n  get phi() {\n    return this[0];\n  }\n\n  set phi(value) {\n    this[0] = checkNumber(value);\n  }\n\n  get theta() {\n    return this[1];\n  }\n\n  set theta(value) {\n    this[1] = checkNumber(value);\n  }\n\n  get psi() {\n    return this[2];\n  }\n\n  set psi(value) {\n    this[2] = checkNumber(value);\n  }\n\n  // roll, pitch, yaw angle notation\n  /** @type {number} */\n  get roll() {\n    return this[0];\n  }\n\n  set roll(value) {\n    this[0] = checkNumber(value);\n  }\n\n  /** @type {number} */\n  get pitch() {\n    return this[1];\n  }\n\n  set pitch(value) {\n    this[1] = checkNumber(value);\n  }\n\n  /** @type {number} */\n  get yaw() {\n    return this[2];\n  }\n\n  set yaw(value) {\n    this[2] = checkNumber(value);\n  }\n\n  // rotation order, in all three angle notations\n  get order() {\n    return this[3];\n  }\n\n  set order(value) {\n    this[3] = checkOrder(value);\n  }\n\n  /* eslint-disable no-multi-spaces, brace-style, no-return-assign */\n\n  // Constructors\n  fromVector3(v, order) {\n    return this.set(v[0], v[1], v[2], Number.isFinite(order) ? order : this[3]);\n  }\n\n  // TODO - with and without 4th element\n  fromArray(array, offset = 0) {\n    this[0] = array[0 + offset];\n    this[1] = array[1 + offset];\n    this[2] = array[2 + offset];\n    if (array[3] !== undefined) {\n      this[3] = array[3];\n    }\n    return this.check();\n  }\n\n  // Common ZYX rotation order\n  fromRollPitchYaw(roll, pitch, yaw) {\n    return this.set(roll, pitch, yaw, Euler.ZYX);\n  }\n\n  fromRotationMatrix(m, order = Euler.DefaultOrder) {\n    this._fromRotationMatrix(m, order);\n    return this.check();\n  }\n\n  // ACCESSORS\n\n  getRotationMatrix(m) {\n    return this._getRotationMatrix(m);\n  }\n\n  // TODO - move to Quaternion\n  getQuaternion() {\n    const q = new Quaternion();\n    switch (this[4]) {\n      case Euler.XYZ:\n        return q.rotateX(this[0]).rotateY(this[1]).rotateZ(this[2]);\n      case Euler.YXZ:\n        return q.rotateY(this[0]).rotateX(this[1]).rotateZ(this[2]);\n      case Euler.ZXY:\n        return q.rotateZ(this[0]).rotateX(this[1]).rotateY(this[2]);\n      case Euler.ZYX:\n        return q.rotateZ(this[0]).rotateY(this[1]).rotateX(this[2]);\n      case Euler.YZX:\n        return q.rotateY(this[0]).rotateZ(this[1]).rotateX(this[2]);\n      case Euler.XZY:\n        return q.rotateX(this[0]).rotateZ(this[1]).rotateY(this[2]);\n      default:\n        throw new Error(ERR_UNKNOWN_ORDER);\n    }\n  }\n\n  // INTERNAL METHODS\n\n  // Concersion from Euler to rotation matrix and from matrix to Euler\n  // Adapted from three.js under MIT license\n\n  // // WARNING: this discards revolution information -bhouston\n  // reorder(newOrder) {\n  //   const q = new Quaternion().setFromEuler(this);\n  //   return this.setFromQuaternion(q, newOrder);\n\n  /* eslint-disable complexity, max-statements, one-var */\n  _fromRotationMatrix(m, order = Euler.DefaultOrder) {\n    // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\n\n    const te = m.elements;\n    const m11 = te[0],\n      m12 = te[4],\n      m13 = te[8];\n    const m21 = te[1],\n      m22 = te[5],\n      m23 = te[9];\n    const m31 = te[2],\n      m32 = te[6],\n      m33 = te[10];\n\n    order = order || this[3];\n\n    switch (order) {\n      case Euler.XYZ:\n        this[1] = Math.asin(clamp(m13, -1, 1));\n\n        if (Math.abs(m13) < ALMOST_ONE) {\n          this[0] = Math.atan2(-m23, m33);\n          this[2] = Math.atan2(-m12, m11);\n        } else {\n          this[0] = Math.atan2(m32, m22);\n          this[2] = 0;\n        }\n        break;\n\n      case Euler.YXZ:\n        this[0] = Math.asin(-clamp(m23, -1, 1));\n\n        if (Math.abs(m23) < ALMOST_ONE) {\n          this[1] = Math.atan2(m13, m33);\n          this[2] = Math.atan2(m21, m22);\n        } else {\n          this[1] = Math.atan2(-m31, m11);\n          this[2] = 0;\n        }\n        break;\n\n      case Euler.ZXY:\n        this[0] = Math.asin(clamp(m32, -1, 1));\n\n        if (Math.abs(m32) < ALMOST_ONE) {\n          this[1] = Math.atan2(-m31, m33);\n          this[2] = Math.atan2(-m12, m22);\n        } else {\n          this[1] = 0;\n          this[2] = Math.atan2(m21, m11);\n        }\n        break;\n\n      case Euler.ZYX:\n        this[1] = Math.asin(-clamp(m31, -1, 1));\n\n        if (Math.abs(m31) < ALMOST_ONE) {\n          this[0] = Math.atan2(m32, m33);\n          this[2] = Math.atan2(m21, m11);\n        } else {\n          this[0] = 0;\n          this[2] = Math.atan2(-m12, m22);\n        }\n        break;\n\n      case Euler.YZX:\n        this[2] = Math.asin(clamp(m21, -1, 1));\n\n        if (Math.abs(m21) < ALMOST_ONE) {\n          this[0] = Math.atan2(-m23, m22);\n          this[1] = Math.atan2(-m31, m11);\n        } else {\n          this[0] = 0;\n          this[1] = Math.atan2(m13, m33);\n        }\n        break;\n\n      case Euler.XZY:\n        this[2] = Math.asin(-clamp(m12, -1, 1));\n\n        if (Math.abs(m12) < ALMOST_ONE) {\n          this[0] = Math.atan2(m32, m22);\n          this[1] = Math.atan2(m13, m11);\n        } else {\n          this[0] = Math.atan2(-m23, m33);\n          this[1] = 0;\n        }\n        break;\n\n      default:\n        throw new Error(ERR_UNKNOWN_ORDER);\n    }\n\n    this[3] = order;\n\n    return this;\n  }\n\n  _getRotationMatrix(result) {\n    const te = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];\n\n    const x = this.x,\n      y = this.y,\n      z = this.z;\n    const a = Math.cos(x);\n    const c = Math.cos(y);\n    const e = Math.cos(z);\n    const b = Math.sin(x);\n    const d = Math.sin(y);\n    const f = Math.sin(z);\n\n    switch (this[3]) {\n      case Euler.XYZ: {\n        const ae = a * e,\n          af = a * f,\n          be = b * e,\n          bf = b * f;\n\n        te[0] = c * e;\n        te[4] = -c * f;\n        te[8] = d;\n\n        te[1] = af + be * d;\n        te[5] = ae - bf * d;\n        te[9] = -b * c;\n\n        te[2] = bf - ae * d;\n        te[6] = be + af * d;\n        te[10] = a * c;\n        break;\n      }\n\n      case Euler.YXZ: {\n        const ce = c * e,\n          cf = c * f,\n          de = d * e,\n          df = d * f;\n\n        te[0] = ce + df * b;\n        te[4] = de * b - cf;\n        te[8] = a * d;\n\n        te[1] = a * f;\n        te[5] = a * e;\n        te[9] = -b;\n\n        te[2] = cf * b - de;\n        te[6] = df + ce * b;\n        te[10] = a * c;\n        break;\n      }\n\n      case Euler.ZXY: {\n        const ce = c * e,\n          cf = c * f,\n          de = d * e,\n          df = d * f;\n\n        te[0] = ce - df * b;\n        te[4] = -a * f;\n        te[8] = de + cf * b;\n\n        te[1] = cf + de * b;\n        te[5] = a * e;\n        te[9] = df - ce * b;\n\n        te[2] = -a * d;\n        te[6] = b;\n        te[10] = a * c;\n        break;\n      }\n\n      case Euler.ZYX: {\n        const ae = a * e,\n          af = a * f,\n          be = b * e,\n          bf = b * f;\n\n        te[0] = c * e;\n        te[4] = be * d - af;\n        te[8] = ae * d + bf;\n\n        te[1] = c * f;\n        te[5] = bf * d + ae;\n        te[9] = af * d - be;\n\n        te[2] = -d;\n        te[6] = b * c;\n        te[10] = a * c;\n        break;\n      }\n\n      case Euler.YZX: {\n        const ac = a * c,\n          ad = a * d,\n          bc = b * c,\n          bd = b * d;\n\n        te[0] = c * e;\n        te[4] = bd - ac * f;\n        te[8] = bc * f + ad;\n\n        te[1] = f;\n        te[5] = a * e;\n        te[9] = -b * e;\n\n        te[2] = -d * e;\n        te[6] = ad * f + bc;\n        te[10] = ac - bd * f;\n        break;\n      }\n\n      case Euler.XZY: {\n        const ac = a * c,\n          ad = a * d,\n          bc = b * c,\n          bd = b * d;\n\n        te[0] = c * e;\n        te[4] = -f;\n        te[8] = d * e;\n\n        te[1] = ac * f + bd;\n        te[5] = a * e;\n        te[9] = ad * f - bc;\n\n        te[2] = bc * f - ad;\n        te[6] = b * e;\n        te[10] = bd * f + ac;\n        break;\n      }\n\n      default:\n        throw new Error(ERR_UNKNOWN_ORDER);\n    }\n\n    // last column\n    te[3] = 0;\n    te[7] = 0;\n    te[11] = 0;\n\n    // bottom row\n    te[12] = 0;\n    te[13] = 0;\n    te[14] = 0;\n    te[15] = 1;\n\n    return te;\n  }\n\n  toQuaternion() {\n    // Abbreviations for the various angular functions\n    const cy = Math.cos(this.yaw * 0.5);\n    const sy = Math.sin(this.yaw * 0.5);\n    const cr = Math.cos(this.roll * 0.5);\n    const sr = Math.sin(this.roll * 0.5);\n    const cp = Math.cos(this.pitch * 0.5);\n    const sp = Math.sin(this.pitch * 0.5);\n\n    const w = cy * cr * cp + sy * sr * sp;\n    const x = cy * sr * cp - sy * cr * sp;\n    const y = cy * cr * sp + sy * sr * cp;\n    const z = sy * cr * cp - cy * sr * sp;\n\n    return new Quaternion(x, y, z, w);\n  }\n}\n","/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\nimport lightingShader from './lights.glsl';\n\nconst INITIAL_MODULE_OPTIONS = {\n  lightSources: {}\n};\n\n// Take color 0-255 and intensity as input and output 0.0-1.0 range\nfunction convertColor({color = [0, 0, 0], intensity = 1.0} = {}) {\n  return color.map(component => (component * intensity) / 255.0);\n}\n\nfunction getLightSourceUniforms({ambientLight, pointLights = [], directionalLights = []}) {\n  const lightSourceUniforms = {};\n\n  if (ambientLight) {\n    lightSourceUniforms['lighting_uAmbientLight.color'] = convertColor(ambientLight);\n  } else {\n    lightSourceUniforms['lighting_uAmbientLight.color'] = [0, 0, 0];\n  }\n\n  pointLights.forEach((pointLight, index) => {\n    lightSourceUniforms[`lighting_uPointLight[${index}].color`] = convertColor(pointLight);\n    lightSourceUniforms[`lighting_uPointLight[${index}].position`] = pointLight.position;\n    lightSourceUniforms[`lighting_uPointLight[${index}].attenuation`] = pointLight.attenuation || [\n      1,\n      0,\n      0\n    ];\n  });\n  lightSourceUniforms.lighting_uPointLightCount = pointLights.length;\n\n  directionalLights.forEach((directionalLight, index) => {\n    lightSourceUniforms[`lighting_uDirectionalLight[${index}].color`] = convertColor(\n      directionalLight\n    );\n    lightSourceUniforms[`lighting_uDirectionalLight[${index}].direction`] =\n      directionalLight.direction;\n  });\n  lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length;\n\n  return lightSourceUniforms;\n}\n\n// eslint-disable-next-line complexity\nfunction getUniforms(opts = INITIAL_MODULE_OPTIONS) {\n  // Specify lights separately\n  if ('lightSources' in opts) {\n    const {ambientLight, pointLights, directionalLights} = opts.lightSources || {};\n    const hasLights =\n      ambientLight ||\n      (pointLights && pointLights.length > 0) ||\n      (directionalLights && directionalLights.length > 0);\n\n    if (!hasLights) {\n      return {lighting_uEnabled: false};\n    }\n\n    return Object.assign(\n      {},\n      getLightSourceUniforms({ambientLight, pointLights, directionalLights}),\n      {\n        lighting_uEnabled: true\n      }\n    );\n  }\n\n  // Support for array of lights. Type of light is detected by type field\n  if ('lights' in opts) {\n    const lightSources = {pointLights: [], directionalLights: []};\n    // @ts-ignore\n    for (const light of opts.lights || []) {\n      switch (light.type) {\n        case 'ambient':\n          // Note: Only uses last ambient light\n          // TODO - add ambient light sources on CPU?\n          lightSources.ambientLight = light;\n          break;\n        case 'directional':\n          lightSources.directionalLights.push(light);\n          break;\n        case 'point':\n          lightSources.pointLights.push(light);\n          break;\n        default:\n        // eslint-disable-next-line\n        // console.warn(light.type);\n      }\n    }\n\n    // Call the `opts.lightSources`` version\n    return getUniforms({lightSources});\n  }\n\n  return {};\n}\n\n/** @type {ShaderModule} */\nexport const lights = {\n  name: 'lights',\n  vs: lightingShader,\n  fs: lightingShader,\n  getUniforms,\n  defines: {\n    MAX_LIGHTS: 3\n  }\n};\n","/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\n// Cheap lighting - single directional light, single dot product, one uniform\n\nimport {project} from '../project/project';\n\n/* eslint-disable camelcase */\nconst DEFAULT_LIGHT_DIRECTION = new Float32Array([1, 1, 2]);\n\nconst DEFAULT_MODULE_OPTIONS = {\n  lightDirection: DEFAULT_LIGHT_DIRECTION\n};\n\nfunction getUniforms(opts = DEFAULT_MODULE_OPTIONS) {\n  const uniforms = {};\n  if (opts.lightDirection) {\n    uniforms.dirlight_uLightDirection = opts.lightDirection;\n  }\n  return uniforms;\n}\n\n// TODO - reuse normal from geometry module\nconst vs = null;\n\nconst fs = `\\\nuniform vec3 dirlight_uLightDirection;\n\n/*\n * Returns color attenuated by angle from light source\n */\nvec4 dirlight_filterColor(vec4 color) {\n  vec3 normal = project_getNormal_World();\n  float d = abs(dot(normalize(normal), normalize(dirlight_uLightDirection)));\n  return vec4(color.rgb * d, color.a);\n}\n`;\n\nexport const dirlight = {\n  name: 'dirlight',\n  vs,\n  fs,\n  getUniforms,\n  dependencies: [project]\n};\n","/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\nconst DEFAULT_HIGHLIGHT_COLOR = new Uint8Array([0, 255, 255, 255]);\n\nconst DEFAULT_MODULE_OPTIONS = {\n  pickingSelectedColor: null, //  Set to a picking color to visually highlight that item\n  pickingHighlightColor: DEFAULT_HIGHLIGHT_COLOR, // Color of visual highlight of \"selected\" item\n  pickingActive: false, // Set to true when rendering to off-screen \"picking\" buffer\n  pickingAttribute: false // Set to true when picking an attribute value instead of object index\n};\n\n/* eslint-disable camelcase */\nfunction getUniforms(opts = DEFAULT_MODULE_OPTIONS) {\n  const uniforms = {};\n  if (opts.pickingSelectedColor !== undefined) {\n    if (!opts.pickingSelectedColor) {\n      uniforms.picking_uSelectedColorValid = 0;\n    } else {\n      const selectedColor = opts.pickingSelectedColor.slice(0, 3);\n      uniforms.picking_uSelectedColorValid = 1;\n      uniforms.picking_uSelectedColor = selectedColor;\n    }\n  }\n  if (opts.pickingHighlightColor) {\n    const color = Array.from(opts.pickingHighlightColor, x => x / 255);\n    if (!Number.isFinite(color[3])) {\n      color[3] = 1;\n    }\n    uniforms.picking_uHighlightColor = color;\n  }\n  if (opts.pickingActive !== undefined) {\n    uniforms.picking_uActive = Boolean(opts.pickingActive);\n    uniforms.picking_uAttribute = Boolean(opts.pickingAttribute);\n  }\n  return uniforms;\n}\n\nconst vs = `\\\nuniform bool picking_uActive;\nuniform bool picking_uAttribute;\nuniform vec3 picking_uSelectedColor;\nuniform bool picking_uSelectedColorValid;\n\nout vec4 picking_vRGBcolor_Avalid;\n\nconst float COLOR_SCALE = 1. / 255.;\n\nbool picking_isColorValid(vec3 color) {\n  return dot(color, vec3(1.0)) > 0.001;\n}\n\nbool isVertexPicked(vec3 vertexColor) {\n  return\n    picking_uSelectedColorValid &&\n    !picking_isColorValid(abs(vertexColor - picking_uSelectedColor));\n}\n\nvoid picking_setPickingColor(vec3 pickingColor) {\n  if (picking_uActive) {\n    // Use alpha as the validity flag. If pickingColor is [0, 0, 0] fragment is non-pickable\n    picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));\n\n    if (!picking_uAttribute) {\n      // Stores the picking color so that the fragment shader can render it during picking\n      picking_vRGBcolor_Avalid.rgb = pickingColor * COLOR_SCALE;\n    }\n  } else {\n    // Do the comparison with selected item color in vertex shader as it should mean fewer compares\n    picking_vRGBcolor_Avalid.a = float(isVertexPicked(pickingColor));\n  }\n}\n\nvoid picking_setPickingAttribute(float value) {\n  if (picking_uAttribute) {\n    picking_vRGBcolor_Avalid.r = value;\n  }\n}\nvoid picking_setPickingAttribute(vec2 value) {\n  if (picking_uAttribute) {\n    picking_vRGBcolor_Avalid.rg = value;\n  }\n}\nvoid picking_setPickingAttribute(vec3 value) {\n  if (picking_uAttribute) {\n    picking_vRGBcolor_Avalid.rgb = value;\n  }\n}\n`;\n\nconst fs = `\\\nuniform bool picking_uActive;\nuniform vec3 picking_uSelectedColor;\nuniform vec4 picking_uHighlightColor;\n\nin vec4 picking_vRGBcolor_Avalid;\n\n/*\n * Returns highlight color if this item is selected.\n */\nvec4 picking_filterHighlightColor(vec4 color) {\n  if (picking_uActive) {\n    return color;\n  }\n  bool selected = bool(picking_vRGBcolor_Avalid.a);\n\n  if (selected) {\n    float highLightAlpha = picking_uHighlightColor.a;\n    float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);\n    float highLightRatio = highLightAlpha / blendedAlpha;\n\n    vec3 blendedRGB = mix(color.rgb, picking_uHighlightColor.rgb, highLightRatio);\n    return vec4(blendedRGB, blendedAlpha);\n  } else {\n    return color;\n  }\n}\n\n/*\n * Returns picking color if picking enabled else unmodified argument.\n */\nvec4 picking_filterPickingColor(vec4 color) {\n  if (picking_uActive) {\n    if (picking_vRGBcolor_Avalid.a == 0.0) {\n      discard;\n    }\n    return picking_vRGBcolor_Avalid;\n  }\n  return color;\n}\n\n/*\n * Returns picking color if picking is enabled if not\n * highlight color if this item is selected, otherwise unmodified argument.\n */\nvec4 picking_filterColor(vec4 color) {\n  vec4 highightColor = picking_filterHighlightColor(color);\n  return picking_filterPickingColor(highightColor);\n}\n\n`;\n\n/** @type {ShaderModule} */\nexport const picking = {\n  name: 'picking',\n  vs,\n  fs,\n  getUniforms\n};\n","/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\nimport {lights} from '../lights/lights';\nimport lightingShader from './phong-lighting.glsl';\n\nconst INITIAL_MODULE_OPTIONS = {};\n\nfunction getMaterialUniforms(material) {\n  const {ambient = 0.35, diffuse = 0.6, shininess = 32, specularColor = [30, 30, 30]} = material;\n\n  return {\n    lighting_uAmbient: ambient,\n    lighting_uDiffuse: diffuse,\n    lighting_uShininess: shininess,\n    lighting_uSpecularColor: specularColor.map(x => x / 255)\n  };\n}\n\nfunction getUniforms(opts = INITIAL_MODULE_OPTIONS) {\n  if (!('material' in opts)) {\n    return {};\n  }\n\n  const {material} = opts;\n\n  if (!material) {\n    return {lighting_uEnabled: false};\n  }\n\n  return getMaterialUniforms(material);\n}\n\n/** @type {ShaderModule} */\nexport const gouraudLighting = {\n  name: 'gouraud-lighting',\n  dependencies: [lights],\n  vs: lightingShader,\n  defines: {\n    LIGHTING_VERTEX: 1\n  },\n  getUniforms\n};\n\n/** @type {ShaderModule} */\nexport const phongLighting = {\n  name: 'phong-lighting',\n  dependencies: [lights],\n  fs: lightingShader,\n  defines: {\n    LIGHTING_FRAGMENT: 1\n  },\n  getUniforms\n};\n","/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\nimport {lights} from '../lights/lights';\n\nimport vs from './pbr-vertex.glsl';\nimport fs from './pbr-fragment.glsl';\n\n/**\n * @type {ShaderModule}\n * PBR lighting shader module\n */\nexport const pbr = {\n  name: 'pbr',\n  vs,\n  fs,\n  defines: {\n    LIGHTING_FRAGMENT: 1\n  },\n  dependencies: [lights]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\nimport {random} from '../utils/random';\n\nconst fs = `\\\nuniform float blurRadius;\nuniform float gradientRadius;\nuniform vec2 start;\nuniform vec2 end;\nuniform bool invert;\n\nvec2 tiltShift_getDelta(vec2 texSize) {\n  vec2 vector = normalize((end - start) * texSize);\n  return invert ? vec2(-vector.y, vector.x) : vector;\n}\n\nvec4 tiltShift_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  vec2 normal = normalize(vec2((start.y - end.y) * texSize.y, (end.x - start.x) * texSize.x));\n  float radius = smoothstep(0.0, 1.0,\n    abs(dot(texCoord * texSize - start * texSize, normal)) / gradientRadius) * blurRadius;\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec4 sample = texture2D(texture, texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius);\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    sample.rgb *= sample.a;\n\n    color += sample * weight;\n    total += weight;\n  }\n\n  color = color / total;\n\n  /* switch back from pre-multiplied alpha */\n  color.rgb /= color.a + 0.00001;\n\n  return color;\n}\n`;\n\nconst uniforms = {\n  blurRadius: {value: 15, min: 0, max: 50},\n  gradientRadius: {value: 200, min: 0, max: 400},\n  start: [0, 0],\n  end: [1, 1],\n  invert: {value: false, private: true}\n};\n\n/** @type {ShaderPass} */\nexport const tiltShift = {\n  name: 'tiltShift',\n  uniforms,\n  fs,\n  dependencies: [random],\n  passes: [{sampler: true, uniforms: {invert: false}}, {sampler: true, uniforms: {invert: true}}]\n};\n\n/*\nfunction tiltShift(startX, startY, endX, endY, blurRadius, gradientRadius) {\n  var dx = endX - startX;\n  var dy = endY - startY;\n  var d = Math.sqrt(dx * dx + dy * dy);\n  simpleShader.call(this, gl.tiltShift, {\n    blurRadius: blurRadius,\n    gradientRadius: gradientRadius,\n    start: [startX, startY],\n    end: [endX, endY],\n    delta: [dx / d, dy / d],\n    texSize: [this.width, this.height]\n  });\n  simpleShader.call(this, gl.tiltShift, {\n    blurRadius: blurRadius,\n    gradientRadius: gradientRadius,\n    start: [startX, startY],\n    end: [endX, endY],\n    delta: [-dy / d, dx / d],\n    texSize: [this.width, this.height]\n  });\n\n  return this;\n}\n*/\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\nimport {random} from '../utils/random';\n\nconst fs = `\\\nuniform float radius;\nuniform vec2 delta;\n\nvec4 triangleBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {\n  vec2 adjustedDelta = delta * radius / texSize;\n\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec4 sample = texture2D(texture, texCoord + adjustedDelta * percent);\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    sample.rgb *= sample.a;\n\n    color += sample * weight;\n    total += weight;\n  }\n\n  color = color / total;\n\n  /* switch back from pre-multiplied alpha */\n  color.rgb /= color.a + 0.00001;\n\n  return color;\n}\n`;\n\nconst uniforms = {\n  radius: {value: 20, min: 0, softMax: 100},\n  delta: {value: [1, 0], private: true}\n};\n\n/** @type {ShaderPass} */\nexport const triangleBlur = {\n  name: 'triangleBlur',\n  uniforms,\n  fs,\n  dependencies: [random],\n  passes: [{sampler: true, uniforms: {delta: [1, 0]}}, {sampler: true, uniforms: {delta: [0, 1]}}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\nimport {random} from '../utils/random';\n\nconst fs = `\nuniform vec2 center;\nuniform float strength;\n\nvec4 zoomBlur_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n  vec2 toCenter = center * texSize - texCoord * texSize;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = 0.0; t <= 40.0; t++) {\n    float percent = (t + offset) / 40.0;\n    float weight = 4.0 * (percent - percent * percent);\n    vec4 sample = texture2D(texture, texCoord + toCenter * percent * strength / texSize);\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    sample.rgb *= sample.a;\n\n    color += sample * weight;\n    total += weight;\n  }\n\n  color = color / total;\n\n  /* switch back from pre-multiplied alpha */\n  color.rgb /= color.a + 0.00001;\n\n  return color;\n}\n`;\n\nconst uniforms = {\n  center: [0.5, 0.5],\n  strength: {value: 0.3, min: 0, softMax: 1}\n};\n\n/** @type {ShaderPass} */\nexport const zoomBlur = {\n  name: 'zoomBlur',\n  uniforms,\n  fs,\n  dependencies: [random],\n  passes: [{sampler: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\nconst fs = `\\\nuniform float brightness;\nuniform float contrast;\n\nvec4 brightnessContrast_filterColor(vec4 color) {\n  color.rgb += brightness;\n  if (contrast > 0.0) {\n    color.rgb = (color.rgb - 0.5) / (1.0 - contrast) + 0.5;\n  } else {\n    color.rgb = (color.rgb - 0.5) * (1.0 + contrast) + 0.5;\n  }\n  return color;\n}\n\nvec4 brightnessContrast_filterColor(vec4 color, vec2 texSize, vec2 texCoords) {\n  return brightnessContrast_filterColor(color);\n}\n`;\n\nconst uniforms = {\n  brightness: {value: 0, min: -1, max: 1},\n  contrast: {value: 0, min: -1, max: 1}\n};\n\n/** @type {ShaderPass} */\nexport const brightnessContrast = {\n  name: 'brightnessContrast',\n  uniforms,\n  fs,\n  passes: [{filter: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\n// Do a 9x9 bilateral box filter\nconst fs = `\\\nuniform float strength;\n\nvec4 denoise_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {\n  float adjustedExponent = 3. + 200. * pow(1. - strength, 4.);\n\n  vec4 center = texture2D(texture, texCoord);\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n  for (float x = -4.0; x <= 4.0; x += 1.0) {\n    for (float y = -4.0; y <= 4.0; y += 1.0) {\n      vec4 sample = texture2D(texture, texCoord + vec2(x, y) / texSize);\n      float weight = 1.0 - abs(dot(sample.rgb - center.rgb, vec3(0.25)));\n      weight = pow(weight, adjustedExponent);\n      color += sample * weight;\n      total += weight;\n    }\n  }\n\n  return color / total;\n}\n`;\n\nconst uniforms = {\n  strength: {\n    value: 0.5,\n    min: 0,\n    max: 0.1,\n    adjust: strength => 0.53 + 200 * Math.pow(1 - strength, 4) // TODO - JS preprocessing\n  }\n};\n\n/** @type {ShaderPass} */\nexport const denoise = {\n  name: 'denoise',\n  uniforms,\n  fs,\n  passes: [{sampler: true}, {sampler: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\nconst fs = `\\\nuniform float hue;\nuniform float saturation;\n\nvec4 hueSaturation_filterColor(vec4 color) {\n  // hue adjustment, wolfram alpha: RotationTransform[angle, {1, 1, 1}][{x, y, z}]\n  float angle = hue * 3.14159265;\n  float s = sin(angle), c = cos(angle);\n  vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;\n  float len = length(color.rgb);\n  color.rgb = vec3(\n    dot(color.rgb, weights.xyz),\n    dot(color.rgb, weights.zxy),\n    dot(color.rgb, weights.yzx)\n  );\n\n  // saturation adjustment\n  float average = (color.r + color.g + color.b) / 3.0;\n  if (saturation > 0.0) {\n    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - saturation));\n  } else {\n    color.rgb += (average - color.rgb) * (-saturation);\n  }\n\n  return color;\n}\n\nvec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return hueSaturation_filterColor(color);\n}\n`;\n\nconst uniforms = {\n  hue: {value: 0, min: -1, max: 1},\n  saturation: {value: 0, min: -1, max: 1}\n};\n\n/** @type {ShaderPass} */\nexport const hueSaturation = {\n  name: 'hueSaturation',\n  uniforms,\n  fs,\n  passes: [{filter: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\nconst fs = `\\\nuniform float amount;\n\nfloat rand(vec2 co) {\n  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nvec4 noise_filterColor(vec4 color, vec2 texCoord) {\n  float diff = (rand(texCoord) - 0.5) * amount;\n  color.r += diff;\n  color.g += diff;\n  color.b += diff;\n  return color;\n}\n\nvec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return noise_filterColor(color, texCoord);\n}\n`;\n\nconst uniforms = {\n  amount: {value: 0.5, min: 0, max: 1}\n};\n\n/** @type {ShaderPass} */\nexport const noise = {\n  name: 'noise',\n  uniforms,\n  fs,\n  passes: [{filter: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\nconst fs = `\\\nuniform float amount;\n\nvec4 sepia_filterColor(vec4 color) {\n  float r = color.r;\n  float g = color.g;\n  float b = color.b;\n\n  color.r =\n    min(1.0, (r * (1.0 - (0.607 * amount))) + (g * (0.769 * amount)) + (b * (0.189 * amount)));\n  color.g = min(1.0, (r * 0.349 * amount) + (g * (1.0 - (0.314 * amount))) + (b * 0.168 * amount));\n  color.b = min(1.0, (r * 0.272 * amount) + (g * 0.534 * amount) + (b * (1.0 - (0.869 * amount))));\n\n  return color;\n}\n\nvec4 sepia_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return sepia_filterColor(color);\n}\n`;\n\nconst uniforms = {\n  amount: {value: 0.5, min: 0, max: 1}\n};\n\n/** @type {ShaderPass} */\nexport const sepia = {\n  name: 'sepia',\n  uniforms,\n  fs,\n  passes: [{filter: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\nconst fs = `\\\nuniform float amount;\n\nvec4 vibrance_filterColor(vec4 color) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  float mx = max(color.r, max(color.g, color.b));\n  float amt = (mx - average) * (-amount * 3.0);\n  color.rgb = mix(color.rgb, vec3(mx), amt);\n  return color;\n}\n\nvec4 vibrance_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vibrance_filterColor(color);\n}\n`;\n\nconst uniforms = {\n  amount: {value: 0, min: -1, max: 1}\n};\n\n/** @type {ShaderPass} */\nexport const vibrance = {\n  name: 'vibrance',\n  uniforms,\n  fs,\n  passes: [{filter: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\nconst fs = `\\\nuniform float radius;\nuniform float amount;\n\nvec4 vignette_filterColor(vec4 color, vec2 texCoord) {\n  float dist = distance(texCoord, vec2(0.5, 0.5));\n  float ratio = smoothstep(0.8, radius * 0.799, dist * (amount + radius));\n  return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);\n}\n\nvec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vignette_filterColor(color, texCoord);\n}\n`;\n\nconst uniforms = {\n  radius: {value: 0.5, min: 0, max: 1},\n  amount: {value: 0.5, min: 0, max: 1}\n};\n\n/** @type {ShaderPass} */\nexport const vignette = {\n  name: 'vignette',\n  fs,\n  uniforms,\n  passes: [{filter: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\n// TODO pass texCoord to angle\nconst fs = `\\\nuniform vec2 center;\nuniform float angle;\nuniform float size;\n\nfloat scale = 3.1514 / size;\n\nfloat pattern(float angle, vec2 texSize, vec2 texCoord) {\n  float s = sin(angle), c = cos(angle);\n  vec2 tex = texCoord * texSize - center * texSize;\n  vec2 point = vec2(\n\tc * tex.x - s * tex.y,\n\ts * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  vec3 cmy = 1.0 - color.rgb;\n  float k = min(cmy.x, min(cmy.y, cmy.z));\n  cmy = (cmy - k) / (1.0 - k);\n  cmy = clamp(\n\tcmy * 10.0 - 3.0 + vec3(\n    pattern(angle + 0.26179, texSize, texCoord),\n\t  pattern(angle + 1.30899, texSize, texCoord),\n    pattern(angle, texSize, texCoord)\n  ),\n\t0.0,\n\t1.0\n  );\n  k = clamp(k * 10.0 - 5.0 + pattern(angle + 0.78539, texSize, texCoord), 0.0, 1.0);\n  return vec4(1.0 - cmy - k, color.a);\n}\n`;\n\nconst uniforms = {\n  center: [0.5, 0.5],\n  angle: {value: 1.1, softMin: 0, softMax: Math.PI / 2},\n  size: {value: 4, min: 1, softMin: 3, softMax: 20}\n};\n\n/** @type {ShaderPass} */\nexport const colorHalftone = {\n  name: 'colorHalftone',\n  uniforms,\n  fs,\n  passes: [{filter: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\nconst fs = `\\\nuniform vec2 center;\nuniform float angle;\nuniform float size;\n\nfloat pattern(vec2 texSize, vec2 texCoord) {\n  float scale = 3.1415 / size;\n\n  float s = sin(angle), c = cos(angle);\n  vec2 tex = texCoord * texSize - center * texSize;\n  vec2 point = vec2(\n    c * tex.x - s * tex.y,\n    s * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);\n}\n`;\n\nconst uniforms = {\n  center: [0.5, 0.5],\n  angle: {value: 1.1, softMin: 0, softMax: Math.PI / 2},\n  size: {value: 3, min: 1, softMin: 3, softMax: 20}\n};\n\n/** @type {ShaderPass} */\nexport const dotScreen = {\n  name: 'dotScreen',\n  uniforms,\n  fs,\n  passes: [{filter: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\nimport {random} from '../utils/random';\n\nconst fs = `\\\nuniform float radius;\nuniform vec2 delta;\n\nvec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 relativeDelta = radius * delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec3 sampleColor = texture2D(source, texCoord + relativeDelta * percent).rgb;\n    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;\n    color.x += average * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += average * weight;\n      total.y += weight;\n    }\n  }\n  return vec4(color / total, 0.0, 1.0);\n}\n\nvec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 relativeDelta = radius * delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec2 sampleColor = texture2D(source, texCoord + relativeDelta * percent).xy;\n    color.x += sampleColor.x * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += sampleColor.y * weight;\n      total.y += weight;\n    }\n  }\n  float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);\n  return vec4(c, c, c, 1.0);\n}\n`;\n\nconst uniforms = {\n  radius: {value: 2, min: 1, softMax: 50},\n  delta: {value: [1, 0], private: true}\n};\n\n/** @type {ShaderPass} */\nexport const edgeWork = {\n  name: 'edgeWork',\n  uniforms,\n  fs,\n  dependencies: [random],\n  passes: [\n    {\n      sampler: 'edgeWork_sampleColor1',\n      uniforms: {delta: [1, 0]}\n    },\n    {\n      sampler: 'edgeWork_sampleColor2',\n      uniforms: {delta: [0, 1]}\n    }\n  ]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\nconst fs = `\\\nuniform vec2 center;\nuniform float scale;\n\nvec4 hexagonalPixelate_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {\n  vec2 tex = (texCoord * texSize - center * texSize) / scale;\n  tex.y /= 0.866025404;\n  tex.x -= tex.y * 0.5;\n\n  vec2 a;\n  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {\n    a = vec2(floor(tex.x), floor(tex.y));\n  }\n  else a = vec2(ceil(tex.x), ceil(tex.y));\n  vec2 b = vec2(ceil(tex.x), floor(tex.y));\n  vec2 c = vec2(floor(tex.x), ceil(tex.y));\n\n  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);\n  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);\n  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);\n  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);\n\n  float alen = length(TEX - A);\n  float blen = length(TEX - B);\n  float clen = length(TEX - C);\n\n  vec2 choice;\n  if (alen < blen) {\n    if (alen < clen) choice = a;\n    else choice = c;\n  } else {\n    if (blen < clen) choice = b;\n    else choice = c;\n  }\n\n  choice.x += choice.y * 0.5;\n  choice.y *= 0.866025404;\n  choice *= scale / texSize;\n\n  return texture2D(texture, choice + center);\n}\n`;\n\nconst uniforms = {\n  center: {value: [0.5, 0.5], hint: 'screenspace'},\n  scale: {value: 10, min: 1, softMin: 5, softMax: 50}\n};\n\n/** @type {ShaderPass} */\nexport const hexagonalPixelate = {\n  name: 'hexagonalPixelate',\n  uniforms,\n  fs,\n  passes: [{sampler: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\nconst fs = `\\\nuniform float strength;\n\nvec4 ink_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {\n  vec2 dx = vec2(1.0 / texSize.x, 0.0);\n  vec2 dy = vec2(0.0, 1.0 / texSize.y);\n  vec4 color = texture2D(texture, texCoord);\n  float bigTotal = 0.0;\n  float smallTotal = 0.0;\n  vec3 bigAverage = vec3(0.0);\n  vec3 smallAverage = vec3(0.0);\n  for (float x = -2.0; x <= 2.0; x += 1.0) {\n    for (float y = -2.0; y <= 2.0; y += 1.0) {\n      vec3 sample = texture2D(texture, texCoord + dx * x + dy * y).rgb;\n      bigAverage += sample;\n      bigTotal += 1.0;\n      if (abs(x) + abs(y) < 2.0) {\n        smallAverage += sample;\n        smallTotal += 1.0;\n      }\n    }\n  }\n  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);\n  float power = strength * strength * strength * strength * strength;\n  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);\n}\n`;\n\nconst uniforms = {\n  strength: {value: 0.25, min: 0, softMax: 1}\n};\n\n/** @type {ShaderPass} */\nexport const ink = {\n  name: 'ink',\n  uniforms,\n  fs,\n  passes: [{sampler: true}]\n};\n","const fs = `\\\nuniform vec2 screenXY;\nuniform float radiusPixels;\nuniform float zoom;\nuniform float borderWidthPixels;\nuniform vec4 borderColor;\n\nvec4 magnify_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {\n  vec2 pos = vec2(screenXY.x, 1.0 - screenXY.y);\n  float dist = distance(texCoord * texSize, pos * texSize);\n  if (dist < radiusPixels) {\n    return texture2D(texture, (texCoord - pos) / zoom + pos);\n  }\n\n  if (dist <= radiusPixels + borderWidthPixels) {\n    return borderColor;\n  }\n  return texture2D(texture, texCoord);\n}\n`;\n\nconst uniforms = {\n  // range 0 to 1\n  screenXY: [0, 0],\n  radiusPixels: 200,\n  zoom: 2.0,\n  borderWidthPixels: 0.0,\n  borderColor: [255, 255, 255, 255]\n};\n\nexport const magnify = {\n  name: 'magnify',\n  uniforms,\n  fs,\n  passes: [{sampler: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\nimport {warp} from './warp';\n\nconst fs = `\\\nuniform float radius;\nuniform float strength;\nuniform vec2 center;\n\nvec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < radius) {\n    float percent = distance / radius;\n    if (strength > 0.0) {\n      coord *= mix(1.0, smoothstep(0.0, radius / distance, percent), strength * 0.75);\n    } else {\n      coord *= mix(1.0, pow(percent, 1.0 + strength * 0.75) * radius / distance, 1.0 - percent);\n    }\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 bulgePinch_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = bulgePinch_warp(coord, center * texSize);\n\n  return warp_sampleColor(texture, texSize, coord);\n}\n`;\n\nconst uniforms = {\n  center: [0.5, 0.5],\n  radius: {value: 200, min: 1, softMax: 600},\n  strength: {value: 0.5, min: -1, max: 1}\n};\n\n/** @type {ShaderPass} */\nexport const bulgePinch = {\n  name: 'bulgePinch',\n  fs,\n  uniforms,\n  dependencies: [warp],\n  passes: [{sampler: true}]\n};\n","/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\nconst fs = `\\\nvec4 warp_sampleColor(sampler2D texture, vec2 texSize, vec2 coord) {\n  vec4 color = texture2D(texture, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n\n  return color;\n}\n`;\n\n/** @type {ShaderModule} */\nexport const warp = {\n  name: 'warp',\n  fs\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\nimport {warp} from './warp';\n\nconst fs = `\\\nuniform float radius;\nuniform float angle;\nuniform vec2 center;\n\nvec2 swirl_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < radius) {\n    float percent = (radius - distance) / radius;\n    float theta = percent * percent * angle;\n    float s = sin(theta);\n    float c = cos(theta);\n    coord = vec2(\n      coord.x * c - coord.y * s,\n      coord.x * s + coord.y * c\n    );\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 swirl_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = swirl_warp(coord, center * texSize);\n\n  return warp_sampleColor(texture, texSize, coord);\n}\n`;\n\nconst uniforms = {\n  center: [0.5, 0.5],\n  radius: {value: 200, min: 1, softMax: 600},\n  angle: {value: 3, softMin: -25, softMax: 25}\n};\n\n/** @type {ShaderPass} */\nexport const swirl = {\n  name: 'swirl',\n  fs,\n  uniforms,\n  dependencies: [warp],\n  passes: [{sampler: true}]\n};\n","/** @typedef {import('../../types').ShaderPass} ShaderPass */\n\n/**\n * ORIGINAL LICENCE\n * @license\n * Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n *  * Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n *  * Redistributions in binary form must reproduce the above copyright\n *    notice, this list of conditions and the following disclaimer in the\n *    documentation and/or other materials provided with the distribution.\n *  * Neither the name of NVIDIA CORPORATION nor the names of its\n *    contributors may be used to endorse or promote products derived\n *    from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY\n * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR\n * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY\n * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n// LUMA.GL\n// WebGL version from cesium.js, used under Apached 2.0 License\n// https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n// with the following modifications:\n// - fxaa_sampleColor to integrate with luma.gl\n// - Return color value with alpha to avoid another tap\n// - Calculate luminance in FxaaLuma\n\n// COMMENTS FROM CESIUM VERSION\n// NVIDIA GameWorks Graphics Samples GitHub link: https://github.com/NVIDIAGameWorks/GraphicsSamples\n// Original FXAA 3.11 shader link: https://github.com/NVIDIAGameWorks/GraphicsSamples/blob/master/samples/es3-kepler/FXAA/FXAA3_11.h\n//\n// Steps used to integrate into Cesium:\n// * The following defines are set:\n//       #define FXAA_PC 1\n//       #define FXAA_WEBGL_1 1\n//       #define FXAA_GREEN_AS_LUMA 1\n//       #define FXAA_EARLY_EXIT 1\n//       #define FXAA_GLSL_120 1\n// * All other preprocessor directives besides the FXAA_QUALITY__P* directives were removed.\n// * Double underscores are invalid for preprocessor directives so replace them with a single underscore. Replace\n//   /FXAA_QUALITY__P(.*)/g with /FXAA_QUALITY__P$1/.\n// * There are no implicit conversions from ivec* to vec* so replace:\n//       #define FxaaInt2 ivec2\n//           with\n//       #define FxaaInt2 vec2\n// * The texture2DLod function is only available in vertex shaders so replace:\n//       #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)\n//       #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)\n//           with\n//       #define FxaaTexTop(t, p) texture2D(t, p)\n//       #define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r))\n// * FXAA_QUALITY_PRESET is prepended in the javascript code. We may want to expose that setting in the future.\n// * The following parameters to FxaaPixelShader_ are unused and can be removed:\n//       fxaaConsolePosPos\n//       fxaaConsoleRcpFrameOpt\n//       fxaaConsoleRcpFrameOpt2\n//       fxaaConsole360RcpFrameOpt2\n//       fxaaConsoleEdgeSharpness\n//       fxaaConsoleEdgeThreshold\n//       fxaaConsoleEdgeThresholdMi\n//       fxaaConsole360ConstDir\n//\n// Choose the quality preset.\n// This needs to be compiled into the shader as it effects code.\n// Best option to include multiple presets is to\n// in each shader define the preset, then include this file.\n//\n// OPTIONS\n// -----------------------------------------------------------------------\n// 10 to 15 - default medium dither (10=fastest, 15=highest quality)\n// 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)\n// 39       - no dither, very expensive\n//\n// NOTES\n// -----------------------------------------------------------------------\n// 12 = slightly faster then FXAA 3.9 and higher edge quality (default)\n// 13 = about same speed as FXAA 3.9 and better than 12\n// 23 = closest to FXAA 3.9 visually and performance wise\n//  _ = the lowest digit is directly related to performance\n// _  = the highest digit is directly related to style\n//\n\nconst fs = `\n#define FXAA_QUALITY_PRESET 29\n\n#if (FXAA_QUALITY_PRESET == 10)\n    #define FXAA_QUALITY_PS 3\n    #define FXAA_QUALITY_P0 1.5\n    #define FXAA_QUALITY_P1 3.0\n    #define FXAA_QUALITY_P2 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 11)\n    #define FXAA_QUALITY_PS 4\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 3.0\n    #define FXAA_QUALITY_P3 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 12)\n    #define FXAA_QUALITY_PS 5\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 4.0\n    #define FXAA_QUALITY_P4 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 13)\n    #define FXAA_QUALITY_PS 6\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 4.0\n    #define FXAA_QUALITY_P5 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 14)\n    #define FXAA_QUALITY_PS 7\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 4.0\n    #define FXAA_QUALITY_P6 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 15)\n    #define FXAA_QUALITY_PS 8\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 4.0\n    #define FXAA_QUALITY_P7 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 20)\n    #define FXAA_QUALITY_PS 3\n    #define FXAA_QUALITY_P0 1.5\n    #define FXAA_QUALITY_P1 2.0\n    #define FXAA_QUALITY_P2 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 21)\n    #define FXAA_QUALITY_PS 4\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 22)\n    #define FXAA_QUALITY_PS 5\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 23)\n    #define FXAA_QUALITY_PS 6\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 24)\n    #define FXAA_QUALITY_PS 7\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 3.0\n    #define FXAA_QUALITY_P6 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 25)\n    #define FXAA_QUALITY_PS 8\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 4.0\n    #define FXAA_QUALITY_P7 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 26)\n    #define FXAA_QUALITY_PS 9\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 4.0\n    #define FXAA_QUALITY_P8 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 27)\n    #define FXAA_QUALITY_PS 10\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 4.0\n    #define FXAA_QUALITY_P9 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 28)\n    #define FXAA_QUALITY_PS 11\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 2.0\n    #define FXAA_QUALITY_P9 4.0\n    #define FXAA_QUALITY_P10 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 29)\n    #define FXAA_QUALITY_PS 12\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 2.0\n    #define FXAA_QUALITY_P9 2.0\n    #define FXAA_QUALITY_P10 4.0\n    #define FXAA_QUALITY_P11 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 39)\n    #define FXAA_QUALITY_PS 12\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.0\n    #define FXAA_QUALITY_P2 1.0\n    #define FXAA_QUALITY_P3 1.0\n    #define FXAA_QUALITY_P4 1.0\n    #define FXAA_QUALITY_P5 1.5\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 2.0\n    #define FXAA_QUALITY_P9 2.0\n    #define FXAA_QUALITY_P10 4.0\n    #define FXAA_QUALITY_P11 8.0\n#endif\n\n#define FxaaBool bool\n#define FxaaFloat float\n#define FxaaFloat2 vec2\n#define FxaaFloat3 vec3\n#define FxaaFloat4 vec4\n#define FxaaHalf float\n#define FxaaHalf2 vec2\n#define FxaaHalf3 vec3\n#define FxaaHalf4 vec4\n#define FxaaInt2 vec2\n#define FxaaTex sampler2D\n\n#define FxaaSat(x) clamp(x, 0.0, 1.0)\n#define FxaaTexTop(t, p) texture2D(t, p)\n#define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r))\n\nFxaaFloat FxaaLuma_(FxaaFloat4 rgba) { return dot(rgba.rgb, vec3(0.2126, 0.7152, 0.0722)); }\n\nFxaaFloat4 FxaaPixelShader_(\n    //\n    // Use noperspective interpolation here (turn off perspective interpolation).\n    // {xy} = center of pixel\n    FxaaFloat2 pos,\n    //\n    // Input color texture.\n    // {rgb_} = color in linear or perceptual color space\n    // if (FXAA_GREEN_AS_LUMA == 0)\n    //     {___a} = luma in perceptual color space (not linear)\n    FxaaTex tex,\n    //\n    // Only used on FXAA Quality.\n    // This must be from a constant/uniform.\n    // {x_} = 1.0/screenWidthInPixels\n    // {_y} = 1.0/screenHeightInPixels\n    FxaaFloat2 fxaaQualityRcpFrame,\n    //\n    // Only used on FXAA Quality.\n    // This used to be the FXAA_QUALITY_SUBPIX define.\n    // It is here now to allow easier tuning.\n    // Choose the amount of sub-pixel aliasing removal.\n    // This can effect sharpness.\n    //   1.00 - upper limit (softer)\n    //   0.75 - default amount of filtering\n    //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)\n    //   0.25 - almost off\n    //   0.00 - completely off\n    FxaaFloat fxaaQualitySubpix,\n    //\n    // Only used on FXAA Quality.\n    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.\n    // It is here now to allow easier tuning.\n    // The minimum amount of local contrast required to apply algorithm.\n    //   0.333 - too little (faster)\n    //   0.250 - low quality\n    //   0.166 - default\n    //   0.125 - high quality\n    //   0.063 - overkill (slower)\n    FxaaFloat fxaaQualityEdgeThreshold,\n    //\n    // Only used on FXAA Quality.\n    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.\n    // It is here now to allow easier tuning.\n    // Trims the algorithm from processing darks.\n    //   0.0833 - upper limit (default, the start of visible unfiltered edges)\n    //   0.0625 - high quality (faster)\n    //   0.0312 - visible limit (slower)\n    // Special notes when using FXAA_GREEN_AS_LUMA,\n    //   Likely want to set this to zero.\n    //   As colors that are mostly not-green\n    //   will appear very dark in the green channel!\n    //   Tune by looking at mostly non-green content,\n    //   then start at zero and increase until aliasing is a problem.\n    FxaaFloat fxaaQualityEdgeThresholdMin\n) {\n/*--------------------------------------------------------------------------*/\n    FxaaFloat2 posM;\n    posM.x = pos.x;\n    posM.y = pos.y;\n    FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);\n    #define lumaM rgbyM.y\n    FxaaFloat lumaS = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaN = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));\n/*--------------------------------------------------------------------------*/\n    FxaaFloat maxSM = max(lumaS, lumaM);\n    FxaaFloat minSM = min(lumaS, lumaM);\n    FxaaFloat maxESM = max(lumaE, maxSM);\n    FxaaFloat minESM = min(lumaE, minSM);\n    FxaaFloat maxWN = max(lumaN, lumaW);\n    FxaaFloat minWN = min(lumaN, lumaW);\n    FxaaFloat rangeMax = max(maxWN, maxESM);\n    FxaaFloat rangeMin = min(minWN, minESM);\n    FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;\n    FxaaFloat range = rangeMax - rangeMin;\n    FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);\n    FxaaBool earlyExit = range < rangeMaxClamped;\n/*--------------------------------------------------------------------------*/\n    if(earlyExit)\n        return rgbyM;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaSE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaNE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaSW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNS = lumaN + lumaS;\n    FxaaFloat lumaWE = lumaW + lumaE;\n    FxaaFloat subpixRcpRange = 1.0/range;\n    FxaaFloat subpixNSWE = lumaNS + lumaWE;\n    FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;\n    FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNESE = lumaNE + lumaSE;\n    FxaaFloat lumaNWNE = lumaNW + lumaNE;\n    FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;\n    FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNWSW = lumaNW + lumaSW;\n    FxaaFloat lumaSWSE = lumaSW + lumaSE;\n    FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);\n    FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);\n    FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;\n    FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;\n    FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;\n    FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;\n    FxaaFloat lengthSign = fxaaQualityRcpFrame.x;\n    FxaaBool horzSpan = edgeHorz >= edgeVert;\n    FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;\n/*--------------------------------------------------------------------------*/\n    if(!horzSpan) lumaN = lumaW;\n    if(!horzSpan) lumaS = lumaE;\n    if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;\n    FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat gradientN = lumaN - lumaM;\n    FxaaFloat gradientS = lumaS - lumaM;\n    FxaaFloat lumaNN = lumaN + lumaM;\n    FxaaFloat lumaSS = lumaS + lumaM;\n    FxaaBool pairN = abs(gradientN) >= abs(gradientS);\n    FxaaFloat gradient = max(abs(gradientN), abs(gradientS));\n    if(pairN) lengthSign = -lengthSign;\n    FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);\n/*--------------------------------------------------------------------------*/\n    FxaaFloat2 posB;\n    posB.x = posM.x;\n    posB.y = posM.y;\n    FxaaFloat2 offNP;\n    offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;\n    offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;\n    if(!horzSpan) posB.x += lengthSign * 0.5;\n    if( horzSpan) posB.y += lengthSign * 0.5;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat2 posN;\n    posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;\n    posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;\n    FxaaFloat2 posP;\n    posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;\n    posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;\n    FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;\n    FxaaFloat lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN));\n    FxaaFloat subpixE = subpixC * subpixC;\n    FxaaFloat lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP));\n/*--------------------------------------------------------------------------*/\n    if(!pairN) lumaNN = lumaSS;\n    FxaaFloat gradientScaled = gradient * 1.0/4.0;\n    FxaaFloat lumaMM = lumaM - lumaNN * 0.5;\n    FxaaFloat subpixF = subpixD * subpixE;\n    FxaaBool lumaMLTZero = lumaMM < 0.0;\n/*--------------------------------------------------------------------------*/\n    lumaEndN -= lumaNN * 0.5;\n    lumaEndP -= lumaNN * 0.5;\n    FxaaBool doneN = abs(lumaEndN) >= gradientScaled;\n    FxaaBool doneP = abs(lumaEndP) >= gradientScaled;\n    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;\n    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;\n    FxaaBool doneNP = (!doneN) || (!doneP);\n    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;\n    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;\n/*--------------------------------------------------------------------------*/\n    if(doneNP) {\n        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n        doneN = abs(lumaEndN) >= gradientScaled;\n        doneP = abs(lumaEndP) >= gradientScaled;\n        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;\n        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;\n        doneNP = (!doneN) || (!doneP);\n        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;\n        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;\n/*--------------------------------------------------------------------------*/\n        #if (FXAA_QUALITY_PS > 3)\n        if(doneNP) {\n            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n            doneN = abs(lumaEndN) >= gradientScaled;\n            doneP = abs(lumaEndP) >= gradientScaled;\n            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;\n            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;\n            doneNP = (!doneN) || (!doneP);\n            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;\n            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;\n/*--------------------------------------------------------------------------*/\n            #if (FXAA_QUALITY_PS > 4)\n            if(doneNP) {\n                if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                doneN = abs(lumaEndN) >= gradientScaled;\n                doneP = abs(lumaEndP) >= gradientScaled;\n                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;\n                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;\n                doneNP = (!doneN) || (!doneP);\n                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;\n                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;\n/*--------------------------------------------------------------------------*/\n                #if (FXAA_QUALITY_PS > 5)\n                if(doneNP) {\n                    if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                    if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                    doneN = abs(lumaEndN) >= gradientScaled;\n                    doneP = abs(lumaEndP) >= gradientScaled;\n                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;\n                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;\n                    doneNP = (!doneN) || (!doneP);\n                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;\n                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;\n/*--------------------------------------------------------------------------*/\n                    #if (FXAA_QUALITY_PS > 6)\n                    if(doneNP) {\n                        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                        doneN = abs(lumaEndN) >= gradientScaled;\n                        doneP = abs(lumaEndP) >= gradientScaled;\n                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;\n                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;\n                        doneNP = (!doneN) || (!doneP);\n                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;\n                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;\n/*--------------------------------------------------------------------------*/\n                        #if (FXAA_QUALITY_PS > 7)\n                        if(doneNP) {\n                            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                            doneN = abs(lumaEndN) >= gradientScaled;\n                            doneP = abs(lumaEndP) >= gradientScaled;\n                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;\n                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;\n                            doneNP = (!doneN) || (!doneP);\n                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;\n                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;\n/*--------------------------------------------------------------------------*/\n    #if (FXAA_QUALITY_PS > 8)\n    if(doneNP) {\n        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n        doneN = abs(lumaEndN) >= gradientScaled;\n        doneP = abs(lumaEndP) >= gradientScaled;\n        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;\n        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;\n        doneNP = (!doneN) || (!doneP);\n        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;\n        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;\n/*--------------------------------------------------------------------------*/\n        #if (FXAA_QUALITY_PS > 9)\n        if(doneNP) {\n            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n            doneN = abs(lumaEndN) >= gradientScaled;\n            doneP = abs(lumaEndP) >= gradientScaled;\n            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;\n            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;\n            doneNP = (!doneN) || (!doneP);\n            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;\n            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;\n/*--------------------------------------------------------------------------*/\n            #if (FXAA_QUALITY_PS > 10)\n            if(doneNP) {\n                if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                doneN = abs(lumaEndN) >= gradientScaled;\n                doneP = abs(lumaEndP) >= gradientScaled;\n                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;\n                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;\n                doneNP = (!doneN) || (!doneP);\n                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;\n                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;\n/*--------------------------------------------------------------------------*/\n                #if (FXAA_QUALITY_PS > 11)\n                if(doneNP) {\n                    if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                    if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                    doneN = abs(lumaEndN) >= gradientScaled;\n                    doneP = abs(lumaEndP) >= gradientScaled;\n                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;\n                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;\n                    doneNP = (!doneN) || (!doneP);\n                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;\n                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;\n/*--------------------------------------------------------------------------*/\n                    #if (FXAA_QUALITY_PS > 12)\n                    if(doneNP) {\n                        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                        doneN = abs(lumaEndN) >= gradientScaled;\n                        doneP = abs(lumaEndP) >= gradientScaled;\n                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;\n                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;\n                        doneNP = (!doneN) || (!doneP);\n                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;\n                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;\n/*--------------------------------------------------------------------------*/\n                    }\n                    #endif\n/*--------------------------------------------------------------------------*/\n                }\n                #endif\n/*--------------------------------------------------------------------------*/\n            }\n            #endif\n/*--------------------------------------------------------------------------*/\n        }\n        #endif\n/*--------------------------------------------------------------------------*/\n    }\n    #endif\n/*--------------------------------------------------------------------------*/\n                        }\n                        #endif\n/*--------------------------------------------------------------------------*/\n                    }\n                    #endif\n/*--------------------------------------------------------------------------*/\n                }\n                #endif\n/*--------------------------------------------------------------------------*/\n            }\n            #endif\n/*--------------------------------------------------------------------------*/\n        }\n        #endif\n/*--------------------------------------------------------------------------*/\n    }\n/*--------------------------------------------------------------------------*/\n    FxaaFloat dstN = posM.x - posN.x;\n    FxaaFloat dstP = posP.x - posM.x;\n    if(!horzSpan) dstN = posM.y - posN.y;\n    if(!horzSpan) dstP = posP.y - posM.y;\n/*--------------------------------------------------------------------------*/\n    FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;\n    FxaaFloat spanLength = (dstP + dstN);\n    FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;\n    FxaaFloat spanLengthRcp = 1.0/spanLength;\n/*--------------------------------------------------------------------------*/\n    FxaaBool directionN = dstN < dstP;\n    FxaaFloat dst = min(dstN, dstP);\n    FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;\n    FxaaFloat subpixG = subpixF * subpixF;\n    FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;\n    FxaaFloat subpixH = subpixG * fxaaQualitySubpix;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;\n    FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);\n    if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;\n    if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;\n    return FxaaTexTop(tex, posM);\n}\n\nvec4 fxaa_sampleColor(sampler2D texture, vec2 texSize, vec2 texCoord) {\n    const float fxaa_QualitySubpix = 0.5;\n    const float fxaa_QualityEdgeThreshold = 0.125;\n    const float fxaa_QualityEdgeThresholdMin = 0.0833;\n\n    return FxaaPixelShader_(\n        texCoord,\n        texture,\n        vec2(1.0) / texSize,\n        fxaa_QualitySubpix,\n        fxaa_QualityEdgeThreshold,\n        fxaa_QualityEdgeThresholdMin\n    );\n}\n`;\n\n/** @type {ShaderPass} */\nexport const fxaa = {\n  name: 'fxaa',\n  uniforms: {},\n  fs,\n  passes: [{sampler: true}]\n};\n","/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\nconst vs = `\\\nattribute float transform_elementID;\n\n// returns half of pixel size, used to move the pixel position to center of the pixel.\nvec2 transform_getPixelSizeHalf(vec2 size) {\n  return vec2(1.) / (2. * size);\n}\n\n// returns current elements pixel indeces [x, y],\n// where x ranges in [0 to texSize-1] and y ranges in [0 to texSize-1]\nvec2 transform_getPixelIndices(vec2 texSize, vec2 pixelSizeHalf) {\n  // Add safe offset (half of pixel height) before doing floor\n  float yIndex = floor((transform_elementID / texSize[0]) + pixelSizeHalf[1]);\n  float xIndex = transform_elementID - (yIndex * texSize[0]);\n  return vec2(xIndex, yIndex);\n}\n\n// returns current elementID's texture co-ordianate\nvec2 transform_getTexCoord(vec2 size) {\n  vec2 pixelSizeHalf = transform_getPixelSizeHalf(size);\n  vec2 indices = transform_getPixelIndices(size, pixelSizeHalf);\n  vec2 coord = indices / size + pixelSizeHalf;\n  return coord;\n}\n\n// returns current elementID's position\nvec2 transform_getPos(vec2 size) {\n  vec2 texCoord = transform_getTexCoord(size);\n  // Change from [0 1] range to [-1 1]\n  vec2 pos = (texCoord * (2.0, 2.0)) - (1., 1.);\n  return pos;\n}\n\n// returns current elementID's pixel value\nvec4 transform_getInput(sampler2D texSampler, vec2 size) {\n  vec2 texCoord = transform_getTexCoord(size);\n  vec4 textureColor = texture2D(texSampler, texCoord);\n  return textureColor;\n}\n`;\n\n/** @type {ShaderModule} */\nexport const transform = {\n  name: 'transform',\n  vs,\n  fs: null\n};\n","import GL from '@luma.gl/constants';\nimport {Buffer, assert} from '@luma.gl/webgl';\n\n// Support for mapping new geometries with glTF attribute names to \"classic\" luma.gl shader names\nconst GLTF_TO_LUMA_ATTRIBUTE_MAP = {\n  POSITION: 'positions',\n  NORMAL: 'normals',\n  COLOR_0: 'colors',\n  TEXCOORD_0: 'texCoords',\n  TEXCOORD_1: 'texCoords1',\n  TEXCOORD_2: 'texCoords2'\n};\n\nexport function getBuffersFromGeometry(gl, geometry, options) {\n  const buffers = {};\n  let indices = geometry.indices;\n\n  for (const name in geometry.attributes) {\n    const attribute = geometry.attributes[name];\n    const remappedName = mapAttributeName(name, options);\n\n    if (name === 'indices') {\n      indices = attribute;\n    } else if (attribute.constant) {\n      buffers[remappedName] = attribute.value;\n    } else {\n      const typedArray = attribute.value;\n      // Create accessor by copying the attribute and removing `value``\n      const accessor = {...attribute};\n      delete accessor.value;\n      buffers[remappedName] = [new Buffer(gl, typedArray), accessor];\n\n      inferAttributeAccessor(name, accessor);\n    }\n  }\n\n  if (indices) {\n    const data = indices.value || indices;\n    assert(\n      data instanceof Uint16Array || data instanceof Uint32Array,\n      'attribute array for \"indices\" must be of integer type'\n    );\n    const accessor = {\n      size: 1,\n      isIndexed: indices.isIndexed === undefined ? true : indices.isIndexed\n    };\n    buffers.indices = [\n      new Buffer(gl, {\n        data,\n        target: GL.ELEMENT_ARRAY_BUFFER\n      }),\n      accessor\n    ];\n  }\n\n  return buffers;\n}\n\nfunction mapAttributeName(name, options) {\n  const {attributeMap = GLTF_TO_LUMA_ATTRIBUTE_MAP} = options || {};\n  return (attributeMap && attributeMap[name]) || name;\n}\n\n// Check for well known attribute names\n// eslint-disable-next-line complexity\nexport function inferAttributeAccessor(attributeName, attribute) {\n  let category;\n  switch (attributeName) {\n    case 'texCoords':\n    case 'texCoord1':\n    case 'texCoord2':\n    case 'texCoord3':\n      category = 'uvs';\n      break;\n    case 'vertices':\n    case 'positions':\n    case 'normals':\n    case 'pickingColors':\n      category = 'vectors';\n      break;\n    default:\n  }\n\n  // Check for categorys\n  switch (category) {\n    case 'vectors':\n      attribute.size = attribute.size || 3;\n      break;\n    case 'uvs':\n      attribute.size = attribute.size || 2;\n      break;\n    default:\n  }\n\n  assert(Number.isFinite(attribute.size), `attribute ${attributeName} needs size`);\n}\n","import GL from '@luma.gl/constants';\nimport {getPassthroughFS} from '@luma.gl/shadertools';\nimport BufferTransform from './buffer-transform';\nimport TextureTransform from './texture-transform';\n\nimport {isWebGL2} from '@luma.gl/gltools';\nimport {assert, isObjectEmpty, getShaderVersion} from '@luma.gl/webgl';\nimport Model from '../lib/model';\n\n// takes source and target buffers/textures and setsup the pipeline\nexport default class Transform {\n  static isSupported(gl) {\n    // TODO : differentiate writting to buffer vs not\n    return isWebGL2(gl);\n  }\n\n  constructor(gl, props = {}) {\n    this.gl = gl;\n    this.model = null;\n    this.elementCount = 0;\n    this.bufferTransform = null;\n    this.textureTransform = null;\n    this.elementIDBuffer = null;\n    this._initialize(props);\n    Object.seal(this);\n  }\n\n  // Delete owned resources.\n  delete() {\n    const {model, bufferTransform, textureTransform} = this;\n    if (model) {\n      model.delete();\n    }\n    if (bufferTransform) {\n      bufferTransform.delete();\n    }\n    if (textureTransform) {\n      textureTransform.delete();\n    }\n  }\n\n  // Run one transform loop.\n  run(opts = {}) {\n    const {clearRenderTarget = true} = opts;\n\n    const updatedOpts = this._updateDrawOptions(opts);\n\n    if (clearRenderTarget && updatedOpts.framebuffer) {\n      updatedOpts.framebuffer.clear({color: true});\n    }\n\n    this.model.transform(updatedOpts);\n  }\n\n  // swap resources if a map is provided\n  swap() {\n    let swapped = false;\n    const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);\n    for (const resourceTransform of resourceTransforms) {\n      swapped = swapped || resourceTransform.swap();\n    }\n    assert(swapped, 'Nothing to swap');\n  }\n\n  // Return Buffer object for given varying name.\n  getBuffer(varyingName = null) {\n    return this.bufferTransform && this.bufferTransform.getBuffer(varyingName);\n  }\n\n  // Return data either from Buffer or from Texture\n  getData(opts = {}) {\n    const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);\n    for (const resourceTransform of resourceTransforms) {\n      // @ts-ignore\n      const data = resourceTransform.getData(opts);\n      if (data) {\n        return data;\n      }\n    }\n    return null;\n  }\n\n  // Return framebuffer object if rendering to textures\n  getFramebuffer() {\n    return this.textureTransform && this.textureTransform.getFramebuffer();\n  }\n\n  // Update some or all buffer/texture bindings.\n  update(opts = {}) {\n    if ('elementCount' in opts) {\n      // @ts-ignore TODO\n      this.model.setVertexCount(opts.elementCount);\n    }\n    const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);\n    for (const resourceTransform of resourceTransforms) {\n      resourceTransform.update(opts);\n    }\n  }\n\n  // Private\n\n  _initialize(props = {}) {\n    const {gl} = this;\n    this._buildResourceTransforms(gl, props);\n\n    props = this._updateModelProps(props);\n    this.model = new Model(\n      gl,\n      Object.assign({}, props, {\n        fs: props.fs || getPassthroughFS({version: getShaderVersion(props.vs)}),\n        id: props.id || 'transform-model',\n        drawMode: props.drawMode || GL.POINTS,\n        vertexCount: props.elementCount\n      })\n    );\n\n    /* eslint-disable no-unused-expressions */\n    this.bufferTransform && this.bufferTransform.setupResources({model: this.model});\n    /* eslint-enable no-unused-expressions */\n  }\n\n  _updateModelProps(props) {\n    let updatedProps = Object.assign({}, props);\n    const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);\n    for (const resourceTransform of resourceTransforms) {\n      updatedProps = resourceTransform.updateModelProps(updatedProps);\n    }\n    return updatedProps;\n  }\n\n  _buildResourceTransforms(gl, props) {\n    if (canCreateBufferTransform(props)) {\n      this.bufferTransform = new BufferTransform(gl, props);\n    }\n    if (canCreateTextureTransform(props)) {\n      this.textureTransform = new TextureTransform(gl, props);\n    }\n    assert(\n      this.bufferTransform || this.textureTransform,\n      'must provide source/feedback buffers or source/target textures'\n    );\n  }\n\n  _updateDrawOptions(opts) {\n    let updatedOpts = Object.assign({}, opts);\n    const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);\n    for (const resourceTransform of resourceTransforms) {\n      updatedOpts = Object.assign(updatedOpts, resourceTransform.getDrawOptions(updatedOpts));\n    }\n    return updatedOpts;\n  }\n}\n\n// Helper Methods\n\nfunction canCreateBufferTransform(props) {\n  if (\n    !isObjectEmpty(props.feedbackBuffers) ||\n    !isObjectEmpty(props.feedbackMap) ||\n    (props.varyings && props.varyings.length > 0)\n  ) {\n    return true;\n  }\n  return false;\n}\n\nfunction canCreateTextureTransform(props) {\n  if (\n    !isObjectEmpty(props._sourceTextures) ||\n    props._targetTexture ||\n    props._targetTextureVarying\n  ) {\n    return true;\n  }\n\n  return false;\n}\n","import {isWebGL2} from '@luma.gl/gltools';\nimport {Buffer, TransformFeedback} from '@luma.gl/webgl';\nimport {assert} from '@luma.gl/webgl';\n\nexport default class BufferTransform {\n  constructor(gl, props = {}) {\n    this.gl = gl;\n    this.currentIndex = 0;\n    this.feedbackMap = {};\n    this.varyings = null; // varyings array\n    this.bindings = []; // each element is an object : {sourceBuffers, feedbackBuffers, transformFeedback}\n\n    this.resources = {}; // resources to be deleted\n\n    this._initialize(props);\n    Object.seal(this);\n  }\n\n  setupResources(opts) {\n    for (const binding of this.bindings) {\n      this._setupTransformFeedback(binding, opts);\n    }\n  }\n\n  updateModelProps(props = {}) {\n    const {varyings} = this;\n    if (varyings.length > 0) {\n      props = Object.assign({}, props, {varyings});\n    }\n    return props;\n  }\n\n  getDrawOptions(opts = {}) {\n    const binding = this.bindings[this.currentIndex];\n    const {sourceBuffers, transformFeedback} = binding;\n    const attributes = Object.assign({}, sourceBuffers, opts.attributes);\n\n    return {attributes, transformFeedback};\n  }\n\n  swap() {\n    if (this.feedbackMap) {\n      this.currentIndex = this._getNextIndex();\n      return true;\n    }\n    return false;\n  }\n\n  // update source and/or feedbackBuffers\n  update(opts = {}) {\n    this._setupBuffers(opts);\n  }\n\n  // returns current feedbackBuffer of given name\n  getBuffer(varyingName) {\n    const {feedbackBuffers} = this.bindings[this.currentIndex];\n    const bufferOrParams = varyingName ? feedbackBuffers[varyingName] : null;\n    if (!bufferOrParams) {\n      return null;\n    }\n    return bufferOrParams instanceof Buffer ? bufferOrParams : bufferOrParams.buffer;\n  }\n\n  getData(options = {}) {\n    const {varyingName} = options;\n    const buffer = this.getBuffer(varyingName);\n    if (buffer) {\n      return buffer.getData();\n    }\n    return null;\n  }\n\n  // Delete owned resources.\n  delete() {\n    for (const name in this.resources) {\n      this.resources[name].delete();\n    }\n  }\n\n  // Private\n\n  _initialize(props = {}) {\n    this._setupBuffers(props);\n    this.varyings = props.varyings || Object.keys(this.bindings[this.currentIndex].feedbackBuffers);\n    if (this.varyings.length > 0) {\n      // if writting to buffers make sure it is WebGL2\n      assert(isWebGL2(this.gl));\n    }\n  }\n\n  // auto create feedback buffers if requested\n  _getFeedbackBuffers(props) {\n    const {sourceBuffers = {}} = props;\n    const feedbackBuffers = {};\n    if (this.bindings[this.currentIndex]) {\n      // this gurantees a partial feedback buffer set doesn't update\n      // previously set buffers during auto creation mode.\n      Object.assign(feedbackBuffers, this.bindings[this.currentIndex].feedbackBuffers);\n    }\n    if (this.feedbackMap) {\n      // feedbackMap is defined as sourceBuffer as key and feedbackBuffer name as object\n      for (const sourceName in this.feedbackMap) {\n        const feedbackName = this.feedbackMap[sourceName];\n        if (sourceName in sourceBuffers) {\n          feedbackBuffers[feedbackName] = sourceName;\n        }\n      }\n    }\n    Object.assign(feedbackBuffers, props.feedbackBuffers);\n    for (const bufferName in feedbackBuffers) {\n      const bufferOrRef = feedbackBuffers[bufferName];\n      if (typeof bufferOrRef === 'string') {\n        // Create new buffer with same layout and settings as source buffer\n        const sourceBuffer = sourceBuffers[bufferOrRef];\n        const {byteLength, usage, accessor} = sourceBuffer;\n        feedbackBuffers[bufferName] = this._createNewBuffer(bufferName, {\n          byteLength,\n          usage,\n          accessor\n        });\n      }\n    }\n\n    return feedbackBuffers;\n  }\n\n  _setupBuffers(props = {}) {\n    const {sourceBuffers = null} = props;\n    Object.assign(this.feedbackMap, props.feedbackMap);\n    const feedbackBuffers = this._getFeedbackBuffers(props);\n    this._updateBindings({sourceBuffers, feedbackBuffers});\n  }\n\n  _setupTransformFeedback(binding, {model}) {\n    const {program} = model;\n    binding.transformFeedback = new TransformFeedback(this.gl, {\n      program,\n      buffers: binding.feedbackBuffers\n    });\n  }\n\n  _updateBindings(opts) {\n    this.bindings[this.currentIndex] = this._updateBinding(this.bindings[this.currentIndex], opts);\n    if (this.feedbackMap) {\n      const {sourceBuffers, feedbackBuffers} = this._swapBuffers(this.bindings[this.currentIndex]);\n      const nextIndex = this._getNextIndex();\n      this.bindings[nextIndex] = this._updateBinding(this.bindings[nextIndex], {\n        sourceBuffers,\n        feedbackBuffers\n      });\n    }\n  }\n\n  _updateBinding(binding, opts) {\n    if (!binding) {\n      return {\n        sourceBuffers: Object.assign({}, opts.sourceBuffers),\n        feedbackBuffers: Object.assign({}, opts.feedbackBuffers)\n      };\n    }\n    Object.assign(binding.sourceBuffers, opts.sourceBuffers);\n    Object.assign(binding.feedbackBuffers, opts.feedbackBuffers);\n    if (binding.transformFeedback) {\n      binding.transformFeedback.setBuffers(binding.feedbackBuffers);\n    }\n    return binding;\n  }\n\n  _swapBuffers(opts) {\n    if (!this.feedbackMap) {\n      return null;\n    }\n    const sourceBuffers = Object.assign({}, opts.sourceBuffers);\n    const feedbackBuffers = Object.assign({}, opts.feedbackBuffers);\n    for (const srcName in this.feedbackMap) {\n      const dstName = this.feedbackMap[srcName];\n      sourceBuffers[srcName] = opts.feedbackBuffers[dstName];\n      feedbackBuffers[dstName] = opts.sourceBuffers[srcName];\n\n      // make sure the new destination buffer is a Buffer object\n      assert(feedbackBuffers[dstName] instanceof Buffer);\n    }\n    return {sourceBuffers, feedbackBuffers};\n  }\n\n  // Create a buffer and add to list of buffers to be deleted.\n  _createNewBuffer(name, opts) {\n    const buffer = new Buffer(this.gl, opts);\n    if (this.resources[name]) {\n      this.resources[name].delete();\n    }\n    this.resources[name] = buffer;\n    return buffer;\n  }\n\n  _getNextIndex() {\n    return (this.currentIndex + 1) % 2;\n  }\n}\n","/** @typedef {import('./transform').TransformProps} TransformProps */\nimport GL from '@luma.gl/constants';\n\nimport {\n  cloneTextureFrom,\n  readPixelsToArray,\n  getShaderVersion,\n  Buffer,\n  Texture2D,\n  Framebuffer\n} from '@luma.gl/webgl';\n\nimport {\n  _transform as transformModule,\n  getPassthroughFS,\n  typeToChannelCount,\n  combineInjects\n} from '@luma.gl/shadertools';\n\nimport {updateForTextures, getSizeUniforms} from './transform-shader-utils';\n\n// TODO: move these constants to transform-shader-utils\n// Texture parameters needed so sample can precisely pick pixel for given element id.\nconst SRC_TEX_PARAMETER_OVERRIDES = {\n  [GL.TEXTURE_MIN_FILTER]: GL.NEAREST,\n  [GL.TEXTURE_MAG_FILTER]: GL.NEAREST,\n  [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,\n  [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE\n};\nconst FS_OUTPUT_VARIABLE = 'transform_output';\n\nexport default class TextureTransform {\n  constructor(gl, props = {}) {\n    this.gl = gl;\n    this.id = this.currentIndex = 0;\n    this._swapTexture = null;\n    this.targetTextureVarying = null;\n    this.targetTextureType = null;\n    this.samplerTextureMap = null;\n    this.bindings = []; // each element is an object : {sourceTextures, targetTexture, framebuffer}\n\n    this.resources = {}; // resources to be deleted\n\n    this._initialize(props);\n    Object.seal(this);\n  }\n\n  updateModelProps(props = {}) {\n    const updatedModelProps = this._processVertexShader(props);\n    return Object.assign({}, props, updatedModelProps);\n  }\n\n  getDrawOptions(opts = {}) {\n    const {sourceBuffers, sourceTextures, framebuffer, targetTexture} = this.bindings[\n      this.currentIndex\n    ];\n\n    const attributes = Object.assign({}, sourceBuffers, opts.attributes);\n    const uniforms = Object.assign({}, opts.uniforms);\n    const parameters = Object.assign({}, opts.parameters);\n    let discard = opts.discard;\n\n    if (this.hasSourceTextures || this.hasTargetTexture) {\n      attributes.transform_elementID = this.elementIDBuffer;\n\n      for (const sampler in this.samplerTextureMap) {\n        const textureName = this.samplerTextureMap[sampler];\n        uniforms[sampler] = sourceTextures[textureName];\n      }\n      this._setSourceTextureParameters();\n      // get texture size uniforms\n      const sizeUniforms = getSizeUniforms({\n        sourceTextureMap: sourceTextures,\n        targetTextureVarying: this.targetTextureVarying,\n        targetTexture\n      });\n      Object.assign(uniforms, sizeUniforms);\n    }\n\n    if (this.hasTargetTexture) {\n      discard = false;\n      parameters.viewport = [0, 0, framebuffer.width, framebuffer.height];\n    }\n\n    return {attributes, framebuffer, uniforms, discard, parameters};\n  }\n\n  swap() {\n    if (this._swapTexture) {\n      this.currentIndex = this._getNextIndex();\n      return true;\n    }\n    return false;\n  }\n\n  // update source and/or feedbackBuffers\n  update(opts = {}) {\n    this._setupTextures(opts);\n  }\n\n  // returns current target texture\n  getTargetTexture() {\n    const {targetTexture} = this.bindings[this.currentIndex];\n    return targetTexture;\n  }\n\n  getData({packed = false} = {}) {\n    const {framebuffer} = this.bindings[this.currentIndex];\n    const pixels = readPixelsToArray(framebuffer);\n\n    if (!packed) {\n      return pixels;\n    }\n\n    // readPixels returns 4 elements for each pixel, pack the elements when requested\n    const ArrayType = pixels.constructor;\n    const channelCount = typeToChannelCount(this.targetTextureType);\n    // @ts-ignore\n    const packedPixels = new ArrayType((pixels.length * channelCount) / 4);\n    let packCount = 0;\n    for (let i = 0; i < pixels.length; i += 4) {\n      for (let j = 0; j < channelCount; j++) {\n        packedPixels[packCount++] = pixels[i + j];\n      }\n    }\n    return packedPixels;\n  }\n\n  // returns current framebuffer object that is being used.\n  getFramebuffer() {\n    const currentResources = this.bindings[this.currentIndex];\n    return currentResources.framebuffer;\n  }\n\n  // Delete owned resources.\n  delete() {\n    if (this.ownTexture) {\n      this.ownTexture.delete();\n    }\n    if (this.elementIDBuffer) {\n      this.elementIDBuffer.delete();\n    }\n  }\n\n  // Private\n\n  _initialize(props = {}) {\n    const {_targetTextureVarying, _swapTexture} = props;\n    this._swapTexture = _swapTexture;\n    this.targetTextureVarying = _targetTextureVarying;\n    this.hasTargetTexture = _targetTextureVarying;\n    this._setupTextures(props);\n  }\n\n  // auto create target texture if requested\n  _createTargetTexture(props) {\n    const {sourceTextures, textureOrReference} = props;\n    if (textureOrReference instanceof Texture2D) {\n      return textureOrReference;\n    }\n    // 'targetTexture' is a reference souce texture.\n    const refTexture = sourceTextures[textureOrReference];\n    if (!refTexture) {\n      return null;\n    }\n\n    // save reference texture name, when corresponding source texture is updated\n    // we also update target texture.\n    this._targetRefTexName = textureOrReference;\n\n    return this._createNewTexture(refTexture);\n  }\n\n  /** @param {TransformProps} props */\n  _setupTextures(props = {}) {\n    const {sourceBuffers, _sourceTextures = {}, _targetTexture} = props;\n    const targetTexture = this._createTargetTexture({\n      sourceTextures: _sourceTextures,\n      textureOrReference: _targetTexture\n    });\n    this.hasSourceTextures =\n      this.hasSourceTextures || (_sourceTextures && Object.keys(_sourceTextures).length > 0);\n    this._updateBindings({sourceBuffers, sourceTextures: _sourceTextures, targetTexture});\n    if ('elementCount' in props) {\n      this._updateElementIDBuffer(props.elementCount);\n    }\n  }\n\n  _updateElementIDBuffer(elementCount) {\n    if (typeof elementCount !== 'number' || this.elementCount >= elementCount) {\n      return;\n    }\n    // NOTE: using float so this will work with GLSL 1.0 shaders.\n    const elementIds = new Float32Array(elementCount);\n    elementIds.forEach((_, index, array) => {\n      array[index] = index;\n    });\n    if (!this.elementIDBuffer) {\n      this.elementIDBuffer = new Buffer(this.gl, {\n        data: elementIds,\n        accessor: {size: 1}\n      });\n    } else {\n      this.elementIDBuffer.setData({data: elementIds});\n    }\n    this.elementCount = elementCount;\n  }\n\n  _updateBindings(opts) {\n    this.bindings[this.currentIndex] = this._updateBinding(this.bindings[this.currentIndex], opts);\n    if (this._swapTexture) {\n      const {sourceTextures, targetTexture} = this._swapTextures(this.bindings[this.currentIndex]);\n      const nextIndex = this._getNextIndex();\n      this.bindings[nextIndex] = this._updateBinding(this.bindings[nextIndex], {\n        sourceTextures,\n        targetTexture\n      });\n    }\n  }\n\n  _updateBinding(binding, opts) {\n    const {sourceBuffers, sourceTextures, targetTexture} = opts;\n    if (!binding) {\n      binding = {\n        sourceBuffers: {},\n        sourceTextures: {},\n        targetTexture: null\n      };\n    }\n    Object.assign(binding.sourceTextures, sourceTextures);\n    Object.assign(binding.sourceBuffers, sourceBuffers);\n    if (targetTexture) {\n      binding.targetTexture = targetTexture;\n\n      const {width, height} = targetTexture;\n      const {framebuffer} = binding;\n      if (framebuffer) {\n        // First update texture without re-sizing attachments\n        framebuffer.update({\n          attachments: {[GL.COLOR_ATTACHMENT0]: targetTexture},\n          resizeAttachments: false\n        });\n        // Resize to new taget texture size\n        framebuffer.resize({width, height});\n      } else {\n        binding.framebuffer = new Framebuffer(this.gl, {\n          id: `transform-framebuffer`,\n          width,\n          height,\n          attachments: {\n            [GL.COLOR_ATTACHMENT0]: targetTexture\n          }\n        });\n      }\n    }\n    return binding;\n  }\n\n  // set texture filtering parameters on source textures.\n  _setSourceTextureParameters() {\n    const index = this.currentIndex;\n    const {sourceTextures} = this.bindings[index];\n    for (const name in sourceTextures) {\n      sourceTextures[name].setParameters(SRC_TEX_PARAMETER_OVERRIDES);\n    }\n  }\n\n  _swapTextures(opts) {\n    if (!this._swapTexture) {\n      return null;\n    }\n    const sourceTextures = Object.assign({}, opts.sourceTextures);\n    sourceTextures[this._swapTexture] = opts.targetTexture;\n\n    const targetTexture = opts.sourceTextures[this._swapTexture];\n\n    return {sourceTextures, targetTexture};\n  }\n\n  // Create a buffer and add to list of buffers to be deleted.\n  _createNewTexture(refTexture) {\n    const texture = cloneTextureFrom(refTexture, {\n      parameters: {\n        [GL.TEXTURE_MIN_FILTER]: GL.NEAREST,\n        [GL.TEXTURE_MAG_FILTER]: GL.NEAREST,\n        [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,\n        [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE\n      },\n      pixelStore: {\n        [GL.UNPACK_FLIP_Y_WEBGL]: false\n      }\n    });\n\n    // thre can only be one target texture\n    if (this.ownTexture) {\n      this.ownTexture.delete();\n    }\n    this.ownTexture = texture;\n\n    return texture;\n  }\n\n  _getNextIndex() {\n    return (this.currentIndex + 1) % 2;\n  }\n\n  // build and return shader releated parameters\n  _processVertexShader(props = {}) {\n    const {sourceTextures, targetTexture} = this.bindings[this.currentIndex];\n    // @ts-ignore TODO - uniforms is not present\n    const {vs, uniforms, targetTextureType, inject, samplerTextureMap} = updateForTextures({\n      vs: props.vs,\n      sourceTextureMap: sourceTextures,\n      targetTextureVarying: this.targetTextureVarying,\n      targetTexture\n    });\n    const combinedInject = combineInjects([props.inject || {}, inject]);\n    this.targetTextureType = targetTextureType;\n    this.samplerTextureMap = samplerTextureMap;\n    const fs =\n      props._fs ||\n      getPassthroughFS({\n        version: getShaderVersion(vs),\n        input: this.targetTextureVarying,\n        inputType: targetTextureType,\n        output: FS_OUTPUT_VARIABLE\n      });\n    const modules =\n      this.hasSourceTextures || this.targetTextureVarying\n        ? [transformModule].concat(props.modules || [])\n        : props.modules;\n    return {vs, fs, modules, uniforms, inject: combinedInject};\n  }\n}\n","import {assert} from '@luma.gl/webgl';\nimport {combineInjects, getQualifierDetails, typeToChannelSuffix} from '@luma.gl/shadertools';\n\nconst SAMPLER_UNIFORM_PREFIX = 'transform_uSampler_';\nconst SIZE_UNIFORM_PREFIX = 'transform_uSize_';\nconst VS_POS_VARIABLE = 'transform_position';\n\n// Scan provided vertex shader\n// for each texture attribute, inject sampler instructions and build uniforms for sampler\n// for texture target, get varying type and inject position instruction\nexport function updateForTextures({vs, sourceTextureMap, targetTextureVarying, targetTexture}) {\n  const texAttributeNames = Object.keys(sourceTextureMap);\n  let sourceCount = texAttributeNames.length;\n  let targetTextureType = null;\n  const samplerTextureMap = {};\n  let updatedVs = vs;\n  let finalInject = {};\n\n  if (sourceCount > 0 || targetTextureVarying) {\n    const vsLines = updatedVs.split('\\n');\n    const updateVsLines = vsLines.slice();\n    vsLines.forEach((line, index, lines) => {\n      // TODO add early exit\n      if (sourceCount > 0) {\n        const updated = processAttributeDefinition(line, sourceTextureMap);\n        if (updated) {\n          const {updatedLine, inject} = updated;\n          updateVsLines[index] = updatedLine;\n          // sampleInstructions.push(sampleInstruction);\n          finalInject = combineInjects([finalInject, inject]);\n          Object.assign(samplerTextureMap, updated.samplerTextureMap);\n          sourceCount--;\n        }\n      }\n      if (targetTextureVarying && !targetTextureType) {\n        targetTextureType = getVaryingType(line, targetTextureVarying);\n      }\n    });\n\n    if (targetTextureVarying) {\n      assert(targetTexture);\n      const sizeName = `${SIZE_UNIFORM_PREFIX}${targetTextureVarying}`;\n\n      const uniformDeclaration = `uniform vec2 ${sizeName};\\n`;\n      const posInstructions = `\\\n     vec2 ${VS_POS_VARIABLE} = transform_getPos(${sizeName});\n     gl_Position = vec4(${VS_POS_VARIABLE}, 0, 1.);\\n`;\n      const inject = {\n        'vs:#decl': uniformDeclaration,\n        'vs:#main-start': posInstructions\n      };\n      finalInject = combineInjects([finalInject, inject]);\n    }\n    updatedVs = updateVsLines.join('\\n');\n  }\n  return {\n    // updated vertex shader (commented texture attribute definition)\n    vs: updatedVs,\n    // type (float, vec2, vec3 of vec4) target texture varying\n    targetTextureType,\n    // required vertex and fragment shader injects\n    inject: finalInject,\n    // map of sampler name to texture name, can be used to set attributes\n    // usefull when swapping textures, as source and destination texture change when swap is called.\n    samplerTextureMap\n  };\n}\n\n// builds and returns an object contaning size uniform for each texture\nexport function getSizeUniforms({sourceTextureMap, targetTextureVarying, targetTexture}) {\n  const uniforms = {};\n  let width;\n  let height;\n  if (targetTextureVarying) {\n    ({width, height} = targetTexture);\n    uniforms[`${SIZE_UNIFORM_PREFIX}${targetTextureVarying}`] = [width, height];\n  }\n  for (const textureName in sourceTextureMap) {\n    ({width, height} = sourceTextureMap[textureName]);\n    uniforms[`${SIZE_UNIFORM_PREFIX}${textureName}`] = [width, height];\n  }\n  return uniforms;\n}\n\n// Checks if provided line is defining an attribute, if so returns details otherwise null\nfunction getAttributeDefinition(line) {\n  return getQualifierDetails(line, ['attribute', 'in']);\n}\n\nfunction getSamplerDeclerations(textureName) {\n  const samplerName = `${SAMPLER_UNIFORM_PREFIX}${textureName}`;\n  const sizeName = `${SIZE_UNIFORM_PREFIX}${textureName}`;\n  const uniformDeclerations = `\\\n  uniform sampler2D ${samplerName};\n  uniform vec2 ${sizeName};`;\n  return {samplerName, sizeName, uniformDeclerations};\n}\n\n// Return size (float, vec2 etc) of a given varying, null if doens't exist.\nexport function getVaryingType(line, varying) {\n  const qualaiferDetails = getQualifierDetails(line, ['varying', 'out']);\n  if (!qualaiferDetails) {\n    return null;\n  }\n  return qualaiferDetails.name === varying ? qualaiferDetails.type : null;\n}\n\n// build required definitions, sample instructions for each texture attribute\nexport function processAttributeDefinition(line, textureMap) {\n  const samplerTextureMap = {};\n  const attributeData = getAttributeDefinition(line);\n  if (!attributeData) {\n    return null;\n  }\n  const {type, name} = attributeData;\n  if (name && textureMap[name]) {\n    // eslint-disable-next-line no-useless-escape\n    const updatedLine = `\\// ${line} => Replaced by Transform with a sampler`;\n    const {samplerName, sizeName, uniformDeclerations} = getSamplerDeclerations(name);\n\n    const channels = typeToChannelSuffix(type);\n    const sampleInstruction = `  ${type} ${name} = transform_getInput(${samplerName}, ${sizeName}).${channels};\\n`;\n\n    samplerTextureMap[samplerName] = name;\n    const inject = {\n      'vs:#decl': uniformDeclerations,\n      'vs:#main-start': sampleInstruction\n    };\n\n    // samplerNameMap\n    return {\n      // update vertex shader line.\n      updatedLine,\n      // inject object with sampler instructions.\n      inject,\n      // sampler name to texture name map\n      samplerTextureMap\n    };\n  }\n  return null;\n}\n","import {uid, assert} from '@luma.gl/webgl';\n\n// Rendering primitives - specify how to extract primitives from vertices.\n// NOTE: These are numerically identical to the corresponding WebGL/OpenGL constants\nexport const DRAW_MODE = {\n  POINTS: 0x0000, // draw single points.\n  LINES: 0x0001, // draw lines. Each vertex connects to the one after it.\n  LINE_LOOP: 0x0002, // draw lines. Each set of two vertices is treated as a separate line segment.\n  LINE_STRIP: 0x0003, // draw a connected group of line segments from the first vertex to the last\n  TRIANGLES: 0x0004, // draw triangles. Each set of three vertices creates a separate triangle.\n  TRIANGLE_STRIP: 0x0005, // draw a connected group of triangles.\n  TRIANGLE_FAN: 0x0006 // draw a connected group of triangles.\n  // Each vertex connects to the previous and the first vertex in the fan.\n};\n\nexport default class Geometry {\n  static get DRAW_MODE() {\n    return DRAW_MODE;\n  }\n\n  constructor(props = {}) {\n    const {\n      id = uid('geometry'),\n      drawMode = DRAW_MODE.TRIANGLES,\n      attributes = {},\n      indices = null,\n      vertexCount = null\n    } = props;\n\n    this.id = id;\n    this.drawMode = drawMode | 0;\n    this.attributes = {};\n    this.userData = {};\n\n    this._setAttributes(attributes, indices);\n\n    this.vertexCount = vertexCount || this._calculateVertexCount(this.attributes, this.indices);\n\n    // stubRemovedMethods(this, [\n    //   'setNeedsRedraw', 'needsRedraw', 'setAttributes'\n    // ], 'Immutable');\n\n    // stubRemovedMethods(this, [\n    //   'hasAttribute', 'getAttribute', 'getArray'\n    // ], 'Use geometry.attributes and geometry.indices');\n\n    // deprecateMethods(this, ['getAttributes'])\n  }\n\n  get mode() {\n    return this.drawMode;\n  }\n\n  getVertexCount() {\n    return this.vertexCount;\n  }\n\n  // Return an object with all attributes plus indices added as a field.\n  getAttributes() {\n    return this.indices ? {indices: this.indices, ...this.attributes} : this.attributes;\n  }\n\n  // PRIVATE\n\n  _print(attributeName) {\n    return `Geometry ${this.id} attribute ${attributeName}`;\n  }\n\n  // Attribute\n  // value: typed array\n  // type: indices, vertices, uvs\n  // size: elements per vertex\n  // target: WebGL buffer type (string or constant)\n  _setAttributes(attributes, indices) {\n    if (indices) {\n      this.indices = ArrayBuffer.isView(indices) ? {value: indices, size: 1} : indices;\n    }\n\n    for (const attributeName in attributes) {\n      let attribute = attributes[attributeName];\n\n      // Wrap \"unwrapped\" arrays and try to autodetect their type\n      attribute = ArrayBuffer.isView(attribute) ? {value: attribute} : attribute;\n\n      assert(\n        ArrayBuffer.isView(attribute.value),\n        `${this._print(attributeName)}: must be typed array or object with value as typed array`\n      );\n\n      if ((attributeName === 'POSITION' || attributeName === 'positions') && !attribute.size) {\n        attribute.size = 3;\n      }\n\n      // Move indices to separate field\n      if (attributeName === 'indices') {\n        assert(!this.indices);\n        this.indices = attribute;\n      } else {\n        this.attributes[attributeName] = attribute;\n      }\n    }\n\n    if (this.indices && this.indices.isIndexed !== undefined) {\n      this.indices = Object.assign({}, this.indices);\n      delete this.indices.isIndexed;\n    }\n\n    return this;\n  }\n\n  _calculateVertexCount(attributes, indices) {\n    if (indices) {\n      return indices.value.length;\n    }\n    let vertexCount = Infinity;\n    for (const attributeName in attributes) {\n      const attribute = attributes[attributeName];\n      const {value, size, constant} = attribute;\n      if (!constant && value && size >= 1) {\n        vertexCount = Math.min(vertexCount, value.length / size);\n      }\n    }\n\n    assert(Number.isFinite(vertexCount));\n    return vertexCount;\n  }\n}\n","import TruncatedConeGeometry from './truncated-cone-geometry';\nimport {uid} from '@luma.gl/webgl';\n\nexport default class ConeGeometry extends TruncatedConeGeometry {\n  constructor(props = {}) {\n    const {id = uid('cone-geometry'), radius = 1, cap = true} = props;\n    super({\n      ...props,\n      id,\n      topRadius: 0,\n      topCap: Boolean(cap),\n      bottomCap: Boolean(cap),\n      bottomRadius: radius\n    });\n  }\n}\n","import Geometry from '../geometry/geometry';\nimport {uid} from '@luma.gl/webgl';\n\nconst INDEX_OFFSETS = {\n  x: [2, 0, 1],\n  y: [0, 1, 2],\n  z: [1, 2, 0]\n};\n\nexport default class TruncatedConeGeometry extends Geometry {\n  constructor(props = {}) {\n    const {id = uid('truncated-code-geometry')} = props;\n    const {indices, attributes} = tesselateTruncatedCone(props);\n    super({\n      ...props,\n      id,\n      indices,\n      attributes: {...attributes, ...props.attributes}\n    });\n  }\n}\n\n// Primitives inspired by TDL http://code.google.com/p/webglsamples/,\n// copyright 2011 Google Inc. new BSD License\n// (http://www.opensource.org/licenses/bsd-license.php).\n/* eslint-disable max-statements, complexity */\nfunction tesselateTruncatedCone(props) {\n  const {\n    bottomRadius = 0,\n    topRadius = 0,\n    height = 1,\n    nradial = 10,\n    nvertical = 10,\n    verticalAxis = 'y',\n    topCap = false,\n    bottomCap = false\n  } = props;\n\n  const extra = (topCap ? 2 : 0) + (bottomCap ? 2 : 0);\n  const numVertices = (nradial + 1) * (nvertical + 1 + extra);\n\n  const slant = Math.atan2(bottomRadius - topRadius, height);\n  const msin = Math.sin;\n  const mcos = Math.cos;\n  const mpi = Math.PI;\n  const cosSlant = mcos(slant);\n  const sinSlant = msin(slant);\n  const start = topCap ? -2 : 0;\n  const end = nvertical + (bottomCap ? 2 : 0);\n  const vertsAroundEdge = nradial + 1;\n\n  const indices = new Uint16Array(nradial * (nvertical + extra) * 6);\n  const indexOffset = INDEX_OFFSETS[verticalAxis];\n\n  const positions = new Float32Array(numVertices * 3);\n  const normals = new Float32Array(numVertices * 3);\n  const texCoords = new Float32Array(numVertices * 2);\n\n  let i3 = 0;\n  let i2 = 0;\n  for (let i = start; i <= end; i++) {\n    let v = i / nvertical;\n    let y = height * v;\n    let ringRadius;\n\n    if (i < 0) {\n      y = 0;\n      v = 1;\n      ringRadius = bottomRadius;\n    } else if (i > nvertical) {\n      y = height;\n      v = 1;\n      ringRadius = topRadius;\n    } else {\n      ringRadius = bottomRadius + (topRadius - bottomRadius) * (i / nvertical);\n    }\n    if (i === -2 || i === nvertical + 2) {\n      ringRadius = 0;\n      v = 0;\n    }\n    y -= height / 2;\n    for (let j = 0; j < vertsAroundEdge; j++) {\n      const sin = msin((j * mpi * 2) / nradial);\n      const cos = mcos((j * mpi * 2) / nradial);\n\n      positions[i3 + indexOffset[0]] = sin * ringRadius;\n      positions[i3 + indexOffset[1]] = y;\n      positions[i3 + indexOffset[2]] = cos * ringRadius;\n\n      normals[i3 + indexOffset[0]] = i < 0 || i > nvertical ? 0 : sin * cosSlant;\n      normals[i3 + indexOffset[1]] = i < 0 ? -1 : i > nvertical ? 1 : sinSlant;\n      normals[i3 + indexOffset[2]] = i < 0 || i > nvertical ? 0 : cos * cosSlant;\n\n      texCoords[i2 + 0] = j / nradial;\n      texCoords[i2 + 1] = v;\n\n      i2 += 2;\n      i3 += 3;\n    }\n  }\n\n  for (let i = 0; i < nvertical + extra; i++) {\n    for (let j = 0; j < nradial; j++) {\n      const index = (i * nradial + j) * 6;\n      indices[index + 0] = vertsAroundEdge * (i + 0) + 0 + j;\n      indices[index + 1] = vertsAroundEdge * (i + 0) + 1 + j;\n      indices[index + 2] = vertsAroundEdge * (i + 1) + 1 + j;\n      indices[index + 3] = vertsAroundEdge * (i + 0) + 0 + j;\n      indices[index + 4] = vertsAroundEdge * (i + 1) + 1 + j;\n      indices[index + 5] = vertsAroundEdge * (i + 1) + 0 + j;\n    }\n  }\n\n  return {\n    indices,\n    attributes: {\n      POSITION: {size: 3, value: positions},\n      NORMAL: {size: 3, value: normals},\n      TEXCOORD_0: {size: 2, value: texCoords}\n    }\n  };\n}\n","import Geometry from '../geometry/geometry';\nimport {uid} from '@luma.gl/webgl';\n\n// prettier-ignore\nconst CUBE_INDICES = new Uint16Array([\n  0, 1, 2, 0, 2, 3, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11, 12, 13,\n  14, 12, 14, 15, 16, 17, 18, 16, 18, 19, 20, 21, 22, 20, 22, 23\n]);\n\n// prettier-ignore\nconst CUBE_POSITIONS = new Float32Array([\n  -1,  -1,  1, 1,  -1,  1,  1,  1,  1,  -1,  1,  1,\n  -1,  -1,  -1,  -1,  1,  -1,  1,  1,  -1,  1,  -1,  -1,\n  -1,  1,  -1,  -1,  1,  1,  1,  1,  1,  1,  1,  -1,\n  -1,  -1,  -1,  1,  -1,  -1,  1,  -1,  1,  -1,  -1,  1,\n  1,  -1,  -1,  1,  1,  -1,  1,  1,  1,  1,  -1,  1,\n  -1,  -1,  -1,  -1,  -1,  1,  -1,  1,  1,  -1,  1,  -1\n]);\n\n// TODO - could be Uint8\n// prettier-ignore\nconst CUBE_NORMALS = new Float32Array([\n  // Front face\n  0,  0,  1,  0,  0,  1,  0,  0,  1,  0,  0,  1,\n  // Back face\n  0,  0,  -1,  0,  0,  -1,  0,  0,  -1,  0,  0,  -1,\n  // Top face\n  0,  1,  0,  0,  1,  0,  0,  1,  0,  0,  1,  0,\n  // Bottom face\n  0,  -1,  0,  0,  -1,  0,  0,  -1,  0,  0,  -1,  0,\n  // Right face\n  1,  0,  0,  1,  0,  0,  1,  0,  0,  1,  0,  0,\n  // Left face\n  -1,  0,  0,  -1,  0,  0,  -1,  0,  0,  -1,  0,  0\n]);\n\n// prettier-ignore\nconst CUBE_TEX_COORDS = new Float32Array([\n  // Front face\n  0,  0,  1,  0,  1,  1,  0,  1,\n  // Back face\n  1,  0,  1,  1,  0,  1,  0,  0,\n  // Top face\n  0,  1,  0,  0,  1,  0,  1,  1,\n  // Bottom face\n  1,  1,  0,  1,  0,  0,  1,  0,\n  // Right face\n  1,  0,  1,  1,  0,  1,  0,  0,\n  // Left face\n  0,  0,  1,  0,  1,  1,  0,  1\n]);\n\nconst ATTRIBUTES = {\n  POSITION: {size: 3, value: new Float32Array(CUBE_POSITIONS)},\n  NORMAL: {size: 3, value: new Float32Array(CUBE_NORMALS)},\n  TEXCOORD_0: {size: 2, value: new Float32Array(CUBE_TEX_COORDS)}\n};\n\nexport default class CubeGeometry extends Geometry {\n  constructor(props = {}) {\n    const {id = uid('cube-geometry')} = props;\n    super({\n      ...props,\n      id,\n      indices: {size: 1, value: new Uint16Array(CUBE_INDICES)},\n      attributes: {...ATTRIBUTES, ...props.attributes}\n    });\n  }\n}\n","import TruncatedConeGeometry from './truncated-cone-geometry';\nimport {uid} from '@luma.gl/webgl';\n\nexport default class CylinderGeometry extends TruncatedConeGeometry {\n  constructor(props = {}) {\n    const {id = uid('cylinder-geometry'), radius = 1} = props;\n    super({\n      ...props,\n      id,\n      bottomRadius: radius,\n      topRadius: radius\n    });\n  }\n}\n","import {Vector3} from '@math.gl/core';\nimport Geometry from '../geometry/geometry';\nimport {uid} from '@luma.gl/webgl';\n\n/* eslint-disable comma-spacing, max-statements, complexity */\n\nconst ICO_POSITIONS = [-1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 1, 0, -1, 0, 1, 0, 0];\nconst ICO_INDICES = [3, 4, 5, 3, 5, 1, 3, 1, 0, 3, 0, 4, 4, 0, 2, 4, 2, 5, 2, 0, 1, 5, 2, 1];\n\nexport default class IcoSphereGeometry extends Geometry {\n  constructor(props = {}) {\n    const {id = uid('ico-sphere-geometry')} = props;\n    const {indices, attributes} = tesselateIcosaHedron(props);\n    super({\n      ...props,\n      id,\n      indices,\n      attributes: {...attributes, ...props.attributes}\n    });\n  }\n}\n\nfunction tesselateIcosaHedron(props) {\n  const {iterations = 0} = props;\n\n  const PI = Math.PI;\n  const PI2 = PI * 2;\n\n  const positions = [...ICO_POSITIONS];\n  let indices = [...ICO_INDICES];\n\n  positions.push();\n  indices.push();\n\n  const getMiddlePoint = (() => {\n    const pointMemo = {};\n\n    return (i1, i2) => {\n      i1 *= 3;\n      i2 *= 3;\n      const mini = i1 < i2 ? i1 : i2;\n      const maxi = i1 > i2 ? i1 : i2;\n      const key = `${mini}|${maxi}`;\n\n      if (key in pointMemo) {\n        return pointMemo[key];\n      }\n\n      const x1 = positions[i1];\n      const y1 = positions[i1 + 1];\n      const z1 = positions[i1 + 2];\n      const x2 = positions[i2];\n      const y2 = positions[i2 + 1];\n      const z2 = positions[i2 + 2];\n      let xm = (x1 + x2) / 2;\n      let ym = (y1 + y2) / 2;\n      let zm = (z1 + z2) / 2;\n      const len = Math.sqrt(xm * xm + ym * ym + zm * zm);\n\n      xm /= len;\n      ym /= len;\n      zm /= len;\n\n      positions.push(xm, ym, zm);\n\n      return (pointMemo[key] = positions.length / 3 - 1);\n    };\n  })();\n\n  for (let i = 0; i < iterations; i++) {\n    const indices2 = [];\n    for (let j = 0; j < indices.length; j += 3) {\n      const a = getMiddlePoint(indices[j + 0], indices[j + 1]);\n      const b = getMiddlePoint(indices[j + 1], indices[j + 2]);\n      const c = getMiddlePoint(indices[j + 2], indices[j + 0]);\n\n      indices2.push(c, indices[j + 0], a, a, indices[j + 1], b, b, indices[j + 2], c, a, b, c);\n    }\n    indices = indices2;\n  }\n\n  // Calculate texCoords and normals\n  const normals = new Array(positions.length);\n  const texCoords = new Array((positions.length / 3) * 2);\n\n  const l = indices.length;\n  for (let i = l - 3; i >= 0; i -= 3) {\n    const i1 = indices[i + 0];\n    const i2 = indices[i + 1];\n    const i3 = indices[i + 2];\n    const in1 = i1 * 3;\n    const in2 = i2 * 3;\n    const in3 = i3 * 3;\n    const iu1 = i1 * 2;\n    const iu2 = i2 * 2;\n    const iu3 = i3 * 2;\n    const x1 = positions[in1 + 0];\n    const y1 = positions[in1 + 1];\n    const z1 = positions[in1 + 2];\n    const theta1 = Math.acos(z1 / Math.sqrt(x1 * x1 + y1 * y1 + z1 * z1));\n    const phi1 = Math.atan2(y1, x1) + PI;\n    const v1 = theta1 / PI;\n    const u1 = 1 - phi1 / PI2;\n    const x2 = positions[in2 + 0];\n    const y2 = positions[in2 + 1];\n    const z2 = positions[in2 + 2];\n    const theta2 = Math.acos(z2 / Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2));\n    const phi2 = Math.atan2(y2, x2) + PI;\n    const v2 = theta2 / PI;\n    const u2 = 1 - phi2 / PI2;\n    const x3 = positions[in3 + 0];\n    const y3 = positions[in3 + 1];\n    const z3 = positions[in3 + 2];\n    const theta3 = Math.acos(z3 / Math.sqrt(x3 * x3 + y3 * y3 + z3 * z3));\n    const phi3 = Math.atan2(y3, x3) + PI;\n    const v3 = theta3 / PI;\n    const u3 = 1 - phi3 / PI2;\n    const vec1 = [x3 - x2, y3 - y2, z3 - z2];\n    const vec2 = [x1 - x2, y1 - y2, z1 - z2];\n    const normal = new Vector3(vec1).cross(vec2).normalize();\n    let newIndex;\n\n    if (\n      (u1 === 0 || u2 === 0 || u3 === 0) &&\n      (u1 === 0 || u1 > 0.5) &&\n      (u2 === 0 || u2 > 0.5) &&\n      (u3 === 0 || u3 > 0.5)\n    ) {\n      positions.push(positions[in1 + 0], positions[in1 + 1], positions[in1 + 2]);\n      newIndex = positions.length / 3 - 1;\n      indices.push(newIndex);\n      texCoords[newIndex * 2 + 0] = 1;\n      texCoords[newIndex * 2 + 1] = v1;\n      normals[newIndex * 3 + 0] = normal.x;\n      normals[newIndex * 3 + 1] = normal.y;\n      normals[newIndex * 3 + 2] = normal.z;\n\n      positions.push(positions[in2 + 0], positions[in2 + 1], positions[in2 + 2]);\n      newIndex = positions.length / 3 - 1;\n      indices.push(newIndex);\n      texCoords[newIndex * 2 + 0] = 1;\n      texCoords[newIndex * 2 + 1] = v2;\n      normals[newIndex * 3 + 0] = normal.x;\n      normals[newIndex * 3 + 1] = normal.y;\n      normals[newIndex * 3 + 2] = normal.z;\n\n      positions.push(positions[in3 + 0], positions[in3 + 1], positions[in3 + 2]);\n      newIndex = positions.length / 3 - 1;\n      indices.push(newIndex);\n      texCoords[newIndex * 2 + 0] = 1;\n      texCoords[newIndex * 2 + 1] = v3;\n      normals[newIndex * 3 + 0] = normal.x;\n      normals[newIndex * 3 + 1] = normal.y;\n      normals[newIndex * 3 + 2] = normal.z;\n    }\n\n    normals[in1 + 0] = normals[in2 + 0] = normals[in3 + 0] = normal.x;\n    normals[in1 + 1] = normals[in2 + 1] = normals[in3 + 1] = normal.y;\n    normals[in1 + 2] = normals[in2 + 2] = normals[in3 + 2] = normal.z;\n\n    texCoords[iu1 + 0] = u1;\n    texCoords[iu1 + 1] = v1;\n\n    texCoords[iu2 + 0] = u2;\n    texCoords[iu2 + 1] = v2;\n\n    texCoords[iu3 + 0] = u3;\n    texCoords[iu3 + 1] = v3;\n  }\n\n  return {\n    indices: {size: 1, value: new Uint16Array(indices)},\n    attributes: {\n      POSITION: {size: 3, value: new Float32Array(positions)},\n      NORMAL: {size: 3, value: new Float32Array(normals)},\n      TEXCOORD_0: {size: 2, value: new Float32Array(texCoords)}\n    }\n  };\n}\n","import Geometry from '../geometry/geometry';\nimport {unpackIndexedGeometry} from '../geometry/geometry-utils';\nimport {uid} from '@luma.gl/webgl';\n\nexport default class PlaneGeometry extends Geometry {\n  constructor(props = {}) {\n    const {id = uid('plane-geometry')} = props;\n\n    const {indices, attributes} = tesselatePlane(props);\n    super({\n      ...props,\n      id,\n      indices,\n      attributes: {...attributes, ...props.attributes}\n    });\n  }\n}\n\n// Primitives inspired by TDL http://code.google.com/p/webglsamples/,\n// copyright 2011 Google Inc. new BSD License\n// (http://www.opensource.org/licenses/bsd-license.php).\n/* eslint-disable max-statements, complexity */\n/* eslint-disable complexity, max-statements */\nfunction tesselatePlane(props) {\n  const {type = 'x,y', offset = 0, flipCull = false, unpack = false} = props;\n\n  const coords = type.split(',');\n  // width, height\n  let c1len = props[`${coords[0]}len`] || 1;\n  const c2len = props[`${coords[1]}len`] || 1;\n  // subdivisionsWidth, subdivisionsDepth\n  const subdivisions1 = props[`n${coords[0]}`] || 1;\n  const subdivisions2 = props[`n${coords[1]}`] || 1;\n  const numVertices = (subdivisions1 + 1) * (subdivisions2 + 1);\n\n  const positions = new Float32Array(numVertices * 3);\n  const normals = new Float32Array(numVertices * 3);\n  const texCoords = new Float32Array(numVertices * 2);\n\n  if (flipCull) {\n    c1len = -c1len;\n  }\n\n  let i2 = 0;\n  let i3 = 0;\n  for (let z = 0; z <= subdivisions2; z++) {\n    for (let x = 0; x <= subdivisions1; x++) {\n      const u = x / subdivisions1;\n      const v = z / subdivisions2;\n      texCoords[i2 + 0] = flipCull ? 1 - u : u;\n      texCoords[i2 + 1] = v;\n\n      switch (type) {\n        case 'x,y':\n          positions[i3 + 0] = c1len * u - c1len * 0.5;\n          positions[i3 + 1] = c2len * v - c2len * 0.5;\n          positions[i3 + 2] = offset;\n\n          normals[i3 + 0] = 0;\n          normals[i3 + 1] = 0;\n          normals[i3 + 2] = flipCull ? 1 : -1;\n          break;\n\n        case 'x,z':\n          positions[i3 + 0] = c1len * u - c1len * 0.5;\n          positions[i3 + 1] = offset;\n          positions[i3 + 2] = c2len * v - c2len * 0.5;\n\n          normals[i3 + 0] = 0;\n          normals[i3 + 1] = flipCull ? 1 : -1;\n          normals[i3 + 2] = 0;\n          break;\n\n        case 'y,z':\n          positions[i3 + 0] = offset;\n          positions[i3 + 1] = c1len * u - c1len * 0.5;\n          positions[i3 + 2] = c2len * v - c2len * 0.5;\n\n          normals[i3 + 0] = flipCull ? 1 : -1;\n          normals[i3 + 1] = 0;\n          normals[i3 + 2] = 0;\n          break;\n\n        default:\n          throw new Error('PlaneGeometry: unknown type');\n      }\n\n      i2 += 2;\n      i3 += 3;\n    }\n  }\n\n  const numVertsAcross = subdivisions1 + 1;\n  const indices = new Uint16Array(subdivisions1 * subdivisions2 * 6);\n\n  for (let z = 0; z < subdivisions2; z++) {\n    for (let x = 0; x < subdivisions1; x++) {\n      const index = (z * subdivisions1 + x) * 6;\n      // Make triangle 1 of quad.\n      indices[index + 0] = (z + 0) * numVertsAcross + x;\n      indices[index + 1] = (z + 1) * numVertsAcross + x;\n      indices[index + 2] = (z + 0) * numVertsAcross + x + 1;\n\n      // Make triangle 2 of quad.\n      indices[index + 3] = (z + 1) * numVertsAcross + x;\n      indices[index + 4] = (z + 1) * numVertsAcross + x + 1;\n      indices[index + 5] = (z + 0) * numVertsAcross + x + 1;\n    }\n  }\n\n  const geometry = {\n    indices: {size: 1, value: indices},\n    attributes: {\n      POSITION: {size: 3, value: positions},\n      NORMAL: {size: 3, value: normals},\n      TEXCOORD_0: {size: 2, value: texCoords}\n    }\n  };\n\n  // Optionally, unpack indexed geometry\n  return unpack ? unpackIndexedGeometry(geometry) : geometry;\n}\n","export function unpackIndexedGeometry(geometry) {\n  const {indices, attributes} = geometry;\n  if (!indices) {\n    return geometry;\n  }\n\n  const vertexCount = indices.value.length;\n  const unpackedAttributes = {};\n\n  for (const attributeName in attributes) {\n    const attribute = attributes[attributeName];\n    const {constant, value, size} = attribute;\n    if (constant || !size) {\n      continue; // eslint-disable-line\n    }\n    const unpackedValue = new value.constructor(vertexCount * size);\n    for (let x = 0; x < vertexCount; ++x) {\n      const index = indices.value[x];\n      for (let i = 0; i < size; i++) {\n        unpackedValue[x * size + i] = value[index * size + i];\n      }\n    }\n    unpackedAttributes[attributeName] = {size, value: unpackedValue};\n  }\n\n  return {\n    attributes: Object.assign({}, attributes, unpackedAttributes)\n  };\n}\n","import Geometry from '../geometry/geometry';\nimport {uid} from '@luma.gl/webgl';\n\nexport default class SphereGeometry extends Geometry {\n  constructor(props = {}) {\n    const {id = uid('sphere-geometry')} = props;\n    const {indices, attributes} = tesselateSphere(props);\n    super({\n      ...props,\n      id,\n      indices,\n      attributes: {...attributes, ...props.attributes}\n    });\n  }\n}\n\n// Primitives inspired by TDL http://code.google.com/p/webglsamples/,\n// copyright 2011 Google Inc. new BSD License\n// (http://www.opensource.org/licenses/bsd-license.php).\n/* eslint-disable max-statements, complexity */\nfunction tesselateSphere(props) {\n  const {nlat = 10, nlong = 10} = props;\n  let {radius = 1} = props;\n\n  const startLat = 0;\n  const endLat = Math.PI;\n  const latRange = endLat - startLat;\n  const startLong = 0;\n  const endLong = 2 * Math.PI;\n  const longRange = endLong - startLong;\n  const numVertices = (nlat + 1) * (nlong + 1);\n\n  if (typeof radius === 'number') {\n    const value = radius;\n    radius = (n1, n2, n3, u, v) => value;\n  }\n\n  const positions = new Float32Array(numVertices * 3);\n  const normals = new Float32Array(numVertices * 3);\n  const texCoords = new Float32Array(numVertices * 2);\n\n  const IndexType = numVertices > 0xffff ? Uint32Array : Uint16Array;\n  const indices = new IndexType(nlat * nlong * 6);\n\n  // Create positions, normals and texCoords\n  for (let y = 0; y <= nlat; y++) {\n    for (let x = 0; x <= nlong; x++) {\n      const u = x / nlong;\n      const v = y / nlat;\n\n      const index = x + y * (nlong + 1);\n      const i2 = index * 2;\n      const i3 = index * 3;\n\n      const theta = longRange * u;\n      const phi = latRange * v;\n      const sinTheta = Math.sin(theta);\n      const cosTheta = Math.cos(theta);\n      const sinPhi = Math.sin(phi);\n      const cosPhi = Math.cos(phi);\n      const ux = cosTheta * sinPhi;\n      const uy = cosPhi;\n      const uz = sinTheta * sinPhi;\n\n      const r = radius(ux, uy, uz, u, v);\n\n      positions[i3 + 0] = r * ux;\n      positions[i3 + 1] = r * uy;\n      positions[i3 + 2] = r * uz;\n\n      normals[i3 + 0] = ux;\n      normals[i3 + 1] = uy;\n      normals[i3 + 2] = uz;\n\n      texCoords[i2 + 0] = u;\n      texCoords[i2 + 1] = 1 - v;\n    }\n  }\n\n  // Create indices\n  const numVertsAround = nlong + 1;\n  for (let x = 0; x < nlong; x++) {\n    for (let y = 0; y < nlat; y++) {\n      const index = (x * nlat + y) * 6;\n\n      indices[index + 0] = y * numVertsAround + x;\n      indices[index + 1] = y * numVertsAround + x + 1;\n      indices[index + 2] = (y + 1) * numVertsAround + x;\n\n      indices[index + 3] = (y + 1) * numVertsAround + x;\n      indices[index + 4] = y * numVertsAround + x + 1;\n      indices[index + 5] = (y + 1) * numVertsAround + x + 1;\n    }\n  }\n\n  return {\n    indices: {size: 1, value: indices},\n    attributes: {\n      POSITION: {size: 3, value: positions},\n      NORMAL: {size: 3, value: normals},\n      TEXCOORD_0: {size: 2, value: texCoords}\n    }\n  };\n}\n","let channelHandles = 1;\nlet animationHandles = 1;\n\nexport class Timeline {\n  constructor() {\n    this.time = 0;\n    this.channels = new Map();\n    this.animations = new Map();\n    this.playing = false;\n    this.lastEngineTime = -1;\n  }\n\n  addChannel(props) {\n    const {delay = 0, duration = Number.POSITIVE_INFINITY, rate = 1, repeat = 1} = props;\n\n    const handle = channelHandles++;\n    const channel = {\n      time: 0,\n      delay,\n      duration,\n      rate,\n      repeat\n    };\n    this._setChannelTime(channel, this.time);\n    this.channels.set(handle, channel);\n\n    return handle;\n  }\n\n  removeChannel(handle) {\n    this.channels.delete(handle);\n\n    for (const [animationHandle, animation] of this.animations) {\n      if (animation.channel === handle) {\n        this.detachAnimation(animationHandle);\n      }\n    }\n  }\n\n  isFinished(handle) {\n    const channel = this.channels.get(handle);\n    if (channel === undefined) {\n      return false;\n    }\n\n    return this.time >= channel.delay + channel.duration * channel.repeat;\n  }\n\n  getTime(handle) {\n    if (handle === undefined) {\n      return this.time;\n    }\n\n    const channel = this.channels.get(handle);\n\n    if (channel === undefined) {\n      return -1;\n    }\n\n    return channel.time;\n  }\n\n  setTime(time) {\n    this.time = Math.max(0, time);\n\n    const channels = this.channels.values();\n    for (const channel of channels) {\n      this._setChannelTime(channel, this.time);\n    }\n\n    const animations = this.animations.values();\n    for (const animationData of animations) {\n      const {animation, channel} = animationData;\n      animation.setTime(this.getTime(channel));\n    }\n  }\n\n  play() {\n    this.playing = true;\n  }\n\n  pause() {\n    this.playing = false;\n    this.lastEngineTime = -1;\n  }\n\n  reset() {\n    this.setTime(0);\n  }\n\n  attachAnimation(animation, channelHandle) {\n    const animationHandle = animationHandles++;\n\n    this.animations.set(animationHandle, {\n      animation,\n      channel: channelHandle\n    });\n\n    animation.setTime(this.getTime(channelHandle));\n\n    return animationHandle;\n  }\n\n  detachAnimation(handle) {\n    this.animations.delete(handle);\n  }\n\n  update(engineTime) {\n    if (this.playing) {\n      if (this.lastEngineTime === -1) {\n        this.lastEngineTime = engineTime;\n      }\n      this.setTime(this.time + (engineTime - this.lastEngineTime));\n      this.lastEngineTime = engineTime;\n    }\n  }\n\n  _setChannelTime(channel, time) {\n    const offsetTime = time - channel.delay;\n    const totalDuration = channel.duration * channel.repeat;\n    // Note(Tarek): Don't loop on final repeat.\n    if (offsetTime >= totalDuration) {\n      channel.time = channel.duration * channel.rate;\n    } else {\n      channel.time = Math.max(0, offsetTime) % channel.duration;\n      channel.time *= channel.rate;\n    }\n  }\n}\n","/** @type {import('@luma.gl/engine').KeyFrames} */\n\nexport class KeyFrames {\n  constructor(keyFrames) {\n    this._lastTime = -1;\n    this.startIndex = -1;\n    this.endIndex = -1;\n    this.factor = 0;\n    this.times = [];\n    this.values = [];\n    this.setKeyFrames(keyFrames);\n    this.setTime(0);\n  }\n\n  setKeyFrames(keyFrames) {\n    const numKeys = keyFrames.length;\n    this.times.length = numKeys;\n    this.values.length = numKeys;\n\n    for (let i = 0; i < numKeys; ++i) {\n      this.times[i] = keyFrames[i][0];\n      this.values[i] = keyFrames[i][1];\n    }\n\n    this._calculateKeys(this._lastTime);\n  }\n\n  setTime(time) {\n    time = Math.max(0, time);\n\n    if (time !== this._lastTime) {\n      this._calculateKeys(time);\n      this._lastTime = time;\n    }\n  }\n\n  getStartTime() {\n    return this.times[this.startIndex];\n  }\n\n  getEndTime() {\n    return this.times[this.endIndex];\n  }\n\n  getStartData() {\n    return this.values[this.startIndex];\n  }\n\n  getEndData() {\n    return this.values[this.endIndex];\n  }\n\n  _calculateKeys(time) {\n    let index = 0;\n    const numKeys = this.times.length;\n\n    for (index = 0; index < numKeys - 2; ++index) {\n      if (this.times[index + 1] > time) {\n        break;\n      }\n    }\n\n    this.startIndex = index;\n    this.endIndex = index + 1;\n\n    const startTime = this.times[this.startIndex];\n    const endTime = this.times[this.endIndex];\n    this.factor = Math.min(Math.max(0, (time - startTime) / (endTime - startTime)), 1);\n  }\n}\n","// ClipSpace\nimport GL from '@luma.gl/constants';\nimport Model from '../lib/model';\nimport Geometry from '../geometry/geometry';\n\nconst CLIPSPACE_VERTEX_SHADER = `\\\nattribute vec2 aClipSpacePosition;\nattribute vec2 aTexCoord;\nattribute vec2 aCoordinate;\n\nvarying vec2 position;\nvarying vec2 coordinate;\nvarying vec2 uv;\n\nvoid main(void) {\n  gl_Position = vec4(aClipSpacePosition, 0., 1.);\n  position = aClipSpacePosition;\n  coordinate = aCoordinate;\n  uv = aTexCoord;\n}\n`;\n\n/* eslint-disable indent, no-multi-spaces */\nconst POSITIONS = [-1, -1, 1, -1, -1, 1, 1, 1];\n\nexport default class ClipSpace extends Model {\n  constructor(gl, opts) {\n    const TEX_COORDS = POSITIONS.map(coord => (coord === -1 ? 0 : coord));\n\n    super(\n      gl,\n      Object.assign({}, opts, {\n        vs: CLIPSPACE_VERTEX_SHADER,\n        geometry: new Geometry({\n          drawMode: GL.TRIANGLE_STRIP,\n          vertexCount: 4,\n          attributes: {\n            aClipSpacePosition: {size: 2, value: new Float32Array(POSITIONS)},\n            aTexCoord: {size: 2, value: new Float32Array(TEX_COORDS)},\n            aCoordinate: {size: 2, value: new Float32Array(TEX_COORDS)}\n          }\n        })\n      })\n    );\n    this.setVertexCount(4);\n  }\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {fp32} from '@luma.gl/core';\nimport geometry from '../misc/geometry';\nimport projectShader from './project.glsl';\nimport {getUniformsFromViewport} from './viewport-uniforms';\n\nconst INITIAL_MODULE_OPTIONS = {};\n\nfunction getUniforms(opts = INITIAL_MODULE_OPTIONS) {\n  if (opts.viewport) {\n    return getUniformsFromViewport(opts);\n  }\n  return {};\n}\n\nexport default {\n  name: 'project',\n  dependencies: [fp32, geometry],\n  vs: projectShader,\n  getUniforms\n};\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nconst vs = `\nstruct VertexGeometry {\n  vec4 position;\n  vec3 worldPosition;\n  vec3 worldPositionAlt;\n  vec3 normal;\n  vec2 uv;\n  vec3 pickingColor;\n} geometry = VertexGeometry(\n  vec4(0.0),\n  vec3(0.0),\n  vec3(0.0),\n  vec3(0.0),\n  vec2(0.0),\n  vec3(0.0)\n);\n`;\n\nconst fs = `\n#define SMOOTH_EDGE_RADIUS 0.5\n\nstruct FragmentGeometry {\n  vec2 uv;\n} geometry;\n\nfloat smoothedge(float edge, float x) {\n  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);\n}\n`;\n\nexport default {name: 'geometry', vs, fs};\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {COORDINATE_SYSTEM, PROJECTION_MODE, UNIT} from '../../lib/constants';\n\n// We are generating these from the js code in constants.js\nconst COORDINATE_SYSTEM_GLSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM)\n  .map(key => `const int COORDINATE_SYSTEM_${key} = ${COORDINATE_SYSTEM[key]};`)\n  .join('');\nconst PROJECTION_MODE_GLSL_CONSTANTS = Object.keys(PROJECTION_MODE)\n  .map(key => `const int PROJECTION_MODE_${key} = ${PROJECTION_MODE[key]};`)\n  .join('');\nconst UNIT_GLSL_CONSTANTS = Object.keys(UNIT)\n  .map(key => `const int UNIT_${key.toUpperCase()} = ${UNIT[key]};`)\n  .join('');\n\nexport default `\\\n${COORDINATE_SYSTEM_GLSL_CONSTANTS}\n${PROJECTION_MODE_GLSL_CONSTANTS}\n${UNIT_GLSL_CONSTANTS}\n\nuniform int project_uCoordinateSystem;\nuniform int project_uProjectionMode;\nuniform float project_uScale;\nuniform bool project_uWrapLongitude;\nuniform vec3 project_uCommonUnitsPerMeter;\nuniform vec3 project_uCommonUnitsPerWorldUnit;\nuniform vec3 project_uCommonUnitsPerWorldUnit2;\nuniform vec4 project_uCenter;\nuniform mat4 project_uModelMatrix;\nuniform mat4 project_uViewProjectionMatrix;\nuniform vec2 project_uViewportSize;\nuniform float project_uDevicePixelRatio;\nuniform float project_uFocalDistance;\nuniform vec3 project_uCameraPosition;\nuniform vec3 project_uCoordinateOrigin;\nuniform vec3 project_uCommonOrigin;\nuniform bool project_uPseudoMeters;\n\nconst float TILE_SIZE = 512.0;\nconst float PI = 3.1415926536;\nconst float WORLD_SCALE = TILE_SIZE / (PI * 2.0);\nconst vec3 ZERO_64_LOW = vec3(0.0);\nconst float EARTH_RADIUS = 6370972.0; // meters\nconst float GLOBE_RADIUS = 256.0;\n\n// returns an adjustment factor for uCommonUnitsPerMeter\nfloat project_size() {\n  if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR &&\n    project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT &&\n    project_uPseudoMeters == false) {\n\n    // uCommonUnitsPerMeter in low-zoom Web Mercator is non-linear\n    // Adjust by 1 / cos(latitude)\n    // If geometry.position (vertex in common space) is populated, use it\n    // Otherwise use geometry.worldPosition (anchor in world space)\n    \n    if (geometry.position.w == 0.0) {\n      float y = clamp(geometry.worldPosition.y, -89.9, 89.9);\n      return 1.0 / cos(radians(y));\n    }\n\n    // latitude from common y: 2.0 * (atan(exp(y / TILE_SIZE * 2.0 * PI - PI)) - PI / 4.0)\n    // Taylor series of 1 / cos(latitude)\n    // Max error < 0.003\n  \n    float y = geometry.position.y / TILE_SIZE * 2.0 - 1.0;\n    float y2 = y * y;\n    float y4 = y2 * y2;\n    float y6 = y4 * y2;\n    return 1.0 + 4.9348 * y2 + 4.0587 * y4 + 1.5642 * y6;\n  }\n  return 1.0;\n}\n//\n// Scaling offsets - scales meters to \"world distance\"\n// Note the scalar version of project_size is for scaling the z component only\n//\nfloat project_size(float meters) {\n  return meters * project_uCommonUnitsPerMeter.z * project_size();\n}\n\nvec2 project_size(vec2 meters) {\n  return meters * project_uCommonUnitsPerMeter.xy * project_size();\n}\n\nvec3 project_size(vec3 meters) {\n  return meters * project_uCommonUnitsPerMeter * project_size();\n}\n\nvec4 project_size(vec4 meters) {\n  return vec4(meters.xyz * project_uCommonUnitsPerMeter, meters.w);\n}\n\n//\n// Projecting normal - transform deltas from current coordinate system to\n// normals in the worldspace\n//\nvec3 project_normal(vec3 vector) {\n  // Apply model matrix\n  vec4 normal_modelspace = project_uModelMatrix * vec4(vector, 0.0);\n  return normalize(normal_modelspace.xyz * project_uCommonUnitsPerMeter);\n}\n\nvec4 project_offset_(vec4 offset) {\n  float dy = offset.y;\n  vec3 commonUnitsPerWorldUnit = project_uCommonUnitsPerWorldUnit + project_uCommonUnitsPerWorldUnit2 * dy;\n  return vec4(offset.xyz * commonUnitsPerWorldUnit, offset.w);\n}\n\n//\n// Projecting positions - non-linear projection: lnglats => unit tile [0-1, 0-1]\n//\nvec2 project_mercator_(vec2 lnglat) {\n  float x = lnglat.x;\n  if (project_uWrapLongitude) {\n    x = mod(x + 180., 360.0) - 180.;\n  }\n  float y = clamp(lnglat.y, -89.9, 89.9);\n  return vec2(\n    radians(x) + PI,\n    PI + log(tan_fp32(PI * 0.25 + radians(y) * 0.5))\n  ) * WORLD_SCALE;\n}\n\nvec3 project_globe_(vec3 lnglatz) {\n  float lambda = radians(lnglatz.x);\n  float phi = radians(lnglatz.y);\n  float cosPhi = cos(phi);\n  float D = (lnglatz.z / EARTH_RADIUS + 1.0) * GLOBE_RADIUS;\n\n  return vec3(\n    sin(lambda) * cosPhi,\n    -cos(lambda) * cosPhi,\n    sin(phi)\n  ) * D;\n}\n\n//\n// Projects positions (defined by project_uCoordinateSystem) to common space (defined by project_uProjectionMode)\n//\nvec4 project_position(vec4 position, vec3 position64Low) {\n  vec4 position_world = project_uModelMatrix * position;\n\n  // Work around for a Mac+NVIDIA bug https://github.com/visgl/deck.gl/issues/4145\n  if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR) {\n    if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n      return vec4(\n        project_mercator_(position_world.xy),\n        project_size(position_world.z),\n        position_world.w\n      );\n    }\n    if (project_uCoordinateSystem == COORDINATE_SYSTEM_CARTESIAN) {\n      position_world.xyz += project_uCoordinateOrigin;\n    }\n  }\n  if (project_uProjectionMode == PROJECTION_MODE_GLOBE) {\n    if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n      return vec4(\n        project_globe_(position_world.xyz),\n        position_world.w\n      );\n    }\n  }\n  if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {\n    if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n      if (abs(position_world.y - project_uCoordinateOrigin.y) > 0.25) {\n        // Too far from the projection center for offset mode to be accurate\n        // Only use high parts\n        return vec4(\n          project_mercator_(position_world.xy) - project_uCommonOrigin.xy,\n          project_size(position_world.z),\n          position_world.w\n        );\n      }\n    }\n  }\n  if (project_uProjectionMode == PROJECTION_MODE_IDENTITY ||\n    (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET &&\n    (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT ||\n     project_uCoordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) {\n    // Subtract high part of 64 bit value. Convert remainder to float32, preserving precision.\n    position_world.xyz -= project_uCoordinateOrigin;\n  }\n\n  // Translation is already added to the high parts\n  return project_offset_(position_world + project_uModelMatrix * vec4(position64Low, 0.0));\n}\n\nvec4 project_position(vec4 position) {\n  return project_position(position, ZERO_64_LOW);\n}\n\nvec3 project_position(vec3 position, vec3 position64Low) {\n  vec4 projected_position = project_position(vec4(position, 1.0), position64Low);\n  return projected_position.xyz;\n}\n\nvec3 project_position(vec3 position) {\n  vec4 projected_position = project_position(vec4(position, 1.0), ZERO_64_LOW);\n  return projected_position.xyz;\n}\n\nvec2 project_position(vec2 position) {\n  vec4 projected_position = project_position(vec4(position, 0.0, 1.0), ZERO_64_LOW);\n  return projected_position.xy;\n}\n\nvec4 project_common_position_to_clipspace(vec4 position, mat4 viewProjectionMatrix, vec4 center) {\n  return viewProjectionMatrix * position + center;\n}\n\n//\n// Projects from common space coordinates to clip space.\n// Uses project_uViewProjectionMatrix\n//\nvec4 project_common_position_to_clipspace(vec4 position) {\n  return project_common_position_to_clipspace(position, project_uViewProjectionMatrix, project_uCenter);\n}\n\n// Returns a clip space offset that corresponds to a given number of screen pixels\nvec2 project_pixel_size_to_clipspace(vec2 pixels) {\n  vec2 offset = pixels / project_uViewportSize * project_uDevicePixelRatio * 2.0;\n  return offset * project_uFocalDistance;\n}\n\nfloat project_size_to_pixel(float meters) {\n  return project_size(meters) * project_uScale;\n}\nfloat project_size_to_pixel(float size, int unit) {\n  if (unit == UNIT_METERS) return project_size_to_pixel(size);\n  if (unit == UNIT_COMMON) return size * project_uScale;\n  // UNIT_PIXELS\n  return size;\n}\nfloat project_pixel_size(float pixels) {\n  return pixels / project_uScale;\n}\nvec2 project_pixel_size(vec2 pixels) {\n  return pixels / project_uScale;\n}\n\n// Get rotation matrix that aligns the z axis with the given up vector\n// Find 3 unit vectors ux, uy, uz that are perpendicular to each other and uz == up\nmat3 project_get_orientation_matrix(vec3 up) {\n  vec3 uz = normalize(up);\n  // Tangent on XY plane\n  vec3 ux = abs(uz.z) == 1.0 ? vec3(1.0, 0.0, 0.0) : normalize(vec3(uz.y, -uz.x, 0));\n  vec3 uy = cross(uz, ux);\n  return mat3(ux, uy, uz);\n}\n\nbool project_needs_rotation(vec3 commonPosition, out mat3 transform) {\n  if (project_uProjectionMode == PROJECTION_MODE_GLOBE) {\n    transform = project_get_orientation_matrix(commonPosition);\n    return true;\n  }\n  return false;\n}\n`;\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// Note: The numeric values here are matched by shader code in the\n// \"project\" and \"project64\" shader modules. Both places need to be\n// updated.\nimport log from '../utils/log';\n\n// Describes the format of positions\nexport const COORDINATE_SYSTEM = {\n  // `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise\n  DEFAULT: -1,\n  // Positions are interpreted as [lng, lat, elevation]\n  // lng lat are degrees, elevation is meters. distances as meters.\n  LNGLAT: 1,\n\n  // Positions are interpreted as meter offsets, distances as meters\n  METER_OFFSETS: 2,\n\n  // Positions are interpreted as lng lat offsets: [deltaLng, deltaLat, elevation]\n  // deltaLng, deltaLat are delta degrees, elevation is meters.\n  // distances as meters.\n  LNGLAT_OFFSETS: 3,\n\n  // Non-geospatial\n  CARTESIAN: 0\n};\n\n// Deprecated\n/* eslint-disable accessor-pairs */\nObject.defineProperty(COORDINATE_SYSTEM, 'IDENTITY', {\n  get: () => log.deprecated('COORDINATE_SYSTEM.IDENTITY', 'COORDINATE_SYSTEM.CARTESIAN')() || 0\n});\n/* eslint-enable accessor-pairs */\n\n// Describes the common space\nexport const PROJECTION_MODE = {\n  WEB_MERCATOR: 1,\n  GLOBE: 2,\n\n  // This is automatically assigned by the project module\n  WEB_MERCATOR_AUTO_OFFSET: 4,\n\n  IDENTITY: 0\n};\n\nexport const UNIT = {\n  common: 0,\n  meters: 1,\n  pixels: 2\n};\n\nexport const EVENTS = {\n  click: {handler: 'onClick'},\n  panstart: {handler: 'onDragStart'},\n  panmove: {handler: 'onDrag'},\n  panend: {handler: 'onDragEnd'}\n};\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n/* eslint-disable complexity */\n\nimport * as mat4 from 'gl-matrix/mat4';\nimport * as vec4 from 'gl-matrix/vec4';\n\nimport {COORDINATE_SYSTEM, PROJECTION_MODE} from '../../lib/constants';\n\nimport memoize from '../../utils/memoize';\n\n// To quickly set a vector to zero\nconst ZERO_VECTOR = [0, 0, 0, 0];\n// 4x4 matrix that drops 4th component of vector\nconst VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0];\nconst IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\nconst DEFAULT_PIXELS_PER_UNIT2 = [0, 0, 0];\nconst DEFAULT_COORDINATE_ORIGIN = [0, 0, 0];\n\nconst getMemoizedViewportUniforms = memoize(calculateViewportUniforms);\n\nexport function getOffsetOrigin(\n  viewport,\n  coordinateSystem,\n  coordinateOrigin = DEFAULT_COORDINATE_ORIGIN\n) {\n  let shaderCoordinateOrigin = coordinateOrigin;\n  let geospatialOrigin;\n  let offsetMode = true;\n\n  if (\n    coordinateSystem === COORDINATE_SYSTEM.LNGLAT_OFFSETS ||\n    coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS\n  ) {\n    geospatialOrigin = coordinateOrigin;\n  } else {\n    geospatialOrigin = viewport.isGeospatial\n      ? [Math.fround(viewport.longitude), Math.fround(viewport.latitude), 0]\n      : null;\n  }\n\n  switch (viewport.projectionMode) {\n    case PROJECTION_MODE.WEB_MERCATOR:\n      if (\n        coordinateSystem === COORDINATE_SYSTEM.LNGLAT ||\n        coordinateSystem === COORDINATE_SYSTEM.CARTESIAN\n      ) {\n        geospatialOrigin = [0, 0, 0];\n        offsetMode = false;\n      }\n      break;\n\n    case PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET:\n      if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT) {\n        // viewport center in world space\n        shaderCoordinateOrigin = geospatialOrigin;\n      } else if (coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) {\n        // viewport center in common space\n        shaderCoordinateOrigin = [\n          Math.fround(viewport.center[0]),\n          Math.fround(viewport.center[1]),\n          0\n        ];\n        // Geospatial origin (wgs84) must match shaderCoordinateOrigin (common)\n        geospatialOrigin = viewport.unprojectPosition(shaderCoordinateOrigin);\n        shaderCoordinateOrigin[0] -= coordinateOrigin[0];\n        shaderCoordinateOrigin[1] -= coordinateOrigin[1];\n        shaderCoordinateOrigin[2] -= coordinateOrigin[2];\n      }\n      break;\n\n    case PROJECTION_MODE.IDENTITY:\n      shaderCoordinateOrigin = viewport.position.map(Math.fround);\n      break;\n\n    case PROJECTION_MODE.GLOBE:\n      offsetMode = false;\n      geospatialOrigin = null;\n      break;\n\n    default:\n      // Unknown projection mode\n      offsetMode = false;\n  }\n\n  shaderCoordinateOrigin[2] = shaderCoordinateOrigin[2] || 0;\n\n  return {geospatialOrigin, shaderCoordinateOrigin, offsetMode};\n}\n\n// The code that utilizes Matrix4 does the same calculation as their mat4 counterparts,\n// has lower performance but provides error checking.\nfunction calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin) {\n  const {viewMatrixUncentered, projectionMatrix} = viewport;\n  let {viewMatrix, viewProjectionMatrix} = viewport;\n\n  let projectionCenter = ZERO_VECTOR;\n  let originCommon = ZERO_VECTOR;\n  let cameraPosCommon = viewport.cameraPosition;\n  const {geospatialOrigin, shaderCoordinateOrigin, offsetMode} = getOffsetOrigin(\n    viewport,\n    coordinateSystem,\n    coordinateOrigin\n  );\n\n  if (offsetMode) {\n    // Calculate transformed projectionCenter (using 64 bit precision JS)\n    // This is the key to offset mode precision\n    // (avoids doing this addition in 32 bit precision in GLSL)\n    originCommon = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin);\n\n    cameraPosCommon = [\n      cameraPosCommon[0] - originCommon[0],\n      cameraPosCommon[1] - originCommon[1],\n      cameraPosCommon[2] - originCommon[2]\n    ];\n\n    originCommon[3] = 1;\n\n    // projectionCenter = new Matrix4(viewProjectionMatrix)\n    //   .transformVector([positionPixels[0], positionPixels[1], 0.0, 1.0]);\n    projectionCenter = vec4.transformMat4([], originCommon, viewProjectionMatrix);\n\n    // Always apply uncentered projection matrix if available (shader adds center)\n    viewMatrix = viewMatrixUncentered || viewMatrix;\n\n    // Zero out 4th coordinate (\"after\" model matrix) - avoids further translations\n    // viewMatrix = new Matrix4(viewMatrixUncentered || viewMatrix)\n    //   .multiplyRight(VECTOR_TO_POINT_MATRIX);\n    viewProjectionMatrix = mat4.multiply([], projectionMatrix, viewMatrix);\n    viewProjectionMatrix = mat4.multiply([], viewProjectionMatrix, VECTOR_TO_POINT_MATRIX);\n  }\n\n  return {\n    viewMatrix,\n    viewProjectionMatrix,\n    projectionCenter,\n    originCommon,\n    cameraPosCommon,\n    shaderCoordinateOrigin,\n    geospatialOrigin\n  };\n}\n\n/**\n * Returns uniforms for shaders based on current projection\n * includes: projection matrix suitable for shaders\n *\n * TODO - Ensure this works with any viewport, not just WebMercatorViewports\n *\n * @param {WebMercatorViewport} viewport -\n * @return {Float32Array} - 4x4 projection matrix that can be used in shaders\n */\nexport function getUniformsFromViewport({\n  viewport,\n  devicePixelRatio = 1,\n  modelMatrix = null,\n  // Match Layer.defaultProps\n  coordinateSystem = COORDINATE_SYSTEM.DEFAULT,\n  coordinateOrigin,\n  autoWrapLongitude = false\n} = {}) {\n  if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) {\n    coordinateSystem = viewport.isGeospatial\n      ? COORDINATE_SYSTEM.LNGLAT\n      : COORDINATE_SYSTEM.CARTESIAN;\n  }\n\n  const uniforms = getMemoizedViewportUniforms({\n    viewport,\n    devicePixelRatio,\n    coordinateSystem,\n    coordinateOrigin\n  });\n\n  uniforms.project_uWrapLongitude = autoWrapLongitude;\n  uniforms.project_uModelMatrix = modelMatrix || IDENTITY_MATRIX;\n\n  return uniforms;\n}\n\nfunction calculateViewportUniforms({\n  viewport,\n  devicePixelRatio,\n  coordinateSystem,\n  coordinateOrigin\n}) {\n  const {\n    projectionCenter,\n    viewProjectionMatrix,\n    originCommon,\n    cameraPosCommon,\n    shaderCoordinateOrigin,\n    geospatialOrigin\n  } = calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin);\n\n  // Calculate projection pixels per unit\n  const distanceScales = viewport.getDistanceScales();\n\n  const viewportSize = [viewport.width * devicePixelRatio, viewport.height * devicePixelRatio];\n\n  // Distance at which screen pixels are projected.\n  // Used to scale sizes in clipspace to match screen pixels.\n  // When using Viewport class's default projection matrix, this yields 1 for orthographic\n  // and `viewport.focalDistance` for perspective views\n  const focalDistance =\n    viewport.projectionMatrix.transform([0, 0, -viewport.focalDistance, 1])[3] || 1;\n\n  const uniforms = {\n    // Projection mode values\n    project_uCoordinateSystem: coordinateSystem,\n    project_uProjectionMode: viewport.projectionMode,\n    project_uCoordinateOrigin: shaderCoordinateOrigin,\n    project_uCommonOrigin: originCommon.slice(0, 3),\n    project_uCenter: projectionCenter,\n\n    // Backward compatibility\n    // TODO: remove in v9\n    project_uPseudoMeters: Boolean(viewport._pseudoMeters),\n\n    // Screen size\n    project_uViewportSize: viewportSize,\n    project_uDevicePixelRatio: devicePixelRatio,\n\n    project_uFocalDistance: focalDistance,\n    project_uCommonUnitsPerMeter: distanceScales.unitsPerMeter,\n    project_uCommonUnitsPerWorldUnit: distanceScales.unitsPerMeter,\n    project_uCommonUnitsPerWorldUnit2: DEFAULT_PIXELS_PER_UNIT2,\n    project_uScale: viewport.scale, // This is the mercator scale (2 ** zoom)\n\n    project_uViewProjectionMatrix: viewProjectionMatrix,\n\n    // This is for lighting calculations\n    project_uCameraPosition: cameraPosCommon\n  };\n\n  if (geospatialOrigin) {\n    const distanceScalesAtOrigin = viewport.getDistanceScales(geospatialOrigin);\n    switch (coordinateSystem) {\n      case COORDINATE_SYSTEM.METER_OFFSETS:\n        uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerMeter;\n        uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerMeter2;\n        break;\n\n      case COORDINATE_SYSTEM.LNGLAT:\n      case COORDINATE_SYSTEM.LNGLAT_OFFSETS:\n        if (!viewport._pseudoMeters) {\n          uniforms.project_uCommonUnitsPerMeter = distanceScalesAtOrigin.unitsPerMeter;\n        }\n        uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerDegree;\n        uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerDegree2;\n        break;\n\n      // a.k.a \"preprojected\" positions\n      case COORDINATE_SYSTEM.CARTESIAN:\n        uniforms.project_uCommonUnitsPerWorldUnit = [1, 1, distanceScalesAtOrigin.unitsPerMeter[2]];\n        uniforms.project_uCommonUnitsPerWorldUnit2 = [\n          0,\n          0,\n          distanceScalesAtOrigin.unitsPerMeter2[2]\n        ];\n        break;\n\n      default:\n        break;\n    }\n  }\n\n  return uniforms;\n}\n","function isEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (Array.isArray(a)) {\n    // Special treatment for arrays: compare 1-level deep\n    // This is to support equality of matrix/coordinate props\n    const len = a.length;\n    if (!b || b.length !== len) {\n      return false;\n    }\n\n    for (let i = 0; i < len; i++) {\n      if (a[i] !== b[i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n  return false;\n}\n\n/**\n * Speed up consecutive function calls by caching the result of calls with identical input\n * https://en.wikipedia.org/wiki/Memoization\n * @param {function} compute - the function to be memoized\n */\nexport default function memoize(compute) {\n  let cachedArgs = {};\n  let cachedResult;\n\n  return args => {\n    for (const key in args) {\n      if (!isEqual(args[key], cachedArgs[key])) {\n        cachedResult = compute(args);\n        cachedArgs = args;\n        break;\n      }\n    }\n    return cachedResult;\n  };\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport project from '../project/project';\n\nconst vs = `\nvec4 project_position_to_clipspace(\n  vec3 position, vec3 position64Low, vec3 offset, out vec4 commonPosition\n) {\n  vec3 projectedPosition = project_position(position, position64Low);\n  if (project_uProjectionMode == PROJECTION_MODE_GLOBE) {\n    // offset is specified as ENU\n    // when in globe projection, rotate offset so that the ground alighs with the surface of the globe\n    mat3 rotation = project_get_orientation_matrix(projectedPosition);\n    offset = rotation * offset;\n  }\n  commonPosition = vec4(projectedPosition + offset, 1.0);\n  return project_common_position_to_clipspace(commonPosition);\n}\n\nvec4 project_position_to_clipspace(\n  vec3 position, vec3 position64Low, vec3 offset\n) {\n  vec4 commonPosition;\n  return project_position_to_clipspace(position, position64Low, offset, commonPosition);\n}\n`;\n\nexport default {\n  name: 'project32',\n  dependencies: [project],\n  vs\n};\n","// Copyright (c) 2015-2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\nimport {COORDINATE_SYSTEM, PROJECTION_MODE} from '../../lib/constants';\nimport project from '../project/project';\nimport {Vector3, Matrix4} from 'math.gl';\nimport memoize from '../../utils/memoize';\nimport {pixelsToWorld} from '@math.gl/web-mercator';\n\nconst vs = `\nconst int max_lights = 2;\nuniform mat4 shadow_uViewProjectionMatrices[max_lights];\nuniform vec4 shadow_uProjectCenters[max_lights];\nuniform bool shadow_uDrawShadowMap;\nuniform bool shadow_uUseShadowMap;\nuniform int shadow_uLightId;\nuniform float shadow_uLightCount;\n\nvarying vec3 shadow_vPosition[max_lights];\n\nvec4 shadow_setVertexPosition(vec4 position_commonspace) {\n  if (shadow_uDrawShadowMap) {\n    return project_common_position_to_clipspace(position_commonspace, shadow_uViewProjectionMatrices[shadow_uLightId], shadow_uProjectCenters[shadow_uLightId]);\n  }\n  if (shadow_uUseShadowMap) {\n    for (int i = 0; i < max_lights; i++) {\n      if(i < int(shadow_uLightCount)) {\n        vec4 shadowMap_position = project_common_position_to_clipspace(position_commonspace, shadow_uViewProjectionMatrices[i], shadow_uProjectCenters[i]);\n        shadow_vPosition[i] = (shadowMap_position.xyz / shadowMap_position.w + 1.0) / 2.0;\n      }\n    }\n  }\n  return gl_Position;\n}\n`;\n\nconst fs = `\nconst int max_lights = 2;\nuniform bool shadow_uDrawShadowMap;\nuniform bool shadow_uUseShadowMap;\nuniform sampler2D shadow_uShadowMap0;\nuniform sampler2D shadow_uShadowMap1;\nuniform vec4 shadow_uColor;\nuniform float shadow_uLightCount;\n\nvarying vec3 shadow_vPosition[max_lights];\n\nconst vec4 bitPackShift = vec4(1.0, 255.0, 65025.0, 16581375.0);\nconst vec4 bitUnpackShift = 1.0 / bitPackShift;\nconst vec4 bitMask = vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0,  0.0);\n\nfloat shadow_getShadowWeight(vec3 position, sampler2D shadowMap) {\n  vec4 rgbaDepth = texture2D(shadowMap, position.xy);\n\n  float z = dot(rgbaDepth, bitUnpackShift);\n  return smoothstep(0.001, 0.01, position.z - z);\n}\n\nvec4 shadow_filterShadowColor(vec4 color) {\n  if (shadow_uDrawShadowMap) {\n    vec4 rgbaDepth = fract(gl_FragCoord.z * bitPackShift);\n    rgbaDepth -= rgbaDepth.gbaa * bitMask;\n    return rgbaDepth;\n  }\n  if (shadow_uUseShadowMap) {\n    float shadowAlpha = 0.0;\n    shadowAlpha += shadow_getShadowWeight(shadow_vPosition[0], shadow_uShadowMap0);\n    if(shadow_uLightCount > 1.0) {\n      shadowAlpha += shadow_getShadowWeight(shadow_vPosition[1], shadow_uShadowMap1);\n    }\n    shadowAlpha *= shadow_uColor.a / shadow_uLightCount;\n    float blendedAlpha = shadowAlpha + color.a * (1.0 - shadowAlpha);\n\n    return vec4(\n      mix(color.rgb, shadow_uColor.rgb, shadowAlpha / blendedAlpha),\n      blendedAlpha\n    );\n  }\n  return color;\n}\n`;\n\nconst getMemoizedViewportCenterPosition = memoize(getViewportCenterPosition);\nconst getMemoizedViewProjectionMatrices = memoize(getViewProjectionMatrices);\n\nconst DEFAULT_SHADOW_COLOR = [0, 0, 0, 1.0];\nconst VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0];\n\nfunction screenToCommonSpace(xyz, pixelUnprojectionMatrix) {\n  const [x, y, z] = xyz;\n  const coord = pixelsToWorld([x, y, z], pixelUnprojectionMatrix);\n\n  if (Number.isFinite(z)) {\n    return coord;\n  }\n  return [coord[0], coord[1], 0];\n}\n\nfunction getViewportCenterPosition({viewport, center}) {\n  return new Matrix4(viewport.viewProjectionMatrix).invert().transform(center);\n}\n\nfunction getViewProjectionMatrices({viewport, shadowMatrices}) {\n  const projectionMatrices = [];\n  const pixelUnprojectionMatrix = viewport.pixelUnprojectionMatrix;\n  const farZ = viewport.isGeospatial ? undefined : 1;\n  const corners = [\n    [0, 0, farZ], // top left ground\n    [viewport.width, 0, farZ], // top right ground\n    [0, viewport.height, farZ], // bottom left ground\n    [viewport.width, viewport.height, farZ], // bottom right ground\n    [0, 0, -1], // top left near\n    [viewport.width, 0, -1], // top right near\n    [0, viewport.height, -1], // bottom left near\n    [viewport.width, viewport.height, -1] // bottom right near\n  ].map(pixel => screenToCommonSpace(pixel, pixelUnprojectionMatrix));\n\n  for (const shadowMatrix of shadowMatrices) {\n    const viewMatrix = shadowMatrix.clone().translate(new Vector3(viewport.center).negate());\n    const positions = corners.map(corner => viewMatrix.transform(corner));\n    const projectionMatrix = new Matrix4().ortho({\n      left: Math.min(...positions.map(position => position[0])),\n      right: Math.max(...positions.map(position => position[0])),\n      bottom: Math.min(...positions.map(position => position[1])),\n      top: Math.max(...positions.map(position => position[1])),\n      near: Math.min(...positions.map(position => -position[2])),\n      far: Math.max(...positions.map(position => -position[2]))\n    });\n    projectionMatrices.push(projectionMatrix.multiplyRight(shadowMatrix));\n  }\n  return projectionMatrices;\n}\n\nfunction createShadowUniforms(opts = {}, context = {}) {\n  const uniforms = {\n    shadow_uDrawShadowMap: Boolean(opts.drawToShadowMap),\n    shadow_uUseShadowMap: opts.shadowMaps ? opts.shadowMaps.length > 0 : false,\n    shadow_uColor: opts.shadowColor || DEFAULT_SHADOW_COLOR,\n    shadow_uLightId: opts.shadowLightId || 0,\n    shadow_uLightCount: opts.shadowMatrices.length\n  };\n\n  const center = getMemoizedViewportCenterPosition({\n    viewport: opts.viewport,\n    center: context.project_uCenter\n  });\n\n  const projectCenters = [];\n  const viewProjectionMatrices = getMemoizedViewProjectionMatrices({\n    shadowMatrices: opts.shadowMatrices,\n    viewport: opts.viewport\n  }).slice();\n\n  for (let i = 0; i < opts.shadowMatrices.length; i++) {\n    const viewProjectionMatrix = viewProjectionMatrices[i];\n    const viewProjectionMatrixCentered = viewProjectionMatrix\n      .clone()\n      .translate(new Vector3(opts.viewport.center).negate());\n\n    if (\n      context.project_uCoordinateSystem === COORDINATE_SYSTEM.LNGLAT &&\n      context.project_uProjectionMode === PROJECTION_MODE.WEB_MERCATOR\n    ) {\n      viewProjectionMatrices[i] = viewProjectionMatrixCentered;\n      projectCenters[i] = center;\n    } else {\n      viewProjectionMatrices[i] = viewProjectionMatrix\n        .clone()\n        .multiplyRight(VECTOR_TO_POINT_MATRIX);\n      projectCenters[i] = viewProjectionMatrixCentered.transform(center);\n    }\n  }\n\n  for (let i = 0; i < viewProjectionMatrices.length; i++) {\n    uniforms[`shadow_uViewProjectionMatrices[${i}]`] = viewProjectionMatrices[i];\n    uniforms[`shadow_uProjectCenters[${i}]`] = projectCenters[i];\n\n    if (opts.shadowMaps && opts.shadowMaps.length > 0) {\n      uniforms[`shadow_uShadowMap${i}`] = opts.shadowMaps[i];\n    } else {\n      uniforms[`shadow_uShadowMap${i}`] = opts.dummyShadowMap;\n    }\n  }\n  return uniforms;\n}\n\nexport default {\n  name: 'shadow',\n  dependencies: [project],\n  vs,\n  fs,\n  inject: {\n    'vs:DECKGL_FILTER_GL_POSITION': `\n    position = shadow_setVertexPosition(geometry.position);\n    `,\n    'fs:DECKGL_FILTER_COLOR': `\n    color = shadow_filterShadowColor(color);\n    `\n  },\n  getUniforms: (opts = {}, context = {}) => {\n    if (opts.drawToShadowMap || (opts.shadowMaps && opts.shadowMaps.length > 0)) {\n      const {shadowEnabled = true} = opts;\n      return shadowEnabled && opts.shadowMatrices && opts.shadowMatrices.length > 0\n        ? createShadowUniforms(opts, context)\n        : {\n            shadow_uDrawShadowMap: false,\n            shadow_uUseShadowMap: false\n          };\n    }\n    return {};\n  }\n};\n","export * from '@math.gl/core';\n","// Classic web-mercator-project\nexport {default} from './web-mercator-viewport';\nexport {default as WebMercatorViewport} from './web-mercator-viewport';\n\nexport {default as getBounds} from './get-bounds';\nexport {default as fitBounds} from './fit-bounds';\nexport {default as normalizeViewportProps} from './normalize-viewport-props';\nexport {default as flyToViewport, getFlyToDuration} from './fly-to-viewport';\n\nexport {\n  lngLatToWorld,\n  worldToLngLat,\n  worldToPixels,\n  pixelsToWorld,\n  zoomToScale,\n  scaleToZoom,\n  altitudeToFovy,\n  fovyToAltitude,\n  getMeterZoom,\n  getDistanceScales,\n  addMetersToLngLat,\n  getViewMatrix,\n  getProjectionMatrix,\n  getProjectionParameters\n} from './web-mercator-utils';\n","// View and Projection Matrix calculations for mapbox-js style map view properties\nimport {createMat4} from './math-utils';\n\nimport {\n  zoomToScale,\n  pixelsToWorld,\n  lngLatToWorld,\n  worldToLngLat,\n  worldToPixels,\n  altitudeToFovy,\n  fovyToAltitude,\n  DEFAULT_ALTITUDE,\n  getProjectionMatrix,\n  getDistanceScales,\n  getViewMatrix\n} from './web-mercator-utils';\nimport fitBounds from './fit-bounds';\nimport getBounds from './get-bounds';\n\nimport * as mat4 from 'gl-matrix/mat4';\nimport * as vec2 from 'gl-matrix/vec2';\nimport * as vec3 from 'gl-matrix/vec3';\n\nexport default class WebMercatorViewport {\n  // eslint-disable-next-line max-statements\n  constructor(\n    {\n      // Map state\n      width,\n      height,\n      latitude = 0,\n      longitude = 0,\n      zoom = 0,\n      pitch = 0,\n      bearing = 0,\n      altitude = null,\n      fovy = null,\n      position = null,\n      nearZMultiplier = 0.02,\n      farZMultiplier = 1.01\n    } = {width: 1, height: 1}\n  ) {\n    // Silently allow apps to send in 0,0 to facilitate isomorphic render etc\n    width = width || 1;\n    height = height || 1;\n\n    // `fovy` & `altitude` are independent parameters, one for the\n    // projection and the latter for the view matrix. In the past,\n    // the `fovy` was always derived from the `altitude`\n    if (fovy === null && altitude === null) {\n      altitude = DEFAULT_ALTITUDE;\n      fovy = altitudeToFovy(altitude);\n    } else if (fovy === null) {\n      fovy = altitudeToFovy(altitude);\n    } else if (altitude === null) {\n      altitude = fovyToAltitude(fovy);\n    }\n\n    const scale = zoomToScale(zoom);\n    // Altitude - prevent division by 0\n    // TODO - just throw an Error instead?\n    altitude = Math.max(0.75, altitude);\n\n    const distanceScales = getDistanceScales({longitude, latitude});\n\n    const center = lngLatToWorld([longitude, latitude]);\n    center[2] = 0;\n\n    if (position) {\n      vec3.add(center, center, vec3.mul([], position, distanceScales.unitsPerMeter));\n    }\n\n    this.projectionMatrix = getProjectionMatrix({\n      width,\n      height,\n      pitch,\n      fovy,\n      nearZMultiplier,\n      farZMultiplier\n    });\n\n    this.viewMatrix = getViewMatrix({\n      height,\n      scale,\n      center,\n      pitch,\n      bearing,\n      altitude\n    });\n\n    // Save parameters\n    this.width = width;\n    this.height = height;\n    this.scale = scale;\n\n    this.latitude = latitude;\n    this.longitude = longitude;\n    this.zoom = zoom;\n    this.pitch = pitch;\n    this.bearing = bearing;\n    this.altitude = altitude;\n    this.fovy = fovy;\n    this.center = center;\n    this.meterOffset = position || [0, 0, 0];\n\n    this.distanceScales = distanceScales;\n\n    this._initMatrices();\n\n    // Bind methods for easy access\n    this.equals = this.equals.bind(this);\n    this.project = this.project.bind(this);\n    this.unproject = this.unproject.bind(this);\n    this.projectPosition = this.projectPosition.bind(this);\n    this.unprojectPosition = this.unprojectPosition.bind(this);\n\n    Object.freeze(this);\n  }\n\n  _initMatrices() {\n    const {width, height, projectionMatrix, viewMatrix} = this;\n\n    // Note: As usual, matrix operations should be applied in \"reverse\" order\n    // since vectors will be multiplied in from the right during transformation\n    const vpm = createMat4();\n    mat4.multiply(vpm, vpm, projectionMatrix);\n    mat4.multiply(vpm, vpm, viewMatrix);\n    this.viewProjectionMatrix = vpm;\n\n    // Calculate matrices and scales needed for projection\n    /**\n     * Builds matrices that converts preprojected lngLats to screen pixels\n     * and vice versa.\n     * Note: Currently returns bottom-left coordinates!\n     * Note: Starts with the GL projection matrix and adds steps to the\n     *       scale and translate that matrix onto the window.\n     * Note: WebGL controls clip space to screen projection with gl.viewport\n     *       and does not need this step.\n     */\n    const m = createMat4();\n\n    // matrix for conversion from location to screen coordinates\n    mat4.scale(m, m, [width / 2, -height / 2, 1]);\n    mat4.translate(m, m, [1, -1, 0]);\n    mat4.multiply(m, m, vpm);\n\n    const mInverse = mat4.invert(createMat4(), m);\n    if (!mInverse) {\n      throw new Error('Pixel project matrix not invertible');\n    }\n\n    this.pixelProjectionMatrix = m;\n    this.pixelUnprojectionMatrix = mInverse;\n  }\n\n  // Two viewports are equal if width and height are identical, and if\n  // their view and projection matrices are (approximately) equal.\n  equals(viewport) {\n    if (!(viewport instanceof WebMercatorViewport)) {\n      return false;\n    }\n\n    return (\n      viewport.width === this.width &&\n      viewport.height === this.height &&\n      mat4.equals(viewport.projectionMatrix, this.projectionMatrix) &&\n      mat4.equals(viewport.viewMatrix, this.viewMatrix)\n    );\n  }\n\n  // Projects xyz (possibly latitude and longitude) to pixel coordinates in window\n  // using viewport projection parameters\n  project(xyz, {topLeft = true} = {}) {\n    const worldPosition = this.projectPosition(xyz);\n    const coord = worldToPixels(worldPosition, this.pixelProjectionMatrix);\n\n    const [x, y] = coord;\n    const y2 = topLeft ? y : this.height - y;\n    return xyz.length === 2 ? [x, y2] : [x, y2, coord[2]];\n  }\n\n  // Unproject pixel coordinates on screen onto world coordinates,\n  // (possibly [lon, lat]) on map.\n  unproject(xyz, {topLeft = true, targetZ = undefined} = {}) {\n    const [x, y, z] = xyz;\n\n    const y2 = topLeft ? y : this.height - y;\n    const targetZWorld = targetZ && targetZ * this.distanceScales.unitsPerMeter[2];\n    const coord = pixelsToWorld([x, y2, z], this.pixelUnprojectionMatrix, targetZWorld);\n    const [X, Y, Z] = this.unprojectPosition(coord);\n\n    if (Number.isFinite(z)) {\n      return [X, Y, Z];\n    }\n    return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y];\n  }\n\n  // NON_LINEAR PROJECTION HOOKS\n  // Used for web meractor projection\n\n  projectPosition(xyz) {\n    const [X, Y] = lngLatToWorld(xyz);\n    const Z = (xyz[2] || 0) * this.distanceScales.unitsPerMeter[2];\n    return [X, Y, Z];\n  }\n\n  unprojectPosition(xyz) {\n    const [X, Y] = worldToLngLat(xyz);\n    const Z = (xyz[2] || 0) * this.distanceScales.metersPerUnit[2];\n    return [X, Y, Z];\n  }\n\n  // Project [lng,lat] on sphere onto [x,y] on 512*512 Mercator Zoom 0 tile.\n  projectFlat(lngLat) {\n    return lngLatToWorld(lngLat);\n  }\n\n  // Unproject world point [x,y] on map onto {lat, lon} on sphere\n  unprojectFlat(xy) {\n    return worldToLngLat(xy);\n  }\n\n  // Get the map center that place a given [lng, lat] coordinate at screen point [x, y]\n  getMapCenterByLngLatPosition({lngLat, pos}) {\n    const fromLocation = pixelsToWorld(pos, this.pixelUnprojectionMatrix);\n    const toLocation = lngLatToWorld(lngLat);\n\n    const translate = vec2.add([], toLocation, vec2.negate([], fromLocation));\n    const newCenter = vec2.add([], this.center, translate);\n\n    return worldToLngLat(newCenter);\n  }\n\n  // Legacy method name\n  getLocationAtPoint({lngLat, pos}) {\n    return this.getMapCenterByLngLatPosition({lngLat, pos});\n  }\n\n  // Returns a new viewport that fit around the given rectangle.\n  fitBounds(bounds, options = {}) {\n    const {width, height} = this;\n    const {longitude, latitude, zoom} = fitBounds(Object.assign({width, height, bounds}, options));\n    return new WebMercatorViewport({width, height, longitude, latitude, zoom});\n  }\n\n  getBounds(options) {\n    const corners = this.getBoundingRegion(options);\n\n    const west = Math.min(...corners.map((p) => p[0]));\n    const east = Math.max(...corners.map((p) => p[0]));\n    const south = Math.min(...corners.map((p) => p[1]));\n    const north = Math.max(...corners.map((p) => p[1]));\n    return [\n      [west, south],\n      [east, north]\n    ];\n  }\n\n  getBoundingRegion(options = {}) {\n    return getBounds(this, options.z || 0);\n  }\n}\n","import * as vec4 from 'gl-matrix/vec4';\n\n// Helper, avoids low-precision 32 bit matrices from gl-matrix mat4.create()\nexport function createMat4() {\n  return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n}\n\n// Transforms a vec4 with a projection matrix\nexport function transformVector(matrix, vector) {\n  const result = vec4.transformMat4([], vector, matrix);\n  vec4.scale(result, result, 1 / result[3]);\n  return result;\n}\n\nexport function mod(value, divisor) {\n  const modulus = value % divisor;\n  return modulus < 0 ? divisor + modulus : modulus;\n}\n\nexport function lerp(start, end, step) {\n  return step * end + (1 - step) * start;\n}\n\nfunction ieLog2(x) {\n  return Math.log(x) * Math.LOG2E;\n}\n// Handle missing log2 in IE 11\nexport const log2 = Math.log2 || ieLog2;\n","// TODO - THE UTILITIES IN THIS FILE SHOULD BE IMPORTED FROM WEB-MERCATOR-VIEWPORT MODULE\n\nimport {createMat4, transformVector, log2} from './math-utils';\n\nimport * as mat4 from 'gl-matrix/mat4';\nimport * as vec2 from 'gl-matrix/vec2';\nimport * as vec3 from 'gl-matrix/vec3';\nimport assert from './assert';\n\n// CONSTANTS\nconst PI = Math.PI;\nconst PI_4 = PI / 4;\nconst DEGREES_TO_RADIANS = PI / 180;\nconst RADIANS_TO_DEGREES = 180 / PI;\nconst TILE_SIZE = 512;\n// Average circumference (40075 km equatorial, 40007 km meridional)\nconst EARTH_CIRCUMFERENCE = 40.03e6;\n\n// Mapbox default altitude\nexport const DEFAULT_ALTITUDE = 1.5;\n\n/** Util functions **/\nexport function zoomToScale(zoom) {\n  return Math.pow(2, zoom);\n}\n\nexport function scaleToZoom(scale) {\n  return log2(scale);\n}\n\n/**\n * Project [lng,lat] on sphere onto [x,y] on 512*512 Mercator Zoom 0 tile.\n * Performs the nonlinear part of the web mercator projection.\n * Remaining projection is done with 4x4 matrices which also handles\n * perspective.\n *\n * @param lngLat - [lng, lat] coordinates\n *   Specifies a point on the sphere to project onto the map.\n * @return [x,y] coordinates.\n */\nexport function lngLatToWorld([lng, lat]) {\n  assert(Number.isFinite(lng));\n  assert(Number.isFinite(lat) && lat >= -90 && lat <= 90, 'invalid latitude');\n\n  const lambda2 = lng * DEGREES_TO_RADIANS;\n  const phi2 = lat * DEGREES_TO_RADIANS;\n  const x = (TILE_SIZE * (lambda2 + PI)) / (2 * PI);\n  const y = (TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5)))) / (2 * PI);\n  return [x, y];\n}\n\n// Unproject world point [x,y] on map onto {lat, lon} on sphere\nexport function worldToLngLat([x, y]) {\n  const lambda2 = (x / TILE_SIZE) * (2 * PI) - PI;\n  const phi2 = 2 * (Math.atan(Math.exp((y / TILE_SIZE) * (2 * PI) - PI)) - PI_4);\n  return [lambda2 * RADIANS_TO_DEGREES, phi2 * RADIANS_TO_DEGREES];\n}\n\n// Returns the zoom level that gives a 1 meter pixel at a certain latitude\n// 1 = C*cos(y)/2^z/TILE_SIZE = C*cos(y)/2^(z+9)\nexport function getMeterZoom({latitude}) {\n  assert(Number.isFinite(latitude));\n  const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS);\n  return scaleToZoom(EARTH_CIRCUMFERENCE * latCosine) - 9;\n}\n\n/**\n * Calculate distance scales in meters around current lat/lon, both for\n * degrees and pixels.\n * In mercator projection mode, the distance scales vary significantly\n * with latitude.\n */\n\nexport function getDistanceScales({latitude, longitude, highPrecision = false}) {\n  assert(Number.isFinite(latitude) && Number.isFinite(longitude));\n\n  const result = {};\n  const worldSize = TILE_SIZE;\n  const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS);\n\n  /**\n   * Number of pixels occupied by one degree longitude around current lat/lon:\n     unitsPerDegreeX = d(lngLatToWorld([lng, lat])[0])/d(lng)\n       = scale * TILE_SIZE * DEGREES_TO_RADIANS / (2 * PI)\n     unitsPerDegreeY = d(lngLatToWorld([lng, lat])[1])/d(lat)\n       = -scale * TILE_SIZE * DEGREES_TO_RADIANS / cos(lat * DEGREES_TO_RADIANS)  / (2 * PI)\n   */\n  const unitsPerDegreeX = worldSize / 360;\n  const unitsPerDegreeY = unitsPerDegreeX / latCosine;\n\n  /**\n   * Number of pixels occupied by one meter around current lat/lon:\n   */\n  const altUnitsPerMeter = worldSize / EARTH_CIRCUMFERENCE / latCosine;\n\n  /**\n   * LngLat: longitude -> east and latitude -> north (bottom left)\n   * UTM meter offset: x -> east and y -> north (bottom left)\n   * World space: x -> east and y -> south (top left)\n   *\n   * Y needs to be flipped when converting delta degree/meter to delta pixels\n   */\n  result.unitsPerMeter = [altUnitsPerMeter, altUnitsPerMeter, altUnitsPerMeter];\n  result.metersPerUnit = [1 / altUnitsPerMeter, 1 / altUnitsPerMeter, 1 / altUnitsPerMeter];\n\n  result.unitsPerDegree = [unitsPerDegreeX, unitsPerDegreeY, altUnitsPerMeter];\n  result.degreesPerUnit = [1 / unitsPerDegreeX, 1 / unitsPerDegreeY, 1 / altUnitsPerMeter];\n\n  /**\n   * Taylor series 2nd order for 1/latCosine\n     f'(a) * (x - a)\n       = d(1/cos(lat * DEGREES_TO_RADIANS))/d(lat) * dLat\n       = DEGREES_TO_RADIANS * tan(lat * DEGREES_TO_RADIANS) / cos(lat * DEGREES_TO_RADIANS) * dLat\n   */\n  if (highPrecision) {\n    const latCosine2 = (DEGREES_TO_RADIANS * Math.tan(latitude * DEGREES_TO_RADIANS)) / latCosine;\n    const unitsPerDegreeY2 = (unitsPerDegreeX * latCosine2) / 2;\n    const altUnitsPerDegree2 = (worldSize / EARTH_CIRCUMFERENCE) * latCosine2;\n    const altUnitsPerMeter2 = (altUnitsPerDegree2 / unitsPerDegreeY) * altUnitsPerMeter;\n\n    result.unitsPerDegree2 = [0, unitsPerDegreeY2, altUnitsPerDegree2];\n    result.unitsPerMeter2 = [altUnitsPerMeter2, 0, altUnitsPerMeter2];\n  }\n\n  // Main results, used for converting meters to latlng deltas and scaling offsets\n  return result;\n}\n\n/**\n * Offset a lng/lat position by meterOffset (northing, easting)\n */\nexport function addMetersToLngLat(lngLatZ, xyz) {\n  const [longitude, latitude, z0] = lngLatZ;\n  const [x, y, z] = xyz;\n\n  const {unitsPerMeter, unitsPerMeter2} = getDistanceScales({\n    longitude,\n    latitude,\n    highPrecision: true\n  });\n\n  const worldspace = lngLatToWorld(lngLatZ);\n  worldspace[0] += x * (unitsPerMeter[0] + unitsPerMeter2[0] * y);\n  worldspace[1] += y * (unitsPerMeter[1] + unitsPerMeter2[1] * y);\n\n  // @ts-ignore\n  const newLngLat = worldToLngLat(worldspace);\n  const newZ = (z0 || 0) + (z || 0);\n\n  return Number.isFinite(z0) || Number.isFinite(z) ? [newLngLat[0], newLngLat[1], newZ] : newLngLat;\n}\n\n// ATTRIBUTION:\n// view and projection matrix creation is intentionally kept compatible with\n// mapbox-gl's implementation to ensure that seamless interoperation\n// with mapbox and react-map-gl. See: https://github.com/mapbox/mapbox-gl-js\n\nexport function getViewMatrix({\n  // Viewport props\n  height,\n  pitch,\n  bearing,\n  altitude,\n  // Pre-calculated parameters\n  scale,\n  center = null\n}) {\n  // VIEW MATRIX: PROJECTS MERCATOR WORLD COORDINATES\n  // Note that mercator world coordinates typically need to be flipped\n  //\n  // Note: As usual, matrix operation orders should be read in reverse\n  // since vectors will be multiplied from the right during transformation\n  const vm = createMat4();\n\n  // Move camera to altitude (along the pitch & bearing direction)\n  mat4.translate(vm, vm, [0, 0, -altitude]);\n\n  // Rotate by bearing, and then by pitch (which tilts the view)\n  mat4.rotateX(vm, vm, -pitch * DEGREES_TO_RADIANS);\n  mat4.rotateZ(vm, vm, bearing * DEGREES_TO_RADIANS);\n\n  scale /= height;\n  mat4.scale(vm, vm, [scale, scale, scale]);\n\n  if (center) {\n    mat4.translate(vm, vm, vec3.negate([], center));\n  }\n\n  return vm;\n}\n\n// PROJECTION MATRIX PARAMETERS\n// Variable fov (in radians)\nexport function getProjectionParameters({\n  width,\n  height,\n  fovy = altitudeToFovy(DEFAULT_ALTITUDE),\n  altitude,\n  pitch = 0,\n  nearZMultiplier = 1,\n  farZMultiplier = 1\n}) {\n  // For back-compatibility allow field of view to be\n  // derived from altitude\n  if (altitude !== undefined) {\n    fovy = altitudeToFovy(altitude);\n  }\n  const halfFov = 0.5 * fovy * DEGREES_TO_RADIANS;\n  const focalDistance = fovyToAltitude(fovy);\n\n  // Find the distance from the center point to the center top\n  // in focal distance units using law of sines.\n  const pitchRadians = pitch * DEGREES_TO_RADIANS;\n  const topHalfSurfaceDistance =\n    (Math.sin(halfFov) * focalDistance) /\n    Math.sin(Math.min(Math.max(Math.PI / 2 - pitchRadians - halfFov, 0.01), Math.PI - 0.01));\n\n  // Calculate z value of the farthest fragment that should be rendered.\n  const farZ = Math.sin(pitchRadians) * topHalfSurfaceDistance + focalDistance;\n\n  return {\n    fov: 2 * halfFov,\n    aspect: width / height,\n    focalDistance,\n    near: nearZMultiplier,\n    far: farZ * farZMultiplier\n  };\n}\n\n// PROJECTION MATRIX: PROJECTS FROM CAMERA (VIEW) SPACE TO CLIPSPACE\n// To match mapbox's z buffer:\n// <= 0.28 - nearZMultiplier: 0.1, farZmultiplier: 1\n// >= 0.29 - nearZMultiplier: 1 / height, farZMultiplier: 1.01\nexport function getProjectionMatrix({\n  width,\n  height,\n  pitch,\n  altitude,\n  fovy,\n  nearZMultiplier,\n  farZMultiplier\n}) {\n  const {fov, aspect, near, far} = getProjectionParameters({\n    width,\n    height,\n    altitude,\n    fovy,\n    pitch,\n    nearZMultiplier,\n    farZMultiplier\n  });\n\n  const projectionMatrix = mat4.perspective(\n    [],\n    fov, // fov in radians\n    aspect, // aspect ratio\n    near, // near plane\n    far // far plane\n  );\n\n  return projectionMatrix;\n}\n\n// Utility function to calculate the field of view such that\n// the focal distance is equal to the ground distance. This\n// is how mapbox's z fov is calculated\nexport function altitudeToFovy(altitude) {\n  return 2 * Math.atan(0.5 / altitude) * RADIANS_TO_DEGREES;\n}\n\nexport function fovyToAltitude(fovy) {\n  return 0.5 / Math.tan(0.5 * fovy * DEGREES_TO_RADIANS);\n}\n\n// Project flat coordinates to pixels on screen.\nexport function worldToPixels(xyz, pixelProjectionMatrix) {\n  const [x, y, z = 0] = xyz;\n  assert(Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z));\n\n  return transformVector(pixelProjectionMatrix, [x, y, z, 1]);\n}\n\n// Unproject pixels on screen to flat coordinates.\nexport function pixelsToWorld(xyz, pixelUnprojectionMatrix, targetZ = 0) {\n  const [x, y, z] = xyz;\n  assert(Number.isFinite(x) && Number.isFinite(y), 'invalid pixel coordinate');\n\n  if (Number.isFinite(z)) {\n    // Has depth component\n    const coord = transformVector(pixelUnprojectionMatrix, [x, y, z, 1]);\n    return coord;\n  }\n\n  // since we don't know the correct projected z value for the point,\n  // unproject two points to get a line and then find the point on that line with z=0\n  const coord0 = transformVector(pixelUnprojectionMatrix, [x, y, 0, 1]);\n  const coord1 = transformVector(pixelUnprojectionMatrix, [x, y, 1, 1]);\n\n  const z0 = coord0[2];\n  const z1 = coord1[2];\n\n  const t = z0 === z1 ? 0 : ((targetZ || 0) - z0) / (z1 - z0);\n  return vec2.lerp([], coord0, coord1, t);\n}\n","// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\nexport default function assert(condition, message) {\n  if (!condition) {\n    throw new Error(message || '@math.gl/web-mercator: assertion failed.');\n  }\n}\n","// @ts-nocheck TODO padding\nimport WebMercatorViewport from './web-mercator-viewport';\nimport assert from './assert';\nimport {log2} from './math-utils';\n\n// Returns map settings {latitude, longitude, zoom}\n// that will contain the provided corners within the provided width.\n// Only supports non-perspective mode.\n\nexport default function fitBounds({\n  width,\n  height,\n  bounds,\n  minExtent = 0, // 0.01 would be about 1000 meters (degree is ~110KM)\n  maxZoom = 24, // ~x4,000,000 => About 10 meter extents\n  // options\n  padding = 0,\n  offset = [0, 0]\n}) {\n  const [[west, south], [east, north]] = bounds;\n\n  if (Number.isFinite(padding)) {\n    const p = padding;\n    padding = {\n      top: p,\n      bottom: p,\n      left: p,\n      right: p\n    };\n  } else {\n    // Make sure all the required properties are set\n    assert(\n      Number.isFinite(padding.top) &&\n        Number.isFinite(padding.bottom) &&\n        Number.isFinite(padding.left) &&\n        Number.isFinite(padding.right)\n    );\n  }\n\n  const viewport = new WebMercatorViewport({\n    width,\n    height,\n    longitude: 0,\n    latitude: 0,\n    zoom: 0\n  });\n\n  const nw = viewport.project([west, north]);\n  const se = viewport.project([east, south]);\n\n  // width/height on the Web Mercator plane\n  const size = [\n    Math.max(Math.abs(se[0] - nw[0]), minExtent),\n    Math.max(Math.abs(se[1] - nw[1]), minExtent)\n  ];\n\n  const targetSize = [\n    width - padding.left - padding.right - Math.abs(offset[0]) * 2,\n    height - padding.top - padding.bottom - Math.abs(offset[1]) * 2\n  ];\n\n  assert(targetSize[0] > 0 && targetSize[1] > 0);\n\n  // scale = screen pixels per unit on the Web Mercator plane\n  const scaleX = targetSize[0] / size[0];\n  const scaleY = targetSize[1] / size[1];\n\n  // Find how much we need to shift the center\n  const offsetX = (padding.right - padding.left) / 2 / scaleX;\n  const offsetY = (padding.bottom - padding.top) / 2 / scaleY;\n\n  const center = [(se[0] + nw[0]) / 2 + offsetX, (se[1] + nw[1]) / 2 + offsetY];\n\n  const centerLngLat = viewport.unproject(center);\n  const zoom = Math.min(maxZoom, viewport.zoom + log2(Math.abs(Math.min(scaleX, scaleY))));\n\n  assert(Number.isFinite(zoom));\n\n  return {\n    longitude: centerLngLat[0],\n    latitude: centerLngLat[1],\n    zoom\n  };\n}\n","import {worldToLngLat} from './web-mercator-utils';\nimport * as vec2 from 'gl-matrix/vec2';\nimport {transformVector} from './math-utils';\n\nconst DEGREES_TO_RADIANS = Math.PI / 180;\n\n/*\n * Returns the quad at the intersection of the frustum and the given z plane\n * @param {WebMercatorViewport} viewport\n * @param {Number} z - elevation in meters\n */\nexport default function getBounds(viewport, z = 0) {\n  const {width, height, unproject} = viewport;\n  const unprojectOps = {targetZ: z};\n  const bottomLeft = unproject([0, height], unprojectOps);\n  const bottomRight = unproject([width, height], unprojectOps);\n  let topLeft;\n  let topRight;\n\n  const halfFov = viewport.fovy\n    ? 0.5 * viewport.fovy * DEGREES_TO_RADIANS\n    : Math.atan(0.5 / viewport.altitude);\n  const angleToGround = (90 - viewport.pitch) * DEGREES_TO_RADIANS;\n  // The top plane is parallel to the ground if halfFov == angleToGround\n  if (halfFov > angleToGround - 0.01) {\n    // intersect with the far plane\n    topLeft = unprojectOnFarPlane(viewport, 0, z);\n    topRight = unprojectOnFarPlane(viewport, width, z);\n  } else {\n    // intersect with the top plane\n    topLeft = unproject([0, 0], unprojectOps);\n    topRight = unproject([width, 0], unprojectOps);\n  }\n\n  return [bottomLeft, bottomRight, topRight, topLeft];\n}\n\n/*\n * Find a point on the far clipping plane of the viewport\n * @param {WebMercatorViewport} viewport\n * @param {Number} x - projected x in screen space\n * @param {Number} targetZ - the elevation of the point in meters\n */\nfunction unprojectOnFarPlane(viewport, x, targetZ) {\n  const {pixelUnprojectionMatrix} = viewport;\n  const coord0 = transformVector(pixelUnprojectionMatrix, [x, 0, 1, 1]);\n  const coord1 = transformVector(pixelUnprojectionMatrix, [x, viewport.height, 1, 1]);\n\n  const z = targetZ * viewport.distanceScales.unitsPerMeter[2];\n  const t = (z - coord0[2]) / (coord1[2] - coord0[2]);\n  const coord = vec2.lerp([], coord0, coord1, t);\n\n  const result = worldToLngLat(coord);\n  result[2] = targetZ;\n  return result;\n}\n","import {worldToLngLat} from './web-mercator-utils';\nimport {mod, log2} from './math-utils';\n\n// defined by mapbox-gl\nconst TILE_SIZE = 512;\n\n// Apply mathematical constraints to viewport props\n// eslint-disable-next-line complexity\nexport default function normalizeViewportProps({\n  width,\n  height,\n  longitude,\n  latitude,\n  zoom,\n  pitch = 0,\n  bearing = 0\n}) {\n  // Normalize degrees\n  if (longitude < -180 || longitude > 180) {\n    longitude = mod(longitude + 180, 360) - 180;\n  }\n  if (bearing < -180 || bearing > 180) {\n    bearing = mod(bearing + 180, 360) - 180;\n  }\n\n  // Constrain zoom and shift center at low zoom levels\n  const minZoom = log2(height / TILE_SIZE);\n  if (zoom <= minZoom) {\n    zoom = minZoom;\n    latitude = 0;\n  } else {\n    // Eliminate white space above and below the map\n    const halfHeightPixels = height / 2 / Math.pow(2, zoom);\n    const minLatitude = worldToLngLat([0, halfHeightPixels])[1];\n    if (latitude < minLatitude) {\n      latitude = minLatitude;\n    } else {\n      const maxLatitude = worldToLngLat([0, TILE_SIZE - halfHeightPixels])[1];\n      if (latitude > maxLatitude) {\n        latitude = maxLatitude;\n      }\n    }\n  }\n\n  return {width, height, longitude, latitude, zoom, pitch, bearing};\n}\n","import {lerp} from './math-utils';\nimport {scaleToZoom, zoomToScale, lngLatToWorld, worldToLngLat} from './web-mercator-utils';\nimport * as vec2 from 'gl-matrix/vec2';\n\nconst EPSILON = 0.01;\nconst VIEWPORT_TRANSITION_PROPS = ['longitude', 'latitude', 'zoom'];\nconst DEFAULT_OPTS = {\n  curve: 1.414,\n  speed: 1.2\n  // screenSpeed and maxDuration are used only if specified\n};\n\n/**\n * mapbox-gl-js flyTo : https://www.mapbox.com/mapbox-gl-js/api/#map#flyto.\n * It implements “Smooth and efficient zooming and panning.” algorithm by\n * \"Jarke J. van Wijk and Wim A.A. Nuij\"\n */\nexport default function flyToViewport(startProps, endProps, t, opts = {}) {\n  // Equations from above paper are referred where needed.\n\n  const viewport = {};\n\n  const {startZoom, startCenterXY, uDelta, w0, u1, S, rho, rho2, r0} = getFlyToTransitionParams(\n    startProps,\n    endProps,\n    opts\n  );\n\n  // If change in center is too small, do linear interpolaiton.\n  if (u1 < EPSILON) {\n    for (const key of VIEWPORT_TRANSITION_PROPS) {\n      const startValue = startProps[key];\n      const endValue = endProps[key];\n      viewport[key] = lerp(startValue, endValue, t);\n    }\n    return viewport;\n  }\n\n  const s = t * S;\n\n  const w = Math.cosh(r0) / Math.cosh(r0 + rho * s);\n  const u = (w0 * ((Math.cosh(r0) * Math.tanh(r0 + rho * s) - Math.sinh(r0)) / rho2)) / u1;\n\n  const scaleIncrement = 1 / w; // Using w method for scaling.\n  const newZoom = startZoom + scaleToZoom(scaleIncrement);\n\n  const newCenterWorld = vec2.scale([], uDelta, u);\n  vec2.add(newCenterWorld, newCenterWorld, startCenterXY);\n\n  const newCenter = worldToLngLat(newCenterWorld);\n  viewport.longitude = newCenter[0];\n  viewport.latitude = newCenter[1];\n  viewport.zoom = newZoom;\n  return viewport;\n}\n\n// returns transition duration in milliseconds\nexport function getFlyToDuration(startProps, endProps, opts = {}) {\n  opts = Object.assign({}, DEFAULT_OPTS, opts);\n  const {screenSpeed, speed, maxDuration} = opts;\n  const {S, rho} = getFlyToTransitionParams(startProps, endProps, opts);\n  const length = 1000 * S;\n  let duration;\n  if (Number.isFinite(screenSpeed)) {\n    duration = length / (screenSpeed / rho);\n  } else {\n    duration = length / speed;\n  }\n\n  return Number.isFinite(maxDuration) && duration > maxDuration ? 0 : duration;\n}\n\n// Private Methods\n\n// Calculate all parameters that are static for given startProps and endProps\nfunction getFlyToTransitionParams(startProps, endProps, opts) {\n  opts = Object.assign({}, DEFAULT_OPTS, opts);\n  const rho = opts.curve;\n  const startZoom = startProps.zoom;\n  const startCenter = [startProps.longitude, startProps.latitude];\n  const startScale = zoomToScale(startZoom);\n  const endZoom = endProps.zoom;\n  const endCenter = [endProps.longitude, endProps.latitude];\n  const scale = zoomToScale(endZoom - startZoom);\n\n  const startCenterXY = lngLatToWorld(startCenter);\n  const endCenterXY = lngLatToWorld(endCenter);\n  const uDelta = vec2.sub([], endCenterXY, startCenterXY);\n\n  const w0 = Math.max(startProps.width, startProps.height);\n  const w1 = w0 / scale;\n  const u1 = vec2.length(uDelta) * startScale;\n  // u0 is treated as '0' in Eq (9).\n\n  // If u1 is too small, will generate invalid number\n  const _u1 = Math.max(u1, EPSILON);\n\n  // Implement Equation (9) from above algorithm.\n  const rho2 = rho * rho;\n  const b0 = (w1 * w1 - w0 * w0 + rho2 * rho2 * _u1 * _u1) / (2 * w0 * rho2 * _u1);\n  const b1 = (w1 * w1 - w0 * w0 - rho2 * rho2 * _u1 * _u1) / (2 * w1 * rho2 * _u1);\n  const r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0);\n  const r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);\n  const S = (r1 - r0) / rho;\n\n  return {startZoom, startCenterXY, uDelta, w0, u1, S, rho, rho2, r0, r1};\n}\n","import {picking} from '@luma.gl/core';\n\nexport default {\n  inject: {\n    'vs:DECKGL_FILTER_COLOR': `\n  picking_setPickingColor(geometry.pickingColor);\n  // for picking depth values\n  picking_setPickingAttribute(geometry.position.z);\n  `,\n    'fs:DECKGL_FILTER_COLOR': {\n      order: 99,\n      injection: `\n  // use highlight color if this fragment belongs to the selected object.\n  color = picking_filterHighlightColor(color);\n\n  // use picking color if rendering to picking FBO.\n  color = picking_filterPickingColor(color);\n    `\n    }\n  },\n  ...picking\n};\n","import {Texture2D, ProgramManager} from '@luma.gl/core';\nimport {AmbientLight} from './ambient-light';\nimport {DirectionalLight} from './directional-light';\nimport Effect from '../../lib/effect';\nimport {Matrix4, Vector3} from 'math.gl';\nimport ShadowPass from '../../passes/shadow-pass';\nimport {default as shadow} from '../../shaderlib/shadow/shadow';\n\nconst DEFAULT_AMBIENT_LIGHT_PROPS = {color: [255, 255, 255], intensity: 1.0};\nconst DEFAULT_DIRECTIONAL_LIGHT_PROPS = [\n  {\n    color: [255, 255, 255],\n    intensity: 1.0,\n    direction: [-1, 3, -1]\n  },\n  {\n    color: [255, 255, 255],\n    intensity: 0.9,\n    direction: [1, -8, -2.5]\n  }\n];\nconst DEFAULT_SHADOW_COLOR = [0, 0, 0, 200 / 255];\n\n// Class to manage ambient, point and directional light sources in deck\nexport default class LightingEffect extends Effect {\n  constructor(props) {\n    super(props);\n    this.ambientLight = null;\n    this.directionalLights = [];\n    this.pointLights = [];\n\n    this.shadowColor = DEFAULT_SHADOW_COLOR;\n    this.shadowPasses = [];\n    this.shadowMaps = [];\n    this.dummyShadowMap = null;\n    this.shadow = false;\n    this.programManager = null;\n\n    for (const key in props) {\n      const lightSource = props[key];\n\n      switch (lightSource.type) {\n        case 'ambient':\n          this.ambientLight = lightSource;\n          break;\n\n        case 'directional':\n          this.directionalLights.push(lightSource);\n          break;\n\n        case 'point':\n          this.pointLights.push(lightSource);\n          break;\n        default:\n      }\n    }\n    this._applyDefaultLights();\n\n    this.shadow = this.directionalLights.some(light => light.shadow);\n  }\n\n  preRender(gl, {layers, layerFilter, viewports, onViewportActive, views}) {\n    if (!this.shadow) return;\n\n    // create light matrix every frame to make sure always updated from light source\n    this.shadowMatrices = this._createLightMatrix();\n\n    if (this.shadowPasses.length === 0) {\n      this._createShadowPasses(gl);\n    }\n    if (!this.programManager) {\n      // TODO - support multiple contexts\n      this.programManager = ProgramManager.getDefaultProgramManager(gl);\n      if (shadow) {\n        this.programManager.addDefaultModule(shadow);\n      }\n    }\n\n    if (!this.dummyShadowMap) {\n      this.dummyShadowMap = new Texture2D(gl, {\n        width: 1,\n        height: 1\n      });\n    }\n\n    for (let i = 0; i < this.shadowPasses.length; i++) {\n      const shadowPass = this.shadowPasses[i];\n      shadowPass.render({\n        layers,\n        layerFilter,\n        viewports,\n        onViewportActive,\n        views,\n        moduleParameters: {\n          shadowLightId: i,\n          dummyShadowMap: this.dummyShadowMap,\n          shadowMatrices: this.shadowMatrices\n        }\n      });\n    }\n  }\n\n  getModuleParameters(layer) {\n    const parameters = this.shadow\n      ? {\n          shadowMaps: this.shadowMaps,\n          dummyShadowMap: this.dummyShadowMap,\n          shadowColor: this.shadowColor,\n          shadowMatrices: this.shadowMatrices\n        }\n      : {};\n\n    // when not rendering to screen, turn off lighting by adding empty light source object\n    // lights shader module relies on the `lightSources` to turn on/off lighting\n    parameters.lightSources = {\n      ambientLight: this.ambientLight,\n      directionalLights: this.directionalLights.map(directionalLight =>\n        directionalLight.getProjectedLight({layer})\n      ),\n      pointLights: this.pointLights.map(pointLight => pointLight.getProjectedLight({layer}))\n    };\n\n    return parameters;\n  }\n\n  cleanup() {\n    for (const shadowPass of this.shadowPasses) {\n      shadowPass.delete();\n    }\n    this.shadowPasses.length = 0;\n    this.shadowMaps.length = 0;\n\n    if (this.dummyShadowMap) {\n      this.dummyShadowMap.delete();\n      this.dummyShadowMap = null;\n    }\n\n    if (this.shadow && this.programManager) {\n      this.programManager.removeDefaultModule(shadow);\n      this.programManager = null;\n    }\n  }\n\n  _createLightMatrix() {\n    const lightMatrices = [];\n    for (const light of this.directionalLights) {\n      const viewMatrix = new Matrix4().lookAt({\n        eye: new Vector3(light.direction).negate()\n      });\n\n      lightMatrices.push(viewMatrix);\n    }\n    return lightMatrices;\n  }\n\n  _createShadowPasses(gl) {\n    for (let i = 0; i < this.directionalLights.length; i++) {\n      const shadowPass = new ShadowPass(gl);\n      this.shadowPasses[i] = shadowPass;\n      this.shadowMaps[i] = shadowPass.shadowMap;\n    }\n  }\n\n  _applyDefaultLights() {\n    const {ambientLight, pointLights, directionalLights} = this;\n    if (!ambientLight && pointLights.length === 0 && directionalLights.length === 0) {\n      this.ambientLight = new AmbientLight(DEFAULT_AMBIENT_LIGHT_PROPS);\n      this.directionalLights.push(\n        new DirectionalLight(DEFAULT_DIRECTIONAL_LIGHT_PROPS[0]),\n        new DirectionalLight(DEFAULT_DIRECTIONAL_LIGHT_PROPS[1])\n      );\n    }\n  }\n}\n","const DEFAULT_LIGHT_COLOR = [255, 255, 255];\nconst DEFAULT_LIGHT_INTENSITY = 1.0;\n\nlet idCount = 0;\n\nexport class AmbientLight {\n  constructor(props = {}) {\n    const {color = DEFAULT_LIGHT_COLOR} = props;\n    const {intensity = DEFAULT_LIGHT_INTENSITY} = props;\n\n    this.id = props.id || `ambient-${idCount++}`;\n    this.color = color;\n    this.intensity = intensity;\n    this.type = 'ambient';\n  }\n}\n","import {Vector3} from 'math.gl';\n\nconst DEFAULT_LIGHT_COLOR = [255, 255, 255];\nconst DEFAULT_LIGHT_INTENSITY = 1.0;\nconst DEFAULT_LIGHT_DIRECTION = [0.0, 0.0, -1.0];\n\nlet idCount = 0;\n\nexport class DirectionalLight {\n  constructor(props = {}) {\n    const {color = DEFAULT_LIGHT_COLOR} = props;\n    const {intensity = DEFAULT_LIGHT_INTENSITY} = props;\n    const {direction = DEFAULT_LIGHT_DIRECTION} = props;\n    const {_shadow = false} = props;\n\n    this.id = props.id || `directional-${idCount++}`;\n    this.color = color;\n    this.intensity = intensity;\n    this.type = 'directional';\n    this.direction = new Vector3(direction).normalize().toArray();\n    this.shadow = _shadow;\n  }\n\n  getProjectedLight() {\n    return this;\n  }\n}\n","export default class Effect {\n  constructor(props = {}) {\n    const {id = 'effect'} = props;\n    this.id = id;\n    this.props = {...props};\n  }\n\n  preRender() {}\n\n  getModuleParameters() {}\n\n  cleanup() {}\n}\n","import {default as LayersPass} from './layers-pass';\nimport {\n  Framebuffer,\n  Texture2D,\n  Renderbuffer,\n  withParameters,\n  cssToDeviceRatio\n} from '@luma.gl/core';\n\nexport default class ShadowPass extends LayersPass {\n  constructor(gl, props) {\n    super(gl, props);\n\n    // The shadowMap texture\n    this.shadowMap = new Texture2D(gl, {\n      width: 1,\n      height: 1,\n      parameters: {\n        [gl.TEXTURE_MIN_FILTER]: gl.LINEAR,\n        [gl.TEXTURE_MAG_FILTER]: gl.LINEAR,\n        [gl.TEXTURE_WRAP_S]: gl.CLAMP_TO_EDGE,\n        [gl.TEXTURE_WRAP_T]: gl.CLAMP_TO_EDGE\n      }\n    });\n\n    this.depthBuffer = new Renderbuffer(gl, {\n      format: gl.DEPTH_COMPONENT16,\n      width: 1,\n      height: 1\n    });\n\n    this.fbo = new Framebuffer(gl, {\n      id: 'shadowmap',\n      width: 1,\n      height: 1,\n      attachments: {\n        [gl.COLOR_ATTACHMENT0]: this.shadowMap,\n        // Depth attachment has to be specified for depth test to work\n        [gl.DEPTH_ATTACHMENT]: this.depthBuffer\n      }\n    });\n  }\n\n  render(params) {\n    const target = this.fbo;\n\n    withParameters(\n      this.gl,\n      {\n        depthRange: [0, 1],\n        depthTest: true,\n        blend: false,\n        clearColor: [1, 1, 1, 1]\n      },\n      () => {\n        const viewport = params.viewports[0];\n        const pixelRatio = cssToDeviceRatio(this.gl);\n        const width = viewport.width * pixelRatio;\n        const height = viewport.height * pixelRatio;\n        if (width !== target.width || height !== target.height) {\n          target.resize({width, height});\n        }\n\n        super.render({...params, target, pass: 'shadow'});\n      }\n    );\n  }\n\n  shouldDrawLayer(layer) {\n    return layer.props.shadowEnabled !== false;\n  }\n\n  getModuleParameters() {\n    return {\n      drawToShadowMap: true\n    };\n  }\n\n  delete() {\n    if (this.fbo) {\n      this.fbo.delete();\n      this.fbo = null;\n    }\n\n    if (this.shadowMap) {\n      this.shadowMap.delete();\n      this.shadowMap = null;\n    }\n\n    if (this.depthBuffer) {\n      this.depthBuffer.delete();\n      this.depthBuffer = null;\n    }\n  }\n}\n","import GL from '@luma.gl/constants';\nimport Pass from './pass';\nimport {clear, setParameters, withParameters, cssToDeviceRatio} from '@luma.gl/core';\n\nexport default class LayersPass extends Pass {\n  render(props) {\n    const gl = this.gl;\n\n    setParameters(gl, {framebuffer: props.target});\n    return this._drawLayers(props);\n  }\n\n  // PRIVATE\n  // Draw a list of layers in a list of viewports\n  _drawLayers(props) {\n    const {viewports, views, onViewportActive, clearCanvas = true} = props;\n    props.pass = props.pass || 'unknown';\n\n    const gl = this.gl;\n    if (clearCanvas) {\n      clearGLCanvas(gl);\n    }\n\n    const renderStats = [];\n\n    for (const viewportOrDescriptor of viewports) {\n      // Get a viewport from a viewport descriptor (which can be a plain viewport)\n      const viewport = viewportOrDescriptor.viewport || viewportOrDescriptor;\n      const view = views && views[viewport.id];\n\n      // Update context to point to this viewport\n      onViewportActive(viewport);\n\n      const drawLayerParams = this._getDrawLayerParams(viewport, props);\n\n      props.view = view;\n\n      // render this viewport\n      const subViewports = viewport.subViewports || [viewport];\n      for (const subViewport of subViewports) {\n        props.viewport = subViewport;\n\n        const stats = this._drawLayersInViewport(gl, props, drawLayerParams);\n        renderStats.push(stats);\n      }\n    }\n    return renderStats;\n  }\n\n  // Resolve the parameters needed to draw each layer\n  // When a viewport contains multiple subviewports (e.g. repeated web mercator map),\n  // this is only done once for the parent viewport\n  _getDrawLayerParams(viewport, {layers, pass, layerFilter, effects, moduleParameters}) {\n    const drawLayerParams = [];\n    const indexResolver = layerIndexResolver();\n    const drawContext = {\n      viewport,\n      isPicking: pass.startsWith('picking'),\n      renderPass: pass\n    };\n    const layerFilterCache = {};\n    for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {\n      const layer = layers[layerIndex];\n      // Check if we should draw layer\n      const shouldDrawLayer = this._shouldDrawLayer(\n        layer,\n        drawContext,\n        layerFilter,\n        layerFilterCache\n      );\n\n      // This is the \"logical\" index for ordering this layer in the stack\n      // used to calculate polygon offsets\n      // It can be the same as another layer\n      const layerRenderIndex = indexResolver(layer, shouldDrawLayer);\n\n      const layerParam = {\n        shouldDrawLayer,\n        layerRenderIndex\n      };\n\n      if (shouldDrawLayer) {\n        layerParam.moduleParameters = this._getModuleParameters(\n          layer,\n          effects,\n          pass,\n          moduleParameters\n        );\n        layerParam.layerParameters = this.getLayerParameters(layer, layerIndex, viewport);\n      }\n      drawLayerParams[layerIndex] = layerParam;\n    }\n    return drawLayerParams;\n  }\n\n  // Draws a list of layers in one viewport\n  // TODO - when picking we could completely skip rendering viewports that dont\n  // intersect with the picking rect\n  /* eslint-disable max-depth, max-statements */\n  _drawLayersInViewport(gl, {layers, pass, viewport, view}, drawLayerParams) {\n    const glViewport = getGLViewport(gl, {viewport});\n\n    if (view && view.props.clear) {\n      const clearOpts = view.props.clear === true ? {color: true, depth: true} : view.props.clear;\n      withParameters(\n        gl,\n        {\n          scissorTest: true,\n          scissor: glViewport\n        },\n        () => clear(gl, clearOpts)\n      );\n    }\n\n    // render layers in normal colors\n    const renderStatus = {\n      totalCount: layers.length,\n      visibleCount: 0,\n      compositeCount: 0,\n      pickableCount: 0\n    };\n\n    setParameters(gl, {viewport: glViewport});\n\n    // render layers in normal colors\n    for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {\n      const layer = layers[layerIndex];\n      const {\n        shouldDrawLayer,\n        layerRenderIndex,\n        moduleParameters,\n        layerParameters\n      } = drawLayerParams[layerIndex];\n\n      // Calculate stats\n      if (shouldDrawLayer && layer.props.pickable) {\n        renderStatus.pickableCount++;\n      }\n      if (layer.isComposite) {\n        renderStatus.compositeCount++;\n      } else if (shouldDrawLayer) {\n        // Draw the layer\n        renderStatus.visibleCount++;\n\n        // overwrite layer.context.viewport with the sub viewport\n        moduleParameters.viewport = viewport;\n\n        try {\n          layer.drawLayer({\n            moduleParameters,\n            uniforms: {layerIndex: layerRenderIndex},\n            parameters: layerParameters\n          });\n        } catch (err) {\n          layer.raiseError(err, `drawing ${layer} to ${pass}`);\n        }\n      }\n    }\n\n    return renderStatus;\n  }\n  /* eslint-enable max-depth, max-statements */\n\n  /* Methods for subclass overrides */\n  shouldDrawLayer(layer) {\n    return true;\n  }\n\n  getModuleParameters(layer, effects) {\n    return null;\n  }\n\n  getLayerParameters(layer, layerIndex) {\n    return layer.props.parameters;\n  }\n\n  /* Private */\n  _shouldDrawLayer(layer, drawContext, layerFilter, layerFilterCache) {\n    const shouldDrawLayer = this.shouldDrawLayer(layer) && layer.props.visible;\n\n    if (!shouldDrawLayer) {\n      return false;\n    }\n\n    drawContext.layer = layer;\n\n    let parent = layer.parent;\n    while (parent) {\n      if (!parent.props.visible || !parent.filterSubLayer(drawContext)) {\n        return false;\n      }\n      drawContext.layer = parent;\n      parent = parent.parent;\n    }\n\n    if (layerFilter) {\n      const rootLayerId = drawContext.layer.id;\n      if (!(rootLayerId in layerFilterCache)) {\n        layerFilterCache[rootLayerId] = layerFilter(drawContext);\n      }\n      if (!layerFilterCache[rootLayerId]) {\n        return false;\n      }\n    }\n\n    // If a layer is drawn, update its viewportChanged flag\n    layer.activateViewport(drawContext.viewport);\n\n    return true;\n  }\n\n  _getModuleParameters(layer, effects, pass, overrides) {\n    const moduleParameters = Object.assign(Object.create(layer.props), {\n      autoWrapLongitude: layer.wrapLongitude,\n      viewport: layer.context.viewport,\n      mousePosition: layer.context.mousePosition,\n      pickingActive: 0,\n      devicePixelRatio: cssToDeviceRatio(this.gl)\n    });\n\n    if (effects) {\n      for (const effect of effects) {\n        Object.assign(moduleParameters, effect.getModuleParameters(layer));\n      }\n    }\n\n    return Object.assign(moduleParameters, this.getModuleParameters(layer, effects), overrides);\n  }\n}\n\n// If the _index prop is defined, return a layer index that's relative to its parent\n// Otherwise return the index of the layer among all rendered layers\n// This is done recursively, i.e. if the user overrides a layer's default index,\n// all its descendants will be resolved relative to that index.\n// This implementation assumes that parent layers always appear before its children\n// which is true if the layer array comes from the LayerManager\nexport function layerIndexResolver(startIndex = 0, layerIndices = {}) {\n  const resolvers = {};\n\n  const resolveLayerIndex = (layer, isDrawn) => {\n    const indexOverride = layer.props._offset;\n    const layerId = layer.id;\n    const parentId = layer.parent && layer.parent.id;\n\n    let index;\n\n    if (parentId && !(parentId in layerIndices)) {\n      // Populate layerIndices with the parent layer's index\n      resolveLayerIndex(layer.parent, false);\n    }\n\n    if (parentId in resolvers) {\n      const resolver = (resolvers[parentId] =\n        resolvers[parentId] || layerIndexResolver(layerIndices[parentId], layerIndices));\n      index = resolver(layer, isDrawn);\n      resolvers[layerId] = resolver;\n    } else if (Number.isFinite(indexOverride)) {\n      index = indexOverride + (layerIndices[parentId] || 0);\n      // Mark layer as needing its own resolver\n      // We don't actually create it until it's used for the first time\n      resolvers[layerId] = null;\n    } else {\n      index = startIndex;\n    }\n\n    if (isDrawn && index >= startIndex) {\n      startIndex = index + 1;\n    }\n\n    layerIndices[layerId] = index;\n    return index;\n  };\n  return resolveLayerIndex;\n}\n\n// Convert viewport top-left CSS coordinates to bottom up WebGL coordinates\nfunction getGLViewport(gl, {viewport}) {\n  // TODO - dummy default for node\n  // Fallback to width/height when clientWidth/clientHeight are 0 or undefined.\n  const height = gl.canvas ? gl.canvas.clientHeight || gl.canvas.height : 100;\n  // Convert viewport top-left CSS coordinates to bottom up WebGL coordinates\n  const dimensions = viewport;\n  const pixelRatio = cssToDeviceRatio(gl);\n  return [\n    dimensions.x * pixelRatio,\n    (height - dimensions.y - dimensions.height) * pixelRatio,\n    dimensions.width * pixelRatio,\n    dimensions.height * pixelRatio\n  ];\n}\n\nfunction clearGLCanvas(gl) {\n  const width = gl.drawingBufferWidth;\n  const height = gl.drawingBufferHeight;\n  // clear depth and color buffers, restoring transparency\n  setParameters(gl, {viewport: [0, 0, width, height]});\n  gl.clear(GL.COLOR_BUFFER_BIT | GL.DEPTH_BUFFER_BIT);\n}\n","export default class Pass {\n  constructor(gl, props = {}) {\n    const {id = 'pass'} = props;\n    this.id = id; // id of this pass\n    this.gl = gl;\n    this.props = {...props};\n  }\n\n  setProps(props) {\n    Object.assign(this.props, props);\n  }\n\n  render() {}\n\n  cleanup() {}\n}\n","import {projectPosition} from '../../shaderlib/project/project-functions';\nimport {COORDINATE_SYSTEM} from '../../lib';\n\nconst DEFAULT_LIGHT_COLOR = [255, 255, 255];\nconst DEFAULT_LIGHT_INTENSITY = 1.0;\nconst DEFAULT_ATTENUATION = [0, 0, 1];\nconst DEFAULT_LIGHT_POSITION = [0.0, 0.0, 1.0];\n\nlet idCount = 0;\n\nexport class PointLight {\n  constructor(props = {}) {\n    const {color = DEFAULT_LIGHT_COLOR} = props;\n    const {intensity = DEFAULT_LIGHT_INTENSITY} = props;\n    const {position = DEFAULT_LIGHT_POSITION} = props;\n\n    this.id = props.id || `point-${idCount++}`;\n    this.color = color;\n    this.intensity = intensity;\n    this.type = 'point';\n    this.position = position;\n    this.attenuation = getAttenuation(props);\n    this.projectedLight = {...this};\n  }\n\n  getProjectedLight({layer}) {\n    const {projectedLight} = this;\n    const viewport = layer.context.viewport;\n    const {coordinateSystem, coordinateOrigin} = layer.props;\n    const position = projectPosition(this.position, {\n      viewport,\n      coordinateSystem,\n      coordinateOrigin,\n      fromCoordinateSystem: viewport.isGeospatial\n        ? COORDINATE_SYSTEM.LNGLAT\n        : COORDINATE_SYSTEM.CARTESIAN,\n      fromCoordinateOrigin: [0, 0, 0]\n    });\n    projectedLight.color = this.color;\n    projectedLight.intensity = this.intensity;\n    projectedLight.position = position;\n    return projectedLight;\n  }\n}\n\nfunction getAttenuation(props) {\n  if ('attenuation' in props) {\n    return props.attenuation;\n  }\n  if ('intensity' in props) {\n    return [0, 0, props.intensity];\n  }\n  return DEFAULT_ATTENUATION;\n}\n","/**\n * Projection utils\n * TODO: move to Viewport class?\n */\nimport {COORDINATE_SYSTEM} from '../../lib/constants';\nimport {getOffsetOrigin} from './viewport-uniforms';\nimport WebMercatorViewport from '../../viewports/web-mercator-viewport';\n\nimport * as vec4 from 'gl-matrix/vec4';\nimport * as vec3 from 'gl-matrix/vec3';\nimport {addMetersToLngLat} from '@math.gl/web-mercator';\n\n// In project.glsl, offset modes calculate z differently from LNG_LAT mode.\n// offset modes apply the y adjustment (unitsPerMeter2) when projecting z\n// LNG_LAT mode only use the linear scale.\nfunction lngLatZToWorldPosition(lngLatZ, viewport, offsetMode = false) {\n  const p = viewport.projectPosition(lngLatZ);\n\n  // TODO - avoid using instanceof\n  if (offsetMode && viewport instanceof WebMercatorViewport) {\n    const [longitude, latitude, z = 0] = lngLatZ;\n    const distanceScales = viewport.getDistanceScales([longitude, latitude]);\n    p[2] = z * distanceScales.unitsPerMeter[2];\n  }\n  return p;\n}\n\nfunction normalizeParameters(opts) {\n  const normalizedParams = {...opts};\n\n  let {coordinateSystem} = opts;\n  const {viewport, coordinateOrigin, fromCoordinateSystem, fromCoordinateOrigin} = opts;\n\n  if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) {\n    coordinateSystem = viewport.isGeospatial\n      ? COORDINATE_SYSTEM.LNGLAT\n      : COORDINATE_SYSTEM.CARTESIAN;\n  }\n\n  if (fromCoordinateSystem === undefined) {\n    normalizedParams.fromCoordinateSystem = coordinateSystem;\n  }\n  if (fromCoordinateOrigin === undefined) {\n    normalizedParams.fromCoordinateOrigin = coordinateOrigin;\n  }\n\n  normalizedParams.coordinateSystem = coordinateSystem;\n\n  return normalizedParams;\n}\n\nexport function getWorldPosition(\n  position,\n  {viewport, modelMatrix, coordinateSystem, coordinateOrigin, offsetMode}\n) {\n  let [x, y, z = 0] = position;\n\n  if (modelMatrix) {\n    [x, y, z] = vec4.transformMat4([], [x, y, z, 1.0], modelMatrix);\n  }\n\n  switch (coordinateSystem) {\n    case COORDINATE_SYSTEM.LNGLAT:\n      return lngLatZToWorldPosition([x, y, z], viewport, offsetMode);\n\n    case COORDINATE_SYSTEM.LNGLAT_OFFSETS:\n      return lngLatZToWorldPosition(\n        [x + coordinateOrigin[0], y + coordinateOrigin[1], z + (coordinateOrigin[2] || 0)],\n        viewport,\n        offsetMode\n      );\n\n    case COORDINATE_SYSTEM.METER_OFFSETS:\n      return lngLatZToWorldPosition(\n        addMetersToLngLat(coordinateOrigin, [x, y, z]),\n        viewport,\n        offsetMode\n      );\n\n    case COORDINATE_SYSTEM.CARTESIAN:\n    default:\n      return viewport.isGeospatial\n        ? [x + coordinateOrigin[0], y + coordinateOrigin[1], z + coordinateOrigin[2]]\n        : viewport.projectPosition([x, y, z]);\n  }\n}\n\n/**\n * Equivalent to project_position in project.glsl\n * projects a user supplied position to world position directly with or without\n * a reference coordinate system\n * @param {array} position - [x, y, z]\n * @param {object} params\n * @param {Viewport} params.viewport - the current viewport\n * @param {number} params.coordinateSystem - the reference coordinate system used\n *   align world position\n * @param {array} params.coordinateOrigin - the reference coordinate origin used\n *   to align world position\n * @param {Matrix4} [params.modelMatrix] - the model matrix of the supplied position\n * @param {number} [params.fromCoordinateSystem] - the coordinate system that the\n *   supplied position is in. Default to the same as `coordinateSystem`.\n * @param {array} [params.fromCoordinateOrigin] - the coordinate origin that the\n *   supplied position is in. Default to the same as `coordinateOrigin`.\n */\nexport function projectPosition(position, params) {\n  const {\n    viewport,\n    coordinateSystem,\n    coordinateOrigin,\n    // optional\n    modelMatrix,\n    fromCoordinateSystem,\n    fromCoordinateOrigin\n  } = normalizeParameters(params);\n\n  const {geospatialOrigin, shaderCoordinateOrigin, offsetMode} = getOffsetOrigin(\n    viewport,\n    coordinateSystem,\n    coordinateOrigin\n  );\n\n  const worldPosition = getWorldPosition(position, {\n    viewport,\n    modelMatrix,\n    coordinateSystem: fromCoordinateSystem,\n    coordinateOrigin: fromCoordinateOrigin,\n    offsetMode\n  });\n\n  if (offsetMode) {\n    const positionCommonSpace = viewport.projectPosition(\n      geospatialOrigin || shaderCoordinateOrigin\n    );\n    vec3.sub(worldPosition, worldPosition, positionCommonSpace);\n  }\n\n  return worldPosition;\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// View and Projection Matrix calculations for mapbox-js style\n// map view properties\nimport Viewport from './viewport';\n\nimport {\n  pixelsToWorld,\n  getViewMatrix,\n  addMetersToLngLat,\n  getProjectionParameters,\n  altitudeToFovy,\n  fovyToAltitude,\n  fitBounds,\n  getBounds\n} from '@math.gl/web-mercator';\n\n// TODO - import from math.gl\nimport * as vec2 from 'gl-matrix/vec2';\nimport {Matrix4} from 'math.gl';\n\nconst TILE_SIZE = 512;\nconst EARTH_CIRCUMFERENCE = 40.03e6;\nconst DEGREES_TO_RADIANS = Math.PI / 180;\n\nfunction unitsPerMeter(latitude) {\n  const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS);\n  return TILE_SIZE / EARTH_CIRCUMFERENCE / latCosine;\n}\n\nexport default class WebMercatorViewport extends Viewport {\n  /**\n   * @classdesc\n   * Creates view/projection matrices from mercator params\n   * Note: The Viewport is immutable in the sense that it only has accessors.\n   * A new viewport instance should be created if any parameters have changed.\n   */\n  /* eslint-disable complexity, max-statements */\n  constructor(opts = {}) {\n    const {\n      latitude = 0,\n      longitude = 0,\n      zoom = 11,\n      pitch = 0,\n      bearing = 0,\n      nearZMultiplier = 0.1,\n      farZMultiplier = 1.01,\n      orthographic = false,\n      projectionMatrix,\n\n      repeat = false,\n      worldOffset = 0,\n\n      // backward compatibility\n      // TODO: remove in v9\n      legacyMeterSizes = false\n    } = opts;\n\n    let {width, height, altitude = 1.5} = opts;\n    const scale = Math.pow(2, zoom);\n\n    // Silently allow apps to send in 0,0 to facilitate isomorphic render etc\n    width = width || 1;\n    height = height || 1;\n\n    let fovy;\n    let projectionParameters = null;\n    if (projectionMatrix) {\n      altitude = projectionMatrix[5] / 2;\n      fovy = altitudeToFovy(altitude);\n    } else {\n      if (opts.fovy) {\n        fovy = opts.fovy;\n        altitude = fovyToAltitude(fovy);\n      } else {\n        fovy = altitudeToFovy(altitude);\n      }\n      projectionParameters = getProjectionParameters({\n        width,\n        height,\n        pitch,\n        fovy,\n        nearZMultiplier,\n        farZMultiplier\n      });\n    }\n\n    // The uncentered matrix allows us two move the center addition to the\n    // shader (cheap) which gives a coordinate system that has its center in\n    // the layer's center position. This makes rotations and other modelMatrx\n    // transforms much more useful.\n    let viewMatrixUncentered = getViewMatrix({\n      height,\n      pitch,\n      bearing,\n      scale,\n      altitude\n    });\n\n    if (worldOffset) {\n      const viewOffset = new Matrix4().translate([512 * worldOffset, 0, 0]);\n      viewMatrixUncentered = viewOffset.multiplyLeft(viewMatrixUncentered);\n    }\n\n    super({\n      ...opts,\n      // x, y,\n      width,\n      height,\n\n      // view matrix\n      viewMatrix: viewMatrixUncentered,\n      longitude,\n      latitude,\n      zoom,\n\n      // projection matrix parameters\n      ...projectionParameters,\n      fovy,\n      focalDistance: altitude\n    });\n\n    // Save parameters\n    this.latitude = latitude;\n    this.longitude = longitude;\n    this.zoom = zoom;\n    this.pitch = pitch;\n    this.bearing = bearing;\n    this.altitude = altitude;\n    this.fovy = fovy;\n\n    this.orthographic = orthographic;\n\n    this._subViewports = repeat ? [] : null;\n    this._pseudoMeters = legacyMeterSizes;\n\n    Object.freeze(this);\n  }\n  /* eslint-enable complexity, max-statements */\n\n  get subViewports() {\n    if (this._subViewports && !this._subViewports.length) {\n      // Cache sub viewports so that we only calculate them once\n      const bounds = this.getBounds();\n\n      const minOffset = Math.floor((bounds[0] + 180) / 360);\n      const maxOffset = Math.ceil((bounds[2] - 180) / 360);\n\n      for (let x = minOffset; x <= maxOffset; x++) {\n        const offsetViewport = x\n          ? new WebMercatorViewport({\n              ...this,\n              worldOffset: x\n            })\n          : this;\n        this._subViewports.push(offsetViewport);\n      }\n    }\n    return this._subViewports;\n  }\n\n  projectPosition(xyz) {\n    if (this._pseudoMeters) {\n      // Backward compatibility\n      return super.projectPosition(xyz);\n    }\n    const [X, Y] = this.projectFlat(xyz);\n    const Z = (xyz[2] || 0) * unitsPerMeter(xyz[1]);\n    return [X, Y, Z];\n  }\n\n  unprojectPosition(xyz) {\n    if (this._pseudoMeters) {\n      // Backward compatibility\n      return super.unprojectPosition(xyz);\n    }\n    const [X, Y] = this.unprojectFlat(xyz);\n    const Z = (xyz[2] || 0) / unitsPerMeter(Y);\n    return [X, Y, Z];\n  }\n\n  /**\n   * Add a meter delta to a base lnglat coordinate, returning a new lnglat array\n   *\n   * Note: Uses simple linear approximation around the viewport center\n   * Error increases with size of offset (roughly 1% per 100km)\n   *\n   * @param {[Number,Number]|[Number,Number,Number]) lngLatZ - base coordinate\n   * @param {[Number,Number]|[Number,Number,Number]) xyz - array of meter deltas\n   * @return {[Number,Number]|[Number,Number,Number]) array of [lng,lat,z] deltas\n   */\n  addMetersToLngLat(lngLatZ, xyz) {\n    return addMetersToLngLat(lngLatZ, xyz);\n  }\n\n  panByPosition(coords, pixel) {\n    const fromLocation = pixelsToWorld(pixel, this.pixelUnprojectionMatrix);\n    const toLocation = this.projectFlat(coords);\n\n    const translate = vec2.add([], toLocation, vec2.negate([], fromLocation));\n    const newCenter = vec2.add([], this.center, translate);\n\n    const [longitude, latitude] = this.unprojectFlat(newCenter);\n    return {longitude, latitude};\n  }\n\n  getBounds(options = {}) {\n    const corners = getBounds(this, options.z || 0);\n\n    return [\n      Math.min(corners[0][0], corners[1][0], corners[2][0], corners[3][0]),\n      Math.min(corners[0][1], corners[1][1], corners[2][1], corners[3][1]),\n      Math.max(corners[0][0], corners[1][0], corners[2][0], corners[3][0]),\n      Math.max(corners[0][1], corners[1][1], corners[2][1], corners[3][1])\n    ];\n  }\n\n  /**\n   * Returns a new viewport that fit around the given rectangle.\n   * Only supports non-perspective mode.\n   * @param {Array} bounds - [[lon, lat], [lon, lat]]\n   * @param {Number} [options.padding] - The amount of padding in pixels to add to the given bounds.\n   * @param {Array} [options.offset] - The center of the given bounds relative to the map's center,\n   *    [x, y] measured in pixels.\n   * @returns {WebMercatorViewport}\n   */\n  fitBounds(bounds, options = {}) {\n    const {width, height} = this;\n    const {longitude, latitude, zoom} = fitBounds({width, height, bounds, ...options});\n    return new WebMercatorViewport({width, height, longitude, latitude, zoom});\n  }\n}\n\nWebMercatorViewport.displayName = 'WebMercatorViewport';\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport log from '../utils/log';\nimport {createMat4, getCameraPosition, getFrustumPlanes} from '../utils/math-utils';\n\nimport {Matrix4, Vector3, equals} from 'math.gl';\nimport * as mat4 from 'gl-matrix/mat4';\n\nimport {\n  getDistanceScales,\n  getMeterZoom,\n  lngLatToWorld,\n  worldToLngLat,\n  worldToPixels,\n  pixelsToWorld\n} from '@math.gl/web-mercator';\n\nimport {PROJECTION_MODE} from '../lib/constants';\n\nconst DEGREES_TO_RADIANS = Math.PI / 180;\n\nconst IDENTITY = createMat4();\n\nconst ZERO_VECTOR = [0, 0, 0];\n\nconst DEFAULT_ZOOM = 0;\n\nconst DEFAULT_DISTANCE_SCALES = {\n  unitsPerMeter: [1, 1, 1],\n  metersPerUnit: [1, 1, 1]\n};\n\nexport default class Viewport {\n  /**\n   * @classdesc\n   * Manages coordinate system transformations for deck.gl.\n   *\n   * Note: The Viewport is immutable in the sense that it only has accessors.\n   * A new viewport instance should be created if any parameters have changed.\n   */\n  constructor(opts = {}) {\n    const {\n      id = null,\n      // Window width/height in pixels (for pixel projection)\n      x = 0,\n      y = 0,\n      width = 1,\n      height = 1\n    } = opts;\n\n    this.id = id || this.constructor.displayName || 'viewport';\n\n    this.x = x;\n    this.y = y;\n    // Silently allow apps to send in w,h = 0,0\n    this.width = width || 1;\n    this.height = height || 1;\n    this._frustumPlanes = {};\n\n    this._initViewMatrix(opts);\n    this._initProjectionMatrix(opts);\n    this._initPixelMatrices();\n\n    // Bind methods for easy access\n    this.equals = this.equals.bind(this);\n    this.project = this.project.bind(this);\n    this.unproject = this.unproject.bind(this);\n    this.projectPosition = this.projectPosition.bind(this);\n    this.unprojectPosition = this.unprojectPosition.bind(this);\n    this.projectFlat = this.projectFlat.bind(this);\n    this.unprojectFlat = this.unprojectFlat.bind(this);\n  }\n\n  get metersPerPixel() {\n    return this.distanceScales.metersPerUnit[2] / this.scale;\n  }\n\n  get projectionMode() {\n    if (this.isGeospatial) {\n      return this.zoom < 12\n        ? PROJECTION_MODE.WEB_MERCATOR\n        : PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET;\n    }\n    return PROJECTION_MODE.IDENTITY;\n  }\n\n  // Two viewports are equal if width and height are identical, and if\n  // their view and projection matrices are (approximately) equal.\n  equals(viewport) {\n    if (!(viewport instanceof Viewport)) {\n      return false;\n    }\n    if (this === viewport) {\n      return true;\n    }\n\n    return (\n      viewport.width === this.width &&\n      viewport.height === this.height &&\n      viewport.scale === this.scale &&\n      equals(viewport.projectionMatrix, this.projectionMatrix) &&\n      equals(viewport.viewMatrix, this.viewMatrix)\n    );\n    // TODO - check distance scales?\n  }\n\n  /**\n   * Projects xyz (possibly latitude and longitude) to pixel coordinates in window\n   * using viewport projection parameters\n   * - [longitude, latitude] to [x, y]\n   * - [longitude, latitude, Z] => [x, y, z]\n   * Note: By default, returns top-left coordinates for canvas/SVG type render\n   *\n   * @param {Array} lngLatZ - [lng, lat] or [lng, lat, Z]\n   * @param {Object} opts - options\n   * @param {Object} opts.topLeft=true - Whether projected coords are top left\n   * @return {Array} - [x, y] or [x, y, z] in top left coords\n   */\n  project(xyz, {topLeft = true} = {}) {\n    const worldPosition = this.projectPosition(xyz);\n    const coord = worldToPixels(worldPosition, this.pixelProjectionMatrix);\n\n    const [x, y] = coord;\n    const y2 = topLeft ? y : this.height - y;\n    return xyz.length === 2 ? [x, y2] : [x, y2, coord[2]];\n  }\n\n  /**\n   * Unproject pixel coordinates on screen onto world coordinates,\n   * (possibly [lon, lat]) on map.\n   * - [x, y] => [lng, lat]\n   * - [x, y, z] => [lng, lat, Z]\n   * @param {Array} xyz -\n   * @param {Object} opts - options\n   * @param {Object} opts.topLeft=true - Whether origin is top left\n   * @return {Array|null} - [lng, lat, Z] or [X, Y, Z]\n   */\n  unproject(xyz, {topLeft = true, targetZ} = {}) {\n    const [x, y, z] = xyz;\n\n    const y2 = topLeft ? y : this.height - y;\n    const targetZWorld = targetZ && targetZ * this.distanceScales.unitsPerMeter[2];\n    const coord = pixelsToWorld([x, y2, z], this.pixelUnprojectionMatrix, targetZWorld);\n    const [X, Y, Z] = this.unprojectPosition(coord);\n\n    if (Number.isFinite(z)) {\n      return [X, Y, Z];\n    }\n    return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y];\n  }\n\n  // NON_LINEAR PROJECTION HOOKS\n  // Used for web meractor projection\n\n  projectPosition(xyz) {\n    const [X, Y] = this.projectFlat(xyz);\n    const Z = (xyz[2] || 0) * this.distanceScales.unitsPerMeter[2];\n    return [X, Y, Z];\n  }\n\n  unprojectPosition(xyz) {\n    const [X, Y] = this.unprojectFlat(xyz);\n    const Z = (xyz[2] || 0) * this.distanceScales.metersPerUnit[2];\n    return [X, Y, Z];\n  }\n\n  /**\n   * Project [lng,lat] on sphere onto [x,y] on 512*512 Mercator Zoom 0 tile.\n   * Performs the nonlinear part of the web mercator projection.\n   * Remaining projection is done with 4x4 matrices which also handles\n   * perspective.\n   * @param {Array} lngLat - [lng, lat] coordinates\n   *   Specifies a point on the sphere to project onto the map.\n   * @return {Array} [x,y] coordinates.\n   */\n  projectFlat(xyz) {\n    if (this.isGeospatial) {\n      return lngLatToWorld(xyz);\n    }\n    return xyz;\n  }\n\n  /**\n   * Unproject world point [x,y] on map onto {lat, lon} on sphere\n   * @param {object|Vector} xy - object with {x,y} members\n   *  representing point on projected map plane\n   * @return {GeoCoordinates} - object with {lat,lon} of point on sphere.\n   *   Has toArray method if you need a GeoJSON Array.\n   *   Per cartographic tradition, lat and lon are specified as degrees.\n   */\n  unprojectFlat(xyz) {\n    if (this.isGeospatial) {\n      return worldToLngLat(xyz);\n    }\n    return xyz;\n  }\n\n  getBounds(options = {}) {\n    const unprojectOption = {targetZ: options.z || 0};\n\n    const topLeft = this.unproject([0, 0], unprojectOption);\n    const topRight = this.unproject([this.width, 0], unprojectOption);\n    const bottomLeft = this.unproject([0, this.height], unprojectOption);\n    const bottomRight = this.unproject([this.width, this.height], unprojectOption);\n\n    return [\n      Math.min(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]),\n      Math.min(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]),\n      Math.max(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]),\n      Math.max(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1])\n    ];\n  }\n\n  getDistanceScales(coordinateOrigin = null) {\n    if (coordinateOrigin) {\n      return getDistanceScales({\n        longitude: coordinateOrigin[0],\n        latitude: coordinateOrigin[1],\n        highPrecision: true\n      });\n    }\n    return this.distanceScales;\n  }\n\n  containsPixel({x, y, width = 1, height = 1}) {\n    return (\n      x < this.x + this.width &&\n      this.x < x + width &&\n      y < this.y + this.height &&\n      this.y < y + height\n    );\n  }\n\n  // Extract frustum planes in common space\n  getFrustumPlanes() {\n    if (this._frustumPlanes.near) {\n      return this._frustumPlanes;\n    }\n\n    Object.assign(this._frustumPlanes, getFrustumPlanes(this.viewProjectionMatrix));\n\n    return this._frustumPlanes;\n  }\n\n  // EXPERIMENTAL METHODS\n\n  /**\n   * Needed by panning and linear transition\n   * Pan the viewport to place a given world coordinate at screen point [x, y]\n   *\n   * @param {Array} coords - world coordinates\n   * @param {Array} pixel - [x,y] coordinates on screen\n   * @return {Object} props of the new viewport\n   */\n  panByPosition(coords, pixel) {\n    return null;\n  }\n\n  getCameraPosition() {\n    return this.cameraPosition;\n  }\n\n  getCameraDirection() {\n    return this.cameraDirection;\n  }\n\n  getCameraUp() {\n    return this.cameraUp;\n  }\n\n  // INTERNAL METHODS\n\n  _createProjectionMatrix({orthographic, fovyRadians, aspect, focalDistance, near, far}) {\n    return orthographic\n      ? new Matrix4().orthographic({fovy: fovyRadians, aspect, focalDistance, near, far})\n      : new Matrix4().perspective({fovy: fovyRadians, aspect, near, far});\n  }\n\n  /* eslint-disable complexity, max-statements */\n  _initViewMatrix(opts) {\n    const {\n      // view matrix\n      viewMatrix = IDENTITY,\n\n      longitude = null, // Anchor: lng lat zoom makes viewport work w/ geospatial coordinate systems\n      latitude = null,\n      zoom = null,\n\n      position = null, // Anchor position offset (in meters for geospatial viewports)\n      modelMatrix = null, // A model matrix to be applied to position, to match the layer props API\n      focalDistance = 1, // Only needed for orthographic views\n\n      distanceScales = null\n    } = opts;\n\n    // Check if we have a geospatial anchor\n    this.isGeospatial = Number.isFinite(latitude) && Number.isFinite(longitude);\n\n    this.zoom = zoom;\n    if (!Number.isFinite(this.zoom)) {\n      this.zoom = this.isGeospatial\n        ? getMeterZoom({latitude}) + Math.log2(focalDistance)\n        : DEFAULT_ZOOM;\n    }\n    const scale = Math.pow(2, this.zoom);\n    this.scale = scale;\n\n    // Calculate distance scales if lng/lat/zoom are provided\n    this.distanceScales = this.isGeospatial\n      ? getDistanceScales({latitude, longitude})\n      : distanceScales || DEFAULT_DISTANCE_SCALES;\n\n    this.focalDistance = focalDistance;\n\n    this.distanceScales.metersPerUnit = new Vector3(this.distanceScales.metersPerUnit);\n    this.distanceScales.unitsPerMeter = new Vector3(this.distanceScales.unitsPerMeter);\n\n    this.position = ZERO_VECTOR;\n    this.meterOffset = ZERO_VECTOR;\n    if (position) {\n      // Apply model matrix if supplied\n      this.position = position;\n      this.modelMatrix = modelMatrix;\n      this.meterOffset = modelMatrix ? modelMatrix.transformVector(position) : position;\n    }\n\n    if (this.isGeospatial) {\n      // Determine camera center\n      this.longitude = longitude;\n      this.latitude = latitude;\n      this.center = this._getCenterInWorld({longitude, latitude});\n    } else {\n      this.center = position ? this.projectPosition(position) : [0, 0, 0];\n    }\n    this.viewMatrixUncentered = viewMatrix;\n    // Make a centered version of the matrix for projection modes without an offset\n    this.viewMatrix = new Matrix4()\n      // Apply the uncentered view matrix\n      .multiplyRight(this.viewMatrixUncentered)\n      // And center it\n      .translate(new Vector3(this.center || ZERO_VECTOR).negate());\n  }\n  /* eslint-enable complexity, max-statements */\n\n  _getCenterInWorld({longitude, latitude}) {\n    const {meterOffset, distanceScales} = this;\n\n    // Make a centered version of the matrix for projection modes without an offset\n    const center = new Vector3(this.projectPosition([longitude, latitude, 0]));\n\n    if (meterOffset) {\n      const commonPosition = new Vector3(meterOffset)\n        // Convert to pixels in current zoom\n        .scale(distanceScales.unitsPerMeter);\n      center.add(commonPosition);\n    }\n\n    return center;\n  }\n\n  _initProjectionMatrix(opts) {\n    const {\n      // Projection matrix\n      projectionMatrix = null,\n\n      // Projection matrix parameters, used if projectionMatrix not supplied\n      orthographic = false,\n      fovyRadians,\n      fovy = 75,\n      near = 0.1, // Distance of near clipping plane\n      far = 1000, // Distance of far clipping plane\n      focalDistance = 1\n    } = opts;\n\n    this.projectionMatrix =\n      projectionMatrix ||\n      this._createProjectionMatrix({\n        orthographic,\n        fovyRadians: fovyRadians || fovy * DEGREES_TO_RADIANS,\n        aspect: this.width / this.height,\n        focalDistance,\n        near,\n        far\n      });\n  }\n\n  _initPixelMatrices() {\n    // Note: As usual, matrix operations should be applied in \"reverse\" order\n    // since vectors will be multiplied in from the right during transformation\n    const vpm = createMat4();\n    mat4.multiply(vpm, vpm, this.projectionMatrix);\n    mat4.multiply(vpm, vpm, this.viewMatrix);\n    this.viewProjectionMatrix = vpm;\n\n    // console.log('VPM', this.viewMatrix, this.projectionMatrix, this.viewProjectionMatrix);\n\n    // Calculate inverse view matrix\n    this.viewMatrixInverse = mat4.invert([], this.viewMatrix) || this.viewMatrix;\n\n    // Decompose camera parameters\n    this.cameraPosition = getCameraPosition(this.viewMatrixInverse);\n\n    /*\n     * Builds matrices that converts preprojected lngLats to screen pixels\n     * and vice versa.\n     * Note: Currently returns bottom-left coordinates!\n     * Note: Starts with the GL projection matrix and adds steps to the\n     *       scale and translate that matrix onto the window.\n     * Note: WebGL controls clip space to screen projection with gl.viewport\n     *       and does not need this step.\n     */\n\n    // matrix for conversion from world location to screen (pixel) coordinates\n    const viewportMatrix = createMat4(); // matrix from NDC to viewport.\n    const pixelProjectionMatrix = createMat4(); // matrix from world space to viewport.\n    mat4.scale(viewportMatrix, viewportMatrix, [this.width / 2, -this.height / 2, 1]);\n    mat4.translate(viewportMatrix, viewportMatrix, [1, -1, 0]);\n    mat4.multiply(pixelProjectionMatrix, viewportMatrix, this.viewProjectionMatrix);\n    this.pixelProjectionMatrix = pixelProjectionMatrix;\n    this.viewportMatrix = viewportMatrix;\n\n    this.pixelUnprojectionMatrix = mat4.invert(createMat4(), this.pixelProjectionMatrix);\n    if (!this.pixelUnprojectionMatrix) {\n      log.warn('Pixel project matrix not invertible')();\n      // throw new Error('Pixel project matrix not invertible');\n    }\n  }\n}\n\nViewport.displayName = 'Viewport';\n","// Extensions to math.gl library. Intended to be folded back.\nimport typedArrayManager from './typed-array-manager';\nimport {Vector3} from 'math.gl';\n\n// Helper, avoids low-precision 32 bit matrices from gl-matrix mat4.create()\nexport function createMat4() {\n  return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n}\n\nexport function mod(value, divisor) {\n  const modulus = value % divisor;\n  return modulus < 0 ? divisor + modulus : modulus;\n}\n\n// Extract camera vectors (move to math library?)\nexport function getCameraPosition(viewMatrixInverse) {\n  // Read the translation from the inverse view matrix\n  return [viewMatrixInverse[12], viewMatrixInverse[13], viewMatrixInverse[14]];\n}\n\n// https://www.gamedevs.org/uploads/fast-extraction-viewing-frustum-planes-from-world-view-projection-matrix.pdf\nexport function getFrustumPlanes(viewProjectionMatrix) {\n  const planes = {};\n\n  planes.left = getFrustumPlane(\n    viewProjectionMatrix[3] + viewProjectionMatrix[0],\n    viewProjectionMatrix[7] + viewProjectionMatrix[4],\n    viewProjectionMatrix[11] + viewProjectionMatrix[8],\n    viewProjectionMatrix[15] + viewProjectionMatrix[12]\n  );\n  planes.right = getFrustumPlane(\n    viewProjectionMatrix[3] - viewProjectionMatrix[0],\n    viewProjectionMatrix[7] - viewProjectionMatrix[4],\n    viewProjectionMatrix[11] - viewProjectionMatrix[8],\n    viewProjectionMatrix[15] - viewProjectionMatrix[12]\n  );\n  planes.bottom = getFrustumPlane(\n    viewProjectionMatrix[3] + viewProjectionMatrix[1],\n    viewProjectionMatrix[7] + viewProjectionMatrix[5],\n    viewProjectionMatrix[11] + viewProjectionMatrix[9],\n    viewProjectionMatrix[15] + viewProjectionMatrix[13]\n  );\n  planes.top = getFrustumPlane(\n    viewProjectionMatrix[3] - viewProjectionMatrix[1],\n    viewProjectionMatrix[7] - viewProjectionMatrix[5],\n    viewProjectionMatrix[11] - viewProjectionMatrix[9],\n    viewProjectionMatrix[15] - viewProjectionMatrix[13]\n  );\n  planes.near = getFrustumPlane(\n    viewProjectionMatrix[3] + viewProjectionMatrix[2],\n    viewProjectionMatrix[7] + viewProjectionMatrix[6],\n    viewProjectionMatrix[11] + viewProjectionMatrix[10],\n    viewProjectionMatrix[15] + viewProjectionMatrix[14]\n  );\n  planes.far = getFrustumPlane(\n    viewProjectionMatrix[3] - viewProjectionMatrix[2],\n    viewProjectionMatrix[7] - viewProjectionMatrix[6],\n    viewProjectionMatrix[11] - viewProjectionMatrix[10],\n    viewProjectionMatrix[15] - viewProjectionMatrix[14]\n  );\n\n  return planes;\n}\n\nconst scratchVector = new Vector3();\n\nfunction getFrustumPlane(a, b, c, d) {\n  scratchVector.set(a, b, c);\n  const L = scratchVector.len();\n  return {distance: d / L, normal: new Vector3(-a / L, -b / L, -c / L)};\n}\n\n/**\n * Calculate the low part of a WebGL 64 bit float\n * @param x {number} - the input float number\n * @returns {number} - the lower 32 bit of the number\n */\nexport function fp64LowPart(x) {\n  return x - Math.fround(x);\n}\n\nlet scratchArray;\n\n/**\n * Split a Float64Array into a double-length Float32Array\n * @param typedArray {Float64Array}\n * @param size {Number} - per attribute size\n * @param [startIndex] {Number} - start index in the source array\n * @param [endIndex] {Number} - end index in the source array\n * @returns {Float32Array} - high part, low part for each attribute:\n    [1xHi, 1yHi, 1zHi, 1xLow, 1yLow, 1zLow, 2xHi, ...]\n */\nexport function toDoublePrecisionArray(typedArray, {size = 1, startIndex = 0, endIndex}) {\n  if (!Number.isFinite(endIndex)) {\n    endIndex = typedArray.length;\n  }\n  const count = (endIndex - startIndex) / size;\n  scratchArray = typedArrayManager.allocate(scratchArray, count, {\n    type: Float32Array,\n    size: size * 2\n  });\n\n  let sourceIndex = startIndex;\n  let targetIndex = 0;\n  while (sourceIndex < endIndex) {\n    for (let j = 0; j < size; j++) {\n      const value = typedArray[sourceIndex++];\n      scratchArray[targetIndex + j] = value;\n      scratchArray[targetIndex + j + size] = fp64LowPart(value);\n    }\n    targetIndex += size * 2;\n  }\n\n  return scratchArray.subarray(0, count * size * 2);\n}\n","export class TypedArrayManager {\n  constructor(props) {\n    this._pool = [];\n    this.props = {overAlloc: 2, poolSize: 100};\n    this.setProps(props);\n  }\n\n  setProps(props) {\n    Object.assign(this.props, props);\n  }\n\n  allocate(\n    typedArray,\n    count,\n    {size = 1, type, padding = 0, copy = false, initialize = false, maxCount}\n  ) {\n    const Type = type || (typedArray && typedArray.constructor) || Float32Array;\n\n    const newSize = count * size + padding;\n    if (ArrayBuffer.isView(typedArray)) {\n      if (newSize <= typedArray.length) {\n        return typedArray;\n      }\n      if (newSize * typedArray.BYTES_PER_ELEMENT <= typedArray.buffer.byteLength) {\n        return new Type(typedArray.buffer, 0, newSize);\n      }\n    }\n\n    let maxSize;\n    if (maxCount) {\n      maxSize = maxCount * size + padding;\n    }\n\n    const newArray = this._allocate(Type, newSize, initialize, maxSize);\n\n    if (typedArray && copy) {\n      newArray.set(typedArray);\n    } else if (!initialize) {\n      // Hack - always initialize the first 4 elements. NaNs crash the Attribute validation\n      newArray.fill(0, 0, 4);\n    }\n\n    this._release(typedArray);\n    return newArray;\n  }\n\n  release(typedArray) {\n    this._release(typedArray);\n  }\n\n  _allocate(Type, size, initialize, maxSize) {\n    // Allocate at least one element to ensure a valid buffer\n    let sizeToAllocate = Math.max(Math.ceil(size * this.props.overAlloc), 1);\n    // Don't over allocate after certain specified number of elements\n    if (sizeToAllocate > maxSize) {\n      sizeToAllocate = maxSize;\n    }\n\n    // Check if available in pool\n    const pool = this._pool;\n    const byteLength = Type.BYTES_PER_ELEMENT * sizeToAllocate;\n    const i = pool.findIndex(b => b.byteLength >= byteLength);\n    if (i >= 0) {\n      // Create a new array using an existing buffer\n      const array = new Type(pool.splice(i, 1)[0], 0, sizeToAllocate);\n      if (initialize) {\n        // Viewing a buffer with a different type may create NaNs\n        array.fill(0);\n      }\n      return array;\n    }\n    return new Type(sizeToAllocate);\n  }\n\n  _release(typedArray) {\n    if (!ArrayBuffer.isView(typedArray)) {\n      return;\n    }\n    const pool = this._pool;\n    const {buffer} = typedArray;\n    // Save the buffer of the released array into the pool\n    // Sort buffers by size\n    // TODO - implement binary search?\n    const {byteLength} = buffer;\n    const i = pool.findIndex(b => b.byteLength >= byteLength);\n    if (i < 0) {\n      pool.push(buffer);\n    } else if (i > 0 || pool.length < this.props.poolSize) {\n      pool.splice(i, 0, buffer);\n    }\n    if (pool.length > this.props.poolSize) {\n      // Drop the smallest one\n      pool.shift();\n    }\n  }\n}\n\nexport default new TypedArrayManager();\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// Set up deck.gl global state\nexport {COORDINATE_SYSTEM} from './constants';\n\n// Export core objects\nexport {default as Deck} from './deck';\nexport {default as DeckRenderer} from './deck-renderer';\nexport {default as Effect} from './effect';\nexport {default as Layer} from './layer';\nexport {default as CompositeLayer} from './composite-layer';\nexport {default as LayerExtension} from './layer-extension';\nexport {default as AttributeManager} from './attribute/attribute-manager';\nexport {default as LayerManager} from './layer-manager';\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport LayerManager from './layer-manager';\nimport ViewManager from './view-manager';\nimport MapView from '../views/map-view';\nimport EffectManager from './effect-manager';\nimport Effect from './effect';\nimport DeckRenderer from './deck-renderer';\nimport DeckPicker from './deck-picker';\nimport Tooltip from './tooltip';\nimport log from '../utils/log';\nimport {deepEqual} from '../utils/deep-equal';\nimport typedArrayManager from '../utils/typed-array-manager';\nimport deckGlobal from './init';\n\nimport {getBrowser} from 'probe.gl/env';\nimport GL from '@luma.gl/constants';\nimport {\n  AnimationLoop,\n  createGLContext,\n  instrumentGLContext,\n  setParameters,\n  Timeline,\n  lumaStats\n} from '@luma.gl/core';\nimport {Stats} from 'probe.gl';\nimport {EventManager} from 'mjolnir.js';\n\nimport assert from '../utils/assert';\nimport {EVENTS} from './constants';\n/* global document */\n\nfunction noop() {}\n\nconst getCursor = ({isDragging}) => (isDragging ? 'grabbing' : 'grab');\n\nfunction getPropTypes(PropTypes) {\n  // Note: Arrays (layers, views, ) can contain falsy values\n  return {\n    id: PropTypes.string,\n    width: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),\n    height: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),\n\n    // layer/view/controller settings\n    layers: PropTypes.oneOfType([PropTypes.object, PropTypes.array]),\n    layerFilter: PropTypes.func,\n    views: PropTypes.oneOfType([PropTypes.object, PropTypes.array]),\n    viewState: PropTypes.object,\n    effects: PropTypes.arrayOf(PropTypes.instanceOf(Effect)),\n    controller: PropTypes.oneOfType([PropTypes.func, PropTypes.bool, PropTypes.object]),\n\n    // GL settings\n    gl: PropTypes.object,\n    glOptions: PropTypes.object,\n    parameters: PropTypes.object,\n    pickingRadius: PropTypes.number,\n    useDevicePixels: PropTypes.oneOfType([PropTypes.bool, PropTypes.number]),\n    touchAction: PropTypes.string,\n    eventRecognizerOptions: PropTypes.object,\n\n    // Callbacks\n    onWebGLInitialized: PropTypes.func,\n    onResize: PropTypes.func,\n    onViewStateChange: PropTypes.func,\n    onInteractionStateChange: PropTypes.func,\n    onBeforeRender: PropTypes.func,\n    onAfterRender: PropTypes.func,\n    onLoad: PropTypes.func,\n    onError: PropTypes.func,\n\n    // Debug settings\n    debug: PropTypes.bool,\n    drawPickingColors: PropTypes.bool,\n\n    // Experimental props\n    _framebuffer: PropTypes.object,\n    // Forces a redraw every animation frame\n    _animate: PropTypes.bool,\n\n    // UNSAFE options - not exhaustively tested, not guaranteed to work in all cases, use at your own risk\n\n    // Set to false to disable picking - avoiding picking buffer creation can save memory for mobile web browsers\n    _pickable: PropTypes.bool,\n\n    // Adjust parameters of typed array manager, can save memory e.g. for mobile web browsers\n    _typedArrayManagerProps: PropTypes.object //  {overAlloc: number, poolSize: number}\n  };\n}\n\nconst defaultProps = {\n  id: '',\n  width: '100%',\n  height: '100%',\n\n  pickingRadius: 0,\n  layerFilter: null,\n  glOptions: {},\n  gl: null,\n  layers: [],\n  effects: [],\n  views: null,\n  controller: null, // Rely on external controller, e.g. react-map-gl\n  useDevicePixels: true,\n  touchAction: 'none',\n  eventRecognizerOptions: {},\n  _framebuffer: null,\n  _animate: false,\n  _pickable: true,\n  _typedArrayManagerProps: {},\n\n  onWebGLInitialized: noop,\n  onResize: noop,\n  onViewStateChange: noop,\n  onInteractionStateChange: noop,\n  onBeforeRender: noop,\n  onAfterRender: noop,\n  onLoad: noop,\n  onError: (error, layer) => log.error(error)(),\n  _onMetrics: null,\n\n  getCursor,\n\n  debug: false,\n  drawPickingColors: false\n};\n\n/* eslint-disable max-statements */\nexport default class Deck {\n  constructor(props) {\n    props = {...defaultProps, ...props};\n    this.props = {};\n\n    this.width = 0; // \"read-only\", auto-updated from canvas\n    this.height = 0; // \"read-only\", auto-updated from canvas\n\n    // Maps view descriptors to vieports, rebuilds when width/height/viewState/views change\n    this.viewManager = null;\n    this.layerManager = null;\n    this.effectManager = null;\n    this.deckRenderer = null;\n    this.deckPicker = null;\n\n    this._needsRedraw = true;\n    this._pickRequest = {};\n    // Pick and store the object under the pointer on `pointerdown`.\n    // This object is reused for subsequent `onClick` and `onDrag*` callbacks.\n    this._lastPointerDownInfo = null;\n\n    this.viewState = null; // Internal view state if no callback is supplied\n    this.interactiveState = {\n      isHovering: false, // Whether the cursor is over a pickable object\n      isDragging: false // Whether the cursor is down\n    };\n\n    // Bind methods\n    this._onEvent = this._onEvent.bind(this);\n    this._onPointerDown = this._onPointerDown.bind(this);\n    this._onPointerMove = this._onPointerMove.bind(this);\n\n    if (props.viewState && props.initialViewState) {\n      log.warn(\n        'View state tracking is disabled. Use either `initialViewState` for auto update or `viewState` for manual update.'\n      )();\n    }\n    if (getBrowser() === 'IE') {\n      log.warn('IE 11 support will be deprecated in v8.0')();\n    }\n\n    if (!props.gl) {\n      // Note: LayerManager creation deferred until gl context available\n      if (typeof document !== 'undefined') {\n        this.canvas = this._createCanvas(props);\n      }\n    }\n    this.animationLoop = this._createAnimationLoop(props);\n\n    this.stats = new Stats({id: 'deck.gl'});\n    this.metrics = {\n      fps: 0,\n      setPropsTime: 0,\n      updateAttributesTime: 0,\n      framesRedrawn: 0,\n      pickTime: 0,\n      pickCount: 0,\n      gpuTime: 0,\n      gpuTimePerFrame: 0,\n      cpuTime: 0,\n      cpuTimePerFrame: 0,\n      bufferMemory: 0,\n      textureMemory: 0,\n      renderbufferMemory: 0,\n      gpuMemory: 0\n    };\n    this._metricsCounter = 0;\n\n    this.setProps(props);\n\n    // UNSAFE/experimental prop: only set at initialization to avoid performance hit\n    if (props._typedArrayManagerProps) {\n      typedArrayManager.setProps(props._typedArrayManagerProps);\n    }\n\n    this.animationLoop.start();\n  }\n\n  finalize() {\n    this.animationLoop.stop();\n    this.animationLoop = null;\n    this._lastPointerDownInfo = null;\n\n    if (this.layerManager) {\n      this.layerManager.finalize();\n      this.layerManager = null;\n\n      this.viewManager.finalize();\n      this.viewManager = null;\n\n      this.effectManager.finalize();\n      this.effectManager = null;\n\n      this.deckRenderer.finalize();\n      this.deckRenderer = null;\n\n      this.deckPicker.finalize();\n      this.deckPicker = null;\n\n      this.eventManager.destroy();\n      this.eventManager = null;\n\n      this.tooltip.remove();\n      this.tooltip = null;\n    }\n\n    if (!this.props.canvas && !this.props.gl && this.canvas) {\n      // remove internally created canvas\n      this.canvas.parentElement.removeChild(this.canvas);\n      this.canvas = null;\n    }\n  }\n\n  setProps(props) {\n    this.stats.get('setProps Time').timeStart();\n\n    if ('onLayerHover' in props) {\n      log.removed('onLayerHover', 'onHover')();\n    }\n    if ('onLayerClick' in props) {\n      log.removed('onLayerClick', 'onClick')();\n    }\n    if (props.initialViewState && !deepEqual(this.props.initialViewState, props.initialViewState)) {\n      // Overwrite internal view state\n      this.viewState = props.initialViewState;\n    }\n\n    // Merge with existing props\n    Object.assign(this.props, props);\n\n    // Update CSS size of canvas\n    this._setCanvasSize(this.props);\n\n    // We need to overwrite CSS style width and height with actual, numeric values\n    const resolvedProps = Object.create(this.props);\n    Object.assign(resolvedProps, {\n      views: this._getViews(),\n      width: this.width,\n      height: this.height,\n      viewState: this._getViewState()\n    });\n\n    // Update the animation loop\n    this.animationLoop.setProps(resolvedProps);\n\n    // If initialized, update sub manager props\n    if (this.layerManager) {\n      this.viewManager.setProps(resolvedProps);\n      // Make sure that any new layer gets initialized with the current viewport\n      this.layerManager.activateViewport(this.getViewports()[0]);\n      this.layerManager.setProps(resolvedProps);\n      this.effectManager.setProps(resolvedProps);\n      this.deckRenderer.setProps(resolvedProps);\n      this.deckPicker.setProps(resolvedProps);\n    }\n\n    this.stats.get('setProps Time').timeEnd();\n  }\n\n  // Public API\n  // Check if a redraw is needed\n  // Returns `false` or a string summarizing the redraw reason\n  // opts.clearRedrawFlags (Boolean) - clear the redraw flag. Default `true`\n  needsRedraw(opts = {clearRedrawFlags: false}) {\n    if (this.props._animate) {\n      return 'Deck._animate';\n    }\n\n    let redraw = this._needsRedraw;\n\n    if (opts.clearRedrawFlags) {\n      this._needsRedraw = false;\n    }\n\n    const viewManagerNeedsRedraw = this.viewManager.needsRedraw(opts);\n    const layerManagerNeedsRedraw = this.layerManager.needsRedraw(opts);\n    const effectManagerNeedsRedraw = this.effectManager.needsRedraw(opts);\n    const deckRendererNeedsRedraw = this.deckRenderer.needsRedraw(opts);\n\n    redraw =\n      redraw ||\n      viewManagerNeedsRedraw ||\n      layerManagerNeedsRedraw ||\n      effectManagerNeedsRedraw ||\n      deckRendererNeedsRedraw;\n    return redraw;\n  }\n\n  redraw(force) {\n    if (!this.layerManager) {\n      // Not yet initialized\n      return;\n    }\n    // If force is falsy, check if we need to redraw\n    const redrawReason = force || this.needsRedraw({clearRedrawFlags: true});\n\n    if (!redrawReason) {\n      return;\n    }\n\n    this.stats.get('Redraw Count').incrementCount();\n    if (this.props._customRender) {\n      this.props._customRender(redrawReason);\n    } else {\n      this._drawLayers(redrawReason);\n    }\n  }\n\n  getViews() {\n    return this.viewManager.views;\n  }\n\n  // Get a set of viewports for a given width and height\n  getViewports(rect) {\n    return this.viewManager.getViewports(rect);\n  }\n\n  /* {x, y, radius = 0, layerIds = null, unproject3D} */\n  pickObject(opts) {\n    const infos = this._pick('pickObject', 'pickObject Time', opts).result;\n    return infos.length ? infos[0] : null;\n  }\n\n  /* {x, y, radius = 0, layerIds = null, unproject3D, depth = 10} */\n  pickMultipleObjects(opts) {\n    opts.depth = opts.depth || 10;\n    return this._pick('pickObject', 'pickMultipleObjects Time', opts).result;\n  }\n\n  /* {x, y, width = 1, height = 1, layerIds = null} */\n  pickObjects(opts) {\n    return this._pick('pickObjects', 'pickObjects Time', opts);\n  }\n\n  // Experimental\n\n  _addResources(resources, forceUpdate = false) {\n    for (const id in resources) {\n      this.layerManager.resourceManager.add({resourceId: id, data: resources[id], forceUpdate});\n    }\n  }\n\n  _removeResources(resourceIds) {\n    for (const id of resourceIds) {\n      this.layerManager.resourceManager.remove(id);\n    }\n  }\n\n  // Private Methods\n\n  _pick(method, statKey, opts) {\n    const {stats} = this;\n\n    stats.get('Pick Count').incrementCount();\n    stats.get(statKey).timeStart();\n\n    const infos = this.deckPicker[method]({\n      layers: this.layerManager.getLayers(opts),\n      views: this.viewManager.getViews(),\n      viewports: this.getViewports(opts),\n      onViewportActive: this.layerManager.activateViewport,\n      ...opts\n    });\n\n    stats.get(statKey).timeEnd();\n\n    return infos;\n  }\n\n  // canvas, either string, canvas or `null`\n  _createCanvas(props) {\n    let canvas = props.canvas;\n\n    // TODO EventManager should accept element id\n    if (typeof canvas === 'string') {\n      canvas = document.getElementById(canvas);\n      assert(canvas);\n    }\n\n    if (!canvas) {\n      canvas = document.createElement('canvas');\n      canvas.id = props.id || 'deckgl-overlay';\n      const parent = props.parent || document.body;\n      parent.appendChild(canvas);\n    }\n\n    Object.assign(canvas.style, props.style);\n\n    return canvas;\n  }\n\n  // Updates canvas width and/or height, if provided as props\n  _setCanvasSize(props) {\n    if (!this.canvas) {\n      return;\n    }\n\n    let {width, height} = props;\n    // Set size ONLY if props are being provided, otherwise let canvas be layouted freely\n    if (width || width === 0) {\n      width = Number.isFinite(width) ? `${width}px` : width;\n      this.canvas.style.width = width;\n    }\n    if (height || height === 0) {\n      height = Number.isFinite(height) ? `${height}px` : height;\n      // Note: position==='absolute' required for height 100% to work\n      this.canvas.style.position = 'absolute';\n      this.canvas.style.height = height;\n    }\n  }\n\n  // If canvas size has changed, updates\n  _updateCanvasSize() {\n    if (this._checkForCanvasSizeChange()) {\n      const {width, height} = this;\n      this.viewManager.setProps({width, height});\n      this.props.onResize({width: this.width, height: this.height});\n    }\n  }\n\n  // If canvas size has changed, reads out the new size and returns true\n  _checkForCanvasSizeChange() {\n    const {canvas} = this;\n    if (!canvas) {\n      return false;\n    }\n    // Fallback to width/height when clientWidth/clientHeight are 0 or undefined.\n    const newWidth = canvas.clientWidth || canvas.width;\n    const newHeight = canvas.clientHeight || canvas.height;\n    if (newWidth !== this.width || newHeight !== this.height) {\n      this.width = newWidth;\n      this.height = newHeight;\n      return true;\n    }\n    return false;\n  }\n\n  _createAnimationLoop(props) {\n    const {\n      width,\n      height,\n      gl,\n      glOptions,\n      debug,\n      onError,\n      onBeforeRender,\n      onAfterRender,\n      useDevicePixels,\n      autoResizeDrawingBuffer\n    } = props;\n\n    return new AnimationLoop({\n      width,\n      height,\n      useDevicePixels,\n      autoResizeDrawingBuffer,\n      autoResizeViewport: false,\n      gl,\n      onCreateContext: opts =>\n        createGLContext({\n          ...glOptions,\n          ...opts,\n          canvas: this.canvas,\n          debug,\n          onContextLost: () => this._onContextLost()\n        }),\n      onInitialize: context => this._setGLContext(context.gl),\n      onRender: this._onRenderFrame.bind(this),\n      onBeforeRender,\n      onAfterRender,\n      onError\n    });\n  }\n\n  // Get the most relevant view state: props.viewState, if supplied, shadows internal viewState\n  // TODO: For backwards compatibility ensure numeric width and height is added to the viewState\n  _getViewState() {\n    return this.props.viewState || this.viewState;\n  }\n\n  // Get the view descriptor list\n  _getViews() {\n    // Default to a full screen map view port\n    let views = this.props.views || [new MapView({id: 'default-view'})];\n    views = Array.isArray(views) ? views : [views];\n    if (views.length && this.props.controller) {\n      // Backward compatibility: support controller prop\n      views[0].props.controller = this.props.controller;\n    }\n    return views;\n  }\n\n  _onContextLost() {\n    const {onError} = this.props;\n    if (this.animationLoop && onError) {\n      onError(new Error(`WebGL context is lost`));\n    }\n  }\n\n  // The `pointermove` event may fire multiple times in between two animation frames,\n  // it's a waste of time to run picking without rerender. Instead we save the last pick\n  // request and only do it once on the next animation frame.\n  _onPointerMove(event) {\n    const {_pickRequest} = this;\n    if (event.type === 'pointerleave') {\n      _pickRequest.x = -1;\n      _pickRequest.y = -1;\n      _pickRequest.radius = 0;\n    } else if (event.leftButton || event.rightButton) {\n      // Do not trigger onHover callbacks if mouse button is down.\n      return;\n    } else {\n      const pos = event.offsetCenter;\n      // Do not trigger callbacks when click/hover position is invalid. Doing so will cause a\n      // assertion error when attempting to unproject the position.\n      if (!pos) {\n        return;\n      }\n      _pickRequest.x = pos.x;\n      _pickRequest.y = pos.y;\n      _pickRequest.radius = this.props.pickingRadius;\n    }\n\n    if (this.layerManager) {\n      this.layerManager.context.mousePosition = {x: _pickRequest.x, y: _pickRequest.y};\n    }\n\n    _pickRequest.event = event;\n    _pickRequest.mode = 'hover';\n  }\n\n  // Actually run picking\n  _pickAndCallback() {\n    const {_pickRequest} = this;\n\n    if (_pickRequest.event) {\n      // Perform picking\n      const {result, emptyInfo} = this._pick('pickObject', 'pickObject Time', _pickRequest);\n      this.interactiveState.isHovering = result.length > 0;\n\n      // There are 4 possible scenarios:\n      // result is [outInfo, pickedInfo] (moved from one pickable layer to another)\n      // result is [outInfo] (moved outside of a pickable layer)\n      // result is [pickedInfo] (moved into or over a pickable layer)\n      // result is [] (nothing is or was picked)\n      //\n      // `layer.props.onHover` should be called on all affected layers (out/over)\n      // `deck.props.onHover` should be called with the picked info if any, or empty info otherwise\n      // `deck.props.getTooltip` should be called with the picked info if any, or empty info otherwise\n\n      // Execute callbacks\n      let pickedInfo = emptyInfo;\n      let handled = false;\n      for (const info of result) {\n        pickedInfo = info;\n        handled = info.layer.onHover(info, _pickRequest.event);\n      }\n      if (!handled && this.props.onHover) {\n        this.props.onHover(pickedInfo, _pickRequest.event);\n      }\n\n      // Update tooltip\n      if (this.props.getTooltip) {\n        const displayInfo = this.props.getTooltip(pickedInfo);\n        this.tooltip.setTooltip(displayInfo, pickedInfo.x, pickedInfo.y);\n      }\n\n      // Clear pending pickRequest\n      _pickRequest.event = null;\n    }\n  }\n\n  _updateCursor() {\n    const container = this.props.parent || this.canvas;\n    if (container) {\n      container.style.cursor = this.props.getCursor(this.interactiveState);\n    }\n  }\n\n  _setGLContext(gl) {\n    if (this.layerManager) {\n      return;\n    }\n\n    // if external context...\n    if (!this.canvas) {\n      this.canvas = gl.canvas;\n      instrumentGLContext(gl, {enable: true, copyState: true});\n    }\n\n    this.tooltip = new Tooltip(this.canvas);\n\n    setParameters(gl, {\n      blend: true,\n      blendFunc: [GL.SRC_ALPHA, GL.ONE_MINUS_SRC_ALPHA, GL.ONE, GL.ONE_MINUS_SRC_ALPHA],\n      polygonOffsetFill: true,\n      depthTest: true,\n      depthFunc: GL.LEQUAL\n    });\n\n    this.props.onWebGLInitialized(gl);\n\n    // timeline for transitions\n    const timeline = new Timeline();\n    timeline.play();\n    this.animationLoop.attachTimeline(timeline);\n\n    this.eventManager = new EventManager(this.props.parent || gl.canvas, {\n      touchAction: this.props.touchAction,\n      recognizerOptions: this.props.eventRecognizerOptions,\n      events: {\n        pointerdown: this._onPointerDown,\n        pointermove: this._onPointerMove,\n        pointerleave: this._onPointerMove\n      }\n    });\n    for (const eventType in EVENTS) {\n      this.eventManager.on(eventType, this._onEvent);\n    }\n\n    this.viewManager = new ViewManager({\n      timeline,\n      eventManager: this.eventManager,\n      onViewStateChange: this._onViewStateChange.bind(this),\n      onInteractionStateChange: this._onInteractionStateChange.bind(this),\n      views: this._getViews(),\n      viewState: this._getViewState(),\n      width: this.width,\n      height: this.height\n    });\n\n    // viewManager must be initialized before layerManager\n    // layerManager depends on viewport created by viewManager.\n    const viewport = this.viewManager.getViewports()[0];\n\n    // Note: avoid React setState due GL animation loop / setState timing issue\n    this.layerManager = new LayerManager(gl, {\n      deck: this,\n      stats: this.stats,\n      viewport,\n      timeline\n    });\n\n    this.effectManager = new EffectManager();\n\n    this.deckRenderer = new DeckRenderer(gl);\n\n    this.deckPicker = new DeckPicker(gl);\n\n    this.setProps(this.props);\n\n    this._updateCanvasSize();\n    this.props.onLoad();\n  }\n\n  _drawLayers(redrawReason, renderOptions) {\n    const {gl} = this.layerManager.context;\n\n    setParameters(gl, this.props.parameters);\n\n    this.props.onBeforeRender({gl});\n\n    this.deckRenderer.renderLayers({\n      target: this.props._framebuffer,\n      layers: this.layerManager.getLayers(),\n      viewports: this.viewManager.getViewports(),\n      onViewportActive: this.layerManager.activateViewport,\n      views: this.viewManager.getViews(),\n      pass: 'screen',\n      redrawReason,\n      effects: this.effectManager.getEffects(),\n      ...renderOptions\n    });\n\n    this.props.onAfterRender({gl});\n  }\n\n  // Callbacks\n\n  _onRenderFrame(animationProps) {\n    this._getFrameStats();\n\n    // Log perf stats every second\n    if (this._metricsCounter++ % 60 === 0) {\n      this._getMetrics();\n      this.stats.reset();\n      log.table(4, this.metrics)();\n\n      // Experimental: report metrics\n      if (this.props._onMetrics) {\n        this.props._onMetrics(this.metrics);\n      }\n    }\n\n    this._updateCanvasSize();\n\n    this._updateCursor();\n\n    // If view state has changed, clear tooltip\n    if (this.tooltip.isVisible && this.viewManager.needsRedraw()) {\n      this.tooltip.setTooltip(null);\n    }\n\n    // Update layers if needed (e.g. some async prop has loaded)\n    // Note: This can trigger a redraw\n    this.layerManager.updateLayers();\n\n    // Perform picking request if any\n    this._pickAndCallback();\n\n    // Redraw if necessary\n    this.redraw(false);\n\n    // Update viewport transition if needed\n    // Note: this can trigger `onViewStateChange`, and affect layers\n    // We want to defer these changes to the next frame\n    if (this.viewManager) {\n      this.viewManager.updateViewStates();\n    }\n  }\n\n  // Callbacks\n\n  _onViewStateChange(params) {\n    // Let app know that view state is changing, and give it a chance to change it\n    const viewState = this.props.onViewStateChange(params) || params.viewState;\n\n    // If initialViewState was set on creation, auto track position\n    if (this.viewState) {\n      this.viewState = {...this.viewState, [params.viewId]: viewState};\n      if (!this.props.viewState) {\n        // Apply internal view state\n        if (this.viewManager) {\n          this.viewManager.setProps({viewState: this.viewState});\n        }\n      }\n    }\n  }\n\n  _onInteractionStateChange(interactionState) {\n    this.interactiveState.isDragging = interactionState.isDragging;\n    this.props.onInteractionStateChange(interactionState);\n  }\n\n  _onEvent(event) {\n    const eventOptions = EVENTS[event.type];\n    const pos = event.offsetCenter;\n\n    if (!eventOptions || !pos) {\n      return;\n    }\n\n    // Reuse last picked object\n    const layers = this.layerManager.getLayers();\n    const info = this.deckPicker.getLastPickedObject(\n      {\n        x: pos.x,\n        y: pos.y,\n        layers,\n        viewports: this.getViewports(pos)\n      },\n      this._lastPointerDownInfo\n    );\n\n    const {layer} = info;\n    const layerHandler =\n      layer && (layer[eventOptions.handler] || layer.props[eventOptions.handler]);\n    const rootHandler = this.props[eventOptions.handler];\n    let handled = false;\n\n    if (layerHandler) {\n      handled = layerHandler.call(layer, info, event);\n    }\n    if (!handled && rootHandler) {\n      rootHandler(info, event);\n    }\n  }\n\n  _onPointerDown(event) {\n    const pos = event.offsetCenter;\n    this._lastPointerDownInfo = this.pickObject({\n      x: pos.x,\n      y: pos.y,\n      radius: this.props.pickingRadius\n    });\n  }\n\n  _getFrameStats() {\n    const {stats} = this;\n    stats.get('frameRate').timeEnd();\n    stats.get('frameRate').timeStart();\n\n    // Get individual stats from luma.gl so reset works\n    const animationLoopStats = this.animationLoop.stats;\n    stats.get('GPU Time').addTime(animationLoopStats.get('GPU Time').lastTiming);\n    stats.get('CPU Time').addTime(animationLoopStats.get('CPU Time').lastTiming);\n  }\n\n  _getMetrics() {\n    const {metrics, stats} = this;\n    metrics.fps = stats.get('frameRate').getHz();\n    metrics.setPropsTime = stats.get('setProps Time').time;\n    metrics.updateAttributesTime = stats.get('Update Attributes').time;\n    metrics.framesRedrawn = stats.get('Redraw Count').count;\n    metrics.pickTime =\n      stats.get('pickObject Time').time +\n      stats.get('pickMultipleObjects Time').time +\n      stats.get('pickObjects Time').time;\n    metrics.pickCount = stats.get('Pick Count').count;\n\n    // Luma stats\n    metrics.gpuTime = stats.get('GPU Time').time;\n    metrics.cpuTime = stats.get('CPU Time').time;\n    metrics.gpuTimePerFrame = stats.get('GPU Time').getAverageTime();\n    metrics.cpuTimePerFrame = stats.get('CPU Time').getAverageTime();\n\n    const memoryStats = lumaStats.get('Memory Usage');\n    metrics.bufferMemory = memoryStats.get('Buffer Memory').count;\n    metrics.textureMemory = memoryStats.get('Texture Memory').count;\n    metrics.renderbufferMemory = memoryStats.get('Renderbuffer Memory').count;\n    metrics.gpuMemory = memoryStats.get('GPU Memory').count;\n  }\n}\n\nDeck.getPropTypes = getPropTypes;\nDeck.defaultProps = defaultProps;\n\n// This is used to defeat tree shaking of init.js\n// https://github.com/visgl/deck.gl/issues/3213\nDeck.VERSION = deckGlobal.VERSION;\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {Timeline} from '@luma.gl/core';\nimport {LIFECYCLE} from '../lifecycle/constants';\nimport log from '../utils/log';\nimport debug from '../debug';\nimport {flatten} from '../utils/flatten';\nimport {Stats} from 'probe.gl';\nimport ResourceManager from './resource/resource-manager';\n\nimport Viewport from '../viewports/viewport';\nimport {createProgramManager} from '../shaderlib';\n\nconst TRACE_SET_LAYERS = 'layerManager.setLayers';\nconst TRACE_ACTIVATE_VIEWPORT = 'layerManager.activateViewport';\n\n// CONTEXT IS EXPOSED TO LAYERS\nconst INITIAL_CONTEXT = Object.seal({\n  layerManager: null,\n  resourceManager: null,\n  deck: null,\n  gl: null,\n\n  // General resources\n  stats: null, // for tracking lifecycle performance\n\n  // GL Resources\n  shaderCache: null,\n  pickingFBO: null, // Screen-size framebuffer that layers can reuse\n\n  mousePosition: null,\n\n  userData: {} // Place for any custom app `context`\n});\n\nexport default class LayerManager {\n  // eslint-disable-next-line\n  constructor(gl, {deck, stats, viewport, timeline} = {}) {\n    // Currently deck.gl expects the DeckGL.layers array to be different\n    // whenever React rerenders. If the same layers array is used, the\n    // LayerManager's diffing algorithm will generate a fatal error and\n    // break the rendering.\n\n    // `this.lastRenderedLayers` stores the UNFILTERED layers sent\n    // down to LayerManager, so that `layers` reference can be compared.\n    // If it's the same across two React render calls, the diffing logic\n    // will be skipped.\n    this.lastRenderedLayers = [];\n    this.layers = [];\n    this.resourceManager = new ResourceManager({gl, protocol: 'deck://'});\n\n    this.context = {\n      ...INITIAL_CONTEXT,\n      layerManager: this,\n      gl,\n      deck,\n      // Enabling luma.gl Program caching using private API (_cachePrograms)\n      programManager: gl && createProgramManager(gl),\n      stats: stats || new Stats({id: 'deck.gl'}),\n      // Make sure context.viewport is not empty on the first layer initialization\n      viewport: viewport || new Viewport({id: 'DEFAULT-INITIAL-VIEWPORT'}), // Current viewport, exposed to layers for project* function\n      timeline: timeline || new Timeline(),\n      resourceManager: this.resourceManager\n    };\n\n    this._nextLayers = null;\n    this._needsRedraw = 'Initial render';\n    this._needsUpdate = false;\n    this._debug = false;\n\n    this.activateViewport = this.activateViewport.bind(this);\n\n    Object.seal(this);\n  }\n\n  // Method to call when the layer manager is not needed anymore.\n  finalize() {\n    this.resourceManager.finalize();\n    // Finalize all layers\n    for (const layer of this.layers) {\n      this._finalizeLayer(layer);\n    }\n  }\n\n  // Check if a redraw is needed\n  needsRedraw(opts = {clearRedrawFlags: false}) {\n    let redraw = this._needsRedraw;\n    if (opts.clearRedrawFlags) {\n      this._needsRedraw = false;\n    }\n\n    // This layers list doesn't include sublayers, relying on composite layers\n    for (const layer of this.layers) {\n      // Call every layer to clear their flags\n      const layerNeedsRedraw = layer.getNeedsRedraw(opts);\n      redraw = redraw || layerNeedsRedraw;\n    }\n\n    return redraw;\n  }\n\n  // Check if a deep update of all layers is needed\n  needsUpdate() {\n    if (this._nextLayers && this._nextLayers !== this.lastRenderedLayers) {\n      // New layers array may be the same as the old one if `setProps` is called by React\n      return 'layers changed';\n    }\n    return this._needsUpdate;\n  }\n\n  // Layers will be redrawn (in next animation frame)\n  setNeedsRedraw(reason) {\n    this._needsRedraw = this._needsRedraw || reason;\n  }\n\n  // Layers will be updated deeply (in next animation frame)\n  // Potentially regenerating attributes and sub layers\n  setNeedsUpdate(reason) {\n    this._needsUpdate = this._needsUpdate || reason;\n  }\n\n  // Gets an (optionally) filtered list of layers\n  getLayers({layerIds = null} = {}) {\n    // Filtering by layerId compares beginning of strings, so that sublayers will be included\n    // Dependes on the convention of adding suffixes to the parent's layer name\n    return layerIds\n      ? this.layers.filter(layer => layerIds.find(layerId => layer.id.indexOf(layerId) === 0))\n      : this.layers;\n  }\n\n  // Set props needed for layer rendering and picking.\n  setProps(props) {\n    if ('debug' in props) {\n      this._debug = props.debug;\n    }\n\n    // A way for apps to add data to context that can be accessed in layers\n    if ('userData' in props) {\n      this.context.userData = props.userData;\n    }\n\n    // New layers will be processed in `updateLayers` in the next update cycle\n    if ('layers' in props) {\n      this._nextLayers = props.layers;\n    }\n\n    if ('onError' in props) {\n      this.context.onError = props.onError;\n    }\n  }\n\n  // Supply a new layer list, initiating sublayer generation and layer matching\n  setLayers(newLayers, reason) {\n    debug(TRACE_SET_LAYERS, this, reason, newLayers);\n\n    this.lastRenderedLayers = newLayers;\n\n    newLayers = flatten(newLayers, Boolean);\n\n    for (const layer of newLayers) {\n      layer.context = this.context;\n    }\n\n    this._updateLayers(this.layers, newLayers);\n\n    return this;\n  }\n\n  // Update layers from last cycle if `setNeedsUpdate()` has been called\n  updateLayers() {\n    // NOTE: For now, even if only some layer has changed, we update all layers\n    // to ensure that layer id maps etc remain consistent even if different\n    // sublayers are rendered\n    const reason = this.needsUpdate();\n    if (reason) {\n      this.setNeedsRedraw(`updating layers: ${reason}`);\n      // Force a full update\n      this.setLayers(this._nextLayers || this.lastRenderedLayers, reason);\n    }\n    // Updated, clear the backlog\n    this._nextLayers = null;\n  }\n\n  //\n  // PRIVATE METHODS\n  //\n\n  // Make a viewport \"current\" in layer context, updating viewportChanged flags\n  activateViewport(viewport) {\n    debug(TRACE_ACTIVATE_VIEWPORT, this, viewport);\n    if (viewport) {\n      this.context.viewport = viewport;\n    }\n    return this;\n  }\n\n  _handleError(stage, error, layer) {\n    layer.raiseError(error, `${stage} of ${layer}`);\n  }\n\n  // Match all layers, checking for caught errors\n  // To avoid having an exception in one layer disrupt other layers\n  // TODO - mark layers with exceptions as bad and remove from rendering cycle?\n  _updateLayers(oldLayers, newLayers) {\n    // Create old layer map\n    const oldLayerMap = {};\n    for (const oldLayer of oldLayers) {\n      if (oldLayerMap[oldLayer.id]) {\n        log.warn(`Multiple old layers with same id ${oldLayer.id}`)();\n      } else {\n        oldLayerMap[oldLayer.id] = oldLayer;\n      }\n    }\n\n    // Allocate array for generated layers\n    const generatedLayers = [];\n\n    // Match sublayers\n    this._updateSublayersRecursively(newLayers, oldLayerMap, generatedLayers);\n\n    // Finalize unmatched layers\n    this._finalizeOldLayers(oldLayerMap);\n\n    let needsUpdate = false;\n    for (const layer of generatedLayers) {\n      if (layer.hasUniformTransition()) {\n        needsUpdate = true;\n        break;\n      }\n    }\n\n    this._needsUpdate = needsUpdate;\n    this.layers = generatedLayers;\n  }\n\n  /* eslint-disable complexity,max-statements */\n  // Note: adds generated layers to `generatedLayers` array parameter\n  _updateSublayersRecursively(newLayers, oldLayerMap, generatedLayers) {\n    for (const newLayer of newLayers) {\n      newLayer.context = this.context;\n\n      // Given a new coming layer, find its matching old layer (if any)\n      const oldLayer = oldLayerMap[newLayer.id];\n      if (oldLayer === null) {\n        // null, rather than undefined, means this id was originally there\n        log.warn(`Multiple new layers with same id ${newLayer.id}`)();\n      }\n      // Remove the old layer from candidates, as it has been matched with this layer\n      oldLayerMap[newLayer.id] = null;\n\n      let sublayers = null;\n\n      // We must not generate exceptions until after layer matching is complete\n      try {\n        if (this._debug && oldLayer !== newLayer) {\n          newLayer.validateProps();\n        }\n\n        if (!oldLayer) {\n          this._initializeLayer(newLayer);\n        } else {\n          this._transferLayerState(oldLayer, newLayer);\n          this._updateLayer(newLayer);\n        }\n        generatedLayers.push(newLayer);\n\n        // Call layer lifecycle method: render sublayers\n        sublayers = newLayer.isComposite && newLayer.getSubLayers();\n        // End layer lifecycle method: render sublayers\n      } catch (err) {\n        this._handleError('matching', err, newLayer); // Record first exception\n      }\n\n      if (sublayers) {\n        this._updateSublayersRecursively(sublayers, oldLayerMap, generatedLayers);\n      }\n    }\n  }\n  /* eslint-enable complexity,max-statements */\n\n  // Finalize any old layers that were not matched\n  _finalizeOldLayers(oldLayerMap) {\n    for (const layerId in oldLayerMap) {\n      const layer = oldLayerMap[layerId];\n      if (layer) {\n        this._finalizeLayer(layer);\n      }\n    }\n  }\n\n  // EXCEPTION SAFE LAYER ACCESS\n\n  // Initializes a single layer, calling layer methods\n  _initializeLayer(layer) {\n    try {\n      layer._initialize();\n      layer.lifecycle = LIFECYCLE.INITIALIZED;\n    } catch (err) {\n      this._handleError('initialization', err, layer);\n      // TODO - what should the lifecycle state be here? LIFECYCLE.INITIALIZATION_FAILED?\n    }\n  }\n\n  _transferLayerState(oldLayer, newLayer) {\n    newLayer._transferState(oldLayer);\n    newLayer.lifecycle = LIFECYCLE.MATCHED;\n\n    if (newLayer !== oldLayer) {\n      oldLayer.lifecycle = LIFECYCLE.AWAITING_GC;\n    }\n  }\n\n  // Updates a single layer, cleaning all flags\n  _updateLayer(layer) {\n    try {\n      layer._update();\n    } catch (err) {\n      this._handleError('update', err, layer);\n    }\n  }\n\n  // Finalizes a single layer\n  _finalizeLayer(layer) {\n    this._needsRedraw = this._needsRedraw || `finalized ${layer}`;\n\n    layer.lifecycle = LIFECYCLE.AWAITING_FINALIZATION;\n\n    try {\n      layer._finalize();\n      layer.lifecycle = LIFECYCLE.FINALIZED;\n    } catch (err) {\n      this._handleError('finalization', err, layer);\n    }\n  }\n}\n","export const LIFECYCLE = {\n  NO_STATE: 'Awaiting state',\n  MATCHED: 'Matched. State transferred from previous layer',\n  INITIALIZED: 'Initialized',\n  AWAITING_GC: 'Discarded. Awaiting garbage collection',\n  AWAITING_FINALIZATION: 'No longer matched. Awaiting garbage collection',\n  FINALIZED: 'Finalized! Awaiting garbage collection'\n};\n\n/* Secret props keys */\n// Symbols are non-enumerable by default, does not show in for...in or Object.keys\n// but are copied with Object.assign ¯\\_(ツ)_/¯\n// Supported everywhere except IE11, can be polyfilled with core-js\nexport const PROP_SYMBOLS = {\n  COMPONENT: Symbol.for('component'),\n  ASYNC_DEFAULTS: Symbol.for('asyncPropDefaults'),\n  ASYNC_ORIGINAL: Symbol.for('asyncPropOriginal'),\n  ASYNC_RESOLVED: Symbol.for('asyncPropResolved')\n};\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/**\n * Flattens a nested array into a single level array,\n * or a single value into an array with one value\n * @example flatten([[1, [2]], [3], 4]) => [1, 2, 3, 4]\n * @example flatten(1) => [1]\n * @param {Array} array The array to flatten.\n * @param {Function} filter= - Optional predicate called on each `value` to\n *   determine if it should be included (pushed onto) the resulting array.\n * @param {Function} map= - Optional transform applied to each array elements.\n * @param {Array} result=[] - Optional array to push value into\n * @return {Array} Returns the new flattened array (new array or `result` if provided)\n */\nexport function flatten(array, filter = () => true) {\n  // Wrap single object in array\n  if (!Array.isArray(array)) {\n    return filter(array) ? [array] : [];\n  }\n  // Deep flatten and filter the array\n  return flattenArray(array, filter, []);\n}\n\n// Deep flattens an array. Helper to `flatten`, see its parameters\nfunction flattenArray(array, filter, result) {\n  let index = -1;\n  while (++index < array.length) {\n    const value = array[index];\n    if (Array.isArray(value)) {\n      flattenArray(value, filter, result);\n    } else if (filter(value)) {\n      result.push(value);\n    }\n  }\n  return result;\n}\n\n// Uses copyWithin to significantly speed up typed array value filling\nexport function fillArray({target, source, start = 0, count = 1}) {\n  const length = source.length;\n  const total = count * length;\n  let copied = 0;\n  for (let i = start; copied < length; copied++) {\n    target[i++] = source[copied];\n  }\n\n  while (copied < total) {\n    // If we have copied less than half, copy everything we got\n    // else copy remaining in one operation\n    if (copied < total - copied) {\n      target.copyWithin(start + copied, start, start + copied);\n      copied *= 2;\n    } else {\n      target.copyWithin(start + copied, start, start + total - copied);\n      copied = total;\n    }\n  }\n\n  return target;\n}\n","/* global setTimeout */\nimport Resource from './resource';\n\nexport default class ResourceManager {\n  constructor({gl, protocol}) {\n    this.protocol = protocol || 'resource://';\n\n    this._context = {\n      gl,\n      resourceManager: this\n    };\n    this._resources = {};\n    this._consumers = {};\n\n    this._pruneRequest = null;\n  }\n\n  contains(resourceId) {\n    if (resourceId.startsWith(this.protocol)) {\n      return true;\n    }\n    return resourceId in this._resources;\n  }\n\n  add({resourceId, data, forceUpdate = false, persistent = true}) {\n    let res = this._resources[resourceId];\n\n    if (res) {\n      res.setData(data, forceUpdate);\n    } else {\n      res = new Resource(resourceId, data, this._context);\n      this._resources[resourceId] = res;\n    }\n    // persistent resources can only be removed by calling `remove`\n    // non-persistent resources may be released when there are no more consumers\n    res.persistent = persistent;\n  }\n\n  remove(resourceId) {\n    const res = this._resources[resourceId];\n\n    if (res) {\n      res.delete();\n      delete this._resources[resourceId];\n    }\n  }\n\n  unsubscribe({consumerId}) {\n    const consumer = this._consumers[consumerId];\n    if (consumer) {\n      for (const requestId in consumer) {\n        const request = consumer[requestId];\n        if (request.resource) {\n          request.resource.unsubscribe(request);\n        }\n      }\n      delete this._consumers[consumerId];\n      this.prune();\n    }\n  }\n\n  subscribe({resourceId, onChange, consumerId, requestId = 'default'}) {\n    const {_resources: resources, protocol} = this;\n    if (resourceId.startsWith(protocol)) {\n      resourceId = resourceId.replace(protocol, '');\n      if (!resources[resourceId]) {\n        // Add placeholder. When this resource becomes available, the consumer will be notified.\n        this.add({resourceId, data: null, persistent: false});\n      }\n    }\n    const res = resources[resourceId];\n    this._track(consumerId, requestId, res, onChange);\n    if (res) {\n      return res.getData();\n    }\n\n    return undefined;\n  }\n\n  prune() {\n    if (!this._pruneRequest) {\n      // prune() may be called multiple times in the same animation frame.\n      // Batch multiple requests together\n      this._pruneRequest = setTimeout(() => this._prune(), 0);\n    }\n  }\n\n  finalize() {\n    for (const key in this._resources) {\n      this._resources[key].delete();\n    }\n  }\n\n  _track(consumerId, requestId, resource, onChange) {\n    const consumers = this._consumers;\n    const consumer = (consumers[consumerId] = consumers[consumerId] || {});\n    const request = consumer[requestId] || {};\n\n    if (request.resource) {\n      request.resource.unsubscribe(request);\n      request.resource = null;\n      this.prune();\n    }\n    if (resource) {\n      consumer[requestId] = request;\n      request.onChange = onChange;\n      request.resource = resource;\n      resource.subscribe(request);\n    }\n  }\n\n  _prune() {\n    this._pruneRequest = null;\n\n    for (const key of Object.keys(this._resources)) {\n      const res = this._resources[key];\n      if (!res.persistent && !res.inUse()) {\n        res.delete();\n        delete this._resources[key];\n      }\n    }\n  }\n}\n","import {load} from '@loaders.gl/core';\n\nexport default class Resource {\n  constructor(id, data, context) {\n    this.id = id;\n    this.context = context;\n\n    this._loadCount = 0;\n    this._subscribers = new Set();\n\n    this.setData(data);\n  }\n\n  // consumer: {onChange: Function}\n  subscribe(consumer) {\n    this._subscribers.add(consumer);\n  }\n\n  unsubscribe(consumer) {\n    this._subscribers.delete(consumer);\n  }\n\n  inUse() {\n    return this._subscribers.size > 0;\n  }\n\n  delete() {\n    // Remove any resources created\n  }\n\n  getData() {\n    return this.isLoaded\n      ? this._error\n        ? Promise.reject(this._error)\n        : this._content\n      : this._loader.then(() => this.getData());\n  }\n\n  setData(data, forceUpdate) {\n    if (data === this._data && !forceUpdate) {\n      return;\n    }\n    this._data = data;\n    const loadCount = ++this._loadCount;\n\n    let loader = data;\n    if (typeof data === 'string') {\n      loader = load(data);\n    }\n    if (loader instanceof Promise) {\n      this.isLoaded = false;\n      this._loader = loader\n        .then(result => {\n          // check if source has changed\n          if (this._loadCount === loadCount) {\n            this.isLoaded = true;\n            this._error = null;\n            this._content = result;\n          }\n        })\n        .catch(error => {\n          if (this._loadCount === loadCount) {\n            this.isLoaded = true;\n            this._error = error || true;\n          }\n        });\n    } else {\n      this.isLoaded = true;\n      this._error = null;\n      this._content = data;\n    }\n\n    for (const subscriber of this._subscribers) {\n      subscriber.onChange(this.getData());\n    }\n  }\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {deepEqual} from '../utils/deep-equal';\nimport log from '../utils/log';\nimport {flatten} from '../utils/flatten';\n\nexport default class ViewManager {\n  constructor(props = {}) {\n    // List of view descriptors, gets re-evaluated when width/height changes\n    this.views = [];\n    this.width = 100;\n    this.height = 100;\n    this.viewState = {};\n    this.controllers = {};\n    this.timeline = props.timeline;\n\n    this._viewports = []; // Generated viewports\n    this._viewportMap = {};\n    this._isUpdating = false;\n    this._needsRedraw = 'Initial render';\n    this._needsUpdate = true;\n\n    this._eventManager = props.eventManager;\n    this._eventCallbacks = {\n      onViewStateChange: props.onViewStateChange,\n      onInteractionStateChange: props.onInteractionStateChange\n    };\n\n    Object.seal(this);\n\n    // Init with default map viewport\n    this.setProps(props);\n  }\n\n  finalize() {\n    for (const key in this.controllers) {\n      if (this.controllers[key]) {\n        this.controllers[key].finalize();\n      }\n    }\n    this.controllers = {};\n  }\n\n  // Check if a redraw is needed\n  needsRedraw(opts = {clearRedrawFlags: false}) {\n    const redraw = this._needsRedraw;\n    if (opts.clearRedrawFlags) {\n      this._needsRedraw = false;\n    }\n    return redraw;\n  }\n\n  // Layers will be updated deeply (in next animation frame)\n  // Potentially regenerating attributes and sub layers\n  setNeedsUpdate(reason) {\n    this._needsUpdate = this._needsUpdate || reason;\n    this._needsRedraw = this._needsRedraw || reason;\n  }\n\n  // Checks each viewport for transition updates\n  updateViewStates() {\n    for (const viewId in this.controllers) {\n      const controller = this.controllers[viewId];\n      if (controller) {\n        controller.updateTransition();\n      }\n    }\n  }\n\n  /** Get a set of viewports for a given width and height\n   * TODO - Intention is for deck.gl to autodeduce width and height and drop the need for props\n   * @param rect (object, optional) - filter the viewports\n   *   + not provided - return all viewports\n   *   + {x, y} - only return viewports that contain this pixel\n   *   + {x, y, width, height} - only return viewports that overlap with this rectangle\n   */\n  getViewports(rect) {\n    if (rect) {\n      return this._viewports.filter(viewport => viewport.containsPixel(rect));\n    }\n    return this._viewports;\n  }\n\n  getViews() {\n    const viewMap = {};\n    this.views.forEach(view => {\n      viewMap[view.id] = view;\n    });\n    return viewMap;\n  }\n\n  // Resolves a viewId string to a View, if already a View returns it.\n  getView(viewOrViewId) {\n    return typeof viewOrViewId === 'string'\n      ? this.views.find(view => view.id === viewOrViewId)\n      : viewOrViewId;\n  }\n\n  // Returns the viewState for a specific viewId. Matches the viewState by\n  // 1. view.viewStateId\n  // 2. view.id\n  // 3. root viewState\n  // then applies the view's filter if any\n  getViewState(viewId) {\n    const view = this.getView(viewId);\n    // Backward compatibility: view state for single view\n    const viewState = (view && this.viewState[view.getViewStateId()]) || this.viewState;\n    return view ? view.filterViewState(viewState) : viewState;\n  }\n\n  getViewport(viewId) {\n    return this._viewportMap[viewId];\n  }\n\n  /**\n   * Unproject pixel coordinates on screen onto world coordinates,\n   * (possibly [lon, lat]) on map.\n   * - [x, y] => [lng, lat]\n   * - [x, y, z] => [lng, lat, Z]\n   * @param {Array} xyz -\n   * @param {Object} opts - options\n   * @param {Object} opts.topLeft=true - Whether origin is top left\n   * @return {Array|null} - [lng, lat, Z] or [X, Y, Z]\n   */\n  unproject(xyz, opts) {\n    const viewports = this.getViewports();\n    const pixel = {x: xyz[0], y: xyz[1]};\n    for (let i = viewports.length - 1; i >= 0; --i) {\n      const viewport = viewports[i];\n      if (viewport.containsPixel(pixel)) {\n        const p = xyz.slice();\n        p[0] -= viewport.x;\n        p[1] -= viewport.y;\n        return viewport.unproject(p, opts);\n      }\n    }\n    return null;\n  }\n\n  setProps(props) {\n    if ('views' in props) {\n      this._setViews(props.views);\n    }\n\n    // TODO - support multiple view states\n    if ('viewState' in props) {\n      this._setViewState(props.viewState);\n    }\n\n    if ('width' in props || 'height' in props) {\n      this._setSize(props.width, props.height);\n    }\n\n    // Important: avoid invoking _update() inside itself\n    // Nested updates result in unexpected side effects inside _rebuildViewports()\n    // when using auto control in pure-js\n    if (!this._isUpdating) {\n      this._update();\n    }\n  }\n\n  _update() {\n    this._isUpdating = true;\n\n    // Only rebuild viewports if the update flag is set\n    if (this._needsUpdate) {\n      this._needsUpdate = false;\n      this._rebuildViewports();\n    }\n\n    // If viewport transition(s) are triggered during viewports update, controller(s)\n    // will immediately call `onViewStateChange` which calls `viewManager.setProps` again.\n    if (this._needsUpdate) {\n      this._needsUpdate = false;\n      this._rebuildViewports();\n    }\n\n    this._isUpdating = false;\n  }\n\n  _setSize(width, height) {\n    if (width !== this.width || height !== this.height) {\n      this.width = width;\n      this.height = height;\n      this.setNeedsUpdate('Size changed');\n    }\n  }\n\n  // Update the view descriptor list and set change flag if needed\n  // Does not actually rebuild the `Viewport`s until `getViewports` is called\n  _setViews(views) {\n    views = flatten(views, Boolean);\n\n    const viewsChanged = this._diffViews(views, this.views);\n    if (viewsChanged) {\n      this.setNeedsUpdate('views changed');\n    }\n\n    this.views = views;\n  }\n\n  _setViewState(viewState) {\n    if (viewState) {\n      const viewStateChanged = !deepEqual(viewState, this.viewState);\n\n      if (viewStateChanged) {\n        this.setNeedsUpdate('viewState changed');\n      }\n\n      this.viewState = viewState;\n    } else {\n      log.warn('missing `viewState` or `initialViewState`')();\n    }\n  }\n\n  //\n  // PRIVATE METHODS\n  //\n\n  _onViewStateChange(viewId, event) {\n    event.viewId = viewId;\n    if (this._eventCallbacks.onViewStateChange) {\n      this._eventCallbacks.onViewStateChange(event);\n    }\n  }\n\n  _createController(view, props) {\n    const Controller = props.type;\n\n    const controller = new Controller({\n      timeline: this.timeline,\n      eventManager: this._eventManager,\n      // Set an internal callback that calls the prop callback if provided\n      onViewStateChange: this._onViewStateChange.bind(this, props.id),\n      onStateChange: this._eventCallbacks.onInteractionStateChange,\n      makeViewport: viewState =>\n        view._getViewport(viewState, {\n          width: viewState.width,\n          height: viewState.height\n        }),\n      ...props\n    });\n\n    return controller;\n  }\n\n  _updateController(view, viewState, viewport, controller) {\n    let controllerProps = view.controller;\n    if (controllerProps) {\n      controllerProps = {\n        ...viewState,\n        ...view.props,\n        ...controllerProps,\n        id: view.id,\n        x: viewport.x,\n        y: viewport.y,\n        width: viewport.width,\n        height: viewport.height\n      };\n\n      // TODO - check if view / controller type has changed, and replace the controller\n      if (controller) {\n        controller.setProps(controllerProps);\n      } else {\n        controller = this._createController(view, controllerProps);\n      }\n      return controller;\n    }\n    return null;\n  }\n\n  // Rebuilds viewports from descriptors towards a certain window size\n  _rebuildViewports() {\n    const {width, height, views} = this;\n\n    const oldControllers = this.controllers;\n    this._viewports = [];\n    this.controllers = {};\n\n    let invalidateControllers = false;\n    // Create controllers in reverse order, so that views on top receive events first\n    for (let i = views.length; i--; ) {\n      const view = views[i];\n      const viewState = this.getViewState(view);\n      const viewport = view.makeViewport({width, height, viewState});\n\n      let oldController = oldControllers[view.id];\n      if (view.controller && !oldController) {\n        // When a new controller is added, invalidate all controllers below it so that\n        // events are registered in the correct order\n        invalidateControllers = true;\n      }\n      if ((invalidateControllers || !view.controller) && oldController) {\n        // Remove and reattach invalidated controller\n        oldController.finalize();\n        oldController = null;\n      }\n\n      // Update the controller\n      this.controllers[view.id] = this._updateController(view, viewState, viewport, oldController);\n\n      this._viewports.unshift(viewport);\n    }\n\n    // Remove unused controllers\n    for (const id in oldControllers) {\n      if (oldControllers[id] && !this.controllers[id]) {\n        oldControllers[id].finalize();\n      }\n    }\n\n    this._buildViewportMap();\n  }\n\n  _buildViewportMap() {\n    // Build a view id to view index\n    this._viewportMap = {};\n    this._viewports.forEach(viewport => {\n      if (viewport.id) {\n        // TODO - issue warning if multiple viewports use same id\n        this._viewportMap[viewport.id] = this._viewportMap[viewport.id] || viewport;\n      }\n    });\n  }\n\n  // Check if viewport array has changed, returns true if any change\n  // Note that descriptors can be the same\n  _diffViews(newViews, oldViews) {\n    if (newViews.length !== oldViews.length) {\n      return true;\n    }\n\n    return newViews.some((_, i) => !newViews[i].equals(oldViews[i]));\n  }\n}\n","// Partial deep equal (only recursive on arrays)\nexport function deepEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (!a || !b) {\n    return false;\n  }\n  for (const key in a) {\n    const aValue = a[key];\n    const bValue = b[key];\n    const equals =\n      aValue === bValue ||\n      (Array.isArray(aValue) && Array.isArray(bValue) && deepEqual(aValue, bValue));\n    if (!equals) {\n      return false;\n    }\n  }\n  return true;\n}\n","import View from './view';\nimport WebMercatorViewport from '../viewports/web-mercator-viewport';\nimport MapController from '../controllers/map-controller';\n\nexport default class MapView extends View {\n  constructor(props) {\n    super({\n      ...props,\n      type: WebMercatorViewport\n    });\n  }\n\n  get controller() {\n    return this._getControllerProps({\n      type: MapController\n    });\n  }\n}\n\nMapView.displayName = 'MapView';\n","import Viewport from '../viewports/viewport';\nimport {parsePosition, getPosition} from '../utils/positions';\nimport {deepEqual} from '../utils/deep-equal';\nimport assert from '../utils/assert';\n\nexport default class View {\n  constructor(props = {}) {\n    const {\n      id = null,\n\n      // Window width/height in pixels (for pixel projection)\n      x = 0,\n      y = 0,\n      width = '100%',\n      height = '100%',\n\n      // A View can be a wrapper for a viewport instance\n      viewportInstance,\n\n      // Internal: Viewport Type\n      type = Viewport // TODO - default to WebMercator?\n    } = props;\n\n    assert(!viewportInstance || viewportInstance instanceof Viewport);\n    this.viewportInstance = viewportInstance;\n\n    // Id\n    this.id = id || this.constructor.displayName || 'view';\n    this.type = type;\n\n    this.props = {...props, id: this.id};\n\n    // Extents\n    this._parseDimensions({x, y, width, height});\n\n    // Bind methods for easy access\n    this.equals = this.equals.bind(this);\n\n    Object.seal(this);\n  }\n\n  equals(view) {\n    if (this === view) {\n      return true;\n    }\n\n    // if `viewportInstance` is set, it is the only prop that is used\n    // Delegate to `Viewport.equals`\n    if (this.viewportInstance) {\n      return view.viewportInstance && this.viewportInstance.equals(view.viewportInstance);\n    }\n\n    const viewChanged = deepEqual(this.props, view.props);\n\n    return viewChanged;\n  }\n\n  // Build a `Viewport` from a view descriptor\n  // TODO - add support for autosizing viewports using width and height\n  makeViewport({width, height, viewState}) {\n    if (this.viewportInstance) {\n      return this.viewportInstance;\n    }\n\n    viewState = this.filterViewState(viewState);\n\n    // Resolve relative viewport dimensions\n    const viewportDimensions = this.getDimensions({width, height});\n    return this._getViewport(viewState, viewportDimensions);\n  }\n\n  getViewStateId() {\n    switch (typeof this.props.viewState) {\n      case 'string':\n        // if View.viewState is a string, return it\n        return this.props.viewState;\n\n      case 'object':\n        // If it is an object, return its id component\n        return this.props.viewState && this.props.viewState.id;\n\n      default:\n        return this.id;\n    }\n  }\n\n  // Allows view to override (or completely define) viewState\n  filterViewState(viewState) {\n    if (this.props.viewState && typeof this.props.viewState === 'object') {\n      // If we have specified an id, then intent is to override,\n      // If not, completely specify the view state\n      if (!this.props.viewState.id) {\n        return this.props.viewState;\n      }\n\n      // Merge in all props from View's viewState, except id\n      const newViewState = {...viewState};\n      for (const key in this.props.viewState) {\n        if (key !== 'id') {\n          newViewState[key] = this.props.viewState[key];\n        }\n      }\n      return newViewState;\n    }\n\n    return viewState;\n  }\n\n  // Resolve relative viewport dimensions into actual dimensions (y='50%', width=800 => y=400)\n  getDimensions({width, height}) {\n    return {\n      x: getPosition(this._x, width),\n      y: getPosition(this._y, height),\n      width: getPosition(this._width, width),\n      height: getPosition(this._height, height)\n    };\n  }\n\n  // Used by sub classes to resolve controller props\n  _getControllerProps(defaultOpts) {\n    let opts = this.props.controller;\n\n    if (!opts) {\n      return null;\n    }\n    if (opts === true) {\n      return defaultOpts;\n    }\n    if (typeof opts === 'function') {\n      opts = {type: opts};\n    }\n    return {...defaultOpts, ...opts};\n  }\n\n  // Overridable method\n  _getViewport(viewState, viewportDimensions) {\n    // Get the type of the viewport\n    const {type: ViewportType} = this;\n    return new ViewportType({...viewState, ...this.props, ...viewportDimensions});\n  }\n\n  // Parse relative viewport dimension descriptors (e.g {y: '50%', height: '50%'})\n  _parseDimensions({x, y, width, height}) {\n    this._x = parsePosition(x);\n    this._y = parsePosition(y);\n    this._width = parsePosition(width);\n    this._height = parsePosition(height);\n  }\n}\n","const PERCENT_OR_PIXELS_REGEX = /([0-9]+\\.?[0-9]*)(%|px)/;\n\n// Takes a number or a string of formats `50%`, `33.3%` or `200px`\nexport function parsePosition(value) {\n  switch (typeof value) {\n    case 'number':\n      return {\n        position: value,\n        relative: false\n      };\n\n    case 'string':\n      const match = value.match(PERCENT_OR_PIXELS_REGEX);\n      if (match && match.length >= 3) {\n        const relative = match[2] === '%';\n        const position = parseFloat(match[1]);\n        return {\n          position: relative ? position / 100 : position,\n          relative\n        };\n      }\n    // fallthrough\n\n    default:\n      // eslint-disable-line\n      throw new Error(`Could not parse position string ${value}`);\n  }\n}\n\nexport function getPosition(position, extent) {\n  return position.relative ? Math.round(position.position * extent) : position.position;\n}\n","// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\nexport default function assert(condition, message) {\n  if (!condition) {\n    throw new Error(message || 'deck.gl: assertion failed.');\n  }\n}\n","import {clamp} from 'math.gl';\nimport Controller from './controller';\nimport ViewState from './view-state';\nimport {normalizeViewportProps} from '@math.gl/web-mercator';\nimport assert from '../utils/assert';\n\nconst PITCH_MOUSE_THRESHOLD = 5;\nconst PITCH_ACCEL = 1.2;\n\nconst DEFAULT_STATE = {\n  pitch: 0,\n  bearing: 0,\n  altitude: 1.5,\n  minZoom: 0,\n  maxZoom: 20,\n  minPitch: 0,\n  maxPitch: 60\n};\n\n/* Utils */\n\nexport class MapState extends ViewState {\n  constructor({\n    makeViewport,\n\n    /** Mapbox viewport properties */\n    /** The width of the viewport */\n    width,\n    /** The height of the viewport */\n    height,\n    /** The latitude at the center of the viewport */\n    latitude,\n    /** The longitude at the center of the viewport */\n    longitude,\n    /** The tile zoom level of the map. */\n    zoom,\n    /** The bearing of the viewport in degrees */\n    bearing = DEFAULT_STATE.bearing,\n    /** The pitch of the viewport in degrees */\n    pitch = DEFAULT_STATE.pitch,\n    /**\n     * Specify the altitude of the viewport camera\n     * Unit: map heights, default 1.5\n     * Non-public API, see https://github.com/mapbox/mapbox-gl-js/issues/1137\n     */\n    altitude = DEFAULT_STATE.altitude,\n\n    /** Viewport constraints */\n    maxZoom = DEFAULT_STATE.maxZoom,\n    minZoom = DEFAULT_STATE.minZoom,\n    maxPitch = DEFAULT_STATE.maxPitch,\n    minPitch = DEFAULT_STATE.minPitch,\n\n    /** Interaction states, required to calculate change during transform */\n    /* The point on map being grabbed when the operation first started */\n    startPanLngLat,\n    /* Center of the zoom when the operation first started */\n    startZoomLngLat,\n    /* Pointer position when rotation started */\n    startRotatePos,\n    /** Bearing when current perspective rotate operation started */\n    startBearing,\n    /** Pitch when current perspective rotate operation started */\n    startPitch,\n    /** Zoom when current zoom operation started */\n    startZoom,\n\n    /** Normalize viewport props to fit map height into viewport. Default `true` */\n    normalize\n  } = {}) {\n    assert(Number.isFinite(longitude)); // `longitude` must be supplied\n    assert(Number.isFinite(latitude)); // `latitude` must be supplied\n    assert(Number.isFinite(zoom)); // `zoom` must be supplied\n\n    super({\n      width,\n      height,\n      latitude,\n      longitude,\n      zoom,\n      bearing,\n      pitch,\n      altitude,\n      maxZoom,\n      minZoom,\n      maxPitch,\n      minPitch,\n      normalize\n    });\n\n    this._state = {\n      startPanLngLat,\n      startZoomLngLat,\n      startRotatePos,\n      startBearing,\n      startPitch,\n      startZoom\n    };\n\n    this.makeViewport = makeViewport;\n  }\n\n  /**\n   * Start panning\n   * @param {[Number, Number]} pos - position on screen where the pointer grabs\n   */\n  panStart({pos}) {\n    return this._getUpdatedState({\n      startPanLngLat: this._unproject(pos)\n    });\n  }\n\n  /**\n   * Pan\n   * @param {[Number, Number]} pos - position on screen where the pointer is\n   * @param {[Number, Number], optional} startPos - where the pointer grabbed at\n   *   the start of the operation. Must be supplied of `panStart()` was not called\n   */\n  pan({pos, startPos}) {\n    const startPanLngLat = this._state.startPanLngLat || this._unproject(startPos);\n\n    if (!startPanLngLat) {\n      return this;\n    }\n\n    const viewport = this.makeViewport(this._viewportProps);\n    const newProps = viewport.panByPosition(startPanLngLat, pos);\n\n    return this._getUpdatedState(newProps);\n  }\n\n  /**\n   * End panning\n   * Must call if `panStart()` was called\n   */\n  panEnd() {\n    return this._getUpdatedState({\n      startPanLngLat: null\n    });\n  }\n\n  /**\n   * Start rotating\n   * @param {[Number, Number]} pos - position on screen where the center is\n   */\n  rotateStart({pos}) {\n    return this._getUpdatedState({\n      startRotatePos: pos,\n      startBearing: this._viewportProps.bearing,\n      startPitch: this._viewportProps.pitch\n    });\n  }\n\n  /**\n   * Rotate\n   * @param {[Number, Number]} pos - position on screen where the center is\n   */\n  rotate({pos, deltaAngleX = 0, deltaAngleY = 0}) {\n    const {startRotatePos, startBearing, startPitch} = this._state;\n\n    if (!startRotatePos || !Number.isFinite(startBearing) || !Number.isFinite(startPitch)) {\n      return this;\n    }\n    let newRotation;\n    if (pos) {\n      newRotation = this._calculateNewPitchAndBearing({\n        ...this._getRotationParams(pos, startRotatePos),\n        startBearing,\n        startPitch\n      });\n    } else {\n      newRotation = {\n        bearing: startBearing + deltaAngleX,\n        pitch: startPitch + deltaAngleY\n      };\n    }\n    return this._getUpdatedState(newRotation);\n  }\n\n  /**\n   * End rotating\n   * Must call if `rotateStart()` was called\n   */\n  rotateEnd() {\n    return this._getUpdatedState({\n      startBearing: null,\n      startPitch: null\n    });\n  }\n\n  /**\n   * Start zooming\n   * @param {[Number, Number]} pos - position on screen where the center is\n   */\n  zoomStart({pos}) {\n    return this._getUpdatedState({\n      startZoomLngLat: this._unproject(pos),\n      startZoom: this._viewportProps.zoom\n    });\n  }\n\n  /**\n   * Zoom\n   * @param {[Number, Number]} pos - position on screen where the current center is\n   * @param {[Number, Number]} startPos - the center position at\n   *   the start of the operation. Must be supplied of `zoomStart()` was not called\n   * @param {Number} scale - a number between [0, 1] specifying the accumulated\n   *   relative scale.\n   */\n  zoom({pos, startPos, scale}) {\n    // Make sure we zoom around the current mouse position rather than map center\n    let {startZoom, startZoomLngLat} = this._state;\n\n    if (!Number.isFinite(startZoom)) {\n      // We have two modes of zoom:\n      // scroll zoom that are discrete events (transform from the current zoom level),\n      // and pinch zoom that are continuous events (transform from the zoom level when\n      // pinch started).\n      // If startZoom state is defined, then use the startZoom state;\n      // otherwise assume discrete zooming\n      startZoom = this._viewportProps.zoom;\n      startZoomLngLat = this._unproject(startPos) || this._unproject(pos);\n    }\n\n    const zoom = this._calculateNewZoom({scale, startZoom});\n\n    const zoomedViewport = this.makeViewport({...this._viewportProps, zoom});\n\n    return this._getUpdatedState({\n      zoom,\n      ...zoomedViewport.panByPosition(startZoomLngLat, pos)\n    });\n  }\n\n  /**\n   * End zooming\n   * Must call if `zoomStart()` was called\n   */\n  zoomEnd() {\n    return this._getUpdatedState({\n      startZoomLngLat: null,\n      startZoom: null\n    });\n  }\n\n  zoomIn(speed = 2) {\n    return this._zoomFromCenter(speed);\n  }\n\n  zoomOut(speed = 2) {\n    return this._zoomFromCenter(1 / speed);\n  }\n\n  moveLeft(speed = 100) {\n    return this._panFromCenter([speed, 0]);\n  }\n\n  moveRight(speed = 100) {\n    return this._panFromCenter([-speed, 0]);\n  }\n\n  moveUp(speed = 100) {\n    return this._panFromCenter([0, speed]);\n  }\n\n  moveDown(speed = 100) {\n    return this._panFromCenter([0, -speed]);\n  }\n\n  rotateLeft(speed = 15) {\n    return this._getUpdatedState({\n      bearing: this._viewportProps.bearing - speed\n    });\n  }\n\n  rotateRight(speed = 15) {\n    return this._getUpdatedState({\n      bearing: this._viewportProps.bearing + speed\n    });\n  }\n\n  rotateUp(speed = 10) {\n    return this._getUpdatedState({\n      pitch: this._viewportProps.pitch + speed\n    });\n  }\n\n  rotateDown(speed = 10) {\n    return this._getUpdatedState({\n      pitch: this._viewportProps.pitch - speed\n    });\n  }\n\n  shortestPathFrom(viewState) {\n    // const endViewStateProps = new this.ControllerState(endProps).shortestPathFrom(startViewstate);\n    const fromProps = viewState.getViewportProps();\n    const props = {...this._viewportProps};\n    const {bearing, longitude} = props;\n\n    if (Math.abs(bearing - fromProps.bearing) > 180) {\n      props.bearing = bearing < 0 ? bearing + 360 : bearing - 360;\n    }\n    if (Math.abs(longitude - fromProps.longitude) > 180) {\n      props.longitude = longitude < 0 ? longitude + 360 : longitude - 360;\n    }\n    return props;\n  }\n\n  /* Private methods */\n\n  _zoomFromCenter(scale) {\n    const {width, height} = this._viewportProps;\n    return this.zoom({\n      pos: [width / 2, height / 2],\n      scale\n    });\n  }\n\n  _panFromCenter(offset) {\n    const {width, height} = this._viewportProps;\n    return this.pan({\n      startPos: [width / 2, height / 2],\n      pos: [width / 2 + offset[0], height / 2 + offset[1]]\n    });\n  }\n\n  _getUpdatedState(newProps) {\n    // Update _viewportProps\n    return new this.constructor({\n      makeViewport: this.makeViewport,\n      ...this._viewportProps,\n      ...this._state,\n      ...newProps\n    });\n  }\n\n  // Apply any constraints (mathematical or defined by _viewportProps) to map state\n  _applyConstraints(props) {\n    // Ensure zoom is within specified range\n    const {maxZoom, minZoom, zoom} = props;\n    props.zoom = clamp(zoom, minZoom, maxZoom);\n\n    // Ensure pitch is within specified range\n    const {maxPitch, minPitch, pitch} = props;\n    props.pitch = clamp(pitch, minPitch, maxPitch);\n\n    // Normalize viewport props to fit map height into viewport\n    const {normalize = true} = props;\n    if (normalize) {\n      Object.assign(props, normalizeViewportProps(props));\n    }\n\n    return props;\n  }\n\n  _unproject(pos) {\n    const viewport = this.makeViewport(this._viewportProps);\n    return pos && viewport.unproject(pos);\n  }\n\n  // Calculates new zoom\n  _calculateNewZoom({scale, startZoom}) {\n    const {maxZoom, minZoom} = this._viewportProps;\n    const zoom = startZoom + Math.log2(scale);\n    return clamp(zoom, minZoom, maxZoom);\n  }\n\n  // Calculates a new pitch and bearing from a position (coming from an event)\n  _calculateNewPitchAndBearing({deltaScaleX, deltaScaleY, startBearing, startPitch}) {\n    // clamp deltaScaleY to [-1, 1] so that rotation is constrained between minPitch and maxPitch.\n    // deltaScaleX does not need to be clamped as bearing does not have constraints.\n    deltaScaleY = clamp(deltaScaleY, -1, 1);\n\n    const {minPitch, maxPitch} = this._viewportProps;\n\n    const bearing = startBearing + 180 * deltaScaleX;\n    let pitch = startPitch;\n    if (deltaScaleY > 0) {\n      // Gradually increase pitch\n      pitch = startPitch + deltaScaleY * (maxPitch - startPitch);\n    } else if (deltaScaleY < 0) {\n      // Gradually decrease pitch\n      pitch = startPitch - deltaScaleY * (minPitch - startPitch);\n    }\n\n    return {\n      pitch,\n      bearing\n    };\n  }\n\n  _getRotationParams(pos, startPos) {\n    const deltaX = pos[0] - startPos[0];\n    const deltaY = pos[1] - startPos[1];\n    const centerY = pos[1];\n    const startY = startPos[1];\n    const {width, height} = this._viewportProps;\n\n    const deltaScaleX = deltaX / width;\n    let deltaScaleY = 0;\n\n    if (deltaY > 0) {\n      if (Math.abs(height - startY) > PITCH_MOUSE_THRESHOLD) {\n        // Move from 0 to -1 as we drag upwards\n        deltaScaleY = (deltaY / (startY - height)) * PITCH_ACCEL;\n      }\n    } else if (deltaY < 0) {\n      if (startY > PITCH_MOUSE_THRESHOLD) {\n        // Move from 0 to 1 as we drag upwards\n        deltaScaleY = 1 - centerY / startY;\n      }\n    }\n    deltaScaleY = Math.min(1, Math.max(-1, deltaScaleY));\n    return {deltaScaleX, deltaScaleY};\n  }\n}\n\nexport default class MapController extends Controller {\n  constructor(props) {\n    props.dragMode = props.dragMode || 'pan';\n    super(MapState, props);\n  }\n\n  setProps(props) {\n    const oldProps = this.controllerStateProps;\n\n    super.setProps(props);\n\n    const dimensionChanged = !oldProps || oldProps.height !== props.height;\n    if (dimensionChanged) {\n      // Dimensions changed, normalize the props\n      this.updateViewport(\n        new this.ControllerState({\n          makeViewport: this.makeViewport,\n          ...this.controllerStateProps,\n          ...this._state\n        })\n      );\n    }\n  }\n\n  get linearTransitionProps() {\n    return ['longitude', 'latitude', 'zoom', 'bearing', 'pitch'];\n  }\n}\n","// Copyright (c) 2015 Uber Technologies, Inc.\n\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/* eslint-disable max-statements, complexity */\nimport TransitionManager, {TRANSITION_EVENTS} from './transition-manager';\nimport LinearInterpolator from '../transitions/linear-interpolator';\n\nconst NO_TRANSITION_PROPS = {\n  transitionDuration: 0\n};\n\nconst LINEAR_TRANSITION_PROPS = {\n  transitionDuration: 300,\n  transitionEasing: t => t,\n  transitionInterruption: TRANSITION_EVENTS.BREAK\n};\n\nconst DEFAULT_INERTIA = 300;\nconst INERTIA_EASING = t => 1 - (1 - t) * (1 - t);\n\nconst EVENT_TYPES = {\n  WHEEL: ['wheel'],\n  PAN: ['panstart', 'panmove', 'panend'],\n  PINCH: ['pinchstart', 'pinchmove', 'pinchend'],\n  TRIPLE_PAN: ['tripanstart', 'tripanmove', 'tripanend'],\n  DOUBLE_TAP: ['doubletap'],\n  KEYBOARD: ['keydown']\n};\n\nexport default class Controller {\n  constructor(ControllerState, options = {}) {\n    this.ControllerState = ControllerState;\n    this.controllerState = null;\n    this.controllerStateProps = null;\n    this.eventManager = null;\n    this.transitionManager = new TransitionManager(ControllerState, {\n      ...options,\n      onViewStateChange: this._onTransition.bind(this),\n      onStateChange: this._setInteractionState.bind(this)\n    });\n\n    const linearTransitionProps = this.linearTransitionProps;\n    this._transition = linearTransitionProps && {\n      ...LINEAR_TRANSITION_PROPS,\n      transitionInterpolator: new LinearInterpolator({\n        transitionProps: linearTransitionProps\n      })\n    };\n\n    this._events = null;\n    this._interactionState = {\n      isDragging: false\n    };\n    this._customEvents = [];\n    this.onViewStateChange = null;\n    this.onStateChange = null;\n\n    this.handleEvent = this.handleEvent.bind(this);\n\n    this.setProps(options);\n  }\n\n  get linearTransitionProps() {\n    return null;\n  }\n\n  set events(customEvents) {\n    this.toggleEvents(this._customEvents, false);\n    this.toggleEvents(customEvents, true);\n    this._customEvents = customEvents;\n    // Make sure default events are not overwritten\n    this.setProps(this.controllerStateProps);\n  }\n\n  finalize() {\n    for (const eventName in this._events) {\n      if (this._events[eventName]) {\n        this.eventManager.off(eventName, this.handleEvent);\n      }\n    }\n    this.transitionManager.finalize();\n  }\n\n  /**\n   * Callback for events\n   * @param {hammer.Event} event\n   */\n  handleEvent(event) {\n    const {ControllerState} = this;\n    this.controllerState = new ControllerState({\n      makeViewport: this.makeViewport,\n      ...this.controllerStateProps,\n      ...this._state\n    });\n    const eventStartBlocked = this._eventStartBlocked;\n\n    switch (event.type) {\n      case 'panstart':\n        return eventStartBlocked ? false : this._onPanStart(event);\n      case 'panmove':\n        return this._onPan(event);\n      case 'panend':\n        return this._onPanEnd(event);\n      case 'pinchstart':\n        return eventStartBlocked ? false : this._onPinchStart(event);\n      case 'pinchmove':\n        return this._onPinch(event);\n      case 'pinchend':\n        return this._onPinchEnd(event);\n      case 'tripanstart':\n        return eventStartBlocked ? false : this._onTriplePanStart(event);\n      case 'tripanmove':\n        return this._onTriplePan(event);\n      case 'tripanend':\n        return this._onTriplePanEnd(event);\n      case 'doubletap':\n        return this._onDoubleTap(event);\n      case 'wheel':\n        return this._onWheel(event);\n      case 'keydown':\n        return this._onKeyDown(event);\n      default:\n        return false;\n    }\n  }\n\n  /* Event utils */\n  // Event object: http://hammerjs.github.io/api/#event-object\n  getCenter(event) {\n    const {x, y} = this.controllerStateProps;\n    const {offsetCenter} = event;\n    return [offsetCenter.x - x, offsetCenter.y - y];\n  }\n\n  isPointInBounds(pos, event) {\n    const {width, height} = this.controllerStateProps;\n    if (event && event.handled) {\n      return false;\n    }\n\n    const inside = pos[0] >= 0 && pos[0] <= width && pos[1] >= 0 && pos[1] <= height;\n    if (inside && event) {\n      event.stopPropagation();\n    }\n    return inside;\n  }\n\n  isFunctionKeyPressed(event) {\n    const {srcEvent} = event;\n    return Boolean(srcEvent.metaKey || srcEvent.altKey || srcEvent.ctrlKey || srcEvent.shiftKey);\n  }\n\n  isDragging() {\n    return this._interactionState.isDragging;\n  }\n\n  // When a multi-touch event ends, e.g. pinch, not all pointers are lifted at the same time.\n  // This triggers a brief `pan` event.\n  // Calling this method will temporarily disable *start events to avoid conflicting transitions.\n  blockEvents(timeout) {\n    /* global setTimeout */\n    const timer = setTimeout(() => {\n      if (this._eventStartBlocked === timer) {\n        this._eventStartBlocked = null;\n      }\n    }, timeout);\n    this._eventStartBlocked = timer;\n  }\n\n  /**\n   * Extract interactivity options\n   */\n  setProps(props) {\n    if ('onViewStateChange' in props) {\n      this.onViewStateChange = props.onViewStateChange;\n    }\n    if ('onStateChange' in props) {\n      this.onStateChange = props.onStateChange;\n    }\n    if ('makeViewport' in props) {\n      this.makeViewport = props.makeViewport;\n    }\n    if ('dragMode' in props) {\n      this.dragMode = props.dragMode;\n    }\n    this.controllerStateProps = props;\n\n    if ('eventManager' in props && this.eventManager !== props.eventManager) {\n      // EventManager has changed\n      this.eventManager = props.eventManager;\n      this._events = {};\n      this.toggleEvents(this._customEvents, true);\n    }\n\n    if (!('transitionInterpolator' in props)) {\n      // Add default transition interpolator\n      props.transitionInterpolator = this._getTransitionProps().transitionInterpolator;\n    }\n\n    this.transitionManager.processViewStateChange(props);\n\n    let {inertia} = props;\n    if (inertia === true) {\n      inertia = DEFAULT_INERTIA;\n    }\n    this.inertia = inertia;\n\n    // TODO - make sure these are not reset on every setProps\n    const {\n      scrollZoom = true,\n      dragPan = true,\n      dragRotate = true,\n      doubleClickZoom = true,\n      touchZoom = true,\n      touchRotate = false,\n      keyboard = true\n    } = props;\n\n    // Register/unregister events\n    const isInteractive = Boolean(this.onViewStateChange);\n    this.toggleEvents(EVENT_TYPES.WHEEL, isInteractive && scrollZoom);\n    this.toggleEvents(EVENT_TYPES.PAN, isInteractive && (dragPan || dragRotate));\n    this.toggleEvents(EVENT_TYPES.PINCH, isInteractive && (touchZoom || touchRotate));\n    this.toggleEvents(EVENT_TYPES.TRIPLE_PAN, isInteractive && touchRotate);\n    this.toggleEvents(EVENT_TYPES.DOUBLE_TAP, isInteractive && doubleClickZoom);\n    this.toggleEvents(EVENT_TYPES.KEYBOARD, isInteractive && keyboard);\n\n    // Interaction toggles\n    this.scrollZoom = scrollZoom;\n    this.dragPan = dragPan;\n    this.dragRotate = dragRotate;\n    this.doubleClickZoom = doubleClickZoom;\n    this.touchZoom = touchZoom;\n    this.touchRotate = touchRotate;\n    this.keyboard = keyboard;\n  }\n\n  updateTransition() {\n    this.transitionManager.updateTransition();\n  }\n\n  toggleEvents(eventNames, enabled) {\n    if (this.eventManager) {\n      eventNames.forEach(eventName => {\n        if (this._events[eventName] !== enabled) {\n          this._events[eventName] = enabled;\n          if (enabled) {\n            this.eventManager.on(eventName, this.handleEvent);\n          } else {\n            this.eventManager.off(eventName, this.handleEvent);\n          }\n        }\n      });\n    }\n  }\n\n  // Private Methods\n\n  /* Callback util */\n  // formats map state and invokes callback function\n  updateViewport(newControllerState, extraProps = {}, interactionState = {}) {\n    const viewState = {...newControllerState.getViewportProps(), ...extraProps};\n\n    // TODO - to restore diffing, we need to include interactionState\n    const changed = this.controllerState !== newControllerState;\n    // const oldViewState = this.controllerState.getViewportProps();\n    // const changed = Object.keys(viewState).some(key => oldViewState[key] !== viewState[key]);\n\n    this._state = newControllerState.getState();\n    this._setInteractionState(interactionState);\n\n    if (changed) {\n      const oldViewState = this.controllerState ? this.controllerState.getViewportProps() : null;\n      if (this.onViewStateChange) {\n        this.onViewStateChange({viewState, interactionState: this._interactionState, oldViewState});\n      }\n    }\n  }\n\n  _onTransition(params) {\n    if (this.onViewStateChange) {\n      params.interactionState = this._interactionState;\n      this.onViewStateChange(params);\n    }\n  }\n\n  _setInteractionState(newStates) {\n    Object.assign(this._interactionState, newStates);\n    if (this.onStateChange) {\n      this.onStateChange(this._interactionState);\n    }\n  }\n\n  /* Event handlers */\n  // Default handler for the `panstart` event.\n  _onPanStart(event) {\n    const pos = this.getCenter(event);\n    if (!this.isPointInBounds(pos, event)) {\n      return false;\n    }\n    let alternateMode = this.isFunctionKeyPressed(event) || event.rightButton;\n    if (this.invertPan || this.dragMode === 'pan') {\n      // invertPan is replaced by props.dragMode, keeping for backward compatibility\n      alternateMode = !alternateMode;\n    }\n    const newControllerState = this.controllerState[alternateMode ? 'panStart' : 'rotateStart']({\n      pos\n    });\n    this._panMove = alternateMode;\n    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, {isDragging: true});\n    return true;\n  }\n\n  // Default handler for the `panmove` and `panend` event.\n  _onPan(event) {\n    if (!this.isDragging()) {\n      return false;\n    }\n    return this._panMove ? this._onPanMove(event) : this._onPanRotate(event);\n  }\n\n  _onPanEnd(event) {\n    if (!this.isDragging()) {\n      return false;\n    }\n    return this._panMove ? this._onPanMoveEnd(event) : this._onPanRotateEnd(event);\n  }\n\n  // Default handler for panning to move.\n  // Called by `_onPan` when panning without function key pressed.\n  _onPanMove(event) {\n    if (!this.dragPan) {\n      return false;\n    }\n    const pos = this.getCenter(event);\n    const newControllerState = this.controllerState.pan({pos});\n    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, {\n      isDragging: true,\n      isPanning: true\n    });\n    return true;\n  }\n\n  _onPanMoveEnd(event) {\n    const {inertia} = this;\n    if (this.dragPan && inertia && event.velocity) {\n      const pos = this.getCenter(event);\n      const endPos = [\n        pos[0] + (event.velocityX * inertia) / 2,\n        pos[1] + (event.velocityY * inertia) / 2\n      ];\n      const newControllerState = this.controllerState.pan({pos: endPos}).panEnd();\n      this.updateViewport(\n        newControllerState,\n        {\n          ...this._getTransitionProps(),\n          transitionDuration: inertia,\n          transitionEasing: INERTIA_EASING\n        },\n        {\n          isDragging: false,\n          isPanning: true\n        }\n      );\n    } else {\n      const newControllerState = this.controllerState.panEnd();\n      this.updateViewport(newControllerState, null, {\n        isDragging: false,\n        isPanning: false\n      });\n    }\n    return true;\n  }\n\n  // Default handler for panning to rotate.\n  // Called by `_onPan` when panning with function key pressed.\n  _onPanRotate(event) {\n    if (!this.dragRotate) {\n      return false;\n    }\n\n    const pos = this.getCenter(event);\n    const newControllerState = this.controllerState.rotate({pos});\n    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, {\n      isDragging: true,\n      isRotating: true\n    });\n    return true;\n  }\n\n  _onPanRotateEnd(event) {\n    const {inertia} = this;\n    if (this.dragRotate && inertia && event.velocity) {\n      const pos = this.getCenter(event);\n      const endPos = [\n        pos[0] + (event.velocityX * inertia) / 2,\n        pos[1] + (event.velocityY * inertia) / 2\n      ];\n      const newControllerState = this.controllerState.rotate({pos: endPos}).rotateEnd();\n      this.updateViewport(\n        newControllerState,\n        {\n          ...this._getTransitionProps(),\n          transitionDuration: inertia,\n          transitionEasing: INERTIA_EASING\n        },\n        {\n          isDragging: false,\n          isRotating: true\n        }\n      );\n    } else {\n      const newControllerState = this.controllerState.rotateEnd();\n      this.updateViewport(newControllerState, null, {\n        isDragging: false,\n        isRotating: false\n      });\n    }\n    return true;\n  }\n\n  // Default handler for the `wheel` event.\n  _onWheel(event) {\n    if (!this.scrollZoom) {\n      return false;\n    }\n    event.preventDefault();\n\n    const pos = this.getCenter(event);\n    if (!this.isPointInBounds(pos, event)) {\n      return false;\n    }\n\n    const {speed = 0.01, smooth = false} = this.scrollZoom;\n    const {delta} = event;\n\n    // Map wheel delta to relative scale\n    let scale = 2 / (1 + Math.exp(-Math.abs(delta * speed)));\n    if (delta < 0 && scale !== 0) {\n      scale = 1 / scale;\n    }\n\n    const newControllerState = this.controllerState.zoom({pos, scale});\n    this.updateViewport(\n      newControllerState,\n      {...this._getTransitionProps({around: pos}), transitionDuration: smooth ? 250 : 1},\n      {\n        isZooming: true,\n        isPanning: true\n      }\n    );\n    return true;\n  }\n\n  _onTriplePanStart(event) {\n    const pos = this.getCenter(event);\n    if (!this.isPointInBounds(pos, event)) {\n      return false;\n    }\n    const newControllerState = this.controllerState.rotateStart({pos});\n    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, {isDragging: true});\n    return true;\n  }\n\n  _onTriplePan(event) {\n    if (!this.touchRotate) {\n      return false;\n    }\n    if (!this.isDragging()) {\n      return false;\n    }\n\n    const pos = this.getCenter(event);\n    pos[0] -= event.deltaX;\n\n    const newControllerState = this.controllerState.rotate({pos});\n    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, {\n      isDragging: true,\n      isRotating: true\n    });\n    return true;\n  }\n\n  _onTriplePanEnd(event) {\n    if (!this.isDragging()) {\n      return false;\n    }\n    const {inertia} = this;\n    if (this.touchRotate && inertia && event.velocityY) {\n      const pos = this.getCenter(event);\n      const endPos = [pos[0], (pos[1] += (event.velocityY * inertia) / 2)];\n      const newControllerState = this.controllerState.rotate({pos: endPos});\n      this.updateViewport(\n        newControllerState,\n        {\n          ...this._getTransitionProps(),\n          transitionDuration: inertia,\n          transitionEasing: INERTIA_EASING\n        },\n        {\n          isDragging: false,\n          isRotating: true\n        }\n      );\n      this.blockEvents(inertia);\n    } else {\n      const newControllerState = this.controllerState.rotateEnd();\n      this.updateViewport(newControllerState, null, {\n        isDragging: false,\n        isRotating: false\n      });\n    }\n    return true;\n  }\n\n  // Default handler for the `pinchstart` event.\n  _onPinchStart(event) {\n    const pos = this.getCenter(event);\n    if (!this.isPointInBounds(pos, event)) {\n      return false;\n    }\n\n    const newControllerState = this.controllerState.zoomStart({pos}).rotateStart({pos});\n    // hack - hammer's `rotation` field doesn't seem to produce the correct angle\n    this._startPinchRotation = event.rotation;\n    this._lastPinchEvent = event;\n    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, {isDragging: true});\n    return true;\n  }\n\n  // Default handler for the `pinchmove` and `pinchend` events.\n  _onPinch(event) {\n    if (!this.touchZoom && !this.touchRotate) {\n      return false;\n    }\n    if (!this.isDragging()) {\n      return false;\n    }\n\n    let newControllerState = this.controllerState;\n    if (this.touchZoom) {\n      const {scale} = event;\n      const pos = this.getCenter(event);\n      newControllerState = newControllerState.zoom({pos, scale});\n    }\n    if (this.touchRotate) {\n      const {rotation} = event;\n      newControllerState = newControllerState.rotate({\n        deltaAngleX: this._startPinchRotation - rotation\n      });\n    }\n\n    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, {\n      isDragging: true,\n      isPanning: this.touchZoom,\n      isZooming: this.touchZoom,\n      isRotating: this.touchRotate\n    });\n    this._lastPinchEvent = event;\n    return true;\n  }\n\n  _onPinchEnd(event) {\n    if (!this.isDragging()) {\n      return false;\n    }\n    const {inertia, _lastPinchEvent} = this;\n    if (this.touchZoom && inertia && _lastPinchEvent && event.scale !== _lastPinchEvent.scale) {\n      const pos = this.getCenter(event);\n      let newControllerState = this.controllerState.rotateEnd();\n      const z = Math.log2(event.scale);\n      const velocityZ =\n        (z - Math.log2(_lastPinchEvent.scale)) / (event.deltaTime - _lastPinchEvent.deltaTime);\n      const endScale = Math.pow(2, z + (velocityZ * inertia) / 2);\n      newControllerState = newControllerState.zoom({pos, scale: endScale}).zoomEnd();\n\n      this.updateViewport(\n        newControllerState,\n        {\n          ...this._getTransitionProps({around: pos}),\n          transitionDuration: inertia,\n          transitionEasing: INERTIA_EASING\n        },\n        {\n          isDragging: false,\n          isPanning: this.touchZoom,\n          isZooming: this.touchZoom,\n          isRotating: false\n        }\n      );\n      this.blockEvents(inertia);\n    } else {\n      const newControllerState = this.controllerState.zoomEnd().rotateEnd();\n      this.updateViewport(newControllerState, null, {\n        isDragging: false,\n        isPanning: false,\n        isZooming: false,\n        isRotating: false\n      });\n    }\n    this._startPinchRotation = null;\n    this._lastPinchEvent = null;\n    return true;\n  }\n\n  // Default handler for the `doubletap` event.\n  _onDoubleTap(event) {\n    if (!this.doubleClickZoom) {\n      return false;\n    }\n    const pos = this.getCenter(event);\n    if (!this.isPointInBounds(pos, event)) {\n      return false;\n    }\n\n    const isZoomOut = this.isFunctionKeyPressed(event);\n\n    const newControllerState = this.controllerState.zoom({pos, scale: isZoomOut ? 0.5 : 2});\n    this.updateViewport(newControllerState, this._getTransitionProps({around: pos}), {\n      isZooming: true,\n      isPanning: true\n    });\n    this.blockEvents(100);\n    return true;\n  }\n\n  // Default handler for the `keydown` event\n  _onKeyDown(event) {\n    if (!this.keyboard) {\n      return false;\n    }\n    const funcKey = this.isFunctionKeyPressed(event);\n    const {zoomSpeed, moveSpeed, rotateSpeedX, rotateSpeedY} = this.keyboard;\n    const {controllerState} = this;\n    let newControllerState;\n    const interactionState = {};\n\n    switch (event.srcEvent.code) {\n      case 'Minus':\n        newControllerState = funcKey\n          ? controllerState.zoomOut(zoomSpeed).zoomOut(zoomSpeed)\n          : controllerState.zoomOut(zoomSpeed);\n        interactionState.isZooming = true;\n        break;\n      case 'Equal':\n        newControllerState = funcKey\n          ? controllerState.zoomIn(zoomSpeed).zoomIn(zoomSpeed)\n          : controllerState.zoomIn(zoomSpeed);\n        interactionState.isZooming = true;\n        break;\n      case 'ArrowLeft':\n        if (funcKey) {\n          newControllerState = controllerState.rotateLeft(rotateSpeedX);\n          interactionState.isRotating = true;\n        } else {\n          newControllerState = controllerState.moveLeft(moveSpeed);\n          interactionState.isPanning = true;\n        }\n        break;\n      case 'ArrowRight':\n        if (funcKey) {\n          newControllerState = controllerState.rotateRight(rotateSpeedX);\n          interactionState.isRotating = true;\n        } else {\n          newControllerState = controllerState.moveRight(moveSpeed);\n          interactionState.isPanning = true;\n        }\n        break;\n      case 'ArrowUp':\n        if (funcKey) {\n          newControllerState = controllerState.rotateUp(rotateSpeedY);\n          interactionState.isRotating = true;\n        } else {\n          newControllerState = controllerState.moveUp(moveSpeed);\n          interactionState.isPanning = true;\n        }\n        break;\n      case 'ArrowDown':\n        if (funcKey) {\n          newControllerState = controllerState.rotateDown(rotateSpeedY);\n          interactionState.isRotating = true;\n        } else {\n          newControllerState = controllerState.moveDown(moveSpeed);\n          interactionState.isPanning = true;\n        }\n        break;\n      default:\n        return false;\n    }\n    this.updateViewport(newControllerState, this._getTransitionProps(), interactionState);\n    return true;\n  }\n\n  _getTransitionProps(opts) {\n    const {_transition} = this;\n\n    if (!_transition) {\n      return NO_TRANSITION_PROPS;\n    }\n\n    // Enables Transitions on double-tap and key-down events.\n    return opts\n      ? {\n          ..._transition,\n          transitionInterpolator: new LinearInterpolator({\n            ...opts,\n            transitionProps: this.linearTransitionProps,\n            makeViewport: this.controllerState.makeViewport\n          })\n        }\n      : _transition;\n  }\n}\n","import Transition from '../transitions/transition';\n\nconst noop = () => {};\n\nexport const TRANSITION_EVENTS = {\n  BREAK: 1,\n  SNAP_TO_END: 2,\n  IGNORE: 3\n};\n\nconst DEFAULT_PROPS = {\n  transitionEasing: t => t,\n  transitionInterruption: TRANSITION_EVENTS.BREAK,\n  onTransitionStart: noop,\n  onTransitionInterrupt: noop,\n  onTransitionEnd: noop\n};\n\nexport default class TransitionManager {\n  constructor(ControllerState, props = {}) {\n    this.ControllerState = ControllerState;\n    this.props = {...DEFAULT_PROPS, ...props};\n    this.propsInTransition = null;\n    this.transition = new Transition(props.timeline);\n\n    this.onViewStateChange = props.onViewStateChange || noop;\n    this.onStateChange = props.onStateChange || noop;\n\n    this._onTransitionUpdate = this._onTransitionUpdate.bind(this);\n  }\n\n  finalize() {\n    this.transition.cancel();\n  }\n\n  // Returns current transitioned viewport.\n  getViewportInTransition() {\n    return this.propsInTransition;\n  }\n\n  // Process the vewiport change, either ignore or trigger a new transition.\n  // Return true if a new transition is triggered, false otherwise.\n  processViewStateChange(nextProps) {\n    let transitionTriggered = false;\n    const currentProps = this.props;\n    // Set this.props here as '_triggerTransition' calls '_updateViewport' that uses this.props.\n    nextProps = {...DEFAULT_PROPS, ...nextProps};\n    this.props = nextProps;\n\n    // NOTE: Be cautious re-ordering statements in this function.\n    if (this._shouldIgnoreViewportChange(currentProps, nextProps)) {\n      return transitionTriggered;\n    }\n\n    if (this._isTransitionEnabled(nextProps)) {\n      const {interruption, endProps} = this.transition.settings;\n      const startProps = {\n        ...currentProps,\n        ...(interruption === TRANSITION_EVENTS.SNAP_TO_END\n          ? endProps\n          : this.propsInTransition || currentProps)\n      };\n\n      this._triggerTransition(startProps, nextProps);\n\n      transitionTriggered = true;\n    } else {\n      this.transition.cancel();\n    }\n\n    return transitionTriggered;\n  }\n\n  updateTransition() {\n    this.transition.update();\n  }\n\n  // Helper methods\n\n  _isTransitionEnabled(props) {\n    const {transitionDuration, transitionInterpolator} = props;\n    return (\n      (transitionDuration > 0 || transitionDuration === 'auto') && Boolean(transitionInterpolator)\n    );\n  }\n\n  _isUpdateDueToCurrentTransition(props) {\n    if (this.transition.inProgress) {\n      return this.transition.settings.interpolator.arePropsEqual(props, this.propsInTransition);\n    }\n    return false;\n  }\n\n  _shouldIgnoreViewportChange(currentProps, nextProps) {\n    if (this.transition.inProgress) {\n      // Ignore update if it is requested to be ignored\n      return (\n        this.transition.settings.interruption === TRANSITION_EVENTS.IGNORE ||\n        // Ignore update if it is due to current active transition.\n        this._isUpdateDueToCurrentTransition(nextProps)\n      );\n    } else if (this._isTransitionEnabled(nextProps)) {\n      // Ignore if none of the viewport props changed.\n      return nextProps.transitionInterpolator.arePropsEqual(currentProps, nextProps);\n    }\n    return true;\n  }\n\n  _triggerTransition(startProps, endProps) {\n    const startViewstate = new this.ControllerState(startProps);\n    const endViewStateProps = new this.ControllerState(endProps).shortestPathFrom(startViewstate);\n\n    // update transitionDuration for 'auto' mode\n    const {transitionInterpolator} = endProps;\n    const duration = transitionInterpolator.getDuration\n      ? transitionInterpolator.getDuration(startProps, endProps)\n      : endProps.transitionDuration;\n\n    if (duration === 0) {\n      return;\n    }\n\n    const initialProps = endProps.transitionInterpolator.initializeProps(\n      startProps,\n      endViewStateProps\n    );\n\n    this.propsInTransition = {};\n    this.duration = duration;\n    this.transition.start({\n      duration,\n      easing: endProps.transitionEasing,\n      interpolator: endProps.transitionInterpolator,\n      interruption: endProps.transitionInterruption,\n\n      startProps: initialProps.start,\n      endProps: initialProps.end,\n\n      onStart: endProps.onTransitionStart,\n      onUpdate: this._onTransitionUpdate,\n      onInterrupt: this._onTransitionEnd(endProps.onTransitionInterrupt),\n      onEnd: this._onTransitionEnd(endProps.onTransitionEnd)\n    });\n\n    this.onStateChange({inTransition: true});\n\n    this.updateTransition();\n  }\n\n  _onTransitionEnd(callback) {\n    return transition => {\n      this.propsInTransition = null;\n\n      this.onStateChange({\n        inTransition: false,\n        isZooming: false,\n        isPanning: false,\n        isRotating: false\n      });\n\n      callback(transition);\n    };\n  }\n\n  _onTransitionUpdate(transition) {\n    // NOTE: Be cautious re-ordering statements in this function.\n    const {\n      time,\n      settings: {interpolator, startProps, endProps, duration, easing}\n    } = transition;\n    const t = easing(time / duration);\n    const viewport = interpolator.interpolateProps(startProps, endProps, t);\n\n    // This gurantees all props (e.g. bearing, longitude) are normalized\n    // So when viewports are compared they are in same range.\n    this.propsInTransition = new this.ControllerState({\n      ...this.props,\n      ...viewport\n    }).getViewportProps();\n\n    this.onViewStateChange({\n      viewState: this.propsInTransition,\n      oldViewState: this.props\n    });\n  }\n}\n","function noop() {}\n\nconst DEFAULT_SETTINGS = {\n  onStart: noop,\n  onUpdate: noop,\n  onInterrupt: noop,\n  onEnd: noop\n};\n\nexport default class Transition {\n  /**\n   * @params timeline {Timeline}\n   */\n  constructor(timeline) {\n    this._inProgress = false;\n    this._handle = null;\n    this.timeline = timeline;\n\n    // Defaults\n    this.settings = {};\n  }\n\n  /* Public API */\n  get inProgress() {\n    return this._inProgress;\n  }\n\n  /**\n   * (re)start this transition.\n   * @params props {object} - optional overriding props. see constructor\n   */\n  start(props) {\n    this.cancel();\n    this.settings = {...DEFAULT_SETTINGS, ...props};\n    this._inProgress = true;\n    this.settings.onStart(this);\n  }\n\n  /**\n   * end this transition if it is in progress.\n   */\n  end() {\n    if (this._inProgress) {\n      this.timeline.removeChannel(this._handle);\n      this._handle = null;\n      this._inProgress = false;\n      this.settings.onEnd(this);\n    }\n  }\n\n  /**\n   * cancel this transition if it is in progress.\n   */\n  cancel() {\n    if (this._inProgress) {\n      this.settings.onInterrupt(this);\n      this.timeline.removeChannel(this._handle);\n      this._handle = null;\n      this._inProgress = false;\n    }\n  }\n\n  /**\n   * update this transition. Returns `true` if updated.\n   */\n  update() {\n    if (!this._inProgress) {\n      return false;\n    }\n\n    // It is important to initialize the handle during `update` instead of `start`.\n    // The CPU time that the `start` frame takes should not be counted towards the duration.\n    // On the other hand, `update` always happens during a render cycle. The clock starts when the\n    // transition is rendered for the first time.\n    if (this._handle === null) {\n      const {timeline, settings} = this;\n      this._handle = timeline.addChannel({\n        delay: timeline.getTime(),\n        duration: settings.duration\n      });\n    }\n\n    this.time = this.timeline.getTime(this._handle);\n    // Call subclass method\n    this._onUpdate();\n    // Call user callback\n    this.settings.onUpdate(this);\n\n    // This only works if `settings.duration` is set\n    // Spring transition must call `end` manually\n    if (this.timeline.isFinished(this._handle)) {\n      this.end();\n    }\n    return true;\n  }\n\n  /* Private API */\n\n  _onUpdate() {\n    // for subclass override\n  }\n}\n","import TransitionInterpolator from './transition-interpolator';\nimport {lerp} from 'math.gl';\n\nconst DEFAULT_PROPS = ['longitude', 'latitude', 'zoom', 'bearing', 'pitch'];\nconst DEFAULT_REQUIRED_PROPS = ['longitude', 'latitude', 'zoom'];\n\n/**\n * Performs linear interpolation of two view states.\n */\nexport default class LinearInterpolator extends TransitionInterpolator {\n  /**\n   * @param {Object} opts\n   * @param {Array} opts.transitionProps - list of props to apply linear transition to.\n   * @param {Array} opts.around - a screen point to zoom/rotate around.\n   * @param {Function} opts.makeViewport - construct a viewport instance with given props.\n   */\n  constructor(opts = {}) {\n    // Backward compatibility\n    const transitionProps = Array.isArray(opts) ? opts : opts.transitionProps;\n    super(\n      transitionProps || {\n        compare: DEFAULT_PROPS,\n        extract: DEFAULT_PROPS,\n        required: DEFAULT_REQUIRED_PROPS\n      }\n    );\n    this.opts = opts;\n  }\n\n  initializeProps(startProps, endProps) {\n    const result = super.initializeProps(startProps, endProps);\n\n    const {makeViewport, around} = this.opts;\n    if (makeViewport && around) {\n      const startViewport = makeViewport(startProps);\n      const endViewport = makeViewport(endProps);\n      const aroundPosition = startViewport.unproject(around);\n      result.start.around = around;\n      Object.assign(result.end, {\n        around: endViewport.project(aroundPosition),\n        aroundPosition,\n        width: endProps.width,\n        height: endProps.height\n      });\n    }\n\n    return result;\n  }\n\n  interpolateProps(startProps, endProps, t) {\n    const propsInTransition = {};\n    for (const key of this._propsToExtract) {\n      propsInTransition[key] = lerp(startProps[key] || 0, endProps[key] || 0, t);\n    }\n\n    if (endProps.aroundPosition) {\n      // Linear transition should be performed in common space\n      const viewport = this.opts.makeViewport({...endProps, ...propsInTransition});\n      Object.assign(\n        propsInTransition,\n        viewport.panByPosition(\n          endProps.aroundPosition,\n          // anchor point in current screen coordinates\n          lerp(startProps.around, endProps.around, t)\n        )\n      );\n    }\n    return propsInTransition;\n  }\n}\n","import {equals} from 'math.gl';\nimport assert from '../utils/assert';\n\nexport default class TransitionInterpolator {\n  /**\n   * @param opts {array|object}\n   * @param opts.compare {array} - prop names used in equality check\n   * @param opts.extract {array} - prop names needed for interpolation\n   * @param opts.required {array} - prop names that must be supplied\n   * alternatively, supply one list of prop names as `opts` if all of the above are the same.\n   */\n  constructor(opts = {}) {\n    if (Array.isArray(opts)) {\n      opts = {\n        compare: opts,\n        extract: opts,\n        required: opts\n      };\n    }\n    const {compare, extract, required} = opts;\n\n    this._propsToCompare = compare;\n    this._propsToExtract = extract;\n    this._requiredProps = required;\n  }\n\n  /**\n   * Checks if two sets of props need transition in between\n   * @param currentProps {object} - a list of viewport props\n   * @param nextProps {object} - a list of viewport props\n   * @returns {bool} - true if two props are equivalent\n   */\n  arePropsEqual(currentProps, nextProps) {\n    for (const key of this._propsToCompare || Object.keys(nextProps)) {\n      if (\n        !(key in currentProps) ||\n        !(key in nextProps) ||\n        !equals(currentProps[key], nextProps[key])\n      ) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Called before transition starts to validate/pre-process start and end props\n   * @param startProps {object} - a list of starting viewport props\n   * @param endProps {object} - a list of target viewport props\n   * @returns {Object} {start, end} - start and end props to be passed\n   *   to `interpolateProps`\n   */\n  initializeProps(startProps, endProps) {\n    let result;\n\n    if (this._propsToExtract) {\n      const startViewStateProps = {};\n      const endViewStateProps = {};\n\n      for (const key of this._propsToExtract) {\n        startViewStateProps[key] = startProps[key];\n        endViewStateProps[key] = endProps[key];\n      }\n      result = {start: startViewStateProps, end: endViewStateProps};\n    } else {\n      result = {start: startProps, end: endProps};\n    }\n\n    this._checkRequiredProps(result.start);\n    this._checkRequiredProps(result.end);\n\n    return result;\n  }\n\n  /**\n   * Returns viewport props in transition\n   * @param startProps {object} - a list of starting viewport props\n   * @param endProps {object} - a list of target viewport props\n   * @param t {number} - a time factor between [0, 1]\n   * @returns {object} - a list of interpolated viewport props\n   */\n  interpolateProps(startProps, endProps, t) {\n    return endProps;\n  }\n\n  /**\n   * Returns transition duration\n   * @param startProps {object} - a list of starting viewport props\n   * @param endProps {object} - a list of target viewport props\n   * @returns {Number} - transition duration in milliseconds\n   */\n  getDuration(startProps, endProps) {\n    return endProps.transitionDuration;\n  }\n\n  _checkRequiredProps(props) {\n    if (!this._requiredProps) {\n      return;\n    }\n\n    this._requiredProps.forEach(propName => {\n      const value = props[propName];\n      assert(\n        Number.isFinite(value) || Array.isArray(value),\n        `${propName} is required for transition`\n      );\n    });\n  }\n}\n","export default class ViewState {\n  constructor(opts) {\n    this._viewportProps = this._applyConstraints(opts);\n  }\n\n  getViewportProps() {\n    return this._viewportProps;\n  }\n\n  getState() {\n    return this._state;\n  }\n\n  shortestPathFrom(viewState) {\n    return this._viewportProps;\n  }\n\n  // Redefined by subclass\n  // Apply any constraints (mathematical or defined by _viewportProps) to map state\n  _applyConstraints(props) {\n    return props;\n  }\n}\n","import {deepEqual} from '../utils/deep-equal';\nimport {default as LightingEffect} from '../effects/lighting/lighting-effect';\n\nconst DEFAULT_LIGHTING_EFFECT = new LightingEffect();\n\nexport default class EffectManager {\n  constructor() {\n    this.effects = [];\n    this._internalEffects = [];\n    this._needsRedraw = 'Initial render';\n    this.setEffects();\n  }\n\n  setProps(props) {\n    if ('effects' in props) {\n      if (props.effects.length !== this.effects.length || !deepEqual(props.effects, this.effects)) {\n        this.setEffects(props.effects);\n        this._needsRedraw = 'effects changed';\n      }\n    }\n  }\n\n  needsRedraw(opts = {clearRedrawFlags: false}) {\n    const redraw = this._needsRedraw;\n    if (opts.clearRedrawFlags) {\n      this._needsRedraw = false;\n    }\n    return redraw;\n  }\n\n  getEffects() {\n    return this._internalEffects;\n  }\n\n  finalize() {\n    this.cleanup();\n  }\n\n  // Private\n  setEffects(effects = []) {\n    this.cleanup();\n    this.effects = effects;\n    this._createInternalEffects();\n  }\n\n  cleanup() {\n    for (const effect of this.effects) {\n      effect.cleanup();\n    }\n\n    for (const effect of this._internalEffects) {\n      effect.cleanup();\n    }\n    this.effects.length = 0;\n    this._internalEffects.length = 0;\n  }\n\n  _createInternalEffects() {\n    this._internalEffects = this.effects.slice();\n    if (!this.effects.some(effect => effect instanceof LightingEffect)) {\n      this._internalEffects.push(DEFAULT_LIGHTING_EFFECT);\n    }\n  }\n}\n","import debug from '../debug';\nimport DrawLayersPass from '../passes/draw-layers-pass';\nimport PickLayersPass from '../passes/pick-layers-pass';\nimport {Framebuffer} from '@luma.gl/core';\n\nconst TRACE_RENDER_LAYERS = 'deckRenderer.renderLayers';\n\nexport default class DeckRenderer {\n  constructor(gl) {\n    this.gl = gl;\n    this.layerFilter = null;\n    this.drawPickingColors = false;\n    this.drawLayersPass = new DrawLayersPass(gl);\n    this.pickLayersPass = new PickLayersPass(gl);\n    this.renderCount = 0;\n    this._needsRedraw = 'Initial render';\n    this.renderBuffers = [];\n    this.lastPostProcessEffect = null;\n  }\n\n  setProps(props) {\n    if ('layerFilter' in props && this.layerFilter !== props.layerFilter) {\n      this.layerFilter = props.layerFilter;\n      this._needsRedraw = 'layerFilter changed';\n    }\n\n    if ('drawPickingColors' in props && this.drawPickingColors !== props.drawPickingColors) {\n      this.drawPickingColors = props.drawPickingColors;\n      this._needsRedraw = 'drawPickingColors changed';\n    }\n  }\n\n  /*\n    target,\n    layers,\n    viewports,\n    onViewportActive,\n    views,\n    redrawReason,\n    clearCanvas,\n    effects,\n    pass,\n    stats\n  */\n  renderLayers(opts) {\n    const layerPass = this.drawPickingColors ? this.pickLayersPass : this.drawLayersPass;\n\n    opts.layerFilter = opts.layerFilter || this.layerFilter;\n    opts.effects = opts.effects || [];\n    opts.target = opts.target || Framebuffer.getDefaultFramebuffer(this.gl);\n\n    this._preRender(opts.effects, opts);\n\n    const outputBuffer = this.lastPostProcessEffect ? this.renderBuffers[0] : opts.target;\n    const renderStats = layerPass.render({...opts, target: outputBuffer});\n\n    this._postRender(opts.effects, opts);\n\n    this.renderCount++;\n\n    debug(TRACE_RENDER_LAYERS, this, renderStats, opts);\n  }\n\n  needsRedraw(opts = {clearRedrawFlags: false}) {\n    const redraw = this._needsRedraw;\n    if (opts.clearRedrawFlags) {\n      this._needsRedraw = false;\n    }\n    return redraw;\n  }\n\n  finalize() {\n    const {renderBuffers} = this;\n    for (const buffer of renderBuffers) {\n      buffer.delete();\n    }\n    renderBuffers.length = 0;\n  }\n\n  // Private\n  _preRender(effects, opts) {\n    let lastPostProcessEffect = null;\n\n    for (const effect of effects) {\n      effect.preRender(this.gl, opts);\n      if (effect.postRender) {\n        lastPostProcessEffect = effect;\n      }\n    }\n\n    if (lastPostProcessEffect) {\n      this._resizeRenderBuffers();\n    }\n    this.lastPostProcessEffect = lastPostProcessEffect;\n  }\n\n  _resizeRenderBuffers() {\n    const {renderBuffers} = this;\n    if (renderBuffers.length === 0) {\n      renderBuffers.push(new Framebuffer(this.gl), new Framebuffer(this.gl));\n    }\n    for (const buffer of renderBuffers) {\n      buffer.resize();\n    }\n  }\n\n  _postRender(effects, opts) {\n    const {renderBuffers} = this;\n    const params = {\n      inputBuffer: renderBuffers[0],\n      swapBuffer: renderBuffers[1],\n      target: null\n    };\n    for (const effect of effects) {\n      if (effect.postRender) {\n        if (effect === this.lastPostProcessEffect) {\n          params.target = opts.target;\n          effect.postRender(this.gl, params);\n          break;\n        }\n        const buffer = effect.postRender(this.gl, params);\n        params.inputBuffer = buffer;\n        params.swapBuffer = buffer === renderBuffers[0] ? renderBuffers[1] : renderBuffers[0];\n      }\n    }\n  }\n}\n","import LayersPass from './layers-pass';\n\nexport default class DrawLayersPass extends LayersPass {}\n","import LayersPass from './layers-pass';\nimport {withParameters} from '@luma.gl/core';\nimport GL from '@luma.gl/constants';\nimport log from '../utils/log';\n\nconst PICKING_PARAMETERS = {\n  blendFunc: [GL.ONE, GL.ZERO, GL.CONSTANT_ALPHA, GL.ZERO],\n  blendEquation: GL.FUNC_ADD\n};\n\nexport default class PickLayersPass extends LayersPass {\n  render(props) {\n    if (props.pickingFBO) {\n      // When drawing into an off-screen buffer, use the alpha channel to encode layer index\n      return this._drawPickingBuffer(props);\n    }\n    // When drawing to screen (debug mode), do not use the alpha channel so that result is always visible\n    return super.render(props);\n  }\n\n  // Private\n  // Draws list of layers and viewports into the picking buffer\n  // Note: does not sample the buffer, that has to be done by the caller\n  _drawPickingBuffer({\n    layers,\n    layerFilter,\n    views,\n    viewports,\n    onViewportActive,\n    pickingFBO,\n    deviceRect: {x, y, width, height},\n    pass = 'picking',\n    redrawReason,\n    pickZ\n  }) {\n    const gl = this.gl;\n    this.pickZ = pickZ;\n\n    // Track encoded layer indices\n    const encodedColors = !pickZ && {\n      byLayer: new Map(),\n      byAlpha: []\n    };\n    // Temporarily store it on the instance so that it can be accessed by this.getLayerParameters\n    this._colors = encodedColors;\n\n    // Make sure we clear scissor test and fbo bindings in case of exceptions\n    // We are only interested in one pixel, no need to render anything else\n    // Note that the callback here is called synchronously.\n    // Set blend mode for picking\n    // always overwrite existing pixel with [r,g,b,layerIndex]\n    const renderStatus = withParameters(\n      gl,\n      {\n        scissorTest: true,\n        scissor: [x, y, width, height],\n        clearColor: [0, 0, 0, 0],\n        // When used as Mapbox custom layer, the context state may be dirty\n        // TODO - Remove when mapbox fixes this issue\n        // https://github.com/mapbox/mapbox-gl-js/issues/7801\n        depthMask: true,\n        depthTest: true,\n        depthRange: [0, 1],\n        colorMask: [true, true, true, true],\n        // Blending\n        ...PICKING_PARAMETERS,\n        blend: !pickZ\n      },\n      () =>\n        super.render({\n          target: pickingFBO,\n          layers,\n          layerFilter,\n          views,\n          viewports,\n          onViewportActive,\n          pass,\n          redrawReason\n        })\n    );\n\n    // Clear the temp field\n    this._colors = null;\n    const decodePickingColor = encodedColors && decodeColor.bind(null, encodedColors);\n    return {decodePickingColor, stats: renderStatus};\n  }\n\n  // PRIVATE\n  shouldDrawLayer(layer) {\n    return layer.props.pickable;\n  }\n\n  getModuleParameters() {\n    return {\n      pickingActive: 1,\n      pickingAttribute: this.pickZ,\n      // turn off lighting by adding empty light source object\n      // lights shader module relies on the `lightSources` to turn on/off lighting\n      lightSources: {}\n    };\n  }\n\n  getLayerParameters(layer, layerIndex, viewport) {\n    const pickParameters = {...layer.props.parameters};\n\n    if (this.pickZ) {\n      pickParameters.blend = false;\n    } else {\n      Object.assign(pickParameters, PICKING_PARAMETERS);\n      pickParameters.blend = true;\n      pickParameters.blendColor = encodeColor(this._colors, layer, viewport);\n    }\n\n    return pickParameters;\n  }\n}\n\n// Assign an unique alpha value for each pickable layer and track the encoding in the cache object\n// Returns normalized blend color\nfunction encodeColor(encoded, layer, viewport) {\n  const {byLayer, byAlpha} = encoded;\n  let a;\n\n  // Encode layerIndex in the alpha channel\n  // TODO - combine small layers to better utilize the picking color space\n  if (byLayer.has(layer)) {\n    const entry = byLayer.get(layer);\n    entry.viewports.push(viewport);\n    a = entry.a;\n  } else {\n    a = byLayer.size + 1;\n    if (a <= 255) {\n      const entry = {a, layer, viewports: [viewport]};\n      byLayer.set(layer, entry);\n      byAlpha[a] = entry;\n    } else {\n      log.warn('Too many pickable layers, only picking the first 255')();\n      a = 0;\n    }\n  }\n  return [0, 0, 0, a / 255];\n}\n\n// Given a picked color, retrieve the corresponding layer and viewports from cache\nfunction decodeColor(encoded, pickedColor) {\n  const entry = encoded.byAlpha[pickedColor[3]];\n  return (\n    entry && {\n      pickedLayer: entry.layer,\n      pickedViewports: entry.viewports,\n      pickedObjectIndex: entry.layer.decodePickingColor(pickedColor)\n    }\n  );\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {\n  Framebuffer,\n  Texture2D,\n  isWebGL2,\n  readPixelsToArray,\n  cssToDeviceRatio,\n  cssToDevicePixels\n} from '@luma.gl/core';\nimport GL from '@luma.gl/constants';\nimport PickLayersPass from '../passes/pick-layers-pass';\nimport {getClosestObject, getUniqueObjects} from './picking/query-object';\nimport {processPickInfo, getLayerPickingInfo, getEmptyPickingInfo} from './picking/pick-info';\n\nexport default class DeckPicker {\n  constructor(gl) {\n    this.gl = gl;\n    this.pickingFBO = null;\n    this.pickLayersPass = new PickLayersPass(gl);\n    this.layerFilter = null;\n    this.lastPickedInfo = {\n      // For callback tracking and auto highlight\n      index: -1,\n      layerId: null,\n      info: null\n    };\n  }\n\n  setProps(props) {\n    if ('layerFilter' in props) {\n      this.layerFilter = props.layerFilter;\n    }\n\n    if ('_pickable' in props) {\n      this._pickable = props._pickable;\n    }\n  }\n\n  finalize() {\n    if (this.pickingFBO) {\n      this.pickingFBO.delete();\n    }\n    if (this.depthFBO) {\n      this.depthFBO.color.delete();\n      this.depthFBO.delete();\n    }\n  }\n\n  // Pick the closest info at given coordinate\n  pickObject(opts) {\n    return this._pickClosestObject(opts);\n  }\n\n  // Get all unique infos within a bounding box\n  pickObjects(opts) {\n    return this._pickVisibleObjects(opts);\n  }\n\n  // Returns a new picking info object by assuming the last picked object is still picked\n  getLastPickedObject({x, y, layers, viewports}, lastPickedInfo = this.lastPickedInfo.info) {\n    const lastPickedLayerId = lastPickedInfo && lastPickedInfo.layer && lastPickedInfo.layer.id;\n    const lastPickedViewportId =\n      lastPickedInfo && lastPickedInfo.viewport && lastPickedInfo.viewport.id;\n    const layer = lastPickedLayerId ? layers.find(l => l.id === lastPickedLayerId) : null;\n    const viewport =\n      (lastPickedViewportId && viewports.find(v => v.id === lastPickedViewportId)) || viewports[0];\n    const coordinate = viewport && viewport.unproject([x - viewport.x, y - viewport.y]);\n\n    const info = {\n      x,\n      y,\n      viewport,\n      coordinate,\n      layer\n    };\n\n    if (layer) {\n      return {...lastPickedInfo, ...info};\n    }\n    return Object.assign(info, {color: null, object: null, index: -1});\n  }\n\n  // Private\n  _resizeBuffer() {\n    const {gl} = this;\n\n    // Create a frame buffer if not already available\n    if (!this.pickingFBO) {\n      this.pickingFBO = new Framebuffer(gl);\n      if (Framebuffer.isSupported(gl, {colorBufferFloat: true})) {\n        this.depthFBO = new Framebuffer(gl);\n        this.depthFBO.attach({\n          [GL.COLOR_ATTACHMENT0]: new Texture2D(gl, {\n            format: isWebGL2(gl) ? GL.RGBA32F : GL.RGBA,\n            type: GL.FLOAT\n          })\n        });\n      }\n    }\n    // Resize it to current canvas size (this is a noop if size hasn't changed)\n    this.pickingFBO.resize({width: gl.canvas.width, height: gl.canvas.height});\n    if (this.depthFBO) {\n      this.depthFBO.resize({width: gl.canvas.width, height: gl.canvas.height});\n    }\n    return this.pickingFBO;\n  }\n\n  // picking can only handle up to 255 layers. Drop non-pickable/invisible layers from the list.\n  _getPickable(layers) {\n    if (this._pickable === false) {\n      return null;\n    }\n    const pickableLayers = layers.filter(layer => layer.isPickable() && !layer.isComposite);\n    return pickableLayers.length ? pickableLayers : null;\n  }\n\n  // Pick the closest object at the given (x,y) coordinate\n  // eslint-disable-next-line max-statements,complexity\n  _pickClosestObject({\n    layers,\n    views,\n    viewports,\n    x,\n    y,\n    radius = 0,\n    depth = 1,\n    mode = 'query',\n    unproject3D,\n    onViewportActive\n  }) {\n    layers = this._getPickable(layers);\n\n    if (!layers) {\n      return {\n        result: [],\n        emptyInfo: getEmptyPickingInfo({viewports, x, y})\n      };\n    }\n\n    this._resizeBuffer();\n\n    // Convert from canvas top-left to WebGL bottom-left coordinates\n    // Top-left coordinates [x, y] to bottom-left coordinates [deviceX, deviceY]\n    // And compensate for pixelRatio\n    const pixelRatio = cssToDeviceRatio(this.gl);\n    const devicePixelRange = cssToDevicePixels(this.gl, [x, y], true);\n    const devicePixel = [\n      devicePixelRange.x + Math.floor(devicePixelRange.width / 2),\n      devicePixelRange.y + Math.floor(devicePixelRange.height / 2)\n    ];\n\n    const deviceRadius = Math.round(radius * pixelRatio);\n    const {width, height} = this.pickingFBO;\n    const deviceRect = this._getPickingRect({\n      deviceX: devicePixel[0],\n      deviceY: devicePixel[1],\n      deviceRadius,\n      deviceWidth: width,\n      deviceHeight: height\n    });\n\n    let infos;\n    const result = [];\n    const affectedLayers = {};\n\n    for (let i = 0; i < depth; i++) {\n      const pickedResult =\n        deviceRect &&\n        this._drawAndSample({\n          layers,\n          views,\n          viewports,\n          onViewportActive,\n          deviceRect,\n          pass: `picking:${mode}`,\n          redrawReason: mode\n        });\n\n      const pickInfo = getClosestObject({\n        ...pickedResult,\n        deviceX: devicePixel[0],\n        deviceY: devicePixel[1],\n        deviceRadius,\n        deviceRect\n      });\n\n      let z;\n      if (pickInfo.pickedLayer && unproject3D && this.depthFBO) {\n        const pickedResultPass2 = this._drawAndSample({\n          layers: [pickInfo.pickedLayer],\n          views,\n          viewports,\n          onViewportActive,\n          deviceRect: {x: pickInfo.pickedX, y: pickInfo.pickedY, width: 1, height: 1},\n          pass: `picking:${mode}`,\n          redrawReason: 'pick-z',\n          pickZ: true\n        });\n        // picked value is in common space (pixels) from the camera target (viewport.position)\n        // convert it to meters from the ground\n        z =\n          pickedResultPass2.pickedColors[0] * viewports[0].distanceScales.metersPerUnit[2] +\n          viewports[0].position[2];\n      }\n\n      // Only exclude if we need to run picking again.\n      // We need to run picking again if an object is detected AND\n      // we have not exhausted the requested depth.\n      if (pickInfo.pickedColor && i + 1 < depth) {\n        const layerId = pickInfo.pickedColor[3] - 1;\n        affectedLayers[layerId] = true;\n        layers[layerId].disablePickingIndex(pickInfo.pickedObjectIndex);\n      }\n\n      // This logic needs to run even if no object is picked.\n      infos = processPickInfo({\n        pickInfo,\n        lastPickedInfo: this.lastPickedInfo,\n        mode,\n        layers,\n        viewports,\n        x,\n        y,\n        z,\n        pixelRatio\n      });\n\n      for (const info of infos.values()) {\n        if (info.layer) {\n          result.push(info);\n        }\n      }\n\n      // If no object is picked stop.\n      if (!pickInfo.pickedColor) {\n        break;\n      }\n    }\n\n    // reset only affected buffers\n    for (const layerId in affectedLayers) {\n      layers[layerId].restorePickingColors();\n    }\n\n    return {result, emptyInfo: infos && infos.get(null)};\n  }\n\n  // Pick all objects within the given bounding box\n  _pickVisibleObjects({\n    layers,\n    views,\n    viewports,\n    x,\n    y,\n    width = 1,\n    height = 1,\n    mode = 'query',\n    maxObjects = null,\n    onViewportActive\n  }) {\n    layers = this._getPickable(layers);\n\n    if (!layers) {\n      return [];\n    }\n\n    this._resizeBuffer();\n    // Convert from canvas top-left to WebGL bottom-left coordinates\n    // And compensate for pixelRatio\n    const pixelRatio = cssToDeviceRatio(this.gl);\n    const leftTop = cssToDevicePixels(this.gl, [x, y], true);\n\n    // take left and top (y inverted in device pixels) from start location\n    const deviceLeft = leftTop.x;\n    const deviceTop = leftTop.y + leftTop.height;\n\n    // take right and bottom (y inverted in device pixels) from end location\n    const rightBottom = cssToDevicePixels(this.gl, [x + width, y + height], true);\n    const deviceRight = rightBottom.x + rightBottom.width;\n    const deviceBottom = rightBottom.y;\n\n    const deviceRect = {\n      x: deviceLeft,\n      y: deviceBottom,\n      // deviceTop and deviceRight represent the first pixel outside the desired rect\n      width: deviceRight - deviceLeft,\n      height: deviceTop - deviceBottom\n    };\n\n    const pickedResult = this._drawAndSample({\n      layers,\n      views,\n      viewports,\n      onViewportActive,\n      deviceRect,\n      pass: `picking:${mode}`,\n      redrawReason: mode\n    });\n\n    const pickInfos = getUniqueObjects(pickedResult);\n\n    // Only return unique infos, identified by info.object\n    const uniqueInfos = new Map();\n\n    const isMaxObjects = Number.isFinite(maxObjects);\n\n    for (let i = 0; i < pickInfos.length; i++) {\n      if (isMaxObjects && uniqueInfos.size >= maxObjects) {\n        break;\n      }\n      const pickInfo = pickInfos[i];\n      let info = {\n        color: pickInfo.pickedColor,\n        layer: null,\n        index: pickInfo.pickedObjectIndex,\n        picked: true,\n        x,\n        y,\n        width,\n        height,\n        pixelRatio\n      };\n\n      info = getLayerPickingInfo({layer: pickInfo.pickedLayer, info, mode});\n      if (!uniqueInfos.has(info.object)) {\n        uniqueInfos.set(info.object, info);\n      }\n    }\n\n    return Array.from(uniqueInfos.values());\n  }\n\n  // returns pickedColor or null if no pickable layers found.\n  _drawAndSample({\n    layers,\n    views,\n    viewports,\n    onViewportActive,\n    deviceRect,\n    pass,\n    redrawReason,\n    pickZ\n  }) {\n    const pickingFBO = pickZ ? this.depthFBO : this.pickingFBO;\n\n    const {decodePickingColor} = this.pickLayersPass.render({\n      layers,\n      layerFilter: this.layerFilter,\n      views,\n      viewports,\n      onViewportActive,\n      pickingFBO,\n      deviceRect,\n      pass,\n      redrawReason,\n      pickZ\n    });\n\n    // Read from an already rendered picking buffer\n    // Returns an Uint8ClampedArray of picked pixels\n    const {x, y, width, height} = deviceRect;\n    const pickedColors = new (pickZ ? Float32Array : Uint8Array)(width * height * 4);\n    readPixelsToArray(pickingFBO, {\n      sourceX: x,\n      sourceY: y,\n      sourceWidth: width,\n      sourceHeight: height,\n      target: pickedColors\n    });\n\n    return {pickedColors, decodePickingColor};\n  }\n\n  // Calculate a picking rect centered on deviceX and deviceY and clipped to device\n  // Returns null if pixel is outside of device\n  _getPickingRect({deviceX, deviceY, deviceRadius, deviceWidth, deviceHeight}) {\n    // Create a box of size `radius * 2 + 1` centered at [deviceX, deviceY]\n    const x = Math.max(0, deviceX - deviceRadius);\n    const y = Math.max(0, deviceY - deviceRadius);\n    const width = Math.min(deviceWidth, deviceX + deviceRadius + 1) - x;\n    const height = Math.min(deviceHeight, deviceY + deviceRadius + 1) - y;\n\n    // x, y out of bounds.\n    if (width <= 0 || height <= 0) {\n      return null;\n    }\n\n    return {x, y, width, height};\n  }\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport log from '../../utils/log';\n\nconst NO_PICKED_OBJECT = {\n  pickedColor: null,\n  pickedLayer: null,\n  pickedObjectIndex: -1\n};\n\n/* eslint-disable max-depth, max-statements */\n/**\n * Pick at a specified pixel with a tolerance radius\n * Returns the closest object to the pixel in shape `{pickedColor, pickedLayer, pickedObjectIndex}`\n */\nexport function getClosestObject({\n  pickedColors,\n  decodePickingColor,\n  deviceX,\n  deviceY,\n  deviceRadius,\n  deviceRect\n}) {\n  if (pickedColors) {\n    // Traverse all pixels in picking results and find the one closest to the supplied\n    // [deviceX, deviceY]\n    const {x, y, width, height} = deviceRect;\n    let minSquareDistanceToCenter = deviceRadius * deviceRadius;\n    let closestPixelIndex = -1;\n    let i = 0;\n\n    for (let row = 0; row < height; row++) {\n      const dy = row + y - deviceY;\n      const dy2 = dy * dy;\n\n      if (dy2 > minSquareDistanceToCenter) {\n        // skip this row\n        i += 4 * width;\n      } else {\n        for (let col = 0; col < width; col++) {\n          // Decode picked layer from color\n          const pickedLayerIndex = pickedColors[i + 3] - 1;\n\n          if (pickedLayerIndex >= 0) {\n            const dx = col + x - deviceX;\n            const d2 = dx * dx + dy2;\n\n            if (d2 <= minSquareDistanceToCenter) {\n              minSquareDistanceToCenter = d2;\n              closestPixelIndex = i;\n            }\n          }\n          i += 4;\n        }\n      }\n    }\n\n    if (closestPixelIndex >= 0) {\n      // Decode picked object index from color\n      const pickedColor = pickedColors.slice(closestPixelIndex, closestPixelIndex + 4);\n      const pickedObject = decodePickingColor(pickedColor);\n      if (pickedObject) {\n        const dy = Math.floor(closestPixelIndex / 4 / width);\n        const dx = closestPixelIndex / 4 - dy * width;\n        return {\n          ...pickedObject,\n          pickedColor,\n          pickedX: x + dx,\n          pickedY: y + dy\n        };\n      }\n      log.error('Picked non-existent layer. Is picking buffer corrupt?')();\n    }\n  }\n  return NO_PICKED_OBJECT;\n}\n\n/**\n * Examines a picking buffer for unique colors\n * Returns array of unique objects in shape `{x, y, pickedColor, pickedLayer, pickedObjectIndex}`\n */\nexport function getUniqueObjects({pickedColors, decodePickingColor}) {\n  const uniqueColors = new Map();\n\n  // Traverse all pixels in picking results and get unique colors\n  if (pickedColors) {\n    for (let i = 0; i < pickedColors.length; i += 4) {\n      // Decode picked layer from color\n      const pickedLayerIndex = pickedColors[i + 3] - 1;\n\n      if (pickedLayerIndex >= 0) {\n        const pickedColor = pickedColors.slice(i, i + 4);\n        const colorKey = pickedColor.join(',');\n        // eslint-disable-next-line\n        if (!uniqueColors.has(colorKey)) {\n          const pickedObject = decodePickingColor(pickedColor);\n          // eslint-disable-next-line\n          if (pickedObject) {\n            uniqueColors.set(colorKey, {\n              ...pickedObject,\n              pickedColor\n            });\n          } else {\n            log.error('Picked non-existent layer. Is picking buffer corrupt?')();\n          }\n        }\n      }\n    }\n  }\n\n  return Array.from(uniqueColors.values());\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// Even if nothing gets picked, we need to expose some information of the picking action:\n// x, y, coordinates etc.\nexport function getEmptyPickingInfo({pickInfo, viewports, pixelRatio, x, y, z}) {\n  // If more than one viewports are used in the picking pass, locate the viewport that\n  // drew the picked pixel\n  let pickedViewport = viewports[0];\n  if (viewports.length > 1) {\n    // Find the viewport that contain the picked pixel\n    pickedViewport = getViewportFromCoordinates(pickInfo?.pickedViewports || viewports, {x, y});\n  }\n  const coordinate =\n    pickedViewport &&\n    pickedViewport.unproject([x - pickedViewport.x, y - pickedViewport.y], {targetZ: z});\n\n  return {\n    color: null,\n    layer: null,\n    viewport: pickedViewport,\n    index: -1,\n    picked: false,\n    x,\n    y,\n    pixel: [x, y],\n    coordinate,\n    devicePixel: pickInfo && [pickInfo.pickedX, pickInfo.pickedY],\n    pixelRatio\n  };\n}\n\n/* eslint-disable max-depth */\nexport function processPickInfo(opts) {\n  const {pickInfo, lastPickedInfo, mode, layers} = opts;\n  const {pickedColor, pickedLayer, pickedObjectIndex} = pickInfo;\n\n  const affectedLayers = pickedLayer ? [pickedLayer] : [];\n\n  if (mode === 'hover') {\n    // only invoke onHover events if picked object has changed\n    const lastPickedObjectIndex = lastPickedInfo.index;\n    const lastPickedLayerId = lastPickedInfo.layerId;\n    const pickedLayerId = pickedLayer && pickedLayer.props.id;\n\n    // proceed only if picked object changed\n    if (pickedLayerId !== lastPickedLayerId || pickedObjectIndex !== lastPickedObjectIndex) {\n      if (pickedLayerId !== lastPickedLayerId) {\n        // We cannot store a ref to lastPickedLayer in the context because\n        // the state of an outdated layer is no longer valid\n        // and the props may have changed\n        const lastPickedLayer = layers.find(layer => layer.props.id === lastPickedLayerId);\n        if (lastPickedLayer) {\n          // Let leave event fire before enter event\n          affectedLayers.unshift(lastPickedLayer);\n        }\n      }\n\n      // Update layer manager context\n      lastPickedInfo.layerId = pickedLayerId;\n      lastPickedInfo.index = pickedObjectIndex;\n      lastPickedInfo.info = null;\n    }\n  }\n\n  const baseInfo = getEmptyPickingInfo(opts);\n\n  // Use a Map to store all picking infos.\n  // The following two forEach loops are the result of\n  // https://github.com/visgl/deck.gl/issues/443\n  // Please be very careful when changing this pattern\n  const infos = new Map();\n\n  // Make sure infos always contain something even if no layer is affected\n  infos.set(null, baseInfo);\n\n  affectedLayers.forEach(layer => {\n    let info = {...baseInfo};\n\n    if (layer === pickedLayer) {\n      info.color = pickedColor;\n      info.index = pickedObjectIndex;\n      info.picked = true;\n    }\n\n    info = getLayerPickingInfo({layer, info, mode});\n\n    if (layer === pickedLayer && mode === 'hover') {\n      lastPickedInfo.info = info;\n    }\n\n    // This guarantees that there will be only one copy of info for\n    // one composite layer\n    infos.set(info.layer.id, info);\n\n    if (mode === 'hover') {\n      info.layer.updateAutoHighlight(info);\n    }\n  });\n\n  return infos;\n}\n\n// Walk up the layer composite chain to populate the info object\nexport function getLayerPickingInfo({layer, info, mode}) {\n  while (layer && info) {\n    // For a composite layer, sourceLayer will point to the sublayer\n    // where the event originates from.\n    // It provides additional context for the composite layer's\n    // getPickingInfo() method to populate the info object\n    const sourceLayer = info.layer || null;\n    info.sourceLayer = sourceLayer;\n    info.layer = layer;\n    // layer.pickLayer() function requires a non-null ```layer.state```\n    // object to function properly. So the layer referenced here\n    // must be the \"current\" layer, not an \"out-dated\" / \"invalidated\" layer\n    info = layer.getPickingInfo({info, mode, sourceLayer});\n    layer = layer.parent;\n  }\n  return info;\n}\n\n// Indentifies which viewport, if any corresponds to x and y\n// If multiple viewports contain the target pixel, last viewport drawn is returend\n// Returns first viewport if no match\nfunction getViewportFromCoordinates(viewports, pixel) {\n  // find the last viewport that contains the pixel\n  for (let i = viewports.length - 1; i >= 0; i--) {\n    const viewport = viewports[i];\n    if (viewport.containsPixel(pixel)) {\n      return viewport;\n    }\n  }\n  return viewports[0];\n}\n","// Copyright (c) 2015 - 2019 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/* global document */\nconst defaultStyle = {\n  zIndex: 1,\n  position: 'absolute',\n  pointerEvents: 'none',\n  color: '#a0a7b4',\n  backgroundColor: '#29323c',\n  padding: '10px',\n  top: 0,\n  left: 0,\n  display: 'none'\n};\n\nexport default class Tooltip {\n  constructor(canvas) {\n    const canvasParent = canvas.parentElement;\n\n    if (canvasParent) {\n      this.el = document.createElement('div');\n      this.el.className = 'deck-tooltip';\n      Object.assign(this.el.style, defaultStyle);\n      canvasParent.appendChild(this.el);\n    }\n\n    this.isVisible = false;\n  }\n\n  setTooltip(displayInfo, x, y) {\n    const el = this.el;\n\n    if (typeof displayInfo === 'string') {\n      el.innerText = displayInfo;\n    } else if (!displayInfo) {\n      this.isVisible = false;\n      el.style.display = 'none';\n      return;\n    } else {\n      if ('text' in displayInfo) {\n        el.innerText = displayInfo.text;\n      }\n      if ('html' in displayInfo) {\n        el.innerHTML = displayInfo.html;\n      }\n      if ('className' in displayInfo) {\n        el.className = displayInfo.className;\n      }\n      Object.assign(el.style, displayInfo.style);\n    }\n    this.isVisible = true;\n    el.style.display = 'block';\n    el.style.transform = `translate(${x}px, ${y}px)`;\n  }\n\n  remove() {\n    if (this.el) {\n      this.el.remove();\n    }\n  }\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nexport {default as EventManager} from './event-manager';\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {Manager} from './utils/hammer';\n\nimport WheelInput from './inputs/wheel-input';\nimport MoveInput from './inputs/move-input';\nimport KeyInput from './inputs/key-input';\nimport ContextmenuInput from './inputs/contextmenu-input';\n\nimport EventRegistrar from './utils/event-registrar';\n\nimport {\n  BASIC_EVENT_ALIASES,\n  EVENT_RECOGNIZER_MAP,\n  GESTURE_EVENT_ALIASES,\n  RECOGNIZERS,\n  RECOGNIZER_COMPATIBLE_MAP,\n  RECOGNIZER_FALLBACK_MAP\n} from './constants';\n\nconst DEFAULT_OPTIONS = {\n  // event handlers\n  events: null,\n  // custom recognizers\n  recognizers: null,\n  recognizerOptions: {},\n  // Manager class\n  Manager,\n  // allow browser default touch action\n  // https://github.com/uber/react-map-gl/issues/506\n  touchAction: 'none',\n  tabIndex: 0\n};\n\n// Unified API for subscribing to events about both\n// basic input events (e.g. 'mousemove', 'touchstart', 'wheel')\n// and gestural input (e.g. 'click', 'tap', 'panstart').\n// Delegates gesture related event registration and handling to Hammer.js.\nexport default class EventManager {\n  constructor(element = null, options = {}) {\n    this.options = Object.assign({}, DEFAULT_OPTIONS, options);\n    this.events = new Map();\n\n    this._onBasicInput = this._onBasicInput.bind(this);\n    this._onOtherEvent = this._onOtherEvent.bind(this);\n\n    this.setElement(element);\n\n    // Register all passed events.\n    const {events} = options;\n    if (events) {\n      this.on(events);\n    }\n  }\n\n  setElement(element) {\n    if (this.element) {\n      // unregister all events\n      this.destroy();\n    }\n    this.element = element;\n    if (!element) {\n      return;\n    }\n\n    const {options} = this;\n    const ManagerClass = options.Manager;\n\n    this.manager = new ManagerClass(element, {\n      touchAction: options.touchAction,\n      recognizers: options.recognizers || RECOGNIZERS\n    }).on('hammer.input', this._onBasicInput);\n\n    if (!options.recognizers) {\n      // Set default recognize withs\n      // http://hammerjs.github.io/recognize-with/\n      Object.keys(RECOGNIZER_COMPATIBLE_MAP).forEach(name => {\n        const recognizer = this.manager.get(name);\n        if (recognizer) {\n          RECOGNIZER_COMPATIBLE_MAP[name].forEach(otherName => {\n            recognizer.recognizeWith(otherName);\n          });\n        }\n      });\n    }\n\n    // Set recognizer options\n    for (const recognizerName in options.recognizerOptions) {\n      const recognizer = this.manager.get(recognizerName);\n      if (recognizer) {\n        const recognizerOption = options.recognizerOptions[recognizerName];\n        // `enable` is managed by the event registrations\n        delete recognizerOption.enable;\n        recognizer.set(recognizerOption);\n      }\n    }\n\n    // Handle events not handled by Hammer.js:\n    // - mouse wheel\n    // - pointer/touch/mouse move\n    this.wheelInput = new WheelInput(element, this._onOtherEvent, {\n      enable: false\n    });\n    this.moveInput = new MoveInput(element, this._onOtherEvent, {\n      enable: false\n    });\n    this.keyInput = new KeyInput(element, this._onOtherEvent, {\n      enable: false,\n      tabIndex: options.tabIndex\n    });\n    this.contextmenuInput = new ContextmenuInput(element, this._onOtherEvent, {\n      enable: false\n    });\n\n    // Register all existing events\n    for (const [eventAlias, eventRegistrar] of this.events) {\n      if (!eventRegistrar.isEmpty()) {\n        // Enable recognizer for this event.\n        this._toggleRecognizer(eventRegistrar.recognizerName, true);\n        this.manager.on(eventAlias, eventRegistrar.handleEvent);\n      }\n    }\n  }\n\n  // Tear down internal event management implementations.\n  destroy() {\n    if (this.element) {\n      // wheelInput etc. are created in setElement() and therefore\n      // cannot exist if there is no element\n      this.wheelInput.destroy();\n      this.moveInput.destroy();\n      this.keyInput.destroy();\n      this.contextmenuInput.destroy();\n      this.manager.destroy();\n\n      this.wheelInput = null;\n      this.moveInput = null;\n      this.keyInput = null;\n      this.contextmenuInput = null;\n      this.manager = null;\n      this.element = null;\n    }\n  }\n\n  // Register an event handler function to be called on `event`.\n  on(event, handler, opts) {\n    this._addEventHandler(event, handler, opts, false);\n  }\n\n  // Register an event handler function to be called on `event`, then remove it\n  once(event, handler, opts) {\n    this._addEventHandler(event, handler, opts, true);\n  }\n\n  // Register an event handler function to be called on `event`\n  // This handler does not ask the event to be recognized at all times.\n  // Instead, it only \"intercepts\" the event if some other handler is getting it.\n  watch(event, handler, opts) {\n    this._addEventHandler(event, handler, opts, false, true);\n  }\n\n  /**\n   * Deregister a previously-registered event handler.\n   * @param {string|Object} event   An event name (String) or map of event names to handlers\n   * @param {Function} [handler]    The function to be called on `event`.\n   */\n  off(event, handler) {\n    this._removeEventHandler(event, handler);\n  }\n\n  /*\n   * Enable/disable recognizer for the given event\n   */\n  _toggleRecognizer(name, enabled) {\n    const {manager} = this;\n    if (!manager) {\n      return;\n    }\n    const recognizer = manager.get(name);\n    if (recognizer && recognizer.options.enable !== enabled) {\n      recognizer.set({enable: enabled});\n\n      const fallbackRecognizers = RECOGNIZER_FALLBACK_MAP[name];\n      if (fallbackRecognizers && !this.options.recognizers) {\n        // Set default require failures\n        // http://hammerjs.github.io/require-failure/\n        fallbackRecognizers.forEach(otherName => {\n          const otherRecognizer = manager.get(otherName);\n          if (enabled) {\n            // Wait for this recognizer to fail\n            otherRecognizer.requireFailure(name);\n            /**\n             * This seems to be a bug in hammerjs:\n             * requireFailure() adds both ways\n             * dropRequireFailure() only drops one way\n             * https://github.com/hammerjs/hammer.js/blob/master/src/recognizerjs/\n               recognizer-constructor.js#L136\n             */\n            recognizer.dropRequireFailure(otherName);\n          } else {\n            // Do not wait for this recognizer to fail\n            otherRecognizer.dropRequireFailure(name);\n          }\n        });\n      }\n    }\n    this.wheelInput.enableEventType(name, enabled);\n    this.moveInput.enableEventType(name, enabled);\n    this.keyInput.enableEventType(name, enabled);\n    this.contextmenuInput.enableEventType(name, enabled);\n  }\n\n  /**\n   * Process the event registration for a single event + handler.\n   */\n  _addEventHandler(event, handler, opts, once, passive) {\n    if (typeof event !== 'string') {\n      opts = handler;\n      // If `event` is a map, call `on()` for each entry.\n      for (const eventName in event) {\n        this._addEventHandler(eventName, event[eventName], opts, once, passive);\n      }\n      return;\n    }\n\n    const {manager, events} = this;\n    // Alias to a recognized gesture as necessary.\n    const eventAlias = GESTURE_EVENT_ALIASES[event] || event;\n\n    let eventRegistrar = events.get(eventAlias);\n    if (!eventRegistrar) {\n      eventRegistrar = new EventRegistrar(this);\n      events.set(eventAlias, eventRegistrar);\n      // Enable recognizer for this event.\n      eventRegistrar.recognizerName = EVENT_RECOGNIZER_MAP[eventAlias] || eventAlias;\n      // Listen to the event\n      if (manager) {\n        manager.on(eventAlias, eventRegistrar.handleEvent);\n      }\n    }\n    eventRegistrar.add(event, handler, opts, once, passive);\n    if (!eventRegistrar.isEmpty()) {\n      this._toggleRecognizer(eventRegistrar.recognizerName, true);\n    }\n  }\n\n  /**\n   * Process the event deregistration for a single event + handler.\n   */\n  _removeEventHandler(event, handler) {\n    if (typeof event !== 'string') {\n      // If `event` is a map, call `off()` for each entry.\n      for (const eventName in event) {\n        this._removeEventHandler(eventName, event[eventName]);\n      }\n      return;\n    }\n\n    const {events} = this;\n    // Alias to a recognized gesture as necessary.\n    const eventAlias = GESTURE_EVENT_ALIASES[event] || event;\n\n    const eventRegistrar = events.get(eventAlias);\n\n    if (!eventRegistrar) {\n      return;\n    }\n\n    eventRegistrar.remove(event, handler);\n\n    if (eventRegistrar.isEmpty()) {\n      const {recognizerName} = eventRegistrar;\n      // Disable recognizer if no more handlers are attached to its events\n      let isRecognizerUsed = false;\n      for (const eh of events.values()) {\n        if (eh.recognizerName === recognizerName && !eh.isEmpty()) {\n          isRecognizerUsed = true;\n          break;\n        }\n      }\n      if (!isRecognizerUsed) {\n        this._toggleRecognizer(recognizerName, false);\n      }\n    }\n  }\n\n  /**\n   * Handle basic events using the 'hammer.input' Hammer.js API:\n   * Before running Recognizers, Hammer emits a 'hammer.input' event\n   * with the basic event info. This function emits all basic events\n   * aliased to the \"class\" of event received.\n   * See constants.BASIC_EVENT_CLASSES basic event class definitions.\n   */\n  _onBasicInput(event) {\n    const {srcEvent} = event;\n    const alias = BASIC_EVENT_ALIASES[srcEvent.type];\n    if (alias) {\n      // fire all events aliased to srcEvent.type\n      this.manager.emit(alias, event);\n    }\n  }\n\n  /**\n   * Handle events not supported by Hammer.js,\n   * and pipe back out through same (Hammer) channel used by other events.\n   */\n  _onOtherEvent(event) {\n    // console.log('onotherevent', event.type, event)\n    this.manager.emit(event.type, event);\n  }\n}\n","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}","export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}","import hammerjs from 'hammerjs';\nimport {enhancePointerEventInput, enhanceMouseInput} from './hammer-overrides';\n\nenhancePointerEventInput(hammerjs.PointerEventInput);\nenhanceMouseInput(hammerjs.MouseInput);\n\nexport const Manager = hammerjs.Manager;\n\nexport default hammerjs;\n","/*! Hammer.JS - v2.0.7 - 2016-04-22\n * http://hammerjs.github.io/\n *\n * Copyright (c) 2016 Jorik Tangelder;\n * Licensed under the MIT license */\n(function(window, document, exportName, undefined) {\n  'use strict';\n\nvar VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\nvar TEST_ELEMENT = document.createElement('div');\n\nvar TYPE_FUNCTION = 'function';\n\nvar round = Math.round;\nvar abs = Math.abs;\nvar now = Date.now;\n\n/**\n * set a timeout with a given scope\n * @param {Function} fn\n * @param {Number} timeout\n * @param {Object} context\n * @returns {number}\n */\nfunction setTimeoutContext(fn, timeout, context) {\n    return setTimeout(bindFn(fn, context), timeout);\n}\n\n/**\n * if the argument is an array, we want to execute the fn on each entry\n * if it aint an array we don't want to do a thing.\n * this is used by all the methods that accept a single and array argument.\n * @param {*|Array} arg\n * @param {String} fn\n * @param {Object} [context]\n * @returns {Boolean}\n */\nfunction invokeArrayArg(arg, fn, context) {\n    if (Array.isArray(arg)) {\n        each(arg, context[fn], context);\n        return true;\n    }\n    return false;\n}\n\n/**\n * walk objects and arrays\n * @param {Object} obj\n * @param {Function} iterator\n * @param {Object} context\n */\nfunction each(obj, iterator, context) {\n    var i;\n\n    if (!obj) {\n        return;\n    }\n\n    if (obj.forEach) {\n        obj.forEach(iterator, context);\n    } else if (obj.length !== undefined) {\n        i = 0;\n        while (i < obj.length) {\n            iterator.call(context, obj[i], i, obj);\n            i++;\n        }\n    } else {\n        for (i in obj) {\n            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);\n        }\n    }\n}\n\n/**\n * wrap a method with a deprecation warning and stack trace\n * @param {Function} method\n * @param {String} name\n * @param {String} message\n * @returns {Function} A new function wrapping the supplied method.\n */\nfunction deprecate(method, name, message) {\n    var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\\n' + message + ' AT \\n';\n    return function() {\n        var e = new Error('get-stack-trace');\n        var stack = e && e.stack ? e.stack.replace(/^[^\\(]+?[\\n$]/gm, '')\n            .replace(/^\\s+at\\s+/gm, '')\n            .replace(/^Object.<anonymous>\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n\n        var log = window.console && (window.console.warn || window.console.log);\n        if (log) {\n            log.call(window.console, deprecationMessage, stack);\n        }\n        return method.apply(this, arguments);\n    };\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} target\n * @param {...Object} objects_to_assign\n * @returns {Object} target\n */\nvar assign;\nif (typeof Object.assign !== 'function') {\n    assign = function assign(target) {\n        if (target === undefined || target === null) {\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n\n        var output = Object(target);\n        for (var index = 1; index < arguments.length; index++) {\n            var source = arguments[index];\n            if (source !== undefined && source !== null) {\n                for (var nextKey in source) {\n                    if (source.hasOwnProperty(nextKey)) {\n                        output[nextKey] = source[nextKey];\n                    }\n                }\n            }\n        }\n        return output;\n    };\n} else {\n    assign = Object.assign;\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} dest\n * @param {Object} src\n * @param {Boolean} [merge=false]\n * @returns {Object} dest\n */\nvar extend = deprecate(function extend(dest, src, merge) {\n    var keys = Object.keys(src);\n    var i = 0;\n    while (i < keys.length) {\n        if (!merge || (merge && dest[keys[i]] === undefined)) {\n            dest[keys[i]] = src[keys[i]];\n        }\n        i++;\n    }\n    return dest;\n}, 'extend', 'Use `assign`.');\n\n/**\n * merge the values from src in the dest.\n * means that properties that exist in dest will not be overwritten by src\n * @param {Object} dest\n * @param {Object} src\n * @returns {Object} dest\n */\nvar merge = deprecate(function merge(dest, src) {\n    return extend(dest, src, true);\n}, 'merge', 'Use `assign`.');\n\n/**\n * simple class inheritance\n * @param {Function} child\n * @param {Function} base\n * @param {Object} [properties]\n */\nfunction inherit(child, base, properties) {\n    var baseP = base.prototype,\n        childP;\n\n    childP = child.prototype = Object.create(baseP);\n    childP.constructor = child;\n    childP._super = baseP;\n\n    if (properties) {\n        assign(childP, properties);\n    }\n}\n\n/**\n * simple function bind\n * @param {Function} fn\n * @param {Object} context\n * @returns {Function}\n */\nfunction bindFn(fn, context) {\n    return function boundFn() {\n        return fn.apply(context, arguments);\n    };\n}\n\n/**\n * let a boolean value also be a function that must return a boolean\n * this first item in args will be used as the context\n * @param {Boolean|Function} val\n * @param {Array} [args]\n * @returns {Boolean}\n */\nfunction boolOrFn(val, args) {\n    if (typeof val == TYPE_FUNCTION) {\n        return val.apply(args ? args[0] || undefined : undefined, args);\n    }\n    return val;\n}\n\n/**\n * use the val2 when val1 is undefined\n * @param {*} val1\n * @param {*} val2\n * @returns {*}\n */\nfunction ifUndefined(val1, val2) {\n    return (val1 === undefined) ? val2 : val1;\n}\n\n/**\n * addEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction addEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.addEventListener(type, handler, false);\n    });\n}\n\n/**\n * removeEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction removeEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.removeEventListener(type, handler, false);\n    });\n}\n\n/**\n * find if a node is in the given parent\n * @method hasParent\n * @param {HTMLElement} node\n * @param {HTMLElement} parent\n * @return {Boolean} found\n */\nfunction hasParent(node, parent) {\n    while (node) {\n        if (node == parent) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\n\n/**\n * small indexOf wrapper\n * @param {String} str\n * @param {String} find\n * @returns {Boolean} found\n */\nfunction inStr(str, find) {\n    return str.indexOf(find) > -1;\n}\n\n/**\n * split string on whitespace\n * @param {String} str\n * @returns {Array} words\n */\nfunction splitStr(str) {\n    return str.trim().split(/\\s+/g);\n}\n\n/**\n * find if a array contains the object using indexOf or a simple polyFill\n * @param {Array} src\n * @param {String} find\n * @param {String} [findByKey]\n * @return {Boolean|Number} false when not found, or the index\n */\nfunction inArray(src, find, findByKey) {\n    if (src.indexOf && !findByKey) {\n        return src.indexOf(find);\n    } else {\n        var i = 0;\n        while (i < src.length) {\n            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {\n                return i;\n            }\n            i++;\n        }\n        return -1;\n    }\n}\n\n/**\n * convert array-like objects to real arrays\n * @param {Object} obj\n * @returns {Array}\n */\nfunction toArray(obj) {\n    return Array.prototype.slice.call(obj, 0);\n}\n\n/**\n * unique array with objects based on a key (like 'id') or just by the array's value\n * @param {Array} src [{id:1},{id:2},{id:1}]\n * @param {String} [key]\n * @param {Boolean} [sort=False]\n * @returns {Array} [{id:1},{id:2}]\n */\nfunction uniqueArray(src, key, sort) {\n    var results = [];\n    var values = [];\n    var i = 0;\n\n    while (i < src.length) {\n        var val = key ? src[i][key] : src[i];\n        if (inArray(values, val) < 0) {\n            results.push(src[i]);\n        }\n        values[i] = val;\n        i++;\n    }\n\n    if (sort) {\n        if (!key) {\n            results = results.sort();\n        } else {\n            results = results.sort(function sortUniqueArray(a, b) {\n                return a[key] > b[key];\n            });\n        }\n    }\n\n    return results;\n}\n\n/**\n * get the prefixed property\n * @param {Object} obj\n * @param {String} property\n * @returns {String|Undefined} prefixed\n */\nfunction prefixed(obj, property) {\n    var prefix, prop;\n    var camelProp = property[0].toUpperCase() + property.slice(1);\n\n    var i = 0;\n    while (i < VENDOR_PREFIXES.length) {\n        prefix = VENDOR_PREFIXES[i];\n        prop = (prefix) ? prefix + camelProp : property;\n\n        if (prop in obj) {\n            return prop;\n        }\n        i++;\n    }\n    return undefined;\n}\n\n/**\n * get a unique id\n * @returns {number} uniqueId\n */\nvar _uniqueId = 1;\nfunction uniqueId() {\n    return _uniqueId++;\n}\n\n/**\n * get the window object of an element\n * @param {HTMLElement} element\n * @returns {DocumentView|Window}\n */\nfunction getWindowForElement(element) {\n    var doc = element.ownerDocument || element;\n    return (doc.defaultView || doc.parentWindow || window);\n}\n\nvar MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n\nvar SUPPORT_TOUCH = ('ontouchstart' in window);\nvar SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\nvar SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n\nvar INPUT_TYPE_TOUCH = 'touch';\nvar INPUT_TYPE_PEN = 'pen';\nvar INPUT_TYPE_MOUSE = 'mouse';\nvar INPUT_TYPE_KINECT = 'kinect';\n\nvar COMPUTE_INTERVAL = 25;\n\nvar INPUT_START = 1;\nvar INPUT_MOVE = 2;\nvar INPUT_END = 4;\nvar INPUT_CANCEL = 8;\n\nvar DIRECTION_NONE = 1;\nvar DIRECTION_LEFT = 2;\nvar DIRECTION_RIGHT = 4;\nvar DIRECTION_UP = 8;\nvar DIRECTION_DOWN = 16;\n\nvar DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\nvar DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\nvar DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n\nvar PROPS_XY = ['x', 'y'];\nvar PROPS_CLIENT_XY = ['clientX', 'clientY'];\n\n/**\n * create new input type manager\n * @param {Manager} manager\n * @param {Function} callback\n * @returns {Input}\n * @constructor\n */\nfunction Input(manager, callback) {\n    var self = this;\n    this.manager = manager;\n    this.callback = callback;\n    this.element = manager.element;\n    this.target = manager.options.inputTarget;\n\n    // smaller wrapper around the handler, for the scope and the enabled state of the manager,\n    // so when disabled the input events are completely bypassed.\n    this.domHandler = function(ev) {\n        if (boolOrFn(manager.options.enable, [manager])) {\n            self.handler(ev);\n        }\n    };\n\n    this.init();\n\n}\n\nInput.prototype = {\n    /**\n     * should handle the inputEvent data and trigger the callback\n     * @virtual\n     */\n    handler: function() { },\n\n    /**\n     * bind the events\n     */\n    init: function() {\n        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    },\n\n    /**\n     * unbind the events\n     */\n    destroy: function() {\n        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    }\n};\n\n/**\n * create new input type manager\n * called by the Manager constructor\n * @param {Hammer} manager\n * @returns {Input}\n */\nfunction createInputInstance(manager) {\n    var Type;\n    var inputClass = manager.options.inputClass;\n\n    if (inputClass) {\n        Type = inputClass;\n    } else if (SUPPORT_POINTER_EVENTS) {\n        Type = PointerEventInput;\n    } else if (SUPPORT_ONLY_TOUCH) {\n        Type = TouchInput;\n    } else if (!SUPPORT_TOUCH) {\n        Type = MouseInput;\n    } else {\n        Type = TouchMouseInput;\n    }\n    return new (Type)(manager, inputHandler);\n}\n\n/**\n * handle input events\n * @param {Manager} manager\n * @param {String} eventType\n * @param {Object} input\n */\nfunction inputHandler(manager, eventType, input) {\n    var pointersLen = input.pointers.length;\n    var changedPointersLen = input.changedPointers.length;\n    var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));\n    var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));\n\n    input.isFirst = !!isFirst;\n    input.isFinal = !!isFinal;\n\n    if (isFirst) {\n        manager.session = {};\n    }\n\n    // source event is the normalized value of the domEvents\n    // like 'touchstart, mouseup, pointerdown'\n    input.eventType = eventType;\n\n    // compute scale, rotation etc\n    computeInputData(manager, input);\n\n    // emit secret event\n    manager.emit('hammer.input', input);\n\n    manager.recognize(input);\n    manager.session.prevInput = input;\n}\n\n/**\n * extend the data with some usable properties like scale, rotate, velocity etc\n * @param {Object} manager\n * @param {Object} input\n */\nfunction computeInputData(manager, input) {\n    var session = manager.session;\n    var pointers = input.pointers;\n    var pointersLength = pointers.length;\n\n    // store the first input to calculate the distance and direction\n    if (!session.firstInput) {\n        session.firstInput = simpleCloneInputData(input);\n    }\n\n    // to compute scale and rotation we need to store the multiple touches\n    if (pointersLength > 1 && !session.firstMultiple) {\n        session.firstMultiple = simpleCloneInputData(input);\n    } else if (pointersLength === 1) {\n        session.firstMultiple = false;\n    }\n\n    var firstInput = session.firstInput;\n    var firstMultiple = session.firstMultiple;\n    var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;\n\n    var center = input.center = getCenter(pointers);\n    input.timeStamp = now();\n    input.deltaTime = input.timeStamp - firstInput.timeStamp;\n\n    input.angle = getAngle(offsetCenter, center);\n    input.distance = getDistance(offsetCenter, center);\n\n    computeDeltaXY(session, input);\n    input.offsetDirection = getDirection(input.deltaX, input.deltaY);\n\n    var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);\n    input.overallVelocityX = overallVelocity.x;\n    input.overallVelocityY = overallVelocity.y;\n    input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;\n\n    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n\n    input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >\n        session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);\n\n    computeIntervalInputData(session, input);\n\n    // find the correct target\n    var target = manager.element;\n    if (hasParent(input.srcEvent.target, target)) {\n        target = input.srcEvent.target;\n    }\n    input.target = target;\n}\n\nfunction computeDeltaXY(session, input) {\n    var center = input.center;\n    var offset = session.offsetDelta || {};\n    var prevDelta = session.prevDelta || {};\n    var prevInput = session.prevInput || {};\n\n    if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {\n        prevDelta = session.prevDelta = {\n            x: prevInput.deltaX || 0,\n            y: prevInput.deltaY || 0\n        };\n\n        offset = session.offsetDelta = {\n            x: center.x,\n            y: center.y\n        };\n    }\n\n    input.deltaX = prevDelta.x + (center.x - offset.x);\n    input.deltaY = prevDelta.y + (center.y - offset.y);\n}\n\n/**\n * velocity is calculated every x ms\n * @param {Object} session\n * @param {Object} input\n */\nfunction computeIntervalInputData(session, input) {\n    var last = session.lastInterval || input,\n        deltaTime = input.timeStamp - last.timeStamp,\n        velocity, velocityX, velocityY, direction;\n\n    if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {\n        var deltaX = input.deltaX - last.deltaX;\n        var deltaY = input.deltaY - last.deltaY;\n\n        var v = getVelocity(deltaTime, deltaX, deltaY);\n        velocityX = v.x;\n        velocityY = v.y;\n        velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;\n        direction = getDirection(deltaX, deltaY);\n\n        session.lastInterval = input;\n    } else {\n        // use latest velocity info if it doesn't overtake a minimum period\n        velocity = last.velocity;\n        velocityX = last.velocityX;\n        velocityY = last.velocityY;\n        direction = last.direction;\n    }\n\n    input.velocity = velocity;\n    input.velocityX = velocityX;\n    input.velocityY = velocityY;\n    input.direction = direction;\n}\n\n/**\n * create a simple clone from the input used for storage of firstInput and firstMultiple\n * @param {Object} input\n * @returns {Object} clonedInputData\n */\nfunction simpleCloneInputData(input) {\n    // make a simple copy of the pointers because we will get a reference if we don't\n    // we only need clientXY for the calculations\n    var pointers = [];\n    var i = 0;\n    while (i < input.pointers.length) {\n        pointers[i] = {\n            clientX: round(input.pointers[i].clientX),\n            clientY: round(input.pointers[i].clientY)\n        };\n        i++;\n    }\n\n    return {\n        timeStamp: now(),\n        pointers: pointers,\n        center: getCenter(pointers),\n        deltaX: input.deltaX,\n        deltaY: input.deltaY\n    };\n}\n\n/**\n * get the center of all the pointers\n * @param {Array} pointers\n * @return {Object} center contains `x` and `y` properties\n */\nfunction getCenter(pointers) {\n    var pointersLength = pointers.length;\n\n    // no need to loop when only one touch\n    if (pointersLength === 1) {\n        return {\n            x: round(pointers[0].clientX),\n            y: round(pointers[0].clientY)\n        };\n    }\n\n    var x = 0, y = 0, i = 0;\n    while (i < pointersLength) {\n        x += pointers[i].clientX;\n        y += pointers[i].clientY;\n        i++;\n    }\n\n    return {\n        x: round(x / pointersLength),\n        y: round(y / pointersLength)\n    };\n}\n\n/**\n * calculate the velocity between two points. unit is in px per ms.\n * @param {Number} deltaTime\n * @param {Number} x\n * @param {Number} y\n * @return {Object} velocity `x` and `y`\n */\nfunction getVelocity(deltaTime, x, y) {\n    return {\n        x: x / deltaTime || 0,\n        y: y / deltaTime || 0\n    };\n}\n\n/**\n * get the direction between two points\n * @param {Number} x\n * @param {Number} y\n * @return {Number} direction\n */\nfunction getDirection(x, y) {\n    if (x === y) {\n        return DIRECTION_NONE;\n    }\n\n    if (abs(x) >= abs(y)) {\n        return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;\n    }\n    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\n}\n\n/**\n * calculate the absolute distance between two points\n * @param {Object} p1 {x, y}\n * @param {Object} p2 {x, y}\n * @param {Array} [props] containing x and y keys\n * @return {Number} distance\n */\nfunction getDistance(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n\n    return Math.sqrt((x * x) + (y * y));\n}\n\n/**\n * calculate the angle between two coordinates\n * @param {Object} p1\n * @param {Object} p2\n * @param {Array} [props] containing x and y keys\n * @return {Number} angle\n */\nfunction getAngle(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n    return Math.atan2(y, x) * 180 / Math.PI;\n}\n\n/**\n * calculate the rotation degrees between two pointersets\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} rotation\n */\nfunction getRotation(start, end) {\n    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\n}\n\n/**\n * calculate the scale factor between two pointersets\n * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} scale\n */\nfunction getScale(start, end) {\n    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n}\n\nvar MOUSE_INPUT_MAP = {\n    mousedown: INPUT_START,\n    mousemove: INPUT_MOVE,\n    mouseup: INPUT_END\n};\n\nvar MOUSE_ELEMENT_EVENTS = 'mousedown';\nvar MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n\n/**\n * Mouse events input\n * @constructor\n * @extends Input\n */\nfunction MouseInput() {\n    this.evEl = MOUSE_ELEMENT_EVENTS;\n    this.evWin = MOUSE_WINDOW_EVENTS;\n\n    this.pressed = false; // mousedown state\n\n    Input.apply(this, arguments);\n}\n\ninherit(MouseInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function MEhandler(ev) {\n        var eventType = MOUSE_INPUT_MAP[ev.type];\n\n        // on start we want to have the left mouse button down\n        if (eventType & INPUT_START && ev.button === 0) {\n            this.pressed = true;\n        }\n\n        if (eventType & INPUT_MOVE && ev.which !== 1) {\n            eventType = INPUT_END;\n        }\n\n        // mouse must be down\n        if (!this.pressed) {\n            return;\n        }\n\n        if (eventType & INPUT_END) {\n            this.pressed = false;\n        }\n\n        this.callback(this.manager, eventType, {\n            pointers: [ev],\n            changedPointers: [ev],\n            pointerType: INPUT_TYPE_MOUSE,\n            srcEvent: ev\n        });\n    }\n});\n\nvar POINTER_INPUT_MAP = {\n    pointerdown: INPUT_START,\n    pointermove: INPUT_MOVE,\n    pointerup: INPUT_END,\n    pointercancel: INPUT_CANCEL,\n    pointerout: INPUT_CANCEL\n};\n\n// in IE10 the pointer types is defined as an enum\nvar IE10_POINTER_TYPE_ENUM = {\n    2: INPUT_TYPE_TOUCH,\n    3: INPUT_TYPE_PEN,\n    4: INPUT_TYPE_MOUSE,\n    5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816\n};\n\nvar POINTER_ELEMENT_EVENTS = 'pointerdown';\nvar POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';\n\n// IE10 has prefixed support, and case-sensitive\nif (window.MSPointerEvent && !window.PointerEvent) {\n    POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n}\n\n/**\n * Pointer events input\n * @constructor\n * @extends Input\n */\nfunction PointerEventInput() {\n    this.evEl = POINTER_ELEMENT_EVENTS;\n    this.evWin = POINTER_WINDOW_EVENTS;\n\n    Input.apply(this, arguments);\n\n    this.store = (this.manager.session.pointerEvents = []);\n}\n\ninherit(PointerEventInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function PEhandler(ev) {\n        var store = this.store;\n        var removePointer = false;\n\n        var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');\n        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];\n        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;\n\n        var isTouch = (pointerType == INPUT_TYPE_TOUCH);\n\n        // get index of the event in the store\n        var storeIndex = inArray(store, ev.pointerId, 'pointerId');\n\n        // start and mouse must be down\n        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {\n            if (storeIndex < 0) {\n                store.push(ev);\n                storeIndex = store.length - 1;\n            }\n        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n            removePointer = true;\n        }\n\n        // it not found, so the pointer hasn't been down (so it's probably a hover)\n        if (storeIndex < 0) {\n            return;\n        }\n\n        // update the event in the store\n        store[storeIndex] = ev;\n\n        this.callback(this.manager, eventType, {\n            pointers: store,\n            changedPointers: [ev],\n            pointerType: pointerType,\n            srcEvent: ev\n        });\n\n        if (removePointer) {\n            // remove from the store\n            store.splice(storeIndex, 1);\n        }\n    }\n});\n\nvar SINGLE_TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\nvar SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Touch events input\n * @constructor\n * @extends Input\n */\nfunction SingleTouchInput() {\n    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n    this.started = false;\n\n    Input.apply(this, arguments);\n}\n\ninherit(SingleTouchInput, Input, {\n    handler: function TEhandler(ev) {\n        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];\n\n        // should we handle the touch events?\n        if (type === INPUT_START) {\n            this.started = true;\n        }\n\n        if (!this.started) {\n            return;\n        }\n\n        var touches = normalizeSingleTouches.call(this, ev, type);\n\n        // when done, reset the started state\n        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {\n            this.started = false;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction normalizeSingleTouches(ev, type) {\n    var all = toArray(ev.touches);\n    var changed = toArray(ev.changedTouches);\n\n    if (type & (INPUT_END | INPUT_CANCEL)) {\n        all = uniqueArray(all.concat(changed), 'identifier', true);\n    }\n\n    return [all, changed];\n}\n\nvar TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Multi-user touch events input\n * @constructor\n * @extends Input\n */\nfunction TouchInput() {\n    this.evTarget = TOUCH_TARGET_EVENTS;\n    this.targetIds = {};\n\n    Input.apply(this, arguments);\n}\n\ninherit(TouchInput, Input, {\n    handler: function MTEhandler(ev) {\n        var type = TOUCH_INPUT_MAP[ev.type];\n        var touches = getTouches.call(this, ev, type);\n        if (!touches) {\n            return;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction getTouches(ev, type) {\n    var allTouches = toArray(ev.touches);\n    var targetIds = this.targetIds;\n\n    // when there is only one touch, the process can be simplified\n    if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {\n        targetIds[allTouches[0].identifier] = true;\n        return [allTouches, allTouches];\n    }\n\n    var i,\n        targetTouches,\n        changedTouches = toArray(ev.changedTouches),\n        changedTargetTouches = [],\n        target = this.target;\n\n    // get target touches from touches\n    targetTouches = allTouches.filter(function(touch) {\n        return hasParent(touch.target, target);\n    });\n\n    // collect touches\n    if (type === INPUT_START) {\n        i = 0;\n        while (i < targetTouches.length) {\n            targetIds[targetTouches[i].identifier] = true;\n            i++;\n        }\n    }\n\n    // filter changed touches to only contain touches that exist in the collected target ids\n    i = 0;\n    while (i < changedTouches.length) {\n        if (targetIds[changedTouches[i].identifier]) {\n            changedTargetTouches.push(changedTouches[i]);\n        }\n\n        // cleanup removed touches\n        if (type & (INPUT_END | INPUT_CANCEL)) {\n            delete targetIds[changedTouches[i].identifier];\n        }\n        i++;\n    }\n\n    if (!changedTargetTouches.length) {\n        return;\n    }\n\n    return [\n        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),\n        changedTargetTouches\n    ];\n}\n\n/**\n * Combined touch and mouse input\n *\n * Touch has a higher priority then mouse, and while touching no mouse events are allowed.\n * This because touch devices also emit mouse events while doing a touch.\n *\n * @constructor\n * @extends Input\n */\n\nvar DEDUP_TIMEOUT = 2500;\nvar DEDUP_DISTANCE = 25;\n\nfunction TouchMouseInput() {\n    Input.apply(this, arguments);\n\n    var handler = bindFn(this.handler, this);\n    this.touch = new TouchInput(this.manager, handler);\n    this.mouse = new MouseInput(this.manager, handler);\n\n    this.primaryTouch = null;\n    this.lastTouches = [];\n}\n\ninherit(TouchMouseInput, Input, {\n    /**\n     * handle mouse and touch events\n     * @param {Hammer} manager\n     * @param {String} inputEvent\n     * @param {Object} inputData\n     */\n    handler: function TMEhandler(manager, inputEvent, inputData) {\n        var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),\n            isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);\n\n        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {\n            return;\n        }\n\n        // when we're in a touch event, record touches to  de-dupe synthetic mouse event\n        if (isTouch) {\n            recordTouches.call(this, inputEvent, inputData);\n        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {\n            return;\n        }\n\n        this.callback(manager, inputEvent, inputData);\n    },\n\n    /**\n     * remove the event listeners\n     */\n    destroy: function destroy() {\n        this.touch.destroy();\n        this.mouse.destroy();\n    }\n});\n\nfunction recordTouches(eventType, eventData) {\n    if (eventType & INPUT_START) {\n        this.primaryTouch = eventData.changedPointers[0].identifier;\n        setLastTouch.call(this, eventData);\n    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n        setLastTouch.call(this, eventData);\n    }\n}\n\nfunction setLastTouch(eventData) {\n    var touch = eventData.changedPointers[0];\n\n    if (touch.identifier === this.primaryTouch) {\n        var lastTouch = {x: touch.clientX, y: touch.clientY};\n        this.lastTouches.push(lastTouch);\n        var lts = this.lastTouches;\n        var removeLastTouch = function() {\n            var i = lts.indexOf(lastTouch);\n            if (i > -1) {\n                lts.splice(i, 1);\n            }\n        };\n        setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n    }\n}\n\nfunction isSyntheticEvent(eventData) {\n    var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;\n    for (var i = 0; i < this.lastTouches.length; i++) {\n        var t = this.lastTouches[i];\n        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n            return true;\n        }\n    }\n    return false;\n}\n\nvar PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\nvar NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;\n\n// magical touchAction value\nvar TOUCH_ACTION_COMPUTE = 'compute';\nvar TOUCH_ACTION_AUTO = 'auto';\nvar TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\nvar TOUCH_ACTION_NONE = 'none';\nvar TOUCH_ACTION_PAN_X = 'pan-x';\nvar TOUCH_ACTION_PAN_Y = 'pan-y';\nvar TOUCH_ACTION_MAP = getTouchActionProps();\n\n/**\n * Touch Action\n * sets the touchAction property or uses the js alternative\n * @param {Manager} manager\n * @param {String} value\n * @constructor\n */\nfunction TouchAction(manager, value) {\n    this.manager = manager;\n    this.set(value);\n}\n\nTouchAction.prototype = {\n    /**\n     * set the touchAction value on the element or enable the polyfill\n     * @param {String} value\n     */\n    set: function(value) {\n        // find out the touch-action by the event handlers\n        if (value == TOUCH_ACTION_COMPUTE) {\n            value = this.compute();\n        }\n\n        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {\n            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;\n        }\n        this.actions = value.toLowerCase().trim();\n    },\n\n    /**\n     * just re-set the touchAction value\n     */\n    update: function() {\n        this.set(this.manager.options.touchAction);\n    },\n\n    /**\n     * compute the value for the touchAction property based on the recognizer's settings\n     * @returns {String} value\n     */\n    compute: function() {\n        var actions = [];\n        each(this.manager.recognizers, function(recognizer) {\n            if (boolOrFn(recognizer.options.enable, [recognizer])) {\n                actions = actions.concat(recognizer.getTouchAction());\n            }\n        });\n        return cleanTouchActions(actions.join(' '));\n    },\n\n    /**\n     * this method is called on each input cycle and provides the preventing of the browser behavior\n     * @param {Object} input\n     */\n    preventDefaults: function(input) {\n        var srcEvent = input.srcEvent;\n        var direction = input.offsetDirection;\n\n        // if the touch action did prevented once this session\n        if (this.manager.session.prevented) {\n            srcEvent.preventDefault();\n            return;\n        }\n\n        var actions = this.actions;\n        var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];\n        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];\n        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];\n\n        if (hasNone) {\n            //do not prevent defaults if this is a tap gesture\n\n            var isTapPointer = input.pointers.length === 1;\n            var isTapMovement = input.distance < 2;\n            var isTapTouchTime = input.deltaTime < 250;\n\n            if (isTapPointer && isTapMovement && isTapTouchTime) {\n                return;\n            }\n        }\n\n        if (hasPanX && hasPanY) {\n            // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent\n            return;\n        }\n\n        if (hasNone ||\n            (hasPanY && direction & DIRECTION_HORIZONTAL) ||\n            (hasPanX && direction & DIRECTION_VERTICAL)) {\n            return this.preventSrc(srcEvent);\n        }\n    },\n\n    /**\n     * call preventDefault to prevent the browser's default behavior (scrolling in most cases)\n     * @param {Object} srcEvent\n     */\n    preventSrc: function(srcEvent) {\n        this.manager.session.prevented = true;\n        srcEvent.preventDefault();\n    }\n};\n\n/**\n * when the touchActions are collected they are not a valid value, so we need to clean things up. *\n * @param {String} actions\n * @returns {*}\n */\nfunction cleanTouchActions(actions) {\n    // none\n    if (inStr(actions, TOUCH_ACTION_NONE)) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);\n    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);\n\n    // if both pan-x and pan-y are set (different recognizers\n    // for different directions, e.g. horizontal pan but vertical swipe?)\n    // we need none (as otherwise with pan-x pan-y combined none of these\n    // recognizers will work, since the browser would handle all panning\n    if (hasPanX && hasPanY) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    // pan-x OR pan-y\n    if (hasPanX || hasPanY) {\n        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n    }\n\n    // manipulation\n    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n        return TOUCH_ACTION_MANIPULATION;\n    }\n\n    return TOUCH_ACTION_AUTO;\n}\n\nfunction getTouchActionProps() {\n    if (!NATIVE_TOUCH_ACTION) {\n        return false;\n    }\n    var touchMap = {};\n    var cssSupports = window.CSS && window.CSS.supports;\n    ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {\n\n        // If css.supports is not supported but there is native touch-action assume it supports\n        // all values. This is the case for IE 10 and 11.\n        touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;\n    });\n    return touchMap;\n}\n\n/**\n * Recognizer flow explained; *\n * All recognizers have the initial state of POSSIBLE when a input session starts.\n * The definition of a input session is from the first input until the last input, with all it's movement in it. *\n * Example session for mouse-input: mousedown -> mousemove -> mouseup\n *\n * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed\n * which determines with state it should be.\n *\n * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to\n * POSSIBLE to give it another change on the next cycle.\n *\n *               Possible\n *                  |\n *            +-----+---------------+\n *            |                     |\n *      +-----+-----+               |\n *      |           |               |\n *   Failed      Cancelled          |\n *                          +-------+------+\n *                          |              |\n *                      Recognized       Began\n *                                         |\n *                                      Changed\n *                                         |\n *                                  Ended/Recognized\n */\nvar STATE_POSSIBLE = 1;\nvar STATE_BEGAN = 2;\nvar STATE_CHANGED = 4;\nvar STATE_ENDED = 8;\nvar STATE_RECOGNIZED = STATE_ENDED;\nvar STATE_CANCELLED = 16;\nvar STATE_FAILED = 32;\n\n/**\n * Recognizer\n * Every recognizer needs to extend from this class.\n * @constructor\n * @param {Object} options\n */\nfunction Recognizer(options) {\n    this.options = assign({}, this.defaults, options || {});\n\n    this.id = uniqueId();\n\n    this.manager = null;\n\n    // default is enable true\n    this.options.enable = ifUndefined(this.options.enable, true);\n\n    this.state = STATE_POSSIBLE;\n\n    this.simultaneous = {};\n    this.requireFail = [];\n}\n\nRecognizer.prototype = {\n    /**\n     * @virtual\n     * @type {Object}\n     */\n    defaults: {},\n\n    /**\n     * set options\n     * @param {Object} options\n     * @return {Recognizer}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // also update the touchAction, in case something changed about the directions/enabled state\n        this.manager && this.manager.touchAction.update();\n        return this;\n    },\n\n    /**\n     * recognize simultaneous with an other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    recognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n            return this;\n        }\n\n        var simultaneous = this.simultaneous;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (!simultaneous[otherRecognizer.id]) {\n            simultaneous[otherRecognizer.id] = otherRecognizer;\n            otherRecognizer.recognizeWith(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the simultaneous link. it doesnt remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRecognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        delete this.simultaneous[otherRecognizer.id];\n        return this;\n    },\n\n    /**\n     * recognizer can only run when an other is failing\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    requireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n            return this;\n        }\n\n        var requireFail = this.requireFail;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (inArray(requireFail, otherRecognizer) === -1) {\n            requireFail.push(otherRecognizer);\n            otherRecognizer.requireFailure(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the requireFailure link. it does not remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRequireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        var index = inArray(this.requireFail, otherRecognizer);\n        if (index > -1) {\n            this.requireFail.splice(index, 1);\n        }\n        return this;\n    },\n\n    /**\n     * has require failures boolean\n     * @returns {boolean}\n     */\n    hasRequireFailures: function() {\n        return this.requireFail.length > 0;\n    },\n\n    /**\n     * if the recognizer can recognize simultaneous with an other recognizer\n     * @param {Recognizer} otherRecognizer\n     * @returns {Boolean}\n     */\n    canRecognizeWith: function(otherRecognizer) {\n        return !!this.simultaneous[otherRecognizer.id];\n    },\n\n    /**\n     * You should use `tryEmit` instead of `emit` directly to check\n     * that all the needed recognizers has failed before emitting.\n     * @param {Object} input\n     */\n    emit: function(input) {\n        var self = this;\n        var state = this.state;\n\n        function emit(event) {\n            self.manager.emit(event, input);\n        }\n\n        // 'panstart' and 'panmove'\n        if (state < STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n\n        emit(self.options.event); // simple 'eventName' events\n\n        if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)\n            emit(input.additionalEvent);\n        }\n\n        // panend and pancancel\n        if (state >= STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n    },\n\n    /**\n     * Check that all the require failure recognizers has failed,\n     * if true, it emits a gesture event,\n     * otherwise, setup the state to FAILED.\n     * @param {Object} input\n     */\n    tryEmit: function(input) {\n        if (this.canEmit()) {\n            return this.emit(input);\n        }\n        // it's failing anyway\n        this.state = STATE_FAILED;\n    },\n\n    /**\n     * can we emit?\n     * @returns {boolean}\n     */\n    canEmit: function() {\n        var i = 0;\n        while (i < this.requireFail.length) {\n            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n                return false;\n            }\n            i++;\n        }\n        return true;\n    },\n\n    /**\n     * update the recognizer\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        // make a new copy of the inputData\n        // so we can change the inputData without messing up the other recognizers\n        var inputDataClone = assign({}, inputData);\n\n        // is is enabled and allow recognizing?\n        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n            this.reset();\n            this.state = STATE_FAILED;\n            return;\n        }\n\n        // reset when we've reached the end\n        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n            this.state = STATE_POSSIBLE;\n        }\n\n        this.state = this.process(inputDataClone);\n\n        // the recognizer has recognized a gesture\n        // so trigger an event\n        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {\n            this.tryEmit(inputDataClone);\n        }\n    },\n\n    /**\n     * return the state of the recognizer\n     * the actual recognizing happens in this method\n     * @virtual\n     * @param {Object} inputData\n     * @returns {Const} STATE\n     */\n    process: function(inputData) { }, // jshint ignore:line\n\n    /**\n     * return the preferred touch-action\n     * @virtual\n     * @returns {Array}\n     */\n    getTouchAction: function() { },\n\n    /**\n     * called when the gesture isn't allowed to recognize\n     * like when another is being recognized or it is disabled\n     * @virtual\n     */\n    reset: function() { }\n};\n\n/**\n * get a usable string, used as event postfix\n * @param {Const} state\n * @returns {String} state\n */\nfunction stateStr(state) {\n    if (state & STATE_CANCELLED) {\n        return 'cancel';\n    } else if (state & STATE_ENDED) {\n        return 'end';\n    } else if (state & STATE_CHANGED) {\n        return 'move';\n    } else if (state & STATE_BEGAN) {\n        return 'start';\n    }\n    return '';\n}\n\n/**\n * direction cons to string\n * @param {Const} direction\n * @returns {String}\n */\nfunction directionStr(direction) {\n    if (direction == DIRECTION_DOWN) {\n        return 'down';\n    } else if (direction == DIRECTION_UP) {\n        return 'up';\n    } else if (direction == DIRECTION_LEFT) {\n        return 'left';\n    } else if (direction == DIRECTION_RIGHT) {\n        return 'right';\n    }\n    return '';\n}\n\n/**\n * get a recognizer by name if it is bound to a manager\n * @param {Recognizer|String} otherRecognizer\n * @param {Recognizer} recognizer\n * @returns {Recognizer}\n */\nfunction getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n    var manager = recognizer.manager;\n    if (manager) {\n        return manager.get(otherRecognizer);\n    }\n    return otherRecognizer;\n}\n\n/**\n * This recognizer is just used as a base for the simple attribute recognizers.\n * @constructor\n * @extends Recognizer\n */\nfunction AttrRecognizer() {\n    Recognizer.apply(this, arguments);\n}\n\ninherit(AttrRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof AttrRecognizer\n     */\n    defaults: {\n        /**\n         * @type {Number}\n         * @default 1\n         */\n        pointers: 1\n    },\n\n    /**\n     * Used to check if it the recognizer receives valid input, like input.distance > 10.\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {Boolean} recognized\n     */\n    attrTest: function(input) {\n        var optionPointers = this.options.pointers;\n        return optionPointers === 0 || input.pointers.length === optionPointers;\n    },\n\n    /**\n     * Process the input and return the state for the recognizer\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {*} State\n     */\n    process: function(input) {\n        var state = this.state;\n        var eventType = input.eventType;\n\n        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n        var isValid = this.attrTest(input);\n\n        // on cancel input and we've recognized before, return STATE_CANCELLED\n        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {\n            return state | STATE_CANCELLED;\n        } else if (isRecognized || isValid) {\n            if (eventType & INPUT_END) {\n                return state | STATE_ENDED;\n            } else if (!(state & STATE_BEGAN)) {\n                return STATE_BEGAN;\n            }\n            return state | STATE_CHANGED;\n        }\n        return STATE_FAILED;\n    }\n});\n\n/**\n * Pan\n * Recognized when the pointer is down and moved in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PanRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n\n    this.pX = null;\n    this.pY = null;\n}\n\ninherit(PanRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PanRecognizer\n     */\n    defaults: {\n        event: 'pan',\n        threshold: 10,\n        pointers: 1,\n        direction: DIRECTION_ALL\n    },\n\n    getTouchAction: function() {\n        var direction = this.options.direction;\n        var actions = [];\n        if (direction & DIRECTION_HORIZONTAL) {\n            actions.push(TOUCH_ACTION_PAN_Y);\n        }\n        if (direction & DIRECTION_VERTICAL) {\n            actions.push(TOUCH_ACTION_PAN_X);\n        }\n        return actions;\n    },\n\n    directionTest: function(input) {\n        var options = this.options;\n        var hasMoved = true;\n        var distance = input.distance;\n        var direction = input.direction;\n        var x = input.deltaX;\n        var y = input.deltaY;\n\n        // lock to axis?\n        if (!(direction & options.direction)) {\n            if (options.direction & DIRECTION_HORIZONTAL) {\n                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;\n                hasMoved = x != this.pX;\n                distance = Math.abs(input.deltaX);\n            } else {\n                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;\n                hasMoved = y != this.pY;\n                distance = Math.abs(input.deltaY);\n            }\n        }\n        input.direction = direction;\n        return hasMoved && distance > options.threshold && direction & options.direction;\n    },\n\n    attrTest: function(input) {\n        return AttrRecognizer.prototype.attrTest.call(this, input) &&\n            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));\n    },\n\n    emit: function(input) {\n\n        this.pX = input.deltaX;\n        this.pY = input.deltaY;\n\n        var direction = directionStr(input.direction);\n\n        if (direction) {\n            input.additionalEvent = this.options.event + direction;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Pinch\n * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PinchRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(PinchRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'pinch',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n    },\n\n    emit: function(input) {\n        if (input.scale !== 1) {\n            var inOut = input.scale < 1 ? 'in' : 'out';\n            input.additionalEvent = this.options.event + inOut;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Press\n * Recognized when the pointer is down for x ms without any movement.\n * @constructor\n * @extends Recognizer\n */\nfunction PressRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    this._timer = null;\n    this._input = null;\n}\n\ninherit(PressRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PressRecognizer\n     */\n    defaults: {\n        event: 'press',\n        pointers: 1,\n        time: 251, // minimal time of the pointer to be pressed\n        threshold: 9 // a minimal movement is ok, but keep it low\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_AUTO];\n    },\n\n    process: function(input) {\n        var options = this.options;\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTime = input.deltaTime > options.time;\n\n        this._input = input;\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {\n            this.reset();\n        } else if (input.eventType & INPUT_START) {\n            this.reset();\n            this._timer = setTimeoutContext(function() {\n                this.state = STATE_RECOGNIZED;\n                this.tryEmit();\n            }, options.time, this);\n        } else if (input.eventType & INPUT_END) {\n            return STATE_RECOGNIZED;\n        }\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function(input) {\n        if (this.state !== STATE_RECOGNIZED) {\n            return;\n        }\n\n        if (input && (input.eventType & INPUT_END)) {\n            this.manager.emit(this.options.event + 'up', input);\n        } else {\n            this._input.timeStamp = now();\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Rotate\n * Recognized when two or more pointer are moving in a circular motion.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction RotateRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(RotateRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof RotateRecognizer\n     */\n    defaults: {\n        event: 'rotate',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\n    }\n});\n\n/**\n * Swipe\n * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction SwipeRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(SwipeRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof SwipeRecognizer\n     */\n    defaults: {\n        event: 'swipe',\n        threshold: 10,\n        velocity: 0.3,\n        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,\n        pointers: 1\n    },\n\n    getTouchAction: function() {\n        return PanRecognizer.prototype.getTouchAction.call(this);\n    },\n\n    attrTest: function(input) {\n        var direction = this.options.direction;\n        var velocity;\n\n        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {\n            velocity = input.overallVelocity;\n        } else if (direction & DIRECTION_HORIZONTAL) {\n            velocity = input.overallVelocityX;\n        } else if (direction & DIRECTION_VERTICAL) {\n            velocity = input.overallVelocityY;\n        }\n\n        return this._super.attrTest.call(this, input) &&\n            direction & input.offsetDirection &&\n            input.distance > this.options.threshold &&\n            input.maxPointers == this.options.pointers &&\n            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n    },\n\n    emit: function(input) {\n        var direction = directionStr(input.offsetDirection);\n        if (direction) {\n            this.manager.emit(this.options.event + direction, input);\n        }\n\n        this.manager.emit(this.options.event, input);\n    }\n});\n\n/**\n * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur\n * between the given interval and position. The delay option can be used to recognize multi-taps without firing\n * a single tap.\n *\n * The eventData from the emitted event contains the property `tapCount`, which contains the amount of\n * multi-taps being recognized.\n * @constructor\n * @extends Recognizer\n */\nfunction TapRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    // previous time and center,\n    // used for tap counting\n    this.pTime = false;\n    this.pCenter = false;\n\n    this._timer = null;\n    this._input = null;\n    this.count = 0;\n}\n\ninherit(TapRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'tap',\n        pointers: 1,\n        taps: 1,\n        interval: 300, // max time between the multi-tap taps\n        time: 250, // max time of the pointer to be down (like finger on the screen)\n        threshold: 9, // a minimal movement is ok, but keep it low\n        posThreshold: 10 // a multi-tap can be a bit off the initial position\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_MANIPULATION];\n    },\n\n    process: function(input) {\n        var options = this.options;\n\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTouchTime = input.deltaTime < options.time;\n\n        this.reset();\n\n        if ((input.eventType & INPUT_START) && (this.count === 0)) {\n            return this.failTimeout();\n        }\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (validMovement && validTouchTime && validPointers) {\n            if (input.eventType != INPUT_END) {\n                return this.failTimeout();\n            }\n\n            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;\n            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;\n\n            this.pTime = input.timeStamp;\n            this.pCenter = input.center;\n\n            if (!validMultiTap || !validInterval) {\n                this.count = 1;\n            } else {\n                this.count += 1;\n            }\n\n            this._input = input;\n\n            // if tap count matches we have recognized it,\n            // else it has began recognizing...\n            var tapCount = this.count % options.taps;\n            if (tapCount === 0) {\n                // no failing requirements, immediately trigger the tap event\n                // or wait as long as the multitap interval to trigger\n                if (!this.hasRequireFailures()) {\n                    return STATE_RECOGNIZED;\n                } else {\n                    this._timer = setTimeoutContext(function() {\n                        this.state = STATE_RECOGNIZED;\n                        this.tryEmit();\n                    }, options.interval, this);\n                    return STATE_BEGAN;\n                }\n            }\n        }\n        return STATE_FAILED;\n    },\n\n    failTimeout: function() {\n        this._timer = setTimeoutContext(function() {\n            this.state = STATE_FAILED;\n        }, this.options.interval, this);\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function() {\n        if (this.state == STATE_RECOGNIZED) {\n            this._input.tapCount = this.count;\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Simple way to create a manager with a default set of recognizers.\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Hammer(element, options) {\n    options = options || {};\n    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n    return new Manager(element, options);\n}\n\n/**\n * @const {string}\n */\nHammer.VERSION = '2.0.7';\n\n/**\n * default settings\n * @namespace\n */\nHammer.defaults = {\n    /**\n     * set if DOM events are being triggered.\n     * But this is slower and unused by simple implementations, so disabled by default.\n     * @type {Boolean}\n     * @default false\n     */\n    domEvents: false,\n\n    /**\n     * The value for the touchAction property/fallback.\n     * When set to `compute` it will magically set the correct value based on the added recognizers.\n     * @type {String}\n     * @default compute\n     */\n    touchAction: TOUCH_ACTION_COMPUTE,\n\n    /**\n     * @type {Boolean}\n     * @default true\n     */\n    enable: true,\n\n    /**\n     * EXPERIMENTAL FEATURE -- can be removed/changed\n     * Change the parent input target element.\n     * If Null, then it is being set the to main element.\n     * @type {Null|EventTarget}\n     * @default null\n     */\n    inputTarget: null,\n\n    /**\n     * force an input class\n     * @type {Null|Function}\n     * @default null\n     */\n    inputClass: null,\n\n    /**\n     * Default recognizer setup when calling `Hammer()`\n     * When creating a new Manager these will be skipped.\n     * @type {Array}\n     */\n    preset: [\n        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n        [RotateRecognizer, {enable: false}],\n        [PinchRecognizer, {enable: false}, ['rotate']],\n        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],\n        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],\n        [TapRecognizer],\n        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],\n        [PressRecognizer]\n    ],\n\n    /**\n     * Some CSS properties can be used to improve the working of Hammer.\n     * Add them to this method and they will be set when creating a new Manager.\n     * @namespace\n     */\n    cssProps: {\n        /**\n         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userSelect: 'none',\n\n        /**\n         * Disable the Windows Phone grippers when pressing an element.\n         * @type {String}\n         * @default 'none'\n         */\n        touchSelect: 'none',\n\n        /**\n         * Disables the default callout shown when you touch and hold a touch target.\n         * On iOS, when you touch and hold a touch target such as a link, Safari displays\n         * a callout containing information about the link. This property allows you to disable that callout.\n         * @type {String}\n         * @default 'none'\n         */\n        touchCallout: 'none',\n\n        /**\n         * Specifies whether zooming is enabled. Used by IE10>\n         * @type {String}\n         * @default 'none'\n         */\n        contentZooming: 'none',\n\n        /**\n         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userDrag: 'none',\n\n        /**\n         * Overrides the highlight color shown when the user taps a link or a JavaScript\n         * clickable element in iOS. This property obeys the alpha value, if specified.\n         * @type {String}\n         * @default 'rgba(0,0,0,0)'\n         */\n        tapHighlightColor: 'rgba(0,0,0,0)'\n    }\n};\n\nvar STOP = 1;\nvar FORCED_STOP = 2;\n\n/**\n * Manager\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Manager(element, options) {\n    this.options = assign({}, Hammer.defaults, options || {});\n\n    this.options.inputTarget = this.options.inputTarget || element;\n\n    this.handlers = {};\n    this.session = {};\n    this.recognizers = [];\n    this.oldCssProps = {};\n\n    this.element = element;\n    this.input = createInputInstance(this);\n    this.touchAction = new TouchAction(this, this.options.touchAction);\n\n    toggleCssProps(this, true);\n\n    each(this.options.recognizers, function(item) {\n        var recognizer = this.add(new (item[0])(item[1]));\n        item[2] && recognizer.recognizeWith(item[2]);\n        item[3] && recognizer.requireFailure(item[3]);\n    }, this);\n}\n\nManager.prototype = {\n    /**\n     * set options\n     * @param {Object} options\n     * @returns {Manager}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // Options that need a little more setup\n        if (options.touchAction) {\n            this.touchAction.update();\n        }\n        if (options.inputTarget) {\n            // Clean up existing event listeners and reinitialize\n            this.input.destroy();\n            this.input.target = options.inputTarget;\n            this.input.init();\n        }\n        return this;\n    },\n\n    /**\n     * stop recognizing for this session.\n     * This session will be discarded, when a new [input]start event is fired.\n     * When forced, the recognizer cycle is stopped immediately.\n     * @param {Boolean} [force]\n     */\n    stop: function(force) {\n        this.session.stopped = force ? FORCED_STOP : STOP;\n    },\n\n    /**\n     * run the recognizers!\n     * called by the inputHandler function on every movement of the pointers (touches)\n     * it walks through all the recognizers and tries to detect the gesture that is being made\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        var session = this.session;\n        if (session.stopped) {\n            return;\n        }\n\n        // run the touch-action polyfill\n        this.touchAction.preventDefaults(inputData);\n\n        var recognizer;\n        var recognizers = this.recognizers;\n\n        // this holds the recognizer that is being recognized.\n        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED\n        // if no recognizer is detecting a thing, it is set to `null`\n        var curRecognizer = session.curRecognizer;\n\n        // reset when the last recognizer is recognized\n        // or when we're in a new session\n        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {\n            curRecognizer = session.curRecognizer = null;\n        }\n\n        var i = 0;\n        while (i < recognizers.length) {\n            recognizer = recognizers[i];\n\n            // find out if we are allowed try to recognize the input for this one.\n            // 1.   allow if the session is NOT forced stopped (see the .stop() method)\n            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one\n            //      that is being recognized.\n            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.\n            //      this can be setup with the `recognizeWith()` method on the recognizer.\n            if (session.stopped !== FORCED_STOP && ( // 1\n                    !curRecognizer || recognizer == curRecognizer || // 2\n                    recognizer.canRecognizeWith(curRecognizer))) { // 3\n                recognizer.recognize(inputData);\n            } else {\n                recognizer.reset();\n            }\n\n            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the\n            // current active recognizer. but only if we don't already have an active recognizer\n            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n                curRecognizer = session.curRecognizer = recognizer;\n            }\n            i++;\n        }\n    },\n\n    /**\n     * get a recognizer by its event name.\n     * @param {Recognizer|String} recognizer\n     * @returns {Recognizer|Null}\n     */\n    get: function(recognizer) {\n        if (recognizer instanceof Recognizer) {\n            return recognizer;\n        }\n\n        var recognizers = this.recognizers;\n        for (var i = 0; i < recognizers.length; i++) {\n            if (recognizers[i].options.event == recognizer) {\n                return recognizers[i];\n            }\n        }\n        return null;\n    },\n\n    /**\n     * add a recognizer to the manager\n     * existing recognizers with the same event name will be removed\n     * @param {Recognizer} recognizer\n     * @returns {Recognizer|Manager}\n     */\n    add: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'add', this)) {\n            return this;\n        }\n\n        // remove existing\n        var existing = this.get(recognizer.options.event);\n        if (existing) {\n            this.remove(existing);\n        }\n\n        this.recognizers.push(recognizer);\n        recognizer.manager = this;\n\n        this.touchAction.update();\n        return recognizer;\n    },\n\n    /**\n     * remove a recognizer by name or instance\n     * @param {Recognizer|String} recognizer\n     * @returns {Manager}\n     */\n    remove: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'remove', this)) {\n            return this;\n        }\n\n        recognizer = this.get(recognizer);\n\n        // let's make sure this recognizer exists\n        if (recognizer) {\n            var recognizers = this.recognizers;\n            var index = inArray(recognizers, recognizer);\n\n            if (index !== -1) {\n                recognizers.splice(index, 1);\n                this.touchAction.update();\n            }\n        }\n\n        return this;\n    },\n\n    /**\n     * bind event\n     * @param {String} events\n     * @param {Function} handler\n     * @returns {EventEmitter} this\n     */\n    on: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n        if (handler === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            handlers[event] = handlers[event] || [];\n            handlers[event].push(handler);\n        });\n        return this;\n    },\n\n    /**\n     * unbind event, leave emit blank to remove all handlers\n     * @param {String} events\n     * @param {Function} [handler]\n     * @returns {EventEmitter} this\n     */\n    off: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            if (!handler) {\n                delete handlers[event];\n            } else {\n                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);\n            }\n        });\n        return this;\n    },\n\n    /**\n     * emit event to the listeners\n     * @param {String} event\n     * @param {Object} data\n     */\n    emit: function(event, data) {\n        // we also want to trigger dom events\n        if (this.options.domEvents) {\n            triggerDomEvent(event, data);\n        }\n\n        // no handlers, so skip it all\n        var handlers = this.handlers[event] && this.handlers[event].slice();\n        if (!handlers || !handlers.length) {\n            return;\n        }\n\n        data.type = event;\n        data.preventDefault = function() {\n            data.srcEvent.preventDefault();\n        };\n\n        var i = 0;\n        while (i < handlers.length) {\n            handlers[i](data);\n            i++;\n        }\n    },\n\n    /**\n     * destroy the manager and unbinds all events\n     * it doesn't unbind dom events, that is the user own responsibility\n     */\n    destroy: function() {\n        this.element && toggleCssProps(this, false);\n\n        this.handlers = {};\n        this.session = {};\n        this.input.destroy();\n        this.element = null;\n    }\n};\n\n/**\n * add/remove the css properties as defined in manager.options.cssProps\n * @param {Manager} manager\n * @param {Boolean} add\n */\nfunction toggleCssProps(manager, add) {\n    var element = manager.element;\n    if (!element.style) {\n        return;\n    }\n    var prop;\n    each(manager.options.cssProps, function(value, name) {\n        prop = prefixed(element.style, name);\n        if (add) {\n            manager.oldCssProps[prop] = element.style[prop];\n            element.style[prop] = value;\n        } else {\n            element.style[prop] = manager.oldCssProps[prop] || '';\n        }\n    });\n    if (!add) {\n        manager.oldCssProps = {};\n    }\n}\n\n/**\n * trigger dom event\n * @param {String} event\n * @param {Object} data\n */\nfunction triggerDomEvent(event, data) {\n    var gestureEvent = document.createEvent('Event');\n    gestureEvent.initEvent(event, true, true);\n    gestureEvent.gesture = data;\n    data.target.dispatchEvent(gestureEvent);\n}\n\nassign(Hammer, {\n    INPUT_START: INPUT_START,\n    INPUT_MOVE: INPUT_MOVE,\n    INPUT_END: INPUT_END,\n    INPUT_CANCEL: INPUT_CANCEL,\n\n    STATE_POSSIBLE: STATE_POSSIBLE,\n    STATE_BEGAN: STATE_BEGAN,\n    STATE_CHANGED: STATE_CHANGED,\n    STATE_ENDED: STATE_ENDED,\n    STATE_RECOGNIZED: STATE_RECOGNIZED,\n    STATE_CANCELLED: STATE_CANCELLED,\n    STATE_FAILED: STATE_FAILED,\n\n    DIRECTION_NONE: DIRECTION_NONE,\n    DIRECTION_LEFT: DIRECTION_LEFT,\n    DIRECTION_RIGHT: DIRECTION_RIGHT,\n    DIRECTION_UP: DIRECTION_UP,\n    DIRECTION_DOWN: DIRECTION_DOWN,\n    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,\n    DIRECTION_VERTICAL: DIRECTION_VERTICAL,\n    DIRECTION_ALL: DIRECTION_ALL,\n\n    Manager: Manager,\n    Input: Input,\n    TouchAction: TouchAction,\n\n    TouchInput: TouchInput,\n    MouseInput: MouseInput,\n    PointerEventInput: PointerEventInput,\n    TouchMouseInput: TouchMouseInput,\n    SingleTouchInput: SingleTouchInput,\n\n    Recognizer: Recognizer,\n    AttrRecognizer: AttrRecognizer,\n    Tap: TapRecognizer,\n    Pan: PanRecognizer,\n    Swipe: SwipeRecognizer,\n    Pinch: PinchRecognizer,\n    Rotate: RotateRecognizer,\n    Press: PressRecognizer,\n\n    on: addEventListeners,\n    off: removeEventListeners,\n    each: each,\n    merge: merge,\n    extend: extend,\n    assign: assign,\n    inherit: inherit,\n    bindFn: bindFn,\n    prefixed: prefixed\n});\n\n// this prevents errors when Hammer is loaded in the presence of an AMD\n//  style loader but by script tag, not by the loader.\nvar freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line\nfreeGlobal.Hammer = Hammer;\n\nif (typeof define === 'function' && define.amd) {\n    define(function() {\n        return Hammer;\n    });\n} else if (typeof module != 'undefined' && module.exports) {\n    module.exports = Hammer;\n} else {\n    window[exportName] = Hammer;\n}\n\n})(window, document, 'Hammer');\n","/**\n * This file contains overrides the default\n * hammer.js functions to add our own utility\n */\n\n/* Hammer.js constants */\nconst INPUT_START = 1;\nconst INPUT_MOVE = 2;\nconst INPUT_END = 4;\nconst MOUSE_INPUT_MAP = {\n  mousedown: INPUT_START,\n  mousemove: INPUT_MOVE,\n  mouseup: INPUT_END\n};\n\n/**\n * Helper function that returns true if any element in an array meets given criteria.\n * Because older browsers do not support `Array.prototype.some`\n * @params array {Array}\n * @params predict {Function}\n */\nfunction some(array, predict) {\n  for (let i = 0; i < array.length; i++) {\n    if (predict(array[i])) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/* eslint-disable no-invalid-this */\nexport function enhancePointerEventInput(PointerEventInput) {\n  const oldHandler = PointerEventInput.prototype.handler;\n\n  // overrides PointerEventInput.handler to accept right mouse button\n  PointerEventInput.prototype.handler = function handler(ev) {\n    const store = this.store;\n\n    // Allow non-left mouse buttons through\n    if (ev.button > 0) {\n      if (!some(store, e => e.pointerId === ev.pointerId)) {\n        store.push(ev);\n      }\n    }\n\n    oldHandler.call(this, ev);\n  };\n}\n\n// overrides MouseInput.handler to accept right mouse button\nexport function enhanceMouseInput(MouseInput) {\n  MouseInput.prototype.handler = function handler(ev) {\n    let eventType = MOUSE_INPUT_MAP[ev.type];\n\n    // on start we want to have the mouse button down\n    if (eventType & INPUT_START && ev.button >= 0) {\n      this.pressed = true;\n    }\n\n    if (eventType & INPUT_MOVE && ev.which === 0) {\n      eventType = INPUT_END;\n    }\n\n    // mouse must be down\n    if (!this.pressed) {\n      return;\n    }\n\n    if (eventType & INPUT_END) {\n      this.pressed = false;\n    }\n\n    this.callback(this.manager, eventType, {\n      pointers: [ev],\n      changedPointers: [ev],\n      pointerType: 'mouse',\n      srcEvent: ev\n    });\n  };\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {INPUT_EVENT_TYPES} from '../constants';\nimport {window, userAgent, passiveSupported} from '../utils/globals';\n\nconst firefox = userAgent.indexOf('firefox') !== -1;\n\nconst {WHEEL_EVENTS} = INPUT_EVENT_TYPES;\nconst EVENT_TYPE = 'wheel';\n\n// Constants for normalizing input delta\nconst WHEEL_DELTA_MAGIC_SCALER = 4.000244140625;\nconst WHEEL_DELTA_PER_LINE = 40;\n// Slow down zoom if shift key is held for more precise zooming\nconst SHIFT_MULTIPLIER = 0.25;\n\nexport default class WheelInput {\n  constructor(element, callback, options = {}) {\n    this.element = element;\n    this.callback = callback;\n\n    this.options = Object.assign({enable: true}, options);\n\n    this.events = WHEEL_EVENTS.concat(options.events || []);\n\n    this.handleEvent = this.handleEvent.bind(this);\n    this.events.forEach(event =>\n      element.addEventListener(event, this.handleEvent, passiveSupported ? {passive: false} : false)\n    );\n  }\n\n  destroy() {\n    this.events.forEach(event => this.element.removeEventListener(event, this.handleEvent));\n  }\n\n  /**\n   * Enable this input (begin processing events)\n   * if the specified event type is among those handled by this input.\n   */\n  enableEventType(eventType, enabled) {\n    if (eventType === EVENT_TYPE) {\n      this.options.enable = enabled;\n    }\n  }\n\n  /* eslint-disable complexity, max-statements */\n  handleEvent(event) {\n    if (!this.options.enable) {\n      return;\n    }\n\n    let value = event.deltaY;\n    if (window.WheelEvent) {\n      // Firefox doubles the values on retina screens...\n      if (firefox && event.deltaMode === window.WheelEvent.DOM_DELTA_PIXEL) {\n        value /= window.devicePixelRatio;\n      }\n      if (event.deltaMode === window.WheelEvent.DOM_DELTA_LINE) {\n        value *= WHEEL_DELTA_PER_LINE;\n      }\n    }\n\n    const wheelPosition = {\n      x: event.clientX,\n      y: event.clientY\n    };\n\n    if (value !== 0 && value % WHEEL_DELTA_MAGIC_SCALER === 0) {\n      // This one is definitely a mouse wheel event.\n      // Normalize this value to match trackpad.\n      value = Math.floor(value / WHEEL_DELTA_MAGIC_SCALER);\n    }\n\n    if (event.shiftKey && value) {\n      value = value * SHIFT_MULTIPLIER;\n    }\n\n    this._onWheel(event, -value, wheelPosition);\n  }\n\n  _onWheel(srcEvent, delta, position) {\n    this.callback({\n      type: EVENT_TYPE,\n      center: position,\n      delta,\n      srcEvent,\n      pointerType: 'mouse',\n      target: srcEvent.target\n    });\n  }\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport Hammer from './utils/hammer';\n\n// This module contains constants that must be conditionally required\n// due to `window`/`document` references downstream.\nexport const RECOGNIZERS = Hammer\n  ? [\n      [Hammer.Pan, {event: 'tripan', pointers: 3, threshold: 0, enable: false}],\n      [Hammer.Rotate, {enable: false}],\n      [Hammer.Pinch, {enable: false}],\n      [Hammer.Swipe, {enable: false}],\n      [Hammer.Pan, {threshold: 0, enable: false}],\n      [Hammer.Press, {enable: false}],\n      [Hammer.Tap, {event: 'doubletap', taps: 2, enable: false}],\n      // TODO - rename to 'tap' and 'singletap' in the next major release\n      [Hammer.Tap, {event: 'anytap', enable: false}],\n      [Hammer.Tap, {enable: false}]\n    ]\n  : null;\n\n// Recognize the following gestures even if a given recognizer succeeds\nexport const RECOGNIZER_COMPATIBLE_MAP = {\n  tripan: ['rotate', 'pinch', 'pan'],\n  rotate: ['pinch'],\n  pinch: ['pan'],\n  pan: ['press', 'doubletap', 'anytap', 'tap'],\n  doubletap: ['anytap'],\n  anytap: ['tap']\n};\n\n// Recognize the folling gestures only if a given recognizer fails\nexport const RECOGNIZER_FALLBACK_MAP = {\n  doubletap: ['tap']\n};\n\n/**\n * Only one set of basic input events will be fired by Hammer.js:\n * either pointer, touch, or mouse, depending on system support.\n * In order to enable an application to be agnostic of system support,\n * alias basic input events into \"classes\" of events: down, move, and up.\n * See `_onBasicInput()` for usage of these aliases.\n */\nexport const BASIC_EVENT_ALIASES = {\n  pointerdown: 'pointerdown',\n  pointermove: 'pointermove',\n  pointerup: 'pointerup',\n  touchstart: 'pointerdown',\n  touchmove: 'pointermove',\n  touchend: 'pointerup',\n  mousedown: 'pointerdown',\n  mousemove: 'pointermove',\n  mouseup: 'pointerup'\n};\n\nexport const INPUT_EVENT_TYPES = {\n  KEY_EVENTS: ['keydown', 'keyup'],\n  MOUSE_EVENTS: ['mousedown', 'mousemove', 'mouseup', 'mouseover', 'mouseout', 'mouseleave'],\n  WHEEL_EVENTS: [\n    // Chrome, Safari\n    'wheel',\n    // IE\n    'mousewheel',\n    // legacy Firefox\n    'DOMMouseScroll'\n  ]\n};\n\n/**\n * \"Gestural\" events are those that have semantic meaning beyond the basic input event,\n * e.g. a click or tap is a sequence of `down` and `up` events with no `move` event in between.\n * Hammer.js handles these with its Recognizer system;\n * this block maps event names to the Recognizers required to detect the events.\n */\nexport const EVENT_RECOGNIZER_MAP = {\n  tap: 'tap',\n  anytap: 'anytap',\n  doubletap: 'doubletap',\n  press: 'press',\n  pinch: 'pinch',\n  pinchin: 'pinch',\n  pinchout: 'pinch',\n  pinchstart: 'pinch',\n  pinchmove: 'pinch',\n  pinchend: 'pinch',\n  pinchcancel: 'pinch',\n  rotate: 'rotate',\n  rotatestart: 'rotate',\n  rotatemove: 'rotate',\n  rotateend: 'rotate',\n  rotatecancel: 'rotate',\n  tripan: 'tripan',\n  tripanstart: 'tripan',\n  tripanmove: 'tripan',\n  tripanup: 'tripan',\n  tripandown: 'tripan',\n  tripanleft: 'tripan',\n  tripanright: 'tripan',\n  tripanend: 'tripan',\n  tripancancel: 'tripan',\n  pan: 'pan',\n  panstart: 'pan',\n  panmove: 'pan',\n  panup: 'pan',\n  pandown: 'pan',\n  panleft: 'pan',\n  panright: 'pan',\n  panend: 'pan',\n  pancancel: 'pan',\n  swipe: 'swipe',\n  swipeleft: 'swipe',\n  swiperight: 'swipe',\n  swipeup: 'swipe',\n  swipedown: 'swipe'\n};\n\n/**\n * Map gestural events typically provided by browsers\n * that are not reported in 'hammer.input' events\n * to corresponding Hammer.js gestures.\n */\nexport const GESTURE_EVENT_ALIASES = {\n  click: 'tap',\n  anyclick: 'anytap',\n  dblclick: 'doubletap',\n  mousedown: 'pointerdown',\n  mousemove: 'pointermove',\n  mouseup: 'pointerup',\n  mouseover: 'pointerover',\n  mouseout: 'pointerout',\n  mouseleave: 'pointerleave'\n};\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// Purpose: include this in your module to avoids adding dependencies on\n// micro modules like 'global'\n\n/* global window, global, document, navigator */\nexport const userAgent =\n  typeof navigator !== 'undefined' && navigator.userAgent ? navigator.userAgent.toLowerCase() : '';\n\nconst window_ = typeof window !== 'undefined' ? window : global;\nconst global_ = typeof global !== 'undefined' ? global : window;\nconst document_ = typeof document !== 'undefined' ? document : {};\n\nexport {window_ as window, global_ as global, document_ as document};\n\n/*\n * Detect whether passive option is supported by the current browser.\n * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener\n   #Safely_detecting_option_support\n */\nlet passiveSupported = false;\n\n/* eslint-disable accessor-pairs, no-empty */\ntry {\n  const options = {\n    // This function will be called when the browser\n    // attempts to access the passive property.\n    get passive() {\n      passiveSupported = true;\n      return true;\n    }\n  };\n\n  window_.addEventListener('test', options, options);\n  window_.removeEventListener('test', options, options);\n} catch (err) {}\n\nexport {passiveSupported};\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {INPUT_EVENT_TYPES} from '../constants';\n\nconst {MOUSE_EVENTS} = INPUT_EVENT_TYPES;\nconst MOVE_EVENT_TYPE = 'pointermove';\nconst OVER_EVENT_TYPE = 'pointerover';\nconst OUT_EVENT_TYPE = 'pointerout';\nconst LEAVE_EVENT_TYPE = 'pointerleave';\n\n/**\n * Hammer.js swallows 'move' events (for pointer/touch/mouse)\n * when the pointer is not down. This class sets up a handler\n * specifically for these events to work around this limitation.\n * Note that this could be extended to more intelligently handle\n * move events across input types, e.g. storing multiple simultaneous\n * pointer/touch events, calculating speed/direction, etc.\n */\nexport default class MoveInput {\n  constructor(element, callback, options = {}) {\n    this.element = element;\n    this.callback = callback;\n    this.pressed = false;\n\n    this.options = Object.assign({enable: true}, options);\n    this.enableMoveEvent = this.options.enable;\n    this.enableLeaveEvent = this.options.enable;\n    this.enableOutEvent = this.options.enable;\n    this.enableOverEvent = this.options.enable;\n\n    this.events = MOUSE_EVENTS.concat(options.events || []);\n\n    this.handleEvent = this.handleEvent.bind(this);\n    this.events.forEach(event => element.addEventListener(event, this.handleEvent));\n  }\n\n  destroy() {\n    this.events.forEach(event => this.element.removeEventListener(event, this.handleEvent));\n  }\n\n  /**\n   * Enable this input (begin processing events)\n   * if the specified event type is among those handled by this input.\n   */\n  enableEventType(eventType, enabled) {\n    if (eventType === MOVE_EVENT_TYPE) {\n      this.enableMoveEvent = enabled;\n    }\n    if (eventType === OVER_EVENT_TYPE) {\n      this.enableOverEvent = enabled;\n    }\n    if (eventType === OUT_EVENT_TYPE) {\n      this.enableOutEvent = enabled;\n    }\n    if (eventType === LEAVE_EVENT_TYPE) {\n      this.enableLeaveEvent = enabled;\n    }\n  }\n\n  handleEvent(event) {\n    this.handleOverEvent(event);\n    this.handleOutEvent(event);\n    this.handleLeaveEvent(event);\n    this.handleMoveEvent(event);\n  }\n\n  handleOverEvent(event) {\n    if (this.enableOverEvent) {\n      if (event.type === 'mouseover') {\n        this.callback({\n          type: OVER_EVENT_TYPE,\n          srcEvent: event,\n          pointerType: 'mouse',\n          target: event.target\n        });\n      }\n    }\n  }\n\n  handleOutEvent(event) {\n    if (this.enableOutEvent) {\n      if (event.type === 'mouseout') {\n        this.callback({\n          type: OUT_EVENT_TYPE,\n          srcEvent: event,\n          pointerType: 'mouse',\n          target: event.target\n        });\n      }\n    }\n  }\n\n  handleLeaveEvent(event) {\n    if (this.enableLeaveEvent) {\n      if (event.type === 'mouseleave') {\n        this.callback({\n          type: LEAVE_EVENT_TYPE,\n          srcEvent: event,\n          pointerType: 'mouse',\n          target: event.target\n        });\n      }\n    }\n  }\n\n  handleMoveEvent(event) {\n    if (this.enableMoveEvent) {\n      switch (event.type) {\n        case 'mousedown':\n          if (event.button >= 0) {\n            // Button is down\n            this.pressed = true;\n          }\n          break;\n        case 'mousemove':\n          // Move events use `which` to track the button being pressed\n          if (event.which === 0) {\n            // Button is not down\n            this.pressed = false;\n          }\n          if (!this.pressed) {\n            // Drag events are emitted by hammer already\n            // we just need to emit the move event on hover\n            this.callback({\n              type: MOVE_EVENT_TYPE,\n              srcEvent: event,\n              pointerType: 'mouse',\n              target: event.target\n            });\n          }\n          break;\n        case 'mouseup':\n          this.pressed = false;\n          break;\n        default:\n      }\n    }\n  }\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {INPUT_EVENT_TYPES} from '../constants';\n\nconst {KEY_EVENTS} = INPUT_EVENT_TYPES;\nconst DOWN_EVENT_TYPE = 'keydown';\nconst UP_EVENT_TYPE = 'keyup';\n\nexport default class KeyInput {\n  constructor(element, callback, options = {}) {\n    this.element = element;\n    this.callback = callback;\n\n    this.options = Object.assign({enable: true}, options);\n    this.enableDownEvent = this.options.enable;\n    this.enableUpEvent = this.options.enable;\n\n    this.events = KEY_EVENTS.concat(options.events || []);\n\n    this.handleEvent = this.handleEvent.bind(this);\n\n    element.tabIndex = options.tabIndex || 0;\n    element.style.outline = 'none';\n    this.events.forEach(event => element.addEventListener(event, this.handleEvent));\n  }\n\n  destroy() {\n    this.events.forEach(event => this.element.removeEventListener(event, this.handleEvent));\n  }\n\n  /**\n   * Enable this input (begin processing events)\n   * if the specified event type is among those handled by this input.\n   */\n  enableEventType(eventType, enabled) {\n    if (eventType === DOWN_EVENT_TYPE) {\n      this.enableDownEvent = enabled;\n    }\n    if (eventType === UP_EVENT_TYPE) {\n      this.enableUpEvent = enabled;\n    }\n  }\n\n  handleEvent(event) {\n    // Ignore if focused on text input\n    const targetElement = event.target || event.srcElement;\n    if (\n      (targetElement.tagName === 'INPUT' && targetElement.type === 'text') ||\n      targetElement.tagName === 'TEXTAREA'\n    ) {\n      return;\n    }\n\n    if (this.enableDownEvent && event.type === 'keydown') {\n      this.callback({\n        type: DOWN_EVENT_TYPE,\n        srcEvent: event,\n        key: event.key,\n        target: event.target\n      });\n    }\n\n    if (this.enableUpEvent && event.type === 'keyup') {\n      this.callback({\n        type: UP_EVENT_TYPE,\n        srcEvent: event,\n        key: event.key,\n        target: event.target\n      });\n    }\n  }\n}\n","// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nconst EVENT_TYPE = 'contextmenu';\n\nexport default class ContextmenuInput {\n  constructor(element, callback, options = {}) {\n    this.element = element;\n    this.callback = callback;\n\n    this.options = Object.assign({enable: true}, options);\n\n    this.handleEvent = this.handleEvent.bind(this);\n    element.addEventListener('contextmenu', this.handleEvent);\n  }\n\n  destroy() {\n    this.element.removeEventListener('contextmenu', this.handleEvent);\n  }\n\n  /**\n   * Enable this input (begin processing events)\n   * if the specified event type is among those handled by this input.\n   */\n  enableEventType(eventType, enabled) {\n    if (eventType === EVENT_TYPE) {\n      this.options.enable = enabled;\n    }\n  }\n\n  handleEvent(event) {\n    if (!this.options.enable) {\n      return;\n    }\n\n    this.callback({\n      type: EVENT_TYPE,\n      center: {\n        x: event.clientX,\n        y: event.clientY\n      },\n      srcEvent: event,\n      pointerType: 'mouse',\n      target: event.target\n    });\n  }\n}\n","import {whichButtons, getOffsetPosition} from './event-utils';\n\nconst DEFAULT_OPTIONS = {\n  srcElement: 'root',\n  priority: 0\n};\n\nexport default class EventRegistrar {\n  constructor(eventManager) {\n    this.eventManager = eventManager;\n    this.handlers = [];\n    // Element -> handler map\n    this.handlersByElement = new Map();\n\n    this.handleEvent = this.handleEvent.bind(this);\n    this._active = false;\n  }\n\n  // Returns true if there are no non-passive handlers\n  isEmpty() {\n    return !this._active;\n  }\n\n  add(type, handler, opts, once = false, passive = false) {\n    const {handlers, handlersByElement} = this;\n\n    if (opts && (typeof opts !== 'object' || opts.addEventListener)) {\n      // is DOM element, backward compatibility\n      opts = {srcElement: opts};\n    }\n    opts = opts ? Object.assign({}, DEFAULT_OPTIONS, opts) : DEFAULT_OPTIONS;\n\n    let entries = handlersByElement.get(opts.srcElement);\n    if (!entries) {\n      entries = [];\n      handlersByElement.set(opts.srcElement, entries);\n    }\n    const entry = {type, handler, srcElement: opts.srcElement, priority: opts.priority};\n    if (once) {\n      entry.once = true;\n    }\n    if (passive) {\n      entry.passive = true;\n    }\n    handlers.push(entry);\n    this._active = this._active || !entry.passive;\n\n    // Sort handlers by descending priority\n    // Handlers with the same priority are excuted in the order of registration\n    let insertPosition = entries.length - 1;\n    while (insertPosition >= 0) {\n      if (entries[insertPosition].priority >= entry.priority) {\n        break;\n      }\n      insertPosition--;\n    }\n    entries.splice(insertPosition + 1, 0, entry);\n  }\n\n  remove(type, handler) {\n    const {handlers, handlersByElement} = this;\n\n    for (let i = handlers.length - 1; i >= 0; i--) {\n      const entry = handlers[i];\n\n      if (entry.type === type && entry.handler === handler) {\n        handlers.splice(i, 1);\n        const entries = handlersByElement.get(entry.srcElement);\n        entries.splice(entries.indexOf(entry), 1);\n        if (entries.length === 0) {\n          handlersByElement.delete(entry.srcElement);\n        }\n      }\n    }\n    this._active = handlers.some(entry => !entry.passive);\n  }\n\n  /**\n   * Handles hammerjs event\n   */\n  handleEvent(event) {\n    if (this.isEmpty()) {\n      return;\n    }\n\n    const mjolnirEvent = this._normalizeEvent(event);\n    let target = event.srcEvent.target;\n\n    while (target && target !== mjolnirEvent.rootElement) {\n      this._emit(mjolnirEvent, target);\n      if (mjolnirEvent.handled) {\n        return;\n      }\n      target = target.parentNode;\n    }\n    this._emit(mjolnirEvent, 'root');\n  }\n\n  /**\n   * Invoke handlers on a particular element\n   */\n  _emit(event, srcElement) {\n    const entries = this.handlersByElement.get(srcElement);\n\n    if (entries) {\n      let immediatePropagationStopped = false;\n\n      // Prevents the current event from bubbling up\n      const stopPropagation = () => {\n        event.handled = true;\n      };\n      // Prevent any remaining listeners from being called\n      const stopImmediatePropagation = () => {\n        event.handled = true;\n        immediatePropagationStopped = true;\n      };\n      const entriesToRemove = [];\n\n      for (let i = 0; i < entries.length; i++) {\n        const {type, handler, once} = entries[i];\n        handler(\n          Object.assign({}, event, {\n            type,\n            stopPropagation,\n            stopImmediatePropagation\n          })\n        );\n        if (once) {\n          entriesToRemove.push(entries[i]);\n        }\n        if (immediatePropagationStopped) {\n          break;\n        }\n      }\n\n      for (let i = 0; i < entriesToRemove.length; i++) {\n        const {type, handler} = entriesToRemove[i];\n        this.remove(type, handler);\n      }\n    }\n  }\n\n  /**\n   * Normalizes hammerjs and custom events to have predictable fields.\n   */\n  _normalizeEvent(event) {\n    const rootElement = this.eventManager.element;\n\n    return Object.assign({}, event, whichButtons(event), getOffsetPosition(event, rootElement), {\n      handled: false,\n      rootElement\n    });\n  }\n}\n","export default function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}","/* Constants */\nconst DOWN_EVENT = 1;\nconst MOVE_EVENT = 2;\nconst UP_EVENT = 4;\nconst MOUSE_EVENTS = {\n  pointerdown: DOWN_EVENT,\n  pointermove: MOVE_EVENT,\n  pointerup: UP_EVENT,\n  mousedown: DOWN_EVENT,\n  mousemove: MOVE_EVENT,\n  mouseup: UP_EVENT\n};\n\n// MouseEvent.which https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/which\nconst MOUSE_EVENT_WHICH_LEFT = 1;\nconst MOUSE_EVENT_WHICH_MIDDLE = 2;\nconst MOUSE_EVENT_WHICH_RIGHT = 3;\n// MouseEvent.button https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button\nconst MOUSE_EVENT_BUTTON_LEFT = 0;\nconst MOUSE_EVENT_BUTTON_MIDDLE = 1;\nconst MOUSE_EVENT_BUTTON_RIGHT = 2;\n// MouseEvent.buttons https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons\nconst MOUSE_EVENT_BUTTONS_LEFT_MASK = 1;\nconst MOUSE_EVENT_BUTTONS_RIGHT_MASK = 2;\nconst MOUSE_EVENT_BUTTONS_MIDDLE_MASK = 4;\n\n/**\n * Extract the involved mouse button\n */\nexport function whichButtons(event) {\n  const eventType = MOUSE_EVENTS[event.srcEvent.type];\n  if (!eventType) {\n    // Not a mouse evet\n    return null;\n  }\n\n  const {buttons, button, which} = event.srcEvent;\n  let leftButton = false;\n  let middleButton = false;\n  let rightButton = false;\n\n  if (\n    // button is up, need to find out which one was pressed before\n    eventType === UP_EVENT ||\n    // moving but does not support `buttons` API\n    (eventType === MOVE_EVENT && !Number.isFinite(buttons))\n  ) {\n    leftButton = which === MOUSE_EVENT_WHICH_LEFT;\n    middleButton = which === MOUSE_EVENT_WHICH_MIDDLE;\n    rightButton = which === MOUSE_EVENT_WHICH_RIGHT;\n  } else if (eventType === MOVE_EVENT) {\n    leftButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_LEFT_MASK);\n    middleButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_MIDDLE_MASK);\n    rightButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_RIGHT_MASK);\n  } else if (eventType === DOWN_EVENT) {\n    leftButton = button === MOUSE_EVENT_BUTTON_LEFT;\n    middleButton = button === MOUSE_EVENT_BUTTON_MIDDLE;\n    rightButton = button === MOUSE_EVENT_BUTTON_RIGHT;\n  }\n\n  return {leftButton, middleButton, rightButton};\n}\n\n/**\n * Calculate event position relative to the root element\n */\nexport function getOffsetPosition(event, rootElement) {\n  const {srcEvent} = event;\n\n  // `center` is a hammer.js event property\n  if (!event.center && !Number.isFinite(srcEvent.clientX)) {\n    // Not a gestural event\n    return null;\n  }\n\n  const center = event.center || {\n    x: srcEvent.clientX,\n    y: srcEvent.clientY\n  };\n\n  const rect = rootElement.getBoundingClientRect();\n\n  // Fix scale for map affected by a CSS transform.\n  // See https://stackoverflow.com/a/26893663/3528533\n  const scaleX = rect.width / rootElement.offsetWidth;\n  const scaleY = rect.height / rootElement.offsetHeight;\n\n  // Calculate center relative to the root element\n  const offsetCenter = {\n    x: (center.x - rect.left - rootElement.clientLeft) / scaleX,\n    y: (center.y - rect.top - rootElement.clientTop) / scaleY\n  };\n\n  return {center, offsetCenter};\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/* eslint-disable react/no-direct-mutation-state */\nimport {COORDINATE_SYSTEM} from './constants';\nimport AttributeManager from './attribute/attribute-manager';\nimport UniformTransitionManager from './uniform-transition-manager';\nimport {diffProps, validateProps} from '../lifecycle/props';\nimport {count} from '../utils/count';\nimport log from '../utils/log';\nimport debug from '../debug';\nimport GL from '@luma.gl/constants';\nimport {withParameters, setParameters} from '@luma.gl/core';\nimport assert from '../utils/assert';\nimport memoize from '../utils/memoize';\nimport {mergeShaders} from '../utils/shader';\nimport {projectPosition, getWorldPosition} from '../shaderlib/project/project-functions';\nimport typedArrayManager from '../utils/typed-array-manager';\n\nimport Component from '../lifecycle/component';\nimport LayerState from './layer-state';\n\nimport {worldToPixels} from '@math.gl/web-mercator';\n\nimport {load} from '@loaders.gl/core';\n\nconst TRACE_CHANGE_FLAG = 'layer.changeFlag';\nconst TRACE_INITIALIZE = 'layer.initialize';\nconst TRACE_UPDATE = 'layer.update';\nconst TRACE_FINALIZE = 'layer.finalize';\nconst TRACE_MATCHED = 'layer.matched';\n\nconst MAX_PICKING_COLOR_CACHE_SIZE = 2 ** 24 - 1;\n\nconst EMPTY_ARRAY = Object.freeze([]);\n\n// Only compare the same two viewports once\nconst areViewportsEqual = memoize(({oldViewport, viewport}) => {\n  return oldViewport.equals(viewport);\n});\n\nlet pickingColorCache = new Uint8ClampedArray(0);\n\nconst defaultProps = {\n  // data: Special handling for null, see below\n  data: {type: 'data', value: EMPTY_ARRAY, async: true},\n  dataComparator: null,\n  _dataDiff: {type: 'function', value: data => data && data.__diff, compare: false, optional: true},\n  dataTransform: {type: 'function', value: null, compare: false, optional: true},\n  onDataLoad: {type: 'function', value: null, compare: false, optional: true},\n  onError: {type: 'function', value: null, compare: false, optional: true},\n  fetch: {\n    type: 'function',\n    value: (url, {propName, layer, loaders, loadOptions, signal}) => {\n      const {resourceManager} = layer.context;\n      loadOptions = loadOptions || layer.getLoadOptions();\n      loaders = loaders || layer.props.loaders;\n      if (signal) {\n        loadOptions = {\n          ...loadOptions,\n          fetch: {\n            ...loadOptions?.fetch,\n            signal\n          }\n        };\n      }\n\n      let inResourceManager = resourceManager.contains(url);\n\n      if (!inResourceManager && !loadOptions) {\n        // If there is no layer-specific load options, then attempt to cache this resource in the data manager\n        resourceManager.add({resourceId: url, data: load(url, loaders), persistent: false});\n        inResourceManager = true;\n      }\n      if (inResourceManager) {\n        return resourceManager.subscribe({\n          resourceId: url,\n          onChange: data => layer.internalState.reloadAsyncProp(propName, data),\n          consumerId: layer.id,\n          requestId: propName\n        });\n      }\n\n      return load(url, loaders, loadOptions);\n    },\n    compare: false\n  },\n  updateTriggers: {}, // Update triggers: a core change detection mechanism in deck.gl\n\n  visible: true,\n  pickable: false,\n  opacity: {type: 'number', min: 0, max: 1, value: 1},\n\n  onHover: {type: 'function', value: null, compare: false, optional: true},\n  onClick: {type: 'function', value: null, compare: false, optional: true},\n  onDragStart: {type: 'function', value: null, compare: false, optional: true},\n  onDrag: {type: 'function', value: null, compare: false, optional: true},\n  onDragEnd: {type: 'function', value: null, compare: false, optional: true},\n\n  coordinateSystem: COORDINATE_SYSTEM.DEFAULT,\n  coordinateOrigin: {type: 'array', value: [0, 0, 0], compare: true},\n  modelMatrix: {type: 'array', value: null, compare: true, optional: true},\n  wrapLongitude: false,\n  positionFormat: 'XYZ',\n  colorFormat: 'RGBA',\n\n  parameters: {},\n  transitions: null,\n  extensions: [],\n  loaders: {type: 'array', value: [], optional: true, compare: true},\n\n  // Offset depth based on layer index to avoid z-fighting.\n  // Negative values pull layer towards the camera\n  // https://www.opengl.org/archives/resources/faq/technical/polygonoffset.htm\n  getPolygonOffset: {\n    type: 'function',\n    value: ({layerIndex}) => [0, -layerIndex * 100],\n    compare: false\n  },\n\n  // Selection/Highlighting\n  highlightedObjectIndex: -1,\n  autoHighlight: false,\n  highlightColor: {type: 'accessor', value: [0, 0, 128, 128]}\n};\n\nexport default class Layer extends Component {\n  toString() {\n    const className = this.constructor.layerName || this.constructor.name;\n    return `${className}({id: '${this.props.id}'})`;\n  }\n\n  raiseError(error, message) {\n    if (message) {\n      error.message = `${message}: ${error.message}`;\n    }\n    if (!this.props.onError?.(error)) {\n      this.context?.onError?.(error, this);\n    }\n  }\n\n  // Public API\n\n  // Updates selected state members and marks the object for redraw\n  setState(updateObject) {\n    this.setChangeFlags({stateChanged: true});\n    Object.assign(this.state, updateObject);\n    this.setNeedsRedraw();\n  }\n\n  // Sets the redraw flag for this layer, will trigger a redraw next animation frame\n  setNeedsRedraw(redraw = true) {\n    if (this.internalState) {\n      this.internalState.needsRedraw = redraw;\n    }\n  }\n\n  // This layer needs a deep update\n  setNeedsUpdate() {\n    this.context.layerManager.setNeedsUpdate(String(this));\n    this.internalState.needsUpdate = true;\n  }\n\n  // Checks state of attributes and model\n  getNeedsRedraw(opts = {clearRedrawFlags: false}) {\n    return this._getNeedsRedraw(opts);\n  }\n\n  // Checks if layer attributes needs updating\n  needsUpdate() {\n    // Call subclass lifecycle method\n    return (\n      this.internalState.needsUpdate ||\n      this.hasUniformTransition() ||\n      this.shouldUpdateState(this._getUpdateParams())\n    );\n    // End lifecycle method\n  }\n\n  hasUniformTransition() {\n    return this.internalState.uniformTransitions.active;\n  }\n\n  get isLoaded() {\n    return this.internalState && !this.internalState.isAsyncPropLoading();\n  }\n\n  get wrapLongitude() {\n    return this.props.wrapLongitude;\n  }\n\n  // Returns true if the layer is pickable and visible.\n  isPickable() {\n    return this.props.pickable && this.props.visible;\n  }\n\n  // Return an array of models used by this layer, can be overriden by layer subclass\n  getModels() {\n    return this.state && (this.state.models || (this.state.model ? [this.state.model] : []));\n  }\n\n  getAttributeManager() {\n    return this.internalState && this.internalState.attributeManager;\n  }\n\n  // Returns the most recent layer that matched to this state\n  // (When reacting to an async event, this layer may no longer be the latest)\n  getCurrentLayer() {\n    return this.internalState && this.internalState.layer;\n  }\n\n  // Returns the default parse options for async props\n  getLoadOptions() {\n    return this.props.loadOptions;\n  }\n\n  // PROJECTION METHODS\n\n  // Projects a point with current map state (lat, lon, zoom, pitch, bearing)\n  // From the current layer's coordinate system to screen\n  project(xyz) {\n    const {viewport} = this.context;\n    const worldPosition = getWorldPosition(xyz, {\n      viewport,\n      modelMatrix: this.props.modelMatrix,\n      coordinateOrigin: this.props.coordinateOrigin,\n      coordinateSystem: this.props.coordinateSystem\n    });\n    const [x, y, z] = worldToPixels(worldPosition, viewport.pixelProjectionMatrix);\n    return xyz.length === 2 ? [x, y] : [x, y, z];\n  }\n\n  // Note: this does not reverse `project`.\n  // Always unprojects to the viewport's coordinate system\n  unproject(xy) {\n    const {viewport} = this.context;\n    return viewport.unproject(xy);\n  }\n\n  projectPosition(xyz) {\n    return projectPosition(xyz, {\n      viewport: this.context.viewport,\n      modelMatrix: this.props.modelMatrix,\n      coordinateOrigin: this.props.coordinateOrigin,\n      coordinateSystem: this.props.coordinateSystem\n    });\n  }\n\n  use64bitPositions() {\n    const {coordinateSystem} = this.props;\n    return (\n      coordinateSystem === COORDINATE_SYSTEM.DEFAULT ||\n      coordinateSystem === COORDINATE_SYSTEM.LNGLAT ||\n      coordinateSystem === COORDINATE_SYSTEM.CARTESIAN\n    );\n  }\n\n  // Event handling\n  onHover(info, pickingEvent) {\n    if (this.props.onHover) {\n      return this.props.onHover(info, pickingEvent);\n    }\n    return false;\n  }\n\n  onClick(info, pickingEvent) {\n    if (this.props.onClick) {\n      return this.props.onClick(info, pickingEvent);\n    }\n    return false;\n  }\n\n  // Returns the picking color that doesn't match any subfeature\n  // Use if some graphics do not belong to any pickable subfeature\n  // @return {Array} - a black color\n  nullPickingColor() {\n    return [0, 0, 0];\n  }\n\n  // Returns the picking color that doesn't match any subfeature\n  // Use if some graphics do not belong to any pickable subfeature\n  encodePickingColor(i, target = []) {\n    target[0] = (i + 1) & 255;\n    target[1] = ((i + 1) >> 8) & 255;\n    target[2] = (((i + 1) >> 8) >> 8) & 255;\n    return target;\n  }\n\n  // Returns the index corresponding to a picking color that doesn't match any subfeature\n  // @param {Uint8Array} color - color array to be decoded\n  // @return {Array} - the decoded picking color\n  decodePickingColor(color) {\n    assert(color instanceof Uint8Array);\n    const [i1, i2, i3] = color;\n    // 1 was added to seperate from no selection\n    const index = i1 + i2 * 256 + i3 * 65536 - 1;\n    return index;\n  }\n\n  // //////////////////////////////////////////////////\n  // LIFECYCLE METHODS, overridden by the layer subclasses\n\n  // Called once to set up the initial state\n  // App can create WebGL resources\n  initializeState() {\n    throw new Error(`Layer ${this} has not defined initializeState`);\n  }\n\n  getShaders(shaders) {\n    for (const extension of this.props.extensions) {\n      shaders = mergeShaders(shaders, extension.getShaders.call(this, extension));\n    }\n    return shaders;\n  }\n\n  // Let's layer control if updateState should be called\n  shouldUpdateState({oldProps, props, context, changeFlags}) {\n    return changeFlags.propsOrDataChanged;\n  }\n\n  // Default implementation, all attributes will be invalidated and updated\n  // when data changes\n  /* eslint-disable-next-line complexity */\n  updateState({oldProps, props, context, changeFlags}) {\n    const attributeManager = this.getAttributeManager();\n    if (changeFlags.dataChanged && attributeManager) {\n      const {dataChanged} = changeFlags;\n      if (Array.isArray(dataChanged)) {\n        // is partial update\n        for (const dataRange of dataChanged) {\n          attributeManager.invalidateAll(dataRange);\n        }\n      } else {\n        attributeManager.invalidateAll();\n      }\n    }\n\n    const neededPickingBuffer = oldProps.highlightedObjectIndex >= 0 || oldProps.pickable;\n    const needPickingBuffer = props.highlightedObjectIndex >= 0 || props.pickable;\n    if (neededPickingBuffer !== needPickingBuffer && attributeManager) {\n      const {pickingColors, instancePickingColors} = attributeManager.attributes;\n      const pickingColorsAttribute = pickingColors || instancePickingColors;\n      if (pickingColorsAttribute) {\n        if (needPickingBuffer && pickingColorsAttribute.constant) {\n          pickingColorsAttribute.constant = false;\n          attributeManager.invalidate(pickingColorsAttribute.id);\n        }\n        if (!pickingColorsAttribute.value && !needPickingBuffer) {\n          pickingColorsAttribute.constant = true;\n          pickingColorsAttribute.value = [0, 0, 0];\n        }\n      }\n    }\n  }\n\n  // Called once when layer is no longer matched and state will be discarded\n  // App can destroy WebGL resources here\n  finalizeState() {\n    for (const model of this.getModels()) {\n      model.delete();\n    }\n    const attributeManager = this.getAttributeManager();\n    if (attributeManager) {\n      attributeManager.finalize();\n    }\n    this.context.resourceManager.unsubscribe({consumerId: this.id});\n    this.internalState.uniformTransitions.clear();\n    this.internalState.finalize();\n  }\n\n  // If state has a model, draw it with supplied uniforms\n  draw(opts) {\n    for (const model of this.getModels()) {\n      model.draw(opts);\n    }\n  }\n\n  // called to populate the info object that is passed to the event handler\n  // @return null to cancel event\n  getPickingInfo({info, mode}) {\n    const {index} = info;\n\n    if (index >= 0) {\n      // If props.data is an indexable array, get the object\n      if (Array.isArray(this.props.data)) {\n        info.object = this.props.data[index];\n      }\n    }\n\n    return info;\n  }\n\n  // END LIFECYCLE METHODS\n  // //////////////////////////////////////////////////\n\n  // INTERNAL METHODS\n  activateViewport(viewport) {\n    const oldViewport = this.internalState.viewport;\n    this.internalState.viewport = viewport;\n\n    if (!oldViewport || !areViewportsEqual({oldViewport, viewport})) {\n      this.setChangeFlags({viewportChanged: true});\n\n      if (this.isComposite) {\n        if (this.needsUpdate()) {\n          // Composite layers may add/remove sublayers on viewport change\n          // Because we cannot change the layers list during a draw cycle, we don't want to update sublayers right away\n          // This will not call update immediately, but mark the layerManager as needs update on the next frame\n          this.setNeedsUpdate();\n        }\n      } else {\n        this._update();\n      }\n    }\n  }\n\n  // Default implementation of attribute invalidation, can be redefined\n  invalidateAttribute(name = 'all', diffReason = '') {\n    const attributeManager = this.getAttributeManager();\n    if (!attributeManager) {\n      return;\n    }\n\n    if (name === 'all') {\n      attributeManager.invalidateAll();\n    } else {\n      attributeManager.invalidate(name);\n    }\n  }\n\n  updateAttributes(changedAttributes) {\n    for (const model of this.getModels()) {\n      this._setModelAttributes(model, changedAttributes);\n    }\n  }\n\n  // Calls attribute manager to update any WebGL attributes\n  _updateAttributes(props) {\n    const attributeManager = this.getAttributeManager();\n    if (!attributeManager) {\n      return;\n    }\n\n    // Figure out data length\n    const numInstances = this.getNumInstances(props);\n    const startIndices = this.getStartIndices(props);\n\n    attributeManager.update({\n      data: props.data,\n      numInstances,\n      startIndices,\n      props,\n      transitions: props.transitions,\n      buffers: props.data.attributes,\n      context: this,\n      // Don't worry about non-attribute props\n      ignoreUnknownAttributes: true\n    });\n\n    const changedAttributes = attributeManager.getChangedAttributes({clearChangedFlags: true});\n    this.updateAttributes(changedAttributes);\n  }\n\n  // Update attribute transitions. This is called in drawLayer, no model updates required.\n  _updateAttributeTransition() {\n    const attributeManager = this.getAttributeManager();\n    if (attributeManager) {\n      attributeManager.updateTransition();\n    }\n  }\n\n  // Update uniform (prop) transitions. This is called in updateState, may result in model updates.\n  _updateUniformTransition() {\n    const {uniformTransitions} = this.internalState;\n    if (uniformTransitions.active) {\n      // clone props\n      const propsInTransition = uniformTransitions.update();\n      const props = Object.create(this.props);\n      for (const key in propsInTransition) {\n        Object.defineProperty(props, key, {value: propsInTransition[key]});\n      }\n      return props;\n    }\n    return this.props;\n  }\n\n  calculateInstancePickingColors(attribute, {numInstances}) {\n    if (attribute.constant) {\n      return;\n    }\n\n    // calculateInstancePickingColors always generates the same sequence.\n    // pickingColorCache saves the largest generated sequence for reuse\n    const cacheSize = Math.floor(pickingColorCache.length / 3);\n\n    // Record when using the picking buffer cache, so that layers can always point at the most recently allocated cache\n    this.internalState.usesPickingColorCache = true;\n\n    if (cacheSize < numInstances) {\n      if (numInstances > MAX_PICKING_COLOR_CACHE_SIZE) {\n        log.warn(\n          'Layer has too many data objects. Picking might not be able to distinguish all objects.'\n        )();\n      }\n\n      pickingColorCache = typedArrayManager.allocate(pickingColorCache, numInstances, {\n        size: 3,\n        copy: true,\n        maxCount: Math.max(numInstances, MAX_PICKING_COLOR_CACHE_SIZE)\n      });\n\n      // If the attribute is larger than the cache, resize the cache and populate the missing chunk\n      const newCacheSize = Math.floor(pickingColorCache.length / 3);\n      const pickingColor = [];\n      for (let i = cacheSize; i < newCacheSize; i++) {\n        this.encodePickingColor(i, pickingColor);\n        pickingColorCache[i * 3 + 0] = pickingColor[0];\n        pickingColorCache[i * 3 + 1] = pickingColor[1];\n        pickingColorCache[i * 3 + 2] = pickingColor[2];\n      }\n    }\n\n    attribute.value = pickingColorCache.subarray(0, numInstances * 3);\n  }\n\n  _setModelAttributes(model, changedAttributes) {\n    const attributeManager = this.getAttributeManager();\n    const excludeAttributes = model.userData.excludeAttributes || {};\n    const shaderAttributes = attributeManager.getShaderAttributes(\n      changedAttributes,\n      excludeAttributes\n    );\n\n    model.setAttributes(shaderAttributes);\n  }\n\n  // Sets the picking color at the specified index to null picking color. Used for multi-depth picking.\n  // This method may be overriden by layer implementations\n  disablePickingIndex(objectIndex) {\n    this._disablePickingIndex(objectIndex);\n  }\n\n  _disablePickingIndex(objectIndex) {\n    const {pickingColors, instancePickingColors} = this.getAttributeManager().attributes;\n    const colors = pickingColors || instancePickingColors;\n\n    const start = colors.getVertexOffset(objectIndex);\n    const end = colors.getVertexOffset(objectIndex + 1);\n\n    // Fill the sub buffer with 0s\n    colors.buffer.subData({\n      data: new Uint8Array(end - start),\n      offset: start // 1 byte per element\n    });\n  }\n\n  restorePickingColors() {\n    const {pickingColors, instancePickingColors} = this.getAttributeManager().attributes;\n    const colors = pickingColors || instancePickingColors;\n    // The picking color cache may have been freed and then reallocated. This ensures we read from the currently allocated cache.\n    if (\n      this.internalState.usesPickingColorCache &&\n      colors.value.buffer !== pickingColorCache.buffer\n    ) {\n      colors.value = pickingColorCache.subarray(0, colors.value.length);\n    }\n    colors.updateSubBuffer({startOffset: 0});\n  }\n\n  // Deduces numer of instances. Intention is to support:\n  // - Explicit setting of numInstances\n  // - Auto-deduction for ES6 containers that define a size member\n  // - Auto-deduction for Classic Arrays via the built-in length attribute\n  // - Auto-deduction via arrays\n  getNumInstances(props) {\n    props = props || this.props;\n\n    // First Check if app has provided an explicit value\n    if (props.numInstances !== undefined) {\n      return props.numInstances;\n    }\n\n    // Second check if the layer has set its own value\n    if (this.state && this.state.numInstances !== undefined) {\n      return this.state.numInstances;\n    }\n\n    // Use container library to get a count for any ES6 container or object\n    return count(props.data);\n  }\n\n  // Buffer layout describes how many attribute values are packed for each data object\n  // The default (null) is one value each object.\n  // Some data formats (e.g. paths, polygons) have various length. Their buffer layout\n  //  is in the form of [L0, L1, L2, ...]\n  getStartIndices(props) {\n    props = props || this.props;\n\n    // First Check if startIndices is provided as an explicit value\n    if (props.startIndices !== undefined) {\n      return props.startIndices;\n    }\n\n    // Second check if the layer has set its own value\n    if (this.state && this.state.startIndices) {\n      return this.state.startIndices;\n    }\n\n    return null;\n  }\n\n  // LAYER MANAGER API\n  // Should only be called by the deck.gl LayerManager class\n\n  // Called by layer manager when a new layer is found\n  /* eslint-disable max-statements */\n  _initialize() {\n    debug(TRACE_INITIALIZE, this);\n\n    this._initState();\n\n    // Call subclass lifecycle methods\n    this.initializeState(this.context);\n    // Initialize extensions\n    for (const extension of this.props.extensions) {\n      extension.initializeState.call(this, this.context, extension);\n    }\n    // End subclass lifecycle methods\n\n    // initializeState callback tends to clear state\n    this.setChangeFlags({\n      dataChanged: true,\n      propsChanged: true,\n      viewportChanged: true,\n      extensionsChanged: true\n    });\n\n    this._updateState();\n  }\n\n  // Called by layer manager\n  // if this layer is new (not matched with an existing layer) oldProps will be empty object\n  _update() {\n    // Call subclass lifecycle method\n    const stateNeedsUpdate = this.needsUpdate();\n    // End lifecycle method\n    debug(TRACE_UPDATE, this, stateNeedsUpdate);\n\n    if (stateNeedsUpdate) {\n      this._updateState();\n    }\n  }\n\n  // Common code for _initialize and _update\n  _updateState() {\n    const currentProps = this.props;\n    const currentViewport = this.context.viewport;\n    const propsInTransition = this._updateUniformTransition();\n    this.internalState.propsInTransition = propsInTransition;\n    // Overwrite this.context.viewport during update to use the last activated viewport on this layer\n    // In multi-view applications, a layer may only be drawn in one of the views\n    // Which would make the \"active\" viewport different from the shared context\n    this.context.viewport = this.internalState.viewport || currentViewport;\n    // Overwrite this.props during update to use in-transition prop values\n    this.props = propsInTransition;\n\n    try {\n      const updateParams = this._getUpdateParams();\n      const oldModels = this.getModels();\n\n      // Safely call subclass lifecycle methods\n      if (this.context.gl) {\n        this.updateState(updateParams);\n      } else {\n        try {\n          this.updateState(updateParams);\n        } catch (error) {\n          // ignore error if gl context is missing\n        }\n      }\n      // Execute extension updates\n      for (const extension of this.props.extensions) {\n        extension.updateState.call(this, updateParams, extension);\n      }\n\n      const modelChanged = this.getModels()[0] !== oldModels[0];\n      this._updateModules(updateParams, modelChanged);\n      // End subclass lifecycle methods\n\n      if (this.isComposite) {\n        // Render or update previously rendered sublayers\n        this._renderLayers(updateParams);\n      } else {\n        this.setNeedsRedraw();\n        // Add any subclass attributes\n        this._updateAttributes(this.props);\n\n        // Note: Automatic instance count update only works for single layers\n        if (this.state.model) {\n          this.state.model.setInstanceCount(this.getNumInstances());\n        }\n      }\n    } finally {\n      // Restore shared context\n      this.context.viewport = currentViewport;\n      this.props = currentProps;\n      this.clearChangeFlags();\n      this.internalState.needsUpdate = false;\n      this.internalState.resetOldProps();\n    }\n  }\n  /* eslint-enable max-statements */\n\n  // Called by manager when layer is about to be disposed\n  // Note: not guaranteed to be called on application shutdown\n  _finalize() {\n    debug(TRACE_FINALIZE, this);\n\n    // Call subclass lifecycle method\n    this.finalizeState(this.context);\n    // Finalize extensions\n    for (const extension of this.props.extensions) {\n      extension.finalizeState.call(this, extension);\n    }\n  }\n\n  // Calculates uniforms\n  drawLayer({moduleParameters = null, uniforms = {}, parameters = {}}) {\n    this._updateAttributeTransition();\n\n    const currentProps = this.props;\n    // Overwrite this.props during redraw to use in-transition prop values\n    // `internalState.propsInTransition` could be missing if `updateState` failed\n    this.props = this.internalState.propsInTransition || currentProps;\n\n    const {opacity} = this.props;\n    // apply gamma to opacity to make it visually \"linear\"\n    uniforms.opacity = Math.pow(opacity, 1 / 2.2);\n\n    try {\n      // TODO/ib - hack move to luma Model.draw\n      if (moduleParameters) {\n        this.setModuleParameters(moduleParameters);\n      }\n\n      // Apply polygon offset to avoid z-fighting\n      // TODO - move to draw-layers\n      const {getPolygonOffset} = this.props;\n      const offsets = (getPolygonOffset && getPolygonOffset(uniforms)) || [0, 0];\n\n      setParameters(this.context.gl, {polygonOffset: offsets});\n\n      // Call subclass lifecycle method\n      withParameters(this.context.gl, parameters, () => {\n        const opts = {moduleParameters, uniforms, parameters, context: this.context};\n\n        // extensions\n        for (const extension of this.props.extensions) {\n          extension.draw.call(this, opts, extension);\n        }\n\n        this.draw(opts);\n      });\n    } finally {\n      this.props = currentProps;\n    }\n\n    // End lifecycle method\n  }\n\n  // Helper methods\n  getChangeFlags() {\n    return this.internalState.changeFlags;\n  }\n\n  // Dirty some change flags, will be handled by updateLayer\n  /* eslint-disable complexity */\n  setChangeFlags(flags) {\n    const {changeFlags} = this.internalState;\n\n    /* eslint-disable no-fallthrough, max-depth */\n    for (const key in flags) {\n      if (flags[key]) {\n        let flagChanged = false;\n        switch (key) {\n          case 'dataChanged':\n            // changeFlags.dataChanged may be `false`, a string (reason) or an array of ranges\n            if (Array.isArray(changeFlags[key])) {\n              changeFlags[key] = Array.isArray(flags[key])\n                ? changeFlags[key].concat(flags[key])\n                : flags[key];\n              flagChanged = true;\n            }\n\n          default:\n            if (!changeFlags[key]) {\n              changeFlags[key] = flags[key];\n              flagChanged = true;\n            }\n        }\n        if (flagChanged) {\n          debug(TRACE_CHANGE_FLAG, this, key, flags);\n        }\n      }\n    }\n    /* eslint-enable no-fallthrough, max-depth */\n\n    // Update composite flags\n    const propsOrDataChanged =\n      changeFlags.dataChanged ||\n      changeFlags.updateTriggersChanged ||\n      changeFlags.propsChanged ||\n      changeFlags.extensionsChanged;\n    changeFlags.propsOrDataChanged = propsOrDataChanged;\n    changeFlags.somethingChanged =\n      propsOrDataChanged || flags.viewportChanged || flags.stateChanged;\n  }\n  /* eslint-enable complexity */\n\n  // Clear all changeFlags, typically after an update\n  clearChangeFlags() {\n    this.internalState.changeFlags = {\n      // Primary changeFlags, can be strings stating reason for change\n      dataChanged: false,\n      propsChanged: false,\n      updateTriggersChanged: false,\n      viewportChanged: false,\n      stateChanged: false,\n      extensionsChanged: false,\n\n      // Derived changeFlags\n      propsOrDataChanged: false,\n      somethingChanged: false\n    };\n  }\n\n  // Compares the layers props with old props from a matched older layer\n  // and extracts change flags that describe what has change so that state\n  // can be update correctly with minimal effort\n  diffProps(newProps, oldProps) {\n    const changeFlags = diffProps(newProps, oldProps);\n\n    // iterate over changedTriggers\n    if (changeFlags.updateTriggersChanged) {\n      for (const key in changeFlags.updateTriggersChanged) {\n        if (changeFlags.updateTriggersChanged[key]) {\n          this.invalidateAttribute(key);\n        }\n      }\n    }\n\n    // trigger uniform transitions\n    if (changeFlags.transitionsChanged) {\n      for (const key in changeFlags.transitionsChanged) {\n        // prop changed and transition is enabled\n        this.internalState.uniformTransitions.add(\n          key,\n          oldProps[key],\n          newProps[key],\n          newProps.transitions[key]\n        );\n      }\n    }\n\n    return this.setChangeFlags(changeFlags);\n  }\n\n  // Called by layer manager to validate props (in development)\n  validateProps() {\n    validateProps(this.props);\n  }\n\n  setModuleParameters(moduleParameters) {\n    for (const model of this.getModels()) {\n      model.updateModuleSettings(moduleParameters);\n    }\n  }\n\n  updateAutoHighlight(info) {\n    if (this.props.autoHighlight) {\n      this._updateAutoHighlight(info);\n    }\n  }\n\n  // May be overriden by classes\n  _updateAutoHighlight(info) {\n    const pickingModuleParameters = {\n      pickingSelectedColor: info.picked ? info.color : null\n    };\n    const {highlightColor} = this.props;\n    if (info.picked && typeof highlightColor === 'function') {\n      pickingModuleParameters.pickingHighlightColor = highlightColor(info);\n    }\n    this.setModuleParameters(pickingModuleParameters);\n    // setModuleParameters does not trigger redraw\n    this.setNeedsRedraw();\n  }\n\n  // PRIVATE METHODS\n  _updateModules({props, oldProps}, forceUpdate) {\n    // Picking module parameters\n    const {autoHighlight, highlightedObjectIndex, highlightColor} = props;\n    if (\n      forceUpdate ||\n      oldProps.autoHighlight !== autoHighlight ||\n      oldProps.highlightedObjectIndex !== highlightedObjectIndex ||\n      oldProps.highlightColor !== highlightColor\n    ) {\n      const parameters = {};\n      if (!autoHighlight) {\n        parameters.pickingSelectedColor = null;\n      }\n      if (Array.isArray(highlightColor)) {\n        parameters.pickingHighlightColor = highlightColor;\n      }\n\n      // highlightedObjectIndex will overwrite any settings from auto highlighting.\n      if (Number.isInteger(highlightedObjectIndex)) {\n        parameters.pickingSelectedColor =\n          highlightedObjectIndex >= 0 ? this.encodePickingColor(highlightedObjectIndex) : null;\n      }\n\n      this.setModuleParameters(parameters);\n    }\n  }\n\n  _getUpdateParams() {\n    return {\n      props: this.props,\n      oldProps: this.internalState.getOldProps(),\n      context: this.context,\n      changeFlags: this.internalState.changeFlags\n    };\n  }\n\n  // Checks state of attributes and model\n  _getNeedsRedraw(opts) {\n    // this method may be called by the render loop as soon a the layer\n    // has been created, so guard against uninitialized state\n    if (!this.internalState) {\n      return false;\n    }\n\n    let redraw = false;\n    redraw = redraw || (this.internalState.needsRedraw && this.id);\n    this.internalState.needsRedraw = this.internalState.needsRedraw && !opts.clearRedrawFlags;\n\n    // TODO - is attribute manager needed? - Model should be enough.\n    const attributeManager = this.getAttributeManager();\n    const attributeManagerNeedsRedraw = attributeManager && attributeManager.getNeedsRedraw(opts);\n    redraw = redraw || attributeManagerNeedsRedraw;\n\n    return redraw;\n  }\n\n  // Create new attribute manager\n  _getAttributeManager() {\n    return new AttributeManager(this.context.gl, {\n      id: this.props.id,\n      stats: this.context.stats,\n      timeline: this.context.timeline\n    });\n  }\n\n  _initState() {\n    assert(!this.internalState && !this.state); // finalized layer cannot be reused\n    assert(isFinite(this.props.coordinateSystem)); // invalid coordinateSystem\n\n    const attributeManager = this._getAttributeManager();\n\n    if (attributeManager) {\n      // All instanced layers get instancePickingColors attribute by default\n      // Their shaders can use it to render a picking scene\n      // TODO - this slightly slows down non instanced layers\n      attributeManager.addInstanced({\n        instancePickingColors: {\n          type: GL.UNSIGNED_BYTE,\n          size: 3,\n          noAlloc: true,\n          update: this.calculateInstancePickingColors\n        }\n      });\n    }\n\n    this.internalState = new LayerState({\n      attributeManager,\n      layer: this\n    });\n    this.clearChangeFlags(); // populate this.internalState.changeFlags\n\n    this.state = {};\n    // for backwards compatibility with older layers\n    // TODO - remove in next release\n    /* eslint-disable accessor-pairs */\n    Object.defineProperty(this.state, 'attributeManager', {\n      get: () => {\n        log.deprecated('layer.state.attributeManager', 'layer.getAttributeManager()');\n        return attributeManager;\n      }\n    });\n    /* eslint-enable accessor-pairs */\n\n    this.internalState.layer = this;\n    this.internalState.uniformTransitions = new UniformTransitionManager(this.context.timeline);\n    this.internalState.onAsyncPropUpdated = this._onAsyncPropUpdated.bind(this);\n\n    // Ensure any async props are updated\n    this.internalState.setAsyncProps(this.props);\n  }\n\n  // Called by layer manager to transfer state from an old layer\n  _transferState(oldLayer) {\n    debug(TRACE_MATCHED, this, this === oldLayer);\n\n    const {state, internalState} = oldLayer;\n\n    if (this === oldLayer) {\n      return;\n    }\n\n    // Move internalState\n    this.internalState = internalState;\n    this.internalState.layer = this;\n\n    // Move state\n    this.state = state;\n    // We keep the state ref on old layers to support async actions\n    // oldLayer.state = null;\n\n    // Ensure any async props are updated\n    this.internalState.setAsyncProps(this.props);\n\n    this.diffProps(this.props, this.internalState.getOldProps());\n  }\n\n  _onAsyncPropUpdated() {\n    this.diffProps(this.props, this.internalState.getOldProps());\n    this.setNeedsUpdate();\n  }\n}\n\nLayer.layerName = 'Layer';\nLayer.defaultProps = defaultProps;\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/* eslint-disable guard-for-in */\nimport Attribute from './attribute';\nimport log from '../../utils/log';\nimport debug from '../../debug';\n\nimport AttributeTransitionManager from './attribute-transition-manager';\n\nconst TRACE_INVALIDATE = 'attributeManager.invalidate';\nconst TRACE_UPDATE_START = 'attributeManager.updateStart';\nconst TRACE_UPDATE_END = 'attributeManager.updateEnd';\nconst TRACE_ATTRIBUTE_UPDATE_START = 'attribute.updateStart';\nconst TRACE_ATTRIBUTE_ALLOCATE = 'attribute.allocate';\nconst TRACE_ATTRIBUTE_UPDATE_END = 'attribute.updateEnd';\n\nexport default class AttributeManager {\n  /**\n   * @classdesc\n   * Automated attribute generation and management. Suitable when a set of\n   * vertex shader attributes are generated by iteration over a data array,\n   * and updates to these attributes are needed either when the data itself\n   * changes, or when other data relevant to the calculations change.\n   *\n   * - First the application registers descriptions of its dynamic vertex\n   *   attributes using AttributeManager.add().\n   * - Then, when any change that affects attributes is detected by the\n   *   application, the app will call AttributeManager.invalidate().\n   * - Finally before it renders, it calls AttributeManager.update() to\n   *   ensure that attributes are automatically rebuilt if anything has been\n   *   invalidated.\n   *\n   * The application provided update functions describe how attributes\n   * should be updated from a data array and are expected to traverse\n   * that data array (or iterable) and fill in the attribute's typed array.\n   *\n   * Note that the attribute manager intentionally does not do advanced\n   * change detection, but instead makes it easy to build such detection\n   * by offering the ability to \"invalidate\" each attribute separately.\n   */\n  constructor(gl, {id = 'attribute-manager', stats, timeline} = {}) {\n    this.id = id;\n    this.gl = gl;\n\n    this.attributes = {};\n\n    this.updateTriggers = {};\n    this.accessors = {};\n    this.needsRedraw = true;\n\n    this.userData = {};\n    this.stats = stats;\n\n    this.attributeTransitionManager = new AttributeTransitionManager(gl, {\n      id: `${id}-transitions`,\n      timeline\n    });\n\n    // For debugging sanity, prevent uninitialized members\n    Object.seal(this);\n  }\n\n  finalize() {\n    for (const attributeName in this.attributes) {\n      this.attributes[attributeName].delete();\n    }\n    this.attributeTransitionManager.finalize();\n  }\n\n  // Returns the redraw flag, optionally clearing it.\n  // Redraw flag will be set if any attributes attributes changed since\n  // flag was last cleared.\n  //\n  // @param {String} [clearRedrawFlags=false] - whether to clear the flag\n  // @return {false|String} - reason a redraw is needed.\n  getNeedsRedraw(opts = {clearRedrawFlags: false}) {\n    const redraw = this.needsRedraw;\n    this.needsRedraw = this.needsRedraw && !opts.clearRedrawFlags;\n    return redraw && this.id;\n  }\n\n  // Sets the redraw flag.\n  // @param {Boolean} redraw=true\n  // @return {AttributeManager} - for chaining\n  setNeedsRedraw(redraw = true) {\n    this.needsRedraw = true;\n    return this;\n  }\n\n  // Adds attributes\n  add(attributes, updaters) {\n    this._add(attributes, updaters);\n  }\n\n  // Adds attributes\n  addInstanced(attributes, updaters) {\n    this._add(attributes, updaters, {instanced: 1});\n  }\n\n  /**\n   * Removes attributes\n   * Takes an array of attribute names and delete them from\n   * the attribute map if they exists\n   *\n   * @example\n   * attributeManager.remove(['position']);\n   *\n   * @param {Object} attributeNameArray - attribute name array (see above)\n   */\n  remove(attributeNameArray) {\n    for (let i = 0; i < attributeNameArray.length; i++) {\n      const name = attributeNameArray[i];\n      if (this.attributes[name] !== undefined) {\n        this.attributes[name].delete();\n        delete this.attributes[name];\n      }\n    }\n  }\n\n  // Marks an attribute for update\n  invalidate(triggerName, dataRange) {\n    const invalidatedAttributes = this._invalidateTrigger(triggerName, dataRange);\n    // For performance tuning\n    debug(TRACE_INVALIDATE, this, triggerName, invalidatedAttributes);\n  }\n\n  invalidateAll(dataRange) {\n    for (const attributeName in this.attributes) {\n      this.attributes[attributeName].setNeedsUpdate(attributeName, dataRange);\n    }\n    // For performance tuning\n    debug(TRACE_INVALIDATE, this, 'all');\n  }\n\n  // Ensure all attribute buffers are updated from props or data.\n  update({\n    data,\n    numInstances,\n    startIndices = null,\n    transitions,\n    props = {},\n    buffers = {},\n    context = {}\n  } = {}) {\n    // keep track of whether some attributes are updated\n    let updated = false;\n\n    debug(TRACE_UPDATE_START, this);\n    if (this.stats) {\n      this.stats.get('Update Attributes').timeStart();\n    }\n\n    for (const attributeName in this.attributes) {\n      const attribute = this.attributes[attributeName];\n      const accessorName = attribute.settings.accessor;\n      attribute.startIndices = startIndices;\n\n      if (props[attributeName]) {\n        log.removed(`props.${attributeName}`, `data.attributes.${attributeName}`)();\n      }\n\n      if (attribute.setExternalBuffer(buffers[attributeName])) {\n        // Step 1: try update attribute directly from external buffers\n      } else if (attribute.setBinaryValue(buffers[accessorName], data.startIndices)) {\n        // Step 2: try set packed value from external typed array\n      } else if (!buffers[accessorName] && attribute.setConstantValue(props[accessorName])) {\n        // Step 3: try set constant value from props\n        // Note: if buffers[accessorName] is supplied, ignore props[accessorName]\n        // This may happen when setBinaryValue falls through to use the auto updater\n      } else if (attribute.needsUpdate()) {\n        // Step 4: update via updater callback\n        updated = true;\n        this._updateAttribute({\n          attribute,\n          numInstances,\n          data,\n          props,\n          context\n        });\n      }\n\n      this.needsRedraw |= attribute.needsRedraw();\n    }\n\n    if (updated) {\n      // Only initiate alloc/update (and logging) if actually needed\n      debug(TRACE_UPDATE_END, this, numInstances);\n    }\n\n    if (this.stats) {\n      this.stats.get('Update Attributes').timeEnd();\n    }\n\n    this.attributeTransitionManager.update({\n      attributes: this.attributes,\n      numInstances,\n      transitions\n    });\n  }\n\n  // Update attribute transition to the current timestamp\n  // Returns `true` if any transition is in progress\n  updateTransition() {\n    const {attributeTransitionManager} = this;\n    const transitionUpdated = attributeTransitionManager.run();\n    this.needsRedraw = this.needsRedraw || transitionUpdated;\n    return transitionUpdated;\n  }\n\n  /**\n   * Returns all attribute descriptors\n   * Note: Format matches luma.gl Model/Program.setAttributes()\n   * @return {Object} attributes - descriptors\n   */\n  getAttributes() {\n    return this.attributes;\n  }\n\n  /**\n   * Returns changed attribute descriptors\n   * This indicates which WebGLBuffers need to be updated\n   * @return {Object} attributes - descriptors\n   */\n  getChangedAttributes(opts = {clearChangedFlags: false}) {\n    const {attributes, attributeTransitionManager} = this;\n\n    const changedAttributes = {...attributeTransitionManager.getAttributes()};\n\n    for (const attributeName in attributes) {\n      const attribute = attributes[attributeName];\n      if (attribute.needsRedraw(opts) && !attributeTransitionManager.hasAttribute(attributeName)) {\n        changedAttributes[attributeName] = attribute;\n      }\n    }\n\n    return changedAttributes;\n  }\n\n  // Returns shader attributes\n  getShaderAttributes(attributes, excludeAttributes = {}) {\n    if (!attributes) {\n      attributes = this.getAttributes();\n    }\n    const shaderAttributes = {};\n    for (const attributeName in attributes) {\n      if (!excludeAttributes[attributeName]) {\n        Object.assign(shaderAttributes, attributes[attributeName].getShaderAttributes());\n      }\n    }\n    return shaderAttributes;\n  }\n\n  // PROTECTED METHODS - Only to be used by collaborating classes, not by apps\n\n  // Returns object containing all accessors as keys, with non-null values\n  // @return {Object} - accessors object\n  getAccessors() {\n    return this.updateTriggers;\n  }\n\n  // PRIVATE METHODS\n\n  // Used to register an attribute\n  _add(attributes, updaters, extraProps = {}) {\n    if (updaters) {\n      log.warn('AttributeManager.add({updaters}) - updater map no longer supported')();\n    }\n\n    for (const attributeName in attributes) {\n      const attribute = attributes[attributeName];\n\n      // Initialize the attribute descriptor, with WebGL and metadata fields\n      this.attributes[attributeName] = this._createAttribute(attributeName, attribute, extraProps);\n    }\n\n    this._mapUpdateTriggersToAttributes();\n  }\n  /* eslint-enable max-statements */\n\n  _createAttribute(name, attribute, extraProps) {\n    // For expected default values see:\n    // https://github.com/visgl/luma.gl/blob/1affe21352e289eeaccee2a876865138858a765c/modules/webgl/src/classes/accessor.js#L5-L13\n    // and https://deck.gl/docs/api-reference/core/attribute-manager#add\n    const props = {\n      ...attribute,\n      id: name,\n      isIndexed: attribute.isIndexed || attribute.elements || false,\n      // Luma fields\n      constant: attribute.constant || false,\n      size: (attribute.elements && 1) || attribute.size || 1,\n      value: attribute.value || null,\n      divisor: attribute.instanced || extraProps.instanced ? 1 : attribute.divisor || 0\n    };\n\n    return new Attribute(this.gl, props);\n  }\n\n  // build updateTrigger name to attribute name mapping\n  _mapUpdateTriggersToAttributes() {\n    const triggers = {};\n\n    for (const attributeName in this.attributes) {\n      const attribute = this.attributes[attributeName];\n      attribute.getUpdateTriggers().forEach(triggerName => {\n        if (!triggers[triggerName]) {\n          triggers[triggerName] = [];\n        }\n        triggers[triggerName].push(attributeName);\n      });\n    }\n\n    this.updateTriggers = triggers;\n  }\n\n  _invalidateTrigger(triggerName, dataRange) {\n    const {attributes, updateTriggers} = this;\n    const invalidatedAttributes = updateTriggers[triggerName];\n\n    if (invalidatedAttributes) {\n      invalidatedAttributes.forEach(name => {\n        const attribute = attributes[name];\n        if (attribute) {\n          attribute.setNeedsUpdate(attribute.id, dataRange);\n        }\n      });\n    }\n    return invalidatedAttributes;\n  }\n\n  _updateAttribute(opts) {\n    const {attribute, numInstances} = opts;\n    debug(TRACE_ATTRIBUTE_UPDATE_START, attribute);\n\n    if (attribute.constant) {\n      // The attribute is flagged as constant outside of an update cycle\n      // Skip allocation and updater call\n      attribute.setConstantValue(attribute.value);\n      return;\n    }\n\n    if (attribute.allocate(numInstances)) {\n      debug(TRACE_ATTRIBUTE_ALLOCATE, attribute, numInstances);\n    }\n\n    // Calls update on any buffers that need update\n    const updated = attribute.updateBuffer(opts);\n    if (updated) {\n      this.needsRedraw = true;\n      debug(TRACE_ATTRIBUTE_UPDATE_END, attribute, numInstances);\n    }\n  }\n}\n","/* eslint-disable complexity */\nimport DataColumn from './data-column';\nimport assert from '../../utils/assert';\nimport {createIterable, getAccessorFromBuffer} from '../../utils/iterable-utils';\nimport {fillArray} from '../../utils/flatten';\nimport * as range from '../../utils/range';\nimport {normalizeTransitionSettings} from './attribute-transition-utils';\n\nexport default class Attribute extends DataColumn {\n  constructor(gl, opts = {}) {\n    super(gl, opts);\n\n    const {\n      // deck.gl fields\n      transition = false,\n      noAlloc = false,\n      update = null,\n      accessor = null,\n      transform = null,\n      startIndices = null\n    } = opts;\n\n    Object.assign(this.settings, {\n      transition,\n      noAlloc,\n      update: update || (accessor && this._autoUpdater),\n      accessor,\n      transform\n    });\n\n    Object.assign(this.state, {\n      lastExternalBuffer: null,\n      binaryValue: null,\n      binaryAccessor: null,\n      needsUpdate: true,\n      needsRedraw: false,\n      updateRanges: range.FULL,\n      startIndices\n    });\n\n    Object.seal(this.settings);\n    Object.seal(this.state);\n\n    // Check all fields and generate helpful error messages\n    this._validateAttributeUpdaters();\n  }\n\n  get startIndices() {\n    return this.state.startIndices;\n  }\n\n  set startIndices(layout) {\n    this.state.startIndices = layout;\n  }\n\n  needsUpdate() {\n    return this.state.needsUpdate;\n  }\n\n  needsRedraw({clearChangedFlags = false} = {}) {\n    const needsRedraw = this.state.needsRedraw;\n    this.state.needsRedraw = needsRedraw && !clearChangedFlags;\n    return needsRedraw;\n  }\n\n  getUpdateTriggers() {\n    const {accessor} = this.settings;\n\n    // Backards compatibility: allow attribute name to be used as update trigger key\n    return [this.id].concat((typeof accessor !== 'function' && accessor) || []);\n  }\n\n  supportsTransition() {\n    return Boolean(this.settings.transition);\n  }\n\n  // Resolve transition settings object if transition is enabled, otherwise `null`\n  getTransitionSetting(opts) {\n    if (!opts || !this.supportsTransition()) {\n      return null;\n    }\n    const {accessor} = this.settings;\n    // TODO: have the layer resolve these transition settings itself?\n    const layerSettings = this.settings.transition;\n    // these are the transition settings passed in by the user\n    const userSettings = Array.isArray(accessor)\n      ? opts[accessor.find(a => opts[a])]\n      : opts[accessor];\n\n    // Shorthand: use duration instead of parameter object\n    return normalizeTransitionSettings(userSettings, layerSettings);\n  }\n\n  setNeedsUpdate(reason = this.id, dataRange) {\n    this.state.needsUpdate = this.state.needsUpdate || reason;\n    this.setNeedsRedraw(reason);\n    if (dataRange) {\n      const {startRow = 0, endRow = Infinity} = dataRange;\n      this.state.updateRanges = range.add(this.state.updateRanges, [startRow, endRow]);\n    } else {\n      this.state.updateRanges = range.FULL;\n    }\n  }\n\n  clearNeedsUpdate() {\n    this.state.needsUpdate = false;\n    this.state.updateRanges = range.EMPTY;\n  }\n\n  setNeedsRedraw(reason = this.id) {\n    this.state.needsRedraw = this.state.needsRedraw || reason;\n  }\n\n  update(opts) {\n    // backward compatibility\n    this.setData(opts);\n  }\n\n  allocate(numInstances) {\n    const {state, settings} = this;\n\n    if (settings.noAlloc) {\n      // Data is provided through a Buffer object.\n      return false;\n    }\n\n    if (settings.update) {\n      super.allocate({\n        numInstances,\n        copy: state.updateRanges !== range.FULL\n      });\n      return true;\n    }\n\n    return false;\n  }\n\n  updateBuffer({numInstances, data, props, context}) {\n    if (!this.needsUpdate()) {\n      return false;\n    }\n\n    const {\n      state: {updateRanges},\n      settings: {update, noAlloc}\n    } = this;\n\n    let updated = true;\n    if (update) {\n      // Custom updater - typically for non-instanced layers\n      for (const [startRow, endRow] of updateRanges) {\n        update.call(context, this, {data, startRow, endRow, props, numInstances});\n      }\n      if (!this.value) {\n        // no value was assigned during update\n      } else if (\n        this.constant ||\n        this.buffer.byteLength < this.value.byteLength + this.byteOffset\n      ) {\n        this.setData({\n          value: this.value,\n          constant: this.constant\n        });\n        // Setting attribute.constant in updater is a legacy approach that interferes with allocation in the next cycle\n        // Respect it here but reset after use\n        this.constant = false;\n      } else {\n        for (const [startRow, endRow] of updateRanges) {\n          const startOffset = Number.isFinite(startRow) ? this.getVertexOffset(startRow) : 0;\n          const endOffset = Number.isFinite(endRow)\n            ? this.getVertexOffset(endRow)\n            : noAlloc || !Number.isFinite(numInstances)\n              ? this.value.length\n              : numInstances * this.size;\n\n          super.updateSubBuffer({startOffset, endOffset});\n        }\n      }\n      this._checkAttributeArray();\n    } else {\n      updated = false;\n    }\n\n    this.clearNeedsUpdate();\n    this.setNeedsRedraw();\n\n    return updated;\n  }\n\n  // Use generic value\n  // Returns true if successful\n  setConstantValue(value) {\n    if (value === undefined || typeof value === 'function') {\n      return false;\n    }\n\n    const hasChanged = this.setData({constant: true, value});\n\n    if (hasChanged) {\n      this.setNeedsRedraw();\n    }\n    this.clearNeedsUpdate();\n    return true;\n  }\n\n  // Use external buffer\n  // Returns true if successful\n  // eslint-disable-next-line max-statements\n  setExternalBuffer(buffer) {\n    const {state} = this;\n\n    if (!buffer) {\n      state.lastExternalBuffer = null;\n      return false;\n    }\n\n    this.clearNeedsUpdate();\n\n    if (state.lastExternalBuffer === buffer) {\n      return true;\n    }\n    state.lastExternalBuffer = buffer;\n    this.setNeedsRedraw();\n    this.setData(buffer);\n    return true;\n  }\n\n  // Binary value is a typed array packed from mapping the source data with the accessor\n  // If the returned value from the accessor is the same as the attribute value, set it directly\n  // Otherwise use the auto updater for transform/normalization\n  setBinaryValue(buffer, startIndices = null) {\n    const {state, settings} = this;\n\n    if (!buffer) {\n      state.binaryValue = null;\n      state.binaryAccessor = null;\n      return false;\n    }\n\n    if (settings.noAlloc) {\n      // Let the layer handle this\n      return false;\n    }\n\n    if (state.binaryValue === buffer) {\n      this.clearNeedsUpdate();\n      return true;\n    }\n    state.binaryValue = buffer;\n    this.setNeedsRedraw();\n\n    if (ArrayBuffer.isView(buffer)) {\n      buffer = {value: buffer};\n    }\n    const needsUpdate = settings.transform || startIndices !== this.startIndices;\n\n    if (needsUpdate) {\n      assert(ArrayBuffer.isView(buffer.value), `invalid ${settings.accessor}`);\n      const needsNormalize = buffer.size && buffer.size !== this.size;\n\n      state.binaryAccessor = getAccessorFromBuffer(buffer.value, {\n        size: buffer.size || this.size,\n        stride: buffer.stride,\n        offset: buffer.offset,\n        startIndices,\n        nested: needsNormalize\n      });\n      // Fall through to auto updater\n      return false;\n    }\n\n    this.clearNeedsUpdate();\n    this.setData(buffer);\n    return true;\n  }\n\n  getVertexOffset(row) {\n    const {startIndices} = this;\n    const vertexIndex = startIndices ? startIndices[row] : row;\n    return vertexIndex * this.size;\n  }\n\n  getShaderAttributes() {\n    const shaderAttributeDefs = this.settings.shaderAttributes || {[this.id]: null};\n    const shaderAttributes = {};\n\n    for (const shaderAttributeName in shaderAttributeDefs) {\n      Object.assign(\n        shaderAttributes,\n        super.getShaderAttributes(shaderAttributeName, shaderAttributeDefs[shaderAttributeName])\n      );\n    }\n\n    return shaderAttributes;\n  }\n\n  /* eslint-disable max-depth, max-statements */\n  _autoUpdater(attribute, {data, startRow, endRow, props, numInstances}) {\n    if (attribute.constant) {\n      return;\n    }\n    const {settings, state, value, size, startIndices} = attribute;\n\n    const {accessor, transform} = settings;\n    const accessorFunc =\n      state.binaryAccessor || (typeof accessor === 'function' ? accessor : props[accessor]);\n\n    assert(typeof accessorFunc === 'function', `accessor \"${accessor}\" is not a function`);\n\n    let i = attribute.getVertexOffset(startRow);\n    const {iterable, objectInfo} = createIterable(data, startRow, endRow);\n    for (const object of iterable) {\n      objectInfo.index++;\n\n      let objectValue = accessorFunc(object, objectInfo);\n      if (transform) {\n        // transform callbacks could be bound to a particular layer instance.\n        // always point `this` to the current layer.\n        objectValue = transform.call(this, objectValue);\n      }\n\n      if (startIndices) {\n        const numVertices =\n          (objectInfo.index < startIndices.length - 1\n            ? startIndices[objectInfo.index + 1]\n            : numInstances) - startIndices[objectInfo.index];\n        if (objectValue && Array.isArray(objectValue[0])) {\n          let startIndex = i;\n          for (const item of objectValue) {\n            attribute._normalizeValue(item, value, startIndex);\n            startIndex += size;\n          }\n        } else if (objectValue && objectValue.length > size) {\n          value.set(objectValue, i);\n        } else {\n          attribute._normalizeValue(objectValue, objectInfo.target, 0);\n          fillArray({\n            target: value,\n            source: objectInfo.target,\n            start: i,\n            count: numVertices\n          });\n        }\n        i += numVertices * size;\n      } else {\n        attribute._normalizeValue(objectValue, value, i);\n        i += size;\n      }\n    }\n  }\n  /* eslint-enable max-depth, max-statements */\n\n  // Validate deck.gl level fields\n  _validateAttributeUpdaters() {\n    const {settings} = this;\n\n    // Check that 'update' is a valid function\n    const hasUpdater = settings.noAlloc || typeof settings.update === 'function';\n    if (!hasUpdater) {\n      throw new Error(`Attribute ${this.id} missing update or accessor`);\n    }\n  }\n\n  // check that the first few elements of the attribute are reasonable\n  /* eslint-disable no-fallthrough */\n  _checkAttributeArray() {\n    const {value} = this;\n    const limit = Math.min(4, this.size);\n    if (value && value.length >= limit) {\n      let valid = true;\n      switch (limit) {\n        case 4:\n          valid = valid && Number.isFinite(value[3]);\n        case 3:\n          valid = valid && Number.isFinite(value[2]);\n        case 2:\n          valid = valid && Number.isFinite(value[1]);\n        case 1:\n          valid = valid && Number.isFinite(value[0]);\n          break;\n        default:\n          valid = false;\n      }\n\n      if (!valid) {\n        throw new Error(`Illegal attribute generated for ${this.id}`);\n      }\n    }\n  }\n  /* eslint-enable no-fallthrough */\n}\n","/* eslint-disable complexity */\nimport GL from '@luma.gl/constants';\nimport {hasFeature, FEATURES, Buffer} from '@luma.gl/core';\nimport ShaderAttribute from './shader-attribute';\nimport {glArrayFromType} from './gl-utils';\nimport typedArrayManager from '../../utils/typed-array-manager';\nimport {toDoublePrecisionArray} from '../../utils/math-utils';\nimport log from '../../utils/log';\n\nfunction getStride(accessor) {\n  return accessor.stride || accessor.size * accessor.bytesPerElement;\n}\n\nfunction resolveShaderAttribute(baseAccessor, shaderAttributeOptions) {\n  if (shaderAttributeOptions.offset) {\n    log.removed('shaderAttribute.offset', 'vertexOffset, elementOffset')();\n  }\n\n  // All shader attributes share the parent's stride\n  const stride = getStride(baseAccessor);\n  // `vertexOffset` is used to access the neighboring vertex's value\n  // e.g. `nextPositions` in polygon\n  const vertexOffset =\n    'vertexOffset' in shaderAttributeOptions\n      ? shaderAttributeOptions.vertexOffset\n      : baseAccessor.vertexOffset || 0;\n  // `elementOffset` is defined when shader attribute's size is smaller than the parent's\n  // e.g. `translations` in transform matrix\n  const elementOffset = shaderAttributeOptions.elementOffset || 0;\n  const offset =\n    // offsets defined by the attribute\n    vertexOffset * stride +\n    elementOffset * baseAccessor.bytesPerElement +\n    // offsets defined by external buffers if any\n    (baseAccessor.offset || 0);\n\n  return {\n    ...shaderAttributeOptions,\n    offset,\n    stride\n  };\n}\n\nfunction resolveDoublePrecisionShaderAttributes(baseAccessor, shaderAttributeOptions) {\n  const resolvedOptions = resolveShaderAttribute(baseAccessor, shaderAttributeOptions);\n\n  return {\n    high: resolvedOptions,\n    low: {\n      ...resolvedOptions,\n      offset: resolvedOptions.offset + baseAccessor.size * 4\n    }\n  };\n}\n\nexport default class DataColumn {\n  /* eslint-disable max-statements */\n  constructor(gl, opts) {\n    this.gl = gl;\n    this.id = opts.id;\n    this.size = opts.size;\n\n    const logicalType = opts.logicalType || opts.type;\n    const doublePrecision = logicalType === GL.DOUBLE;\n\n    let {defaultValue} = opts;\n    defaultValue = Number.isFinite(defaultValue)\n      ? [defaultValue]\n      : defaultValue || new Array(this.size).fill(0);\n    opts.defaultValue = defaultValue;\n\n    let bufferType = logicalType;\n    if (doublePrecision) {\n      bufferType = GL.FLOAT;\n    } else if (!bufferType && opts.isIndexed) {\n      bufferType =\n        gl && hasFeature(gl, FEATURES.ELEMENT_INDEX_UINT32) ? GL.UNSIGNED_INT : GL.UNSIGNED_SHORT;\n    } else if (!bufferType) {\n      bufferType = GL.FLOAT;\n    }\n    opts.logicalType = logicalType;\n    opts.type = bufferType;\n\n    // This is the attribute type defined by the layer\n    // If an external buffer is provided, this.type may be overwritten\n    // But we always want to use defaultType for allocation\n    let defaultType = glArrayFromType(logicalType || bufferType || GL.FLOAT);\n    this.shaderAttributes = {};\n    this.doublePrecision = doublePrecision;\n\n    // `fp64: false` tells a double-precision attribute to allocate Float32Arrays\n    // by default when using auto-packing. This is more efficient in use cases where\n    // high precision is unnecessary, but the `64Low` attribute is still required\n    // by the shader.\n    if (doublePrecision && opts.fp64 === false) {\n      defaultType = Float32Array;\n    }\n    opts.bytesPerElement = defaultType.BYTES_PER_ELEMENT;\n\n    this.defaultType = defaultType;\n    this.value = null;\n    this.settings = opts;\n    this.state = {\n      externalBuffer: null,\n      bufferAccessor: opts,\n      allocatedValue: null,\n      constant: false\n    };\n    this._buffer = null;\n\n    this.setData(opts);\n  }\n  /* eslint-enable max-statements */\n\n  get buffer() {\n    if (!this._buffer) {\n      const {isIndexed, type} = this.settings;\n      this._buffer = new Buffer(this.gl, {\n        id: this.id,\n        target: isIndexed ? GL.ELEMENT_ARRAY_BUFFER : GL.ARRAY_BUFFER,\n        accessor: {type}\n      });\n    }\n    return this._buffer;\n  }\n\n  get byteOffset() {\n    const accessor = this.getAccessor();\n    if (accessor.vertexOffset) {\n      return accessor.vertexOffset * getStride(accessor);\n    }\n    return 0;\n  }\n\n  delete() {\n    if (this._buffer) {\n      this._buffer.delete();\n      this._buffer = null;\n    }\n    typedArrayManager.release(this.state.allocatedValue);\n  }\n\n  getShaderAttributes(id, options) {\n    if (this.doublePrecision) {\n      const shaderAttributes = {};\n      const isBuffer64Bit = this.value instanceof Float64Array;\n\n      const doubleShaderAttributeDefs = resolveDoublePrecisionShaderAttributes(\n        this.getAccessor(),\n        options || {}\n      );\n\n      shaderAttributes[id] = new ShaderAttribute(this, doubleShaderAttributeDefs.high);\n      shaderAttributes[`${id}64Low`] = isBuffer64Bit\n        ? new ShaderAttribute(this, doubleShaderAttributeDefs.low)\n        : new Float32Array(this.size); // use constant for low part if buffer is 32-bit\n      return shaderAttributes;\n    }\n    if (options) {\n      const shaderAttributeDef = resolveShaderAttribute(this.getAccessor(), options);\n      return {[id]: new ShaderAttribute(this, shaderAttributeDef)};\n    }\n    return {[id]: this};\n  }\n\n  getBuffer() {\n    if (this.state.constant) {\n      return null;\n    }\n    return this.state.externalBuffer || this._buffer;\n  }\n\n  getValue() {\n    if (this.state.constant) {\n      return this.value;\n    }\n    return [this.getBuffer(), this.getAccessor()];\n  }\n\n  getAccessor() {\n    return this.state.bufferAccessor;\n  }\n\n  // returns true if success\n  // eslint-disable-next-line max-statements\n  setData(opts) {\n    const {state} = this;\n    if (ArrayBuffer.isView(opts)) {\n      opts = {value: opts};\n    } else if (opts instanceof Buffer) {\n      opts = {buffer: opts};\n    }\n\n    const accessor = {...this.settings, ...opts};\n    state.bufferAccessor = accessor;\n\n    if (opts.constant) {\n      // set constant\n      let value = opts.value;\n      value = this._normalizeValue(value, [], 0);\n      if (this.settings.normalized) {\n        value = this._normalizeConstant(value);\n      }\n      const hasChanged = !state.constant || !this._areValuesEqual(value, this.value);\n\n      if (!hasChanged) {\n        return false;\n      }\n      state.externalBuffer = null;\n      state.constant = true;\n      this.value = value;\n    } else if (opts.buffer) {\n      const buffer = opts.buffer;\n      state.externalBuffer = buffer;\n      state.constant = false;\n      this.value = opts.value;\n      const isBuffer64Bit = opts.value instanceof Float64Array;\n\n      // Copy the type of the buffer into the accessor\n      accessor.type = opts.type || buffer.accessor.type;\n      accessor.bytesPerElement = buffer.accessor.BYTES_PER_ELEMENT * (isBuffer64Bit ? 2 : 1);\n      accessor.stride = getStride(accessor);\n    } else if (opts.value) {\n      this._checkExternalBuffer(opts);\n\n      let value = opts.value;\n      state.externalBuffer = null;\n      state.constant = false;\n      this.value = value;\n\n      accessor.bytesPerElement = value.BYTES_PER_ELEMENT;\n      accessor.stride = getStride(accessor);\n\n      const {buffer, byteOffset} = this;\n\n      if (this.doublePrecision && value instanceof Float64Array) {\n        value = toDoublePrecisionArray(value, accessor);\n      }\n\n      // A small over allocation is used as safety margin\n      // Shader attributes may try to access this buffer with bigger offsets\n      const requiredBufferSize = value.byteLength + byteOffset + accessor.stride * 2;\n      if (buffer.byteLength < requiredBufferSize) {\n        buffer.reallocate(requiredBufferSize);\n      }\n      // Hack: force Buffer to infer data type\n      buffer.setAccessor(null);\n      buffer.subData({data: value, offset: byteOffset});\n      accessor.type = opts.type || buffer.accessor.type;\n    }\n\n    return true;\n  }\n\n  updateSubBuffer(opts = {}) {\n    const {value} = this;\n    const {startOffset = 0, endOffset} = opts;\n    this.buffer.subData({\n      data:\n        this.doublePrecision && value instanceof Float64Array\n          ? toDoublePrecisionArray(value, {\n              size: this.size,\n              startIndex: startOffset,\n              endIndex: endOffset\n            })\n          : value.subarray(startOffset, endOffset),\n      offset: startOffset * value.BYTES_PER_ELEMENT + this.byteOffset\n    });\n  }\n\n  allocate({numInstances, copy = false}) {\n    const {state} = this;\n    const oldValue = state.allocatedValue;\n\n    // Allocate at least one element to ensure a valid buffer\n    const value = typedArrayManager.allocate(oldValue, numInstances + 1, {\n      size: this.size,\n      type: this.defaultType,\n      copy\n    });\n\n    this.value = value;\n\n    const {buffer, byteOffset} = this;\n\n    if (buffer.byteLength < value.byteLength + byteOffset) {\n      buffer.reallocate(value.byteLength + byteOffset);\n\n      if (copy && oldValue) {\n        // Upload the full existing attribute value to the GPU, so that updateBuffer\n        // can choose to only update a partial range.\n        // TODO - copy old buffer to new buffer on the GPU\n        buffer.subData({\n          data:\n            oldValue instanceof Float64Array ? toDoublePrecisionArray(oldValue, this) : oldValue,\n          offset: byteOffset\n        });\n      }\n    }\n\n    state.allocatedValue = value;\n    state.constant = false;\n    state.externalBuffer = null;\n    state.bufferAccessor = this.settings;\n    return true;\n  }\n\n  // PRIVATE HELPER METHODS\n  _checkExternalBuffer(opts) {\n    const {value} = opts;\n    if (!opts.constant && value) {\n      const ArrayType = this.defaultType;\n\n      let illegalArrayType = false;\n      if (this.doublePrecision) {\n        // not 32bit or 64bit\n        illegalArrayType = value.BYTES_PER_ELEMENT < 4;\n      }\n      if (illegalArrayType) {\n        throw new Error(`Attribute ${this.id} does not support ${value.constructor.name}`);\n      }\n      if (!(value instanceof ArrayType) && this.settings.normalized && !('normalized' in opts)) {\n        log.warn(`Attribute ${this.id} is normalized`)();\n      }\n    }\n  }\n\n  // https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/vertexAttribPointer\n  _normalizeConstant(value) {\n    switch (this.settings.type) {\n      case GL.BYTE:\n        // normalize [-128, 127] to [-1, 1]\n        return new Float32Array(value).map(x => ((x + 128) / 255) * 2 - 1);\n\n      case GL.SHORT:\n        // normalize [-32768, 32767] to [-1, 1]\n        return new Float32Array(value).map(x => ((x + 32768) / 65535) * 2 - 1);\n\n      case GL.UNSIGNED_BYTE:\n        // normalize [0, 255] to [0, 1]\n        return new Float32Array(value).map(x => x / 255);\n\n      case GL.UNSIGNED_SHORT:\n        // normalize [0, 65535] to [0, 1]\n        return new Float32Array(value).map(x => x / 65535);\n\n      default:\n        // No normalization for gl.FLOAT and gl.HALF_FLOAT\n        return value;\n    }\n  }\n\n  /* check user supplied values and apply fallback */\n  _normalizeValue(value, out, start) {\n    const {defaultValue, size} = this.settings;\n\n    if (Number.isFinite(value)) {\n      out[start] = value;\n      return out;\n    }\n    if (!value) {\n      out[start] = defaultValue[0];\n      return out;\n    }\n\n    // Important - switch cases are 5x more performant than a for loop!\n    /* eslint-disable no-fallthrough, default-case */\n    switch (size) {\n      case 4:\n        out[start + 3] = Number.isFinite(value[3]) ? value[3] : defaultValue[3];\n      case 3:\n        out[start + 2] = Number.isFinite(value[2]) ? value[2] : defaultValue[2];\n      case 2:\n        out[start + 1] = Number.isFinite(value[1]) ? value[1] : defaultValue[1];\n      case 1:\n        out[start + 0] = Number.isFinite(value[0]) ? value[0] : defaultValue[0];\n        break;\n\n      default:\n        // In the rare case where the attribute size > 4, do it the slow way\n        // This is used for e.g. transform matrices\n        let i = size;\n        while (--i >= 0) {\n          out[start + i] = Number.isFinite(value[i]) ? value[i] : defaultValue[i];\n        }\n    }\n\n    return out;\n  }\n\n  _areValuesEqual(value1, value2) {\n    if (!value1 || !value2) {\n      return false;\n    }\n    const {size} = this;\n    for (let i = 0; i < size; i++) {\n      if (value1[i] !== value2[i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n","/* eslint-disable complexity */\n\n/* This class creates a luma.gl-compatible \"view\" on top of a DataColumn instance */\nexport default class ShaderAttribute {\n  constructor(dataColumn, opts) {\n    // Options that cannot be changed later\n    this.opts = opts;\n    this.source = dataColumn;\n  }\n\n  get value() {\n    return this.source.value;\n  }\n\n  getValue() {\n    const buffer = this.source.getBuffer();\n    const accessor = this.getAccessor();\n    if (buffer) {\n      return [buffer, accessor];\n    }\n\n    const {value} = this.source;\n    const {size} = accessor;\n    let constantValue = value;\n\n    if (value && value.length !== size) {\n      constantValue = new Float32Array(size);\n      // initiate offset values\n      const index = accessor.elementOffset || 0; // element offset\n      for (let i = 0; i < size; ++i) {\n        constantValue[i] = value[index + i];\n      }\n    }\n\n    return constantValue;\n  }\n\n  getAccessor() {\n    return {\n      // source data accessor\n      ...this.source.getAccessor(),\n      // shader attribute overrides\n      ...this.opts\n    };\n  }\n}\n","import GL from '@luma.gl/constants';\n\n/* eslint-disable complexity */\nexport function glArrayFromType(glType) {\n  // Sorted in some order of likelihood to reduce amount of comparisons\n  switch (glType) {\n    case GL.FLOAT:\n      return Float32Array;\n    case GL.DOUBLE:\n      return Float64Array;\n    case GL.UNSIGNED_SHORT:\n    case GL.UNSIGNED_SHORT_5_6_5:\n    case GL.UNSIGNED_SHORT_4_4_4_4:\n    case GL.UNSIGNED_SHORT_5_5_5_1:\n      return Uint16Array;\n    case GL.UNSIGNED_INT:\n      return Uint32Array;\n    case GL.UNSIGNED_BYTE:\n      return Uint8ClampedArray;\n    case GL.BYTE:\n      return Int8Array;\n    case GL.SHORT:\n      return Int16Array;\n    case GL.INT:\n      return Int32Array;\n    default:\n      throw new Error('Unknown GL type');\n  }\n}\n/* eslint-enable complexity */\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nconst EMPTY_ARRAY = [];\nconst placeholderArray = [];\n\n/*\n * Create an Iterable\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols\n * and a \"context\" tracker from the given data\n */\nexport function createIterable(data, startRow = 0, endRow = Infinity) {\n  let iterable = EMPTY_ARRAY;\n\n  const objectInfo = {\n    index: -1,\n    data,\n    // visitor can optionally utilize this to avoid constructing a new array for every object\n    target: []\n  };\n\n  if (!data) {\n    iterable = EMPTY_ARRAY;\n  } else if (typeof data[Symbol.iterator] === 'function') {\n    // data is already an iterable\n    iterable = data;\n  } else if (data.length > 0) {\n    placeholderArray.length = data.length;\n    iterable = placeholderArray;\n  }\n\n  if (startRow > 0 || Number.isFinite(endRow)) {\n    iterable = (Array.isArray(iterable) ? iterable : Array.from(iterable)).slice(startRow, endRow);\n    objectInfo.index = startRow - 1;\n  }\n\n  return {iterable, objectInfo};\n}\n\n/*\n * Returns true if data is an async iterable object\n */\nexport function isAsyncIterable(data) {\n  return data && data[Symbol.asyncIterator];\n}\n\n/*\n * Create an accessor function from a flat buffer that yields the value at each object index\n */\nexport function getAccessorFromBuffer(typedArray, {size, stride, offset, startIndices, nested}) {\n  const bytesPerElement = typedArray.BYTES_PER_ELEMENT;\n  const elementStride = stride ? stride / bytesPerElement : size;\n  const elementOffset = offset ? offset / bytesPerElement : 0;\n  const vertexCount = Math.floor((typedArray.length - elementOffset) / elementStride);\n\n  return (_, {index, target}) => {\n    if (!startIndices) {\n      const sourceIndex = index * elementStride + elementOffset;\n      for (let j = 0; j < size; j++) {\n        target[j] = typedArray[sourceIndex + j];\n      }\n      return target;\n    }\n    const startIndex = startIndices[index];\n    const endIndex = startIndices[index + 1] || vertexCount;\n    let result;\n\n    if (nested) {\n      result = new Array(endIndex - startIndex);\n      for (let i = startIndex; i < endIndex; i++) {\n        const sourceIndex = i * elementStride + elementOffset;\n        target = new Array(size);\n        for (let j = 0; j < size; j++) {\n          target[j] = typedArray[sourceIndex + j];\n        }\n        result[i - startIndex] = target;\n      }\n    } else if (elementStride === size) {\n      result = typedArray.subarray(\n        startIndex * size + elementOffset,\n        endIndex * size + elementOffset\n      );\n    } else {\n      result = new typedArray.constructor((endIndex - startIndex) * size);\n      let targetIndex = 0;\n      for (let i = startIndex; i < endIndex; i++) {\n        const sourceIndex = i * elementStride + elementOffset;\n        for (let j = 0; j < size; j++) {\n          result[targetIndex++] = typedArray[sourceIndex + j];\n        }\n      }\n    }\n\n    return result;\n  };\n}\n","/* \n * range (Array)\n *   + start (Number) - the start index (incl.)\n *   + end (Number) - the end index (excl.)\n * rangeList (Array) - array of sorted, combined ranges\n */\nexport const EMPTY = [];\nexport const FULL = [[0, Infinity]];\n\n// Insert a range into a range collection\nexport function add(rangeList, range) {\n  // Noop if range collection already covers all\n  if (rangeList === FULL) {\n    return rangeList;\n  }\n\n  // Validate the input range\n  if (range[0] < 0) {\n    range[0] = 0;\n  }\n  if (range[0] >= range[1]) {\n    return rangeList;\n  }\n\n  // TODO - split off to tree-shakable Range class\n  const newRangeList = [];\n  const len = rangeList.length;\n  let insertPosition = 0;\n\n  for (let i = 0; i < len; i++) {\n    const range0 = rangeList[i];\n\n    if (range0[1] < range[0]) {\n      // the current range is to the left of the new range\n      newRangeList.push(range0);\n      insertPosition = i + 1;\n    } else if (range0[0] > range[1]) {\n      // the current range is to the right of the new range\n      newRangeList.push(range0);\n    } else {\n      range = [Math.min(range0[0], range[0]), Math.max(range0[1], range[1])];\n    }\n  }\n  newRangeList.splice(insertPosition, 0, range);\n  return newRangeList;\n}\n","import {padArray} from '../../utils/array-utils';\n\nconst DEFAULT_TRANSITION_SETTINGS = {\n  interpolation: {\n    duration: 0,\n    easing: t => t\n  },\n  spring: {\n    stiffness: 0.05,\n    damping: 0.5\n  }\n};\n\nexport function normalizeTransitionSettings(userSettings, layerSettings) {\n  if (!userSettings) {\n    return null;\n  }\n  if (Number.isFinite(userSettings)) {\n    userSettings = {duration: userSettings};\n  }\n  userSettings.type = userSettings.type || 'interpolation';\n  return {\n    ...DEFAULT_TRANSITION_SETTINGS[userSettings.type],\n    ...layerSettings,\n    ...userSettings\n  };\n}\n\n// NOTE: NOT COPYING OVER OFFSET OR STRIDE HERE BECAUSE:\n// (1) WE DON'T SUPPORT INTERLEAVED BUFFERS FOR TRANSITIONS\n// (2) BUFFERS WITH OFFSETS ALWAYS CONTAIN VALUES OF THE SAME SIZE\n// (3) THE OPERATIONS IN THE SHADER ARE PER-COMPONENT (addition and scaling)\nexport function getSourceBufferAttribute(gl, attribute) {\n  // The Attribute we pass to Transform as a sourceBuffer must have {divisor: 0}\n  // so we create a copy of the attribute (with divisor=0) to use when running\n  // transform feedback\n  const buffer = attribute.getBuffer();\n  if (buffer) {\n    return [\n      attribute.getBuffer(),\n      {\n        divisor: 0,\n        size: attribute.size,\n        normalized: attribute.settings.normalized\n      }\n    ];\n  }\n  // constant\n  // don't pass normalized here because the `value` from a normalized attribute is\n  // already normalized\n  return attribute.value;\n}\n\nexport function getAttributeTypeFromSize(size) {\n  switch (size) {\n    case 1:\n      return 'float';\n    case 2:\n      return 'vec2';\n    case 3:\n      return 'vec3';\n    case 4:\n      return 'vec4';\n    default:\n      throw new Error(`No defined attribute type for size \"${size}\"`);\n  }\n}\n\nexport function cycleBuffers(buffers) {\n  buffers.push(buffers.shift());\n}\n\nexport function getAttributeBufferLength(attribute, numInstances) {\n  const {doublePrecision, settings, value, size} = attribute;\n  const multiplier = doublePrecision && value instanceof Float64Array ? 2 : 1;\n  return (settings.noAlloc ? value.length : numInstances * size) * multiplier;\n}\n\n// This helper is used when transitioning attributes from a set of values in one buffer layout\n// to a set of values in a different buffer layout. (Buffer layouts are used when attribute values\n// within a buffer should be grouped for drawElements, like the Polygon layer.) For example, a\n// buffer layout of [3, 4] might have data [A1, A2, A3, B1, B2, B3, B4]. If it needs to transition\n// to a buffer layout of [4, 2], it should produce a buffer, using the transition setting's `enter`\n// function, that looks like this: [A1, A2, A3, A4 (user `enter` fn), B1, B2, 0]. Note: the final\n// 0 in this buffer is because we never shrink buffers, only grow them, for performance reasons.\nexport function padBuffer({\n  buffer,\n  numInstances,\n  attribute,\n  fromLength,\n  fromStartIndices,\n  getData = x => x\n}) {\n  // TODO: move the precisionMultiplier logic to the attribute when retrieving\n  // its `size` and `elementOffset`?\n  const precisionMultiplier =\n    attribute.doublePrecision && attribute.value instanceof Float64Array ? 2 : 1;\n  const size = attribute.size * precisionMultiplier;\n  const byteOffset = attribute.byteOffset;\n  const toStartIndices = attribute.startIndices;\n  const hasStartIndices = fromStartIndices && toStartIndices;\n  const toLength = getAttributeBufferLength(attribute, numInstances);\n  const isConstant = attribute.state.constant;\n\n  // check if buffer needs to be padded\n  if (!hasStartIndices && fromLength >= toLength) {\n    return;\n  }\n\n  const toData = isConstant\n    ? attribute.value\n    : attribute.getBuffer().getData({srcByteOffset: byteOffset});\n  if (attribute.settings.normalized && !isConstant) {\n    const getter = getData;\n    getData = (value, chunk) => attribute._normalizeConstant(getter(value, chunk));\n  }\n\n  const getMissingData = isConstant\n    ? (i, chunk) => getData(toData, chunk)\n    : (i, chunk) => getData(toData.subarray(i, i + size), chunk);\n\n  const source = buffer.getData({length: fromLength});\n  const data = new Float32Array(toLength);\n  padArray({\n    source,\n    target: data,\n    sourceStartIndices: fromStartIndices,\n    targetStartIndices: toStartIndices,\n    size,\n    getData: getMissingData\n  });\n\n  // TODO: support offset in buffer.setData?\n  if (buffer.byteLength < data.byteLength + byteOffset) {\n    buffer.reallocate(data.byteLength + byteOffset);\n  }\n  buffer.subData({data, offset: byteOffset});\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/*\n * Helper function for padArray\n */\nfunction padArrayChunk({source, target, start = 0, end, size, getData}) {\n  end = end || target.length;\n\n  const sourceLength = source.length;\n  const targetLength = end - start;\n\n  if (sourceLength > targetLength) {\n    target.set(source.subarray(0, targetLength), start);\n    return;\n  }\n\n  target.set(source, start);\n\n  if (!getData) {\n    return;\n  }\n\n  // source is not large enough to fill target space, call `getData` to get filler data\n  let i = sourceLength;\n  while (i < targetLength) {\n    const datum = getData(i, source);\n    for (let j = 0; j < size; j++) {\n      target[start + i] = datum[j] || 0;\n      i++;\n    }\n  }\n}\n\n/*\n * The padArray function stretches a source array to the size of a target array.\n   The arrays can have internal structures (like the attributes of PathLayer and\n   SolidPolygonLayer), defined by the optional sourceStartIndices and targetStartIndices parameters.\n   If the target array is larger, the getData callback is used to fill in the blanks.\n * @params {TypedArray} source - original data\n * @params {TypedArray} target - output data\n * @params {Number} size - length per datum\n * @params {Function} getData - callback to get new data when source is short\n * @params {Array<Number>} [sourceStartIndices] - subdivision of the original data in [object0StartIndex, object1StartIndex, ...]\n * @params {Array<Number>} [targetStartIndices] - subdivision of the output data in [object0StartIndex, object1StartIndex, ...]\n */\nexport function padArray({source, target, size, getData, sourceStartIndices, targetStartIndices}) {\n  if (!Array.isArray(targetStartIndices)) {\n    // Flat arrays\n    padArrayChunk({\n      source,\n      target,\n      size,\n      getData\n    });\n    return target;\n  }\n\n  // Arrays have internal structure\n  let sourceIndex = 0;\n  let targetIndex = 0;\n  const getChunkData = getData && ((i, chunk) => getData(i + targetIndex, chunk));\n\n  const n = Math.min(sourceStartIndices.length, targetStartIndices.length);\n\n  for (let i = 1; i < n; i++) {\n    const nextSourceIndex = sourceStartIndices[i] * size;\n    const nextTargetIndex = targetStartIndices[i] * size;\n\n    padArrayChunk({\n      source: source.subarray(sourceIndex, nextSourceIndex),\n      target,\n      start: targetIndex,\n      end: nextTargetIndex,\n      size,\n      getData: getChunkData\n    });\n\n    sourceIndex = nextSourceIndex;\n    targetIndex = nextTargetIndex;\n  }\n\n  if (targetIndex < target.length) {\n    padArrayChunk({\n      source: [],\n      target,\n      start: targetIndex,\n      size,\n      getData: getChunkData\n    });\n  }\n\n  return target;\n}\n","import {Transform} from '@luma.gl/core';\nimport GPUInterpolationTransition from '../../transitions/gpu-interpolation-transition';\nimport GPUSpringTransition from '../../transitions/gpu-spring-transition';\nimport log from '../../utils/log';\n\nconst TRANSITION_TYPES = {\n  interpolation: GPUInterpolationTransition,\n  spring: GPUSpringTransition\n};\n\nexport default class AttributeTransitionManager {\n  constructor(gl, {id, timeline}) {\n    this.id = id;\n    this.gl = gl;\n    this.timeline = timeline;\n\n    this.transitions = {};\n    this.needsRedraw = false;\n    this.numInstances = 1;\n\n    this.isSupported = Transform.isSupported(gl);\n  }\n\n  finalize() {\n    for (const attributeName in this.transitions) {\n      this._removeTransition(attributeName);\n    }\n  }\n\n  /* Public methods */\n\n  // Called when attribute manager updates\n  // Check the latest attributes for updates.\n  update({attributes, transitions, numInstances}) {\n    // Transform class will crash if elementCount is 0\n    this.numInstances = numInstances || 1;\n\n    for (const attributeName in attributes) {\n      const attribute = attributes[attributeName];\n      const settings = attribute.getTransitionSetting(transitions);\n\n      // this attribute might not support transitions?\n      if (!settings) continue; // eslint-disable-line no-continue\n      this._updateAttribute(attributeName, attribute, settings);\n    }\n\n    for (const attributeName in this.transitions) {\n      const attribute = attributes[attributeName];\n      if (!attribute || !attribute.getTransitionSetting(transitions)) {\n        // Animated attribute has been removed\n        this._removeTransition(attributeName);\n      }\n    }\n  }\n\n  // Returns `true` if attribute is transition-enabled\n  hasAttribute(attributeName) {\n    const transition = this.transitions[attributeName];\n    return transition && transition.inProgress;\n  }\n\n  // Get all the animated attributes\n  getAttributes() {\n    const animatedAttributes = {};\n\n    for (const attributeName in this.transitions) {\n      const transition = this.transitions[attributeName];\n      if (transition.inProgress) {\n        animatedAttributes[attributeName] = transition.attributeInTransition;\n      }\n    }\n\n    return animatedAttributes;\n  }\n\n  /* eslint-disable max-statements */\n  // Called every render cycle, run transform feedback\n  // Returns `true` if anything changes\n  run() {\n    if (!this.isSupported || this.numInstances === 0) {\n      return false;\n    }\n\n    for (const attributeName in this.transitions) {\n      const updated = this.transitions[attributeName].update();\n      if (updated) {\n        this.needsRedraw = true;\n      }\n    }\n\n    const needsRedraw = this.needsRedraw;\n    this.needsRedraw = false;\n    return needsRedraw;\n  }\n  /* eslint-enable max-statements */\n\n  /* Private methods */\n  _removeTransition(attributeName) {\n    this.transitions[attributeName].cancel();\n    delete this.transitions[attributeName];\n  }\n\n  // Check an attributes for updates\n  // Returns a transition object if a new transition is triggered.\n  _updateAttribute(attributeName, attribute, settings) {\n    const transition = this.transitions[attributeName];\n    // an attribute can change transition type when it updates\n    // let's remove the transition when that happens so we can create the new transition type\n    // TODO: when switching transition types, make sure to carry over the attribute's\n    // previous buffers, currentLength, startIndices, etc, to be used as the starting point\n    // for the next transition\n    let isNew = !transition || transition.type !== settings.type;\n    if (isNew) {\n      if (!this.isSupported) {\n        log.warn(\n          `WebGL2 not supported by this browser. Transition for ${attributeName} is disabled.`\n        )();\n        return;\n      }\n\n      if (transition) {\n        this._removeTransition(attributeName);\n      }\n\n      const TransitionType = TRANSITION_TYPES[settings.type];\n      if (TransitionType) {\n        this.transitions[attributeName] = new TransitionType({\n          attribute,\n          timeline: this.timeline,\n          gl: this.gl\n        });\n      } else {\n        log.error(`unsupported transition type '${settings.type}'`)();\n        isNew = false;\n      }\n    }\n\n    if (isNew || attribute.needsRedraw()) {\n      this.needsRedraw = true;\n      this.transitions[attributeName].start(settings, this.numInstances);\n    }\n  }\n}\n","import GL from '@luma.gl/constants';\nimport {Buffer, Transform} from '@luma.gl/core';\nimport Attribute from '../lib/attribute/attribute';\nimport {\n  padBuffer,\n  getAttributeTypeFromSize,\n  getSourceBufferAttribute,\n  getAttributeBufferLength,\n  cycleBuffers\n} from '../lib/attribute/attribute-transition-utils';\nimport Transition from './transition';\n\nexport default class GPUInterpolationTransition {\n  constructor({gl, attribute, timeline}) {\n    this.gl = gl;\n    this.type = 'interpolation';\n    this.transition = new Transition(timeline);\n    this.attribute = attribute;\n    // this is the attribute we return during the transition - note: if it is a constant\n    // attribute, it will be converted and returned as a regular attribute\n    // `attribute.userData` is the original options passed when constructing the attribute.\n    // This ensures that we set the proper `doublePrecision` flag and shader attributes.\n    this.attributeInTransition = new Attribute(gl, attribute.settings);\n    this.currentStartIndices = attribute.startIndices;\n    // storing currentLength because this.buffer may be larger than the actual length we want to use\n    // this is because we only reallocate buffers when they grow, not when they shrink,\n    // due to performance costs\n    this.currentLength = 0;\n    this.transform = getTransform(gl, attribute);\n    const bufferOpts = {\n      byteLength: 0,\n      usage: GL.DYNAMIC_COPY\n    };\n    this.buffers = [\n      new Buffer(gl, bufferOpts), // from\n      new Buffer(gl, bufferOpts) // current\n    ];\n  }\n\n  get inProgress() {\n    return this.transition.inProgress;\n  }\n\n  // this is called when an attribute's values have changed and\n  // we need to start animating towards the new values\n  // this also correctly resizes / pads the transform's buffers\n  // in case the attribute's buffer has changed in length or in\n  // startIndices\n  start(transitionSettings, numInstances) {\n    if (transitionSettings.duration <= 0) {\n      this.transition.cancel();\n      return;\n    }\n\n    const {gl, buffers, attribute} = this;\n    // Alternate between two buffers when new transitions start.\n    // Last destination buffer is used as an attribute (from state),\n    // And the other buffer is now the current buffer.\n    cycleBuffers(buffers);\n\n    const padBufferOpts = {\n      numInstances,\n      attribute,\n      fromLength: this.currentLength,\n      fromStartIndices: this.currentStartIndices,\n      getData: transitionSettings.enter\n    };\n\n    for (const buffer of buffers) {\n      padBuffer({buffer, ...padBufferOpts});\n    }\n\n    this.currentStartIndices = attribute.startIndices;\n    this.currentLength = getAttributeBufferLength(attribute, numInstances);\n    this.attributeInTransition.update({\n      buffer: buffers[1],\n      // Hack: Float64Array is required for double-precision attributes\n      // to generate correct shader attributes\n      value: attribute.value\n    });\n\n    this.transition.start(transitionSettings);\n\n    this.transform.update({\n      elementCount: Math.floor(this.currentLength / attribute.size),\n      sourceBuffers: {\n        aFrom: buffers[0],\n        aTo: getSourceBufferAttribute(gl, attribute)\n      },\n      feedbackBuffers: {\n        vCurrent: buffers[1]\n      }\n    });\n  }\n\n  update() {\n    const updated = this.transition.update();\n    if (updated) {\n      const {\n        time,\n        settings: {duration, easing}\n      } = this.transition;\n      const t = easing(time / duration);\n      this.transform.run({\n        uniforms: {time: t}\n      });\n    }\n    return updated;\n  }\n\n  cancel() {\n    this.transition.cancel();\n    this.transform.delete();\n    while (this.buffers.length) {\n      this.buffers.pop().delete();\n    }\n  }\n}\n\nconst vs = `\n#define SHADER_NAME interpolation-transition-vertex-shader\n\nuniform float time;\nattribute ATTRIBUTE_TYPE aFrom;\nattribute ATTRIBUTE_TYPE aTo;\nvarying ATTRIBUTE_TYPE vCurrent;\n\nvoid main(void) {\n  vCurrent = mix(aFrom, aTo, time);\n  gl_Position = vec4(0.0);\n}\n`;\n\nfunction getTransform(gl, attribute) {\n  const attributeType = getAttributeTypeFromSize(attribute.size);\n  return new Transform(gl, {\n    vs,\n    defines: {\n      ATTRIBUTE_TYPE: attributeType\n    },\n    varyings: ['vCurrent']\n  });\n}\n","/* eslint-disable complexity, max-statements, max-params */\nimport GL from '@luma.gl/constants';\nimport {Buffer, Transform, Framebuffer, Texture2D, readPixelsToArray} from '@luma.gl/core';\nimport {\n  padBuffer,\n  getAttributeTypeFromSize,\n  getSourceBufferAttribute,\n  getAttributeBufferLength,\n  cycleBuffers\n} from '../lib/attribute/attribute-transition-utils';\nimport Attribute from '../lib/attribute/attribute';\nimport Transition from './transition';\n\nexport default class GPUSpringTransition {\n  constructor({gl, attribute, timeline}) {\n    this.gl = gl;\n    this.type = 'spring';\n    this.transition = new Transition(timeline);\n    this.attribute = attribute;\n    // this is the attribute we return during the transition - note: if it is a constant\n    // attribute, it will be converted and returned as a regular attribute\n    // `attribute.userData` is the original options passed when constructing the attribute.\n    // This ensures that we set the proper `doublePrecision` flag and shader attributes.\n    this.attributeInTransition = new Attribute(gl, {...attribute.settings, normalized: false});\n    this.currentStartIndices = attribute.startIndices;\n    // storing currentLength because this.buffer may be larger than the actual length we want to use\n    // this is because we only reallocate buffers when they grow, not when they shrink,\n    // due to performance costs\n    this.currentLength = 0;\n    this.texture = getTexture(gl);\n    this.framebuffer = getFramebuffer(gl, this.texture);\n    this.transform = getTransform(gl, attribute, this.framebuffer);\n    const bufferOpts = {\n      byteLength: 0,\n      usage: GL.DYNAMIC_COPY\n    };\n    this.buffers = [\n      new Buffer(gl, bufferOpts), // previous\n      new Buffer(gl, bufferOpts), // current\n      new Buffer(gl, bufferOpts) // next\n    ];\n  }\n\n  get inProgress() {\n    return this.transition.inProgress;\n  }\n\n  // this is called when an attribute's values have changed and\n  // we need to start animating towards the new values\n  // this also correctly resizes / pads the transform's buffers\n  // in case the attribute's buffer has changed in length or in\n  // startIndices\n  start(transitionSettings, numInstances) {\n    const {gl, buffers, attribute} = this;\n    const padBufferOpts = {\n      numInstances,\n      attribute,\n      fromLength: this.currentLength,\n      fromStartIndices: this.currentStartIndices,\n      getData: transitionSettings.enter\n    };\n\n    for (const buffer of buffers) {\n      padBuffer({buffer, ...padBufferOpts});\n    }\n\n    this.currentStartIndices = attribute.startIndices;\n    this.currentLength = getAttributeBufferLength(attribute, numInstances);\n    this.attributeInTransition.update({\n      buffer: buffers[1],\n      // Hack: Float64Array is required for double-precision attributes\n      // to generate correct shader attributes\n      value: attribute.value\n    });\n\n    // when an attribute changes values, a new transition is started. These\n    // are properties that we have to store on this.transition but can change\n    // when new transitions are started, so we have to keep them up-to-date.\n    // this.transition.start() takes the latest settings and updates them.\n    this.transition.start(transitionSettings);\n\n    this.transform.update({\n      elementCount: Math.floor(this.currentLength / attribute.size),\n      sourceBuffers: {\n        aTo: getSourceBufferAttribute(gl, attribute)\n      }\n    });\n  }\n\n  update() {\n    const {buffers, transform, framebuffer, transition} = this;\n    const updated = transition.update();\n    if (!updated) {\n      return false;\n    }\n\n    transform.update({\n      sourceBuffers: {\n        aPrev: buffers[0],\n        aCur: buffers[1]\n      },\n      feedbackBuffers: {\n        vNext: buffers[2]\n      }\n    });\n    transform.run({\n      framebuffer,\n      discard: false,\n      clearRenderTarget: true,\n      uniforms: {\n        stiffness: transition.settings.stiffness,\n        damping: transition.settings.damping\n      },\n      parameters: {\n        depthTest: false,\n        blend: true,\n        viewport: [0, 0, 1, 1],\n        blendFunc: [GL.ONE, GL.ONE],\n        blendEquation: [GL.MAX, GL.MAX]\n      }\n    });\n\n    cycleBuffers(buffers);\n    this.attributeInTransition.update({\n      buffer: buffers[1],\n      // Hack: Float64Array is required for double-precision attributes\n      // to generate correct shader attributes\n      value: this.attribute.value\n    });\n\n    const isTransitioning = readPixelsToArray(framebuffer)[0] > 0;\n\n    if (!isTransitioning) {\n      transition.end();\n    }\n\n    return true;\n  }\n\n  cancel() {\n    this.transition.cancel();\n    this.transform.delete();\n    while (this.buffers.length) {\n      this.buffers.pop().delete();\n    }\n    this.texture.delete();\n    this.texture = null;\n    this.framebuffer.delete();\n    this.framebuffer = null;\n  }\n}\n\nfunction getTransform(gl, attribute, framebuffer) {\n  const attributeType = getAttributeTypeFromSize(attribute.size);\n  return new Transform(gl, {\n    framebuffer,\n    vs: `\n#define SHADER_NAME spring-transition-vertex-shader\n\n#define EPSILON 0.00001\n\nuniform float stiffness;\nuniform float damping;\nattribute ATTRIBUTE_TYPE aPrev;\nattribute ATTRIBUTE_TYPE aCur;\nattribute ATTRIBUTE_TYPE aTo;\nvarying ATTRIBUTE_TYPE vNext;\nvarying float vIsTransitioningFlag;\n\nATTRIBUTE_TYPE getNextValue(ATTRIBUTE_TYPE cur, ATTRIBUTE_TYPE prev, ATTRIBUTE_TYPE dest) {\n  ATTRIBUTE_TYPE velocity = cur - prev;\n  ATTRIBUTE_TYPE delta = dest - cur;\n  ATTRIBUTE_TYPE spring = delta * stiffness;\n  ATTRIBUTE_TYPE damper = velocity * -1.0 * damping;\n  return spring + damper + velocity + cur;\n}\n\nvoid main(void) {\n  bool isTransitioning = length(aCur - aPrev) > EPSILON || length(aTo - aCur) > EPSILON;\n  vIsTransitioningFlag = isTransitioning ? 1.0 : 0.0;\n\n  vNext = getNextValue(aCur, aPrev, aTo);\n  gl_Position = vec4(0, 0, 0, 1);\n  gl_PointSize = 100.0;\n}\n`,\n    fs: `\n#define SHADER_NAME spring-transition-is-transitioning-fragment-shader\n\nvarying float vIsTransitioningFlag;\n\nvoid main(void) {\n  if (vIsTransitioningFlag == 0.0) {\n    discard;\n  }\n  gl_FragColor = vec4(1.0);\n}`,\n    defines: {\n      ATTRIBUTE_TYPE: attributeType\n    },\n    varyings: ['vNext']\n  });\n}\n\nfunction getTexture(gl) {\n  return new Texture2D(gl, {\n    data: new Uint8Array(4),\n    format: GL.RGBA,\n    type: GL.UNSIGNED_BYTE,\n    border: 0,\n    mipmaps: false,\n    dataFormat: GL.RGBA,\n    width: 1,\n    height: 1\n  });\n}\n\nfunction getFramebuffer(gl, texture) {\n  return new Framebuffer(gl, {\n    id: 'spring-transition-is-transitioning-framebuffer',\n    width: 1,\n    height: 1,\n    attachments: {\n      [GL.COLOR_ATTACHMENT0]: texture\n    }\n  });\n}\n","import {normalizeTransitionSettings} from './attribute/attribute-transition-utils';\nimport CPUInterpolationTransition from '../transitions/cpu-interpolation-transition';\nimport CPUSpringTransition from '../transitions/cpu-spring-transition';\nimport log from '../utils/log';\n\nconst TRANSITION_TYPES = {\n  interpolation: CPUInterpolationTransition,\n  spring: CPUSpringTransition\n};\n\nexport default class UniformTransitionManager {\n  constructor(timeline) {\n    this.transitions = new Map();\n    this.timeline = timeline;\n  }\n\n  get active() {\n    return this.transitions.size > 0;\n  }\n\n  add(key, fromValue, toValue, settings) {\n    const {transitions} = this;\n    if (transitions.has(key)) {\n      const transition = transitions.get(key);\n      // value may not be available if `update()` has not been called. Fallback to `fromValue`\n      const {value = transition.settings.fromValue} = transition;\n      // start from interrupted position\n      fromValue = value;\n      this.remove(key);\n    }\n\n    settings = normalizeTransitionSettings(settings);\n    if (!settings) {\n      return;\n    }\n\n    const TransitionType = TRANSITION_TYPES[settings.type];\n    if (!TransitionType) {\n      log.error(`unsupported transition type '${settings.type}'`)();\n      return;\n    }\n    const transition = new TransitionType(this.timeline);\n    transition.start({\n      ...settings,\n      fromValue,\n      toValue\n    });\n    transitions.set(key, transition);\n  }\n\n  remove(key) {\n    const {transitions} = this;\n    if (transitions.has(key)) {\n      transitions.get(key).cancel();\n      transitions.delete(key);\n    }\n  }\n\n  update() {\n    const propsInTransition = {};\n\n    for (const [key, transition] of this.transitions) {\n      transition.update();\n      propsInTransition[key] = transition.value;\n      if (!transition.inProgress) {\n        // transition ended\n        this.remove(key);\n      }\n    }\n\n    return propsInTransition;\n  }\n\n  clear() {\n    for (const key of this.transitions.keys()) {\n      this.remove(key);\n    }\n  }\n}\n","import {lerp} from 'math.gl';\nimport Transition from './transition';\n\nexport default class CPUInterpolationTransition extends Transition {\n  get value() {\n    return this._value;\n  }\n\n  _onUpdate() {\n    const {\n      time,\n      settings: {fromValue, toValue, duration, easing}\n    } = this;\n    const t = easing(time / duration);\n    this._value = lerp(fromValue, toValue, t);\n  }\n}\n","import Transition from './transition';\n\nconst EPSILON = 1e-5;\n\n/*\n * Calculate the next value in the spring transition\n * @param prev {Number} - previous value\n * @param cur {Number} - current value\n * @param dest {Number} - destination value\n * @param damping {Number}\n * @param stiffness {Number}\n */\nfunction updateSpringElement(prev, cur, dest, damping, stiffness) {\n  const velocity = cur - prev;\n  const delta = dest - cur;\n  const spring = delta * stiffness;\n  const damper = -velocity * damping;\n  return spring + damper + velocity + cur;\n}\n\n/*\n * Calculate the next value in the spring transition\n * @param prev {Number|Array} - previous value\n * @param cur {Number|Array} - current value\n * @param dest {Number|Array} - destination value\n * @param damping {Number}\n * @param stiffness {Number}\n */\nfunction updateSpring(prev, cur, dest, damping, stiffness) {\n  if (Array.isArray(dest)) {\n    const next = [];\n    for (let i = 0; i < dest.length; i++) {\n      next[i] = updateSpringElement(prev[i], cur[i], dest[i], damping, stiffness);\n    }\n    return next;\n  }\n  return updateSpringElement(prev, cur, dest, damping, stiffness);\n}\n\n/*\n * Calculate the distance between two numbers or two vectors\n */\nfunction distance(value1, value2) {\n  if (Array.isArray(value1)) {\n    let distanceSquare = 0;\n    for (let i = 0; i < value1.length; i++) {\n      const d = value1[i] - value2[i];\n      distanceSquare += d * d;\n    }\n    return Math.sqrt(distanceSquare);\n  }\n  return Math.abs(value1 - value2);\n}\n\nexport default class CPUSpringTransition extends Transition {\n  get value() {\n    return this._currValue;\n  }\n\n  _onUpdate() {\n    // TODO - use timeline\n    // const {time} = this;\n\n    const {fromValue, toValue, damping, stiffness} = this.settings;\n    const {_prevValue = fromValue, _currValue = fromValue} = this;\n    let nextValue = updateSpring(_prevValue, _currValue, toValue, damping, stiffness);\n    const delta = distance(nextValue, toValue);\n    const velocity = distance(nextValue, _currValue);\n\n    if (delta < EPSILON && velocity < EPSILON) {\n      nextValue = toValue;\n      this.end();\n    }\n\n    this._prevValue = _currValue;\n    this._currValue = nextValue;\n  }\n}\n","import {PROP_SYMBOLS} from './constants';\n\nconst {COMPONENT} = PROP_SYMBOLS;\n\nexport function validateProps(props) {\n  const propTypes = getPropTypes(props);\n\n  for (const propName in propTypes) {\n    const propType = propTypes[propName];\n    const {validate} = propType;\n    if (validate && !validate(props[propName], propType)) {\n      throw new Error(`Invalid prop ${propName}: ${props[propName]}`);\n    }\n  }\n}\n\n// Returns an object with \"change flags\", either false or strings indicating reason for change\nexport function diffProps(props, oldProps) {\n  // First check if any props have changed (ignore props that will be examined separately)\n  const propsChangedReason = compareProps({\n    newProps: props,\n    oldProps,\n    propTypes: getPropTypes(props),\n    ignoreProps: {data: null, updateTriggers: null, extensions: null, transitions: null}\n  });\n\n  // Now check if any data related props have changed\n  const dataChangedReason = diffDataProps(props, oldProps);\n\n  // Check update triggers to determine if any attributes need regeneration\n  // Note - if data has changed, all attributes will need regeneration, so skip this step\n  let updateTriggersChangedReason = false;\n  if (!dataChangedReason) {\n    updateTriggersChangedReason = diffUpdateTriggers(props, oldProps);\n  }\n\n  return {\n    dataChanged: dataChangedReason,\n    propsChanged: propsChangedReason,\n    updateTriggersChanged: updateTriggersChangedReason,\n    extensionsChanged: diffExtensions(props, oldProps),\n    transitionsChanged: diffTransitions(props, oldProps)\n  };\n}\n\nfunction diffTransitions(props, oldProps) {\n  if (!props.transitions) {\n    return null;\n  }\n  const result = {};\n  const propTypes = getPropTypes(props);\n\n  for (const key in props.transitions) {\n    const propType = propTypes[key];\n    const type = propType && propType.type;\n    const isTransitionable = type === 'number' || type === 'color' || type === 'array';\n    if (isTransitionable && comparePropValues(props[key], oldProps[key], propType)) {\n      result[key] = true;\n    }\n  }\n  return result;\n}\n\n/**\n * Performs equality by iterating through keys on an object and returning false\n * when any key has values which are not strictly equal between the arguments.\n * @param {Object} opt.oldProps - object with old key/value pairs\n * @param {Object} opt.newProps - object with new key/value pairs\n * @param {Object} opt.ignoreProps={} - object, keys that should not be compared\n * @returns {null|String} - null when values of all keys are strictly equal.\n *   if unequal, returns a string explaining what changed.\n */\n/* eslint-disable max-statements, max-depth, complexity */\n/*\n * Note: for better performance, this function assumes that both oldProps and newProps\n   inherit the same prototype (defaultProps). That is, if neither object contains own\n   property <key>, assume `oldProps.<key>` and `newProps.<key>` are equal.\n */\nexport function compareProps({\n  newProps,\n  oldProps,\n  ignoreProps = {},\n  propTypes = {},\n  triggerName = 'props'\n} = {}) {\n  // shallow equality => deep equality\n  if (oldProps === newProps) {\n    return null;\n  }\n\n  // TODO - do we need these checks? Should never happen...\n  if (typeof newProps !== 'object' || newProps === null) {\n    return `${triggerName} changed shallowly`;\n  }\n\n  if (typeof oldProps !== 'object' || oldProps === null) {\n    return `${triggerName} changed shallowly`;\n  }\n\n  // Compare explicitly defined new props against old/default values\n  for (const key of Object.keys(newProps)) {\n    if (!(key in ignoreProps)) {\n      if (!(key in oldProps)) {\n        return `${triggerName}.${key} added`;\n      }\n      const changed = comparePropValues(newProps[key], oldProps[key], propTypes[key]);\n      if (changed) {\n        return `${triggerName}.${key} ${changed}`;\n      }\n    }\n  }\n\n  // Test if any old props have been dropped\n  for (const key of Object.keys(oldProps)) {\n    if (!(key in ignoreProps)) {\n      if (!(key in newProps)) {\n        return `${triggerName}.${key} dropped`;\n      }\n      if (!Object.hasOwnProperty.call(newProps, key)) {\n        // Compare dropped old prop against default value\n        const changed = comparePropValues(newProps[key], oldProps[key], propTypes[key]);\n        if (changed) {\n          return `${triggerName}.${key} ${changed}`;\n        }\n      }\n    }\n  }\n\n  return null;\n}\n/* eslint-enable max-statements, max-depth, complexity */\n\n// HELPERS\nfunction comparePropValues(newProp, oldProp, propType) {\n  // If prop type has an equal function, invoke it\n  let equal = propType && propType.equal;\n  if (equal && !equal(newProp, oldProp, propType)) {\n    return 'changed deeply';\n  }\n\n  if (!equal) {\n    // If object has an equals function, invoke it\n    equal = newProp && oldProp && newProp.equals;\n    if (equal && !equal.call(newProp, oldProp)) {\n      return 'changed deeply';\n    }\n  }\n\n  if (!equal && oldProp !== newProp) {\n    return 'changed shallowly';\n  }\n\n  return null;\n}\n\n// The comparison of the data prop requires special handling\n// the dataComparator should be used if supplied\nfunction diffDataProps(props, oldProps) {\n  if (oldProps === null) {\n    return 'oldProps is null, initial diff';\n  }\n\n  let dataChanged = null;\n  // Support optional app defined comparison of data\n  const {dataComparator, _dataDiff} = props;\n  if (dataComparator) {\n    if (!dataComparator(props.data, oldProps.data)) {\n      dataChanged = 'Data comparator detected a change';\n    }\n    // Otherwise, do a shallow equal on props\n  } else if (props.data !== oldProps.data) {\n    dataChanged = 'A new data container was supplied';\n  }\n  if (dataChanged && _dataDiff) {\n    dataChanged = _dataDiff(props.data, oldProps.data) || dataChanged;\n  }\n\n  return dataChanged;\n}\n\n// Checks if any update triggers have changed\n// also calls callback to invalidate attributes accordingly.\nfunction diffUpdateTriggers(props, oldProps) {\n  if (oldProps === null) {\n    return 'oldProps is null, initial diff';\n  }\n\n  // If the 'all' updateTrigger fires, ignore testing others\n  if ('all' in props.updateTriggers) {\n    const diffReason = diffUpdateTrigger(props, oldProps, 'all');\n    if (diffReason) {\n      return {all: true};\n    }\n  }\n\n  const triggerChanged = {};\n  let reason = false;\n  // If the 'all' updateTrigger didn't fire, need to check all others\n  for (const triggerName in props.updateTriggers) {\n    if (triggerName !== 'all') {\n      const diffReason = diffUpdateTrigger(props, oldProps, triggerName);\n      if (diffReason) {\n        triggerChanged[triggerName] = true;\n        reason = triggerChanged;\n      }\n    }\n  }\n\n  return reason;\n}\n\n// Returns true if any extensions have changed\nfunction diffExtensions(props, oldProps) {\n  if (oldProps === null) {\n    return 'oldProps is null, initial diff';\n  }\n\n  const oldExtensions = oldProps.extensions;\n  const {extensions} = props;\n\n  if (extensions === oldExtensions) {\n    return false;\n  }\n  if (extensions.length !== oldExtensions.length) {\n    return true;\n  }\n  for (let i = 0; i < extensions.length; i++) {\n    if (!extensions[i].equals(oldExtensions[i])) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction diffUpdateTrigger(props, oldProps, triggerName) {\n  let newTriggers = props.updateTriggers[triggerName];\n  newTriggers = newTriggers === undefined || newTriggers === null ? {} : newTriggers;\n  let oldTriggers = oldProps.updateTriggers[triggerName];\n  oldTriggers = oldTriggers === undefined || oldTriggers === null ? {} : oldTriggers;\n  const diffReason = compareProps({\n    oldProps: oldTriggers,\n    newProps: newTriggers,\n    triggerName\n  });\n  return diffReason;\n}\n\nfunction getPropTypes(props) {\n  const layer = props[COMPONENT];\n  const LayerType = layer && layer.constructor;\n  return LayerType ? LayerType._propTypes : {};\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nconst ERR_NOT_OBJECT = 'count(): argument not an object';\nconst ERR_NOT_CONTAINER = 'count(): argument not a container';\n\n/**\n * Deduces numer of elements in a JavaScript container.\n * - Auto-deduction for ES6 containers that define a count() method\n * - Auto-deduction for ES6 containers that define a size member\n * - Auto-deduction for Classic Arrays via the built-in length attribute\n * - Also handles objects, although note that this an O(N) operation\n */\nexport function count(container) {\n  if (!isObject(container)) {\n    throw new Error(ERR_NOT_OBJECT);\n  }\n\n  // Check if ES6 collection \"count\" function is available\n  if (typeof container.count === 'function') {\n    return container.count();\n  }\n\n  // Check if ES6 collection \"size\" attribute is set\n  if (Number.isFinite(container.size)) {\n    return container.size;\n  }\n\n  // Check if array length attribute is set\n  // Note: checking this last since some ES6 collections (Immutable.js)\n  // emit profuse warnings when trying to access `length` attribute\n  if (Number.isFinite(container.length)) {\n    return container.length;\n  }\n\n  // Note that getting the count of an object is O(N)\n  if (isPlainObject(container)) {\n    return Object.keys(container).length;\n  }\n\n  throw new Error(ERR_NOT_CONTAINER);\n}\n\n/**\n * Checks if argument is a plain object (not a class or array etc)\n * @param {*} value - JavaScript value to be tested\n * @return {Boolean} - true if argument is a plain JavaScript object\n */\nfunction isPlainObject(value) {\n  return value !== null && typeof value === 'object' && value.constructor === Object;\n}\n\n/**\n * Checks if argument is an indexable object (not a primitive value, nor null)\n * @param {*} value - JavaScript value to be tested\n * @return {Boolean} - true if argument is a JavaScript object\n */\nfunction isObject(value) {\n  return value !== null && typeof value === 'object';\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// Merge two luma.gl shader descriptors\nexport function mergeShaders(target, source) {\n  if (!source) {\n    return target;\n  }\n  const result = {...target, ...source};\n\n  if ('defines' in source) {\n    result.defines = {...target.defines, ...source.defines};\n  }\n  if ('modules' in source) {\n    result.modules = (target.modules || []).concat(source.modules);\n\n    // Hack: prject32 and project64 cannot co-exist\n    if (source.modules.some(module => module.name === 'project64')) {\n      const index = result.modules.findIndex(module => module.name === 'project32');\n      if (index >= 0) {\n        result.modules.splice(index, 1);\n      }\n    }\n  }\n  if ('inject' in source) {\n    if (!target.inject) {\n      result.inject = source.inject;\n    } else {\n      const mergedInjection = {...target.inject};\n      for (const key in source.inject) {\n        mergedInjection[key] = (mergedInjection[key] || '') + source.inject[key];\n      }\n      result.inject = mergedInjection;\n    }\n  }\n  return result;\n}\n","import {LIFECYCLE} from '../lifecycle/constants';\nimport {createProps} from './create-props';\nimport {PROP_SYMBOLS} from './constants';\nconst {ASYNC_ORIGINAL, ASYNC_RESOLVED, ASYNC_DEFAULTS} = PROP_SYMBOLS;\nimport ComponentState from './component-state';\n\nconst defaultProps = {};\n\nlet counter = 0;\n\nexport default class Component {\n  constructor(/* ...propObjects */) {\n    // Merge supplied props with default props and freeze them.\n    /* eslint-disable prefer-spread */\n    this.props = createProps.apply(this, arguments);\n    /* eslint-enable prefer-spread */\n\n    // Define all members before layer is sealed\n    this.id = this.props.id; // The layer's id, used for matching with layers from last render cycle\n    this.count = counter++; // Keep track of how many layer instances you are generating\n    this.lifecycle = LIFECYCLE.NO_STATE; // Helps track and debug the life cycle of the layers\n    this.parent = null; // reference to the composite layer parent that rendered this layer\n    this.context = null; // Will reference layer manager's context, contains state shared by layers\n    this.state = null; // Will be set to the shared layer state object during layer matching\n    this.internalState = null;\n\n    // Seal the layer\n    Object.seal(this);\n  }\n\n  get root() {\n    // eslint-disable-next-line consistent-this\n    let component = this;\n    while (component.parent) {\n      component = component.parent;\n    }\n    return component;\n  }\n\n  // clone this layer with modified props\n  clone(newProps) {\n    const {props} = this;\n\n    // Async props cannot be copied with Object.assign, copy them separately\n    const asyncProps = {};\n\n    // See async props definition in create-props.js\n    for (const key in props[ASYNC_DEFAULTS]) {\n      if (key in props[ASYNC_RESOLVED]) {\n        asyncProps[key] = props[ASYNC_RESOLVED][key];\n      } else if (key in props[ASYNC_ORIGINAL]) {\n        asyncProps[key] = props[ASYNC_ORIGINAL][key];\n      }\n    }\n\n    // Some custom layer implementation may not support multiple arguments in the constructor\n    return new this.constructor({...props, ...asyncProps, ...newProps});\n  }\n\n  get stats() {\n    return this.internalState.stats;\n  }\n\n  // PROTECTED METHODS, override in subclass\n\n  _initState() {\n    this.internalState = new ComponentState({});\n  }\n}\n\nComponent.componentName = 'Component';\nComponent.defaultProps = defaultProps;\n","import log from '../utils/log';\nimport {isAsyncIterable} from '../utils/iterable-utils';\nimport {parsePropTypes} from './prop-types';\nimport {PROP_SYMBOLS} from './constants';\n\nconst {COMPONENT, ASYNC_ORIGINAL, ASYNC_RESOLVED, ASYNC_DEFAULTS} = PROP_SYMBOLS;\n\n// Create a property object\nexport function createProps() {\n  const component = this; // eslint-disable-line\n\n  // Get default prop object (a prototype chain for now)\n  const propsPrototype = getPropsPrototype(component.constructor);\n\n  // Create a new prop object with default props object in prototype chain\n  const propsInstance = Object.create(propsPrototype);\n\n  // Props need a back pointer to the owning component\n  propsInstance[COMPONENT] = component;\n  // The supplied (original) values for those async props that are set to url strings or Promises.\n  // In this case, the actual (i.e. resolved) values are looked up from component.internalState\n  propsInstance[ASYNC_ORIGINAL] = {};\n  // Note: the actual (resolved) values for props that are NOT set to urls or Promises.\n  // in this case the values are served directly from this map\n  propsInstance[ASYNC_RESOLVED] = {};\n\n  // \"Copy\" all sync props\n  for (let i = 0; i < arguments.length; ++i) {\n    const props = arguments[i];\n    // Do not use Object.assign here to avoid Symbols in props overwriting our private fields\n    // This might happen if one of the arguments is another props instance\n    for (const key in props) {\n      propsInstance[key] = props[key];\n    }\n  }\n\n  // Props must be immutable\n  Object.freeze(propsInstance);\n\n  return propsInstance;\n}\n\n// Return precalculated defaultProps and propType objects if available\n// build them if needed\nfunction getPropsPrototype(componentClass) {\n  const defaultProps = getOwnProperty(componentClass, '_mergedDefaultProps');\n  if (!defaultProps) {\n    createPropsPrototypeAndTypes(componentClass);\n    return componentClass._mergedDefaultProps;\n  }\n  return defaultProps;\n}\n\n// Build defaultProps and propType objects by walking component prototype chain\nfunction createPropsPrototypeAndTypes(componentClass) {\n  const parent = componentClass.prototype;\n  if (!parent) {\n    return;\n  }\n\n  const parentClass = Object.getPrototypeOf(componentClass);\n  const parentDefaultProps = getPropsPrototype(parentClass);\n\n  // Parse propTypes from Component.defaultProps\n  const componentDefaultProps = getOwnProperty(componentClass, 'defaultProps') || {};\n  const componentPropDefs = parsePropTypes(componentDefaultProps);\n\n  // Create any necessary property descriptors and create the default prop object\n  // Assign merged default props\n  const defaultProps = createPropsPrototype(\n    componentPropDefs.defaultProps,\n    parentDefaultProps,\n    componentClass\n  );\n\n  // Create a merged type object\n  const propTypes = {...parentClass._propTypes, ...componentPropDefs.propTypes};\n  // Add getters/setters for async props\n  addAsyncPropsToPropPrototype(defaultProps, propTypes);\n\n  // Create a map for prop whose default value is a callback\n  const deprecatedProps = {\n    ...parentClass._deprecatedProps,\n    ...componentPropDefs.deprecatedProps\n  };\n  // Add setters for deprecated props\n  addDeprecatedPropsToPropPrototype(defaultProps, deprecatedProps);\n\n  // Store the precalculated props\n  componentClass._mergedDefaultProps = defaultProps;\n  componentClass._propTypes = propTypes;\n  componentClass._deprecatedProps = deprecatedProps;\n}\n\n// Builds a pre-merged default props object that component props can inherit from\nfunction createPropsPrototype(props, parentProps, componentClass) {\n  const defaultProps = Object.create(null);\n\n  Object.assign(defaultProps, parentProps, props);\n\n  // Avoid freezing `id` prop\n  const id = getComponentName(componentClass);\n  delete props.id;\n\n  Object.defineProperties(defaultProps, {\n    // `id` is treated specially because layer might need to override it\n    id: {\n      writable: true,\n      value: id\n    }\n  });\n\n  return defaultProps;\n}\n\nfunction addDeprecatedPropsToPropPrototype(defaultProps, deprecatedProps) {\n  for (const propName in deprecatedProps) {\n    /* eslint-disable accessor-pairs */\n    Object.defineProperty(defaultProps, propName, {\n      enumerable: false,\n      set(newValue) {\n        const nameStr = `${this.id}: ${propName}`;\n\n        for (const newPropName of deprecatedProps[propName]) {\n          if (!hasOwnProperty(this, newPropName)) {\n            this[newPropName] = newValue;\n          }\n        }\n\n        log.deprecated(nameStr, deprecatedProps[propName].join('/'))();\n      }\n    });\n    /* eslint-enable accessor-pairs */\n  }\n}\n\n// Create descriptors for overridable props\nfunction addAsyncPropsToPropPrototype(defaultProps, propTypes) {\n  const defaultValues = {};\n\n  const descriptors = {};\n\n  // Move async props into shadow values\n  for (const propName in propTypes) {\n    const propType = propTypes[propName];\n    const {name, value} = propType;\n\n    // Note: async is ES7 keyword, can't destructure\n    if (propType.async) {\n      defaultValues[name] = value;\n      descriptors[name] = getDescriptorForAsyncProp(name, value);\n    }\n  }\n\n  // Default \"resolved\" values for async props, returned if value not yet resolved/set.\n  defaultProps[ASYNC_DEFAULTS] = defaultValues;\n  // Shadowed object, just to make sure \"early indexing\" into the instance does not fail\n  defaultProps[ASYNC_ORIGINAL] = {};\n\n  Object.defineProperties(defaultProps, descriptors);\n}\n\n// Helper: Configures getter and setter for one async prop\nfunction getDescriptorForAsyncProp(name) {\n  return {\n    enumerable: true,\n    // Save the provided value for async props in a special map\n    set(newValue) {\n      if (\n        typeof newValue === 'string' ||\n        newValue instanceof Promise ||\n        isAsyncIterable(newValue)\n      ) {\n        this[ASYNC_ORIGINAL][name] = newValue;\n      } else {\n        this[ASYNC_RESOLVED][name] = newValue;\n      }\n    },\n    // Only the component's state knows the true value of async prop\n    get() {\n      if (this[ASYNC_RESOLVED]) {\n        // Prop value isn't async, so just return it\n        if (name in this[ASYNC_RESOLVED]) {\n          const value = this[ASYNC_RESOLVED][name];\n\n          return value || this[ASYNC_DEFAULTS][name];\n        }\n\n        if (name in this[ASYNC_ORIGINAL]) {\n          // It's an async prop value: look into component state\n          const state = this[COMPONENT] && this[COMPONENT].internalState;\n          if (state && state.hasAsyncProp(name)) {\n            return state.getAsyncProp(name) || this[ASYNC_DEFAULTS][name];\n          }\n        }\n      }\n\n      // the prop is not supplied, or\n      // component not yet initialized/matched, return the component's default value for the prop\n      return this[ASYNC_DEFAULTS][name];\n    }\n  };\n}\n\n// HELPER METHODS\n\nfunction hasOwnProperty(object, prop) {\n  return Object.prototype.hasOwnProperty.call(object, prop);\n}\n\n// Constructors have their super class constructors as prototypes\nfunction getOwnProperty(object, prop) {\n  return hasOwnProperty(object, prop) && object[prop];\n}\n\nfunction getComponentName(componentClass) {\n  const componentName =\n    getOwnProperty(componentClass, 'layerName') || getOwnProperty(componentClass, 'componentName');\n  if (!componentName) {\n    log.once(0, `${componentClass.name}.componentName not specified`)();\n  }\n  return componentName || componentClass.name;\n}\n","import {createTexture, destroyTexture} from '../utils/texture';\n\nconst TYPE_DEFINITIONS = {\n  boolean: {\n    validate(value, propType) {\n      return true;\n    },\n    equal(value1, value2, propType) {\n      return Boolean(value1) === Boolean(value2);\n    }\n  },\n  number: {\n    validate(value, propType) {\n      return (\n        Number.isFinite(value) &&\n        (!('max' in propType) || value <= propType.max) &&\n        (!('min' in propType) || value >= propType.min)\n      );\n    }\n  },\n  color: {\n    validate(value, propType) {\n      return (\n        (propType.optional && !value) ||\n        (isArray(value) && (value.length === 3 || value.length === 4))\n      );\n    },\n    equal(value1, value2, propType) {\n      return arrayEqual(value1, value2);\n    }\n  },\n  accessor: {\n    validate(value, propType) {\n      const valueType = getTypeOf(value);\n      return valueType === 'function' || valueType === getTypeOf(propType.value);\n    },\n    equal(value1, value2, propType) {\n      if (typeof value2 === 'function') {\n        return true;\n      }\n      return arrayEqual(value1, value2);\n    }\n  },\n  array: {\n    validate(value, propType) {\n      return (propType.optional && !value) || isArray(value);\n    },\n    equal(value1, value2, propType) {\n      return propType.compare ? arrayEqual(value1, value2) : value1 === value2;\n    }\n  },\n  function: {\n    validate(value, propType) {\n      return (propType.optional && !value) || typeof value === 'function';\n    },\n    equal(value1, value2, propType) {\n      return !propType.compare || value1 === value2;\n    }\n  },\n  data: {\n    transform: (value, propType, component) => {\n      const {dataTransform} = component ? component.props : {};\n      return dataTransform && value ? dataTransform(value) : value;\n    }\n  },\n  image: {\n    transform: (value, propType, component) => {\n      return createTexture(component, value);\n    },\n    release: value => {\n      destroyTexture(value);\n    }\n  }\n};\n\nfunction arrayEqual(array1, array2) {\n  if (array1 === array2) {\n    return true;\n  }\n  if (!isArray(array1) || !isArray(array2)) {\n    return false;\n  }\n  const len = array1.length;\n  if (len !== array2.length) {\n    return false;\n  }\n  for (let i = 0; i < len; i++) {\n    if (array1[i] !== array2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function parsePropTypes(propDefs) {\n  const propTypes = {};\n  const defaultProps = {};\n  const deprecatedProps = {};\n\n  for (const [propName, propDef] of Object.entries(propDefs)) {\n    if (propDef && propDef.deprecatedFor) {\n      deprecatedProps[propName] = Array.isArray(propDef.deprecatedFor)\n        ? propDef.deprecatedFor\n        : [propDef.deprecatedFor];\n    } else {\n      const propType = parsePropType(propName, propDef);\n      propTypes[propName] = propType;\n      defaultProps[propName] = propType.value;\n    }\n  }\n  return {propTypes, defaultProps, deprecatedProps};\n}\n\n// Parses one property definition entry. Either contains:\n// * a valid prop type object ({type, ...})\n// * or just a default value, in which case type and name inference is used\nfunction parsePropType(name, propDef) {\n  switch (getTypeOf(propDef)) {\n    case 'object':\n      return normalizePropDefinition(name, propDef);\n\n    case 'array':\n      return normalizePropDefinition(name, {type: 'array', value: propDef, compare: false});\n\n    case 'boolean':\n      return normalizePropDefinition(name, {type: 'boolean', value: propDef});\n\n    case 'number':\n      return normalizePropDefinition(name, {type: 'number', value: propDef});\n\n    case 'function':\n      return normalizePropDefinition(name, {type: 'function', value: propDef, compare: true});\n    // return guessFunctionType(name, propDef);\n\n    default:\n      return {name, type: 'unknown', value: propDef};\n  }\n}\n\nfunction normalizePropDefinition(name, propDef) {\n  if (!('type' in propDef)) {\n    if (!('value' in propDef)) {\n      // If no type and value this object is likely the value\n      return {name, type: 'object', value: propDef};\n    }\n    return {name, type: getTypeOf(propDef.value), ...propDef};\n  }\n  return {name, ...TYPE_DEFINITIONS[propDef.type], ...propDef};\n}\n\nfunction isArray(value) {\n  return Array.isArray(value) || ArrayBuffer.isView(value);\n}\n\n// improved version of javascript typeof that can distinguish arrays and null values\nfunction getTypeOf(value) {\n  if (isArray(value)) {\n    return 'array';\n  }\n  if (value === null) {\n    return 'null';\n  }\n  return typeof value;\n}\n","import {Texture2D} from '@luma.gl/core';\nimport GL from '@luma.gl/constants';\n\nconst DEFAULT_TEXTURE_PARAMETERS = {\n  [GL.TEXTURE_MIN_FILTER]: GL.LINEAR_MIPMAP_LINEAR,\n  [GL.TEXTURE_MAG_FILTER]: GL.LINEAR,\n  [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,\n  [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE\n};\n\n// Track the textures that are created by us. They need to be released when they are no longer used.\nconst internalTextures = {};\n\nexport function createTexture(layer, image) {\n  const gl = layer.context && layer.context.gl;\n  if (!gl || !image) {\n    return null;\n  }\n\n  // image could be one of:\n  //  - Texture2D\n  //  - Browser object: Image, ImageData, ImageData, HTMLCanvasElement, HTMLVideoElement, ImageBitmap\n  //  - Plain object: {width: <number>, height: <number>, data: <Uint8Array>}\n  if (image instanceof Texture2D) {\n    return image;\n  } else if (image.constructor && image.constructor.name !== 'Object') {\n    // Browser object\n    image = {data: image};\n  }\n\n  let specialTextureParameters = null;\n  if (image.compressed) {\n    specialTextureParameters = {\n      [GL.TEXTURE_MIN_FILTER]: image.data.length > 1 ? GL.LINEAR_MIPMAP_NEAREST : GL.LINEAR\n    };\n  }\n\n  const texture = new Texture2D(gl, {\n    ...image,\n    parameters: {\n      ...DEFAULT_TEXTURE_PARAMETERS,\n      ...specialTextureParameters,\n      ...layer.props.textureParameters\n    }\n  });\n  // Track this texture\n  internalTextures[texture.id] = true;\n  return texture;\n}\n\nexport function destroyTexture(texture) {\n  if (!texture || !(texture instanceof Texture2D)) {\n    return;\n  }\n  if (internalTextures[texture.id]) {\n    texture.delete();\n    delete internalTextures[texture.id];\n  }\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {isAsyncIterable} from '../utils/iterable-utils';\nimport {PROP_SYMBOLS} from './constants';\nconst {ASYNC_ORIGINAL, ASYNC_RESOLVED, ASYNC_DEFAULTS} = PROP_SYMBOLS;\n\nconst EMPTY_PROPS = Object.freeze({});\n\nexport default class ComponentState {\n  constructor(component = null) {\n    this.component = component;\n    this.asyncProps = {}; // Prop values that the layer sees\n    this.onAsyncPropUpdated = () => {};\n    this.oldProps = EMPTY_PROPS; // Last props before update\n    this.oldAsyncProps = null; // Last props before update, with async values copied.\n  }\n\n  finalize() {\n    for (const propName in this.asyncProps) {\n      const asyncProp = this.asyncProps[propName];\n      if (asyncProp.type && asyncProp.type.release) {\n        // Release any resources created by transforms\n        asyncProp.type.release(asyncProp.resolvedValue, asyncProp.type, this.component);\n      }\n    }\n  }\n\n  getOldProps() {\n    return this.oldAsyncProps || this.oldProps;\n  }\n\n  resetOldProps() {\n    this.oldAsyncProps = null;\n    this.oldProps = this.component.props;\n  }\n\n  // Whenever async props are changing, we need to make a copy of oldProps\n  // otherwise the prop rewriting will affect the value both in props and oldProps.\n  // While the copy is relatively expensive, this only happens on load completion.\n  freezeAsyncOldProps() {\n    if (!this.oldAsyncProps) {\n      // Make sure oldProps is set\n      this.oldProps = this.oldProps || this.component.props;\n\n      // 1. inherit all synchronous props from oldProps\n      // 2. reconfigure the async prop descriptors to fixed values\n      this.oldAsyncProps = Object.create(this.oldProps);\n      for (const propName in this.asyncProps) {\n        Object.defineProperty(this.oldAsyncProps, propName, {\n          enumerable: true,\n          value: this.oldProps[propName]\n        });\n      }\n    }\n  }\n\n  // ASYNC PROP HANDLING\n  //\n\n  // Checks if a prop is overridden\n  hasAsyncProp(propName) {\n    return propName in this.asyncProps;\n  }\n\n  // Returns value of an overriden prop\n  getAsyncProp(propName) {\n    const asyncProp = this.asyncProps[propName];\n    return asyncProp && asyncProp.resolvedValue;\n  }\n\n  isAsyncPropLoading(propName) {\n    if (propName) {\n      const asyncProp = this.asyncProps[propName];\n      return Boolean(\n        asyncProp &&\n          asyncProp.pendingLoadCount > 0 &&\n          asyncProp.pendingLoadCount !== asyncProp.resolvedLoadCount\n      );\n    }\n    for (const key in this.asyncProps) {\n      if (this.isAsyncPropLoading(key)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  // Without changing the original prop value, swap out the data resolution under the hood\n  reloadAsyncProp(propName, value) {\n    this._watchPromise(propName, Promise.resolve(value));\n  }\n\n  // Updates all async/overridden props (when new props come in)\n  // Checks if urls have changed, starts loading, or removes override\n  setAsyncProps(props) {\n    // NOTE: prop param and default values are only support for testing\n    const resolvedValues = props[ASYNC_RESOLVED] || {};\n    const originalValues = props[ASYNC_ORIGINAL] || props;\n    const defaultValues = props[ASYNC_DEFAULTS] || {};\n\n    // TODO - use async props from the layer's prop types\n    for (const propName in resolvedValues) {\n      const value = resolvedValues[propName];\n      this._createAsyncPropData(propName, defaultValues[propName]);\n      this._updateAsyncProp(propName, value);\n      // Use transformed value\n      resolvedValues[propName] = this.getAsyncProp(propName);\n    }\n\n    for (const propName in originalValues) {\n      const value = originalValues[propName];\n      // Makes sure a record exists for this prop\n      this._createAsyncPropData(propName, defaultValues[propName]);\n      this._updateAsyncProp(propName, value);\n    }\n  }\n\n  // Intercept strings (URLs) and Promises and activates loading and prop rewriting\n  _updateAsyncProp(propName, value) {\n    if (!this._didAsyncInputValueChange(propName, value)) {\n      return;\n    }\n\n    // interpret value string as url and start a new load tracked by a promise\n    if (typeof value === 'string') {\n      const fetch = this.layer?.props.fetch;\n      const url = value;\n      if (fetch) {\n        value = fetch(url, {propName, layer: this.layer});\n      }\n    }\n\n    // interprets promise and track the \"loading\"\n    if (value instanceof Promise) {\n      this._watchPromise(propName, value);\n      return;\n    }\n\n    if (isAsyncIterable(value)) {\n      this._resolveAsyncIterable(propName, value);\n      return;\n    }\n\n    // else, normal, non-async value. Just store value for now\n    this._setPropValue(propName, value);\n  }\n\n  // Checks if an input value actually changed (to avoid reloading/rewatching promises/urls)\n  _didAsyncInputValueChange(propName, value) {\n    const asyncProp = this.asyncProps[propName];\n    if (value === asyncProp.resolvedValue || value === asyncProp.lastValue) {\n      return false;\n    }\n    asyncProp.lastValue = value;\n    return true;\n  }\n\n  // Set normal, non-async value\n  _setPropValue(propName, value) {\n    // Save the current value before overwriting so that diffProps can access both\n    this.freezeAsyncOldProps();\n\n    const asyncProp = this.asyncProps[propName];\n    value = this._postProcessValue(asyncProp, value);\n    asyncProp.resolvedValue = value;\n    asyncProp.pendingLoadCount++;\n    asyncProp.resolvedLoadCount = asyncProp.pendingLoadCount;\n  }\n\n  // Set a just resolved async value, calling onAsyncPropUpdates if value changes asynchronously\n  _setAsyncPropValue(propName, value, loadCount) {\n    // Only update if loadCount is larger or equal to resolvedLoadCount\n    // otherwise a more recent load has already completed\n    const asyncProp = this.asyncProps[propName];\n    if (asyncProp && loadCount >= asyncProp.resolvedLoadCount && value !== undefined) {\n      // Save the current value before overwriting so that diffProps can access both\n      this.freezeAsyncOldProps();\n\n      asyncProp.resolvedValue = value;\n      asyncProp.resolvedLoadCount = loadCount;\n\n      // Call callback to inform listener\n      this.onAsyncPropUpdated(propName, value);\n    }\n  }\n\n  // Tracks a promise, sets the prop when loaded, handles load count\n  _watchPromise(propName, promise) {\n    const asyncProp = this.asyncProps[propName];\n    asyncProp.pendingLoadCount++;\n    const loadCount = asyncProp.pendingLoadCount;\n    promise\n      .then(data => {\n        data = this._postProcessValue(asyncProp, data);\n        this._setAsyncPropValue(propName, data, loadCount);\n\n        const onDataLoad = this.layer?.props.onDataLoad;\n        if (propName === 'data' && onDataLoad) {\n          onDataLoad(data, {propName, layer: this.layer});\n        }\n      })\n      .catch(error => {\n        this.layer?.raiseError(error, `loading ${propName} of ${this.layer}`);\n      });\n  }\n\n  async _resolveAsyncIterable(propName, iterable) {\n    if (propName !== 'data') {\n      // we only support data as async iterable\n      this._setPropValue(propName, iterable);\n    }\n\n    const asyncProp = this.asyncProps[propName];\n    asyncProp.pendingLoadCount++;\n    const loadCount = asyncProp.pendingLoadCount;\n    let data = [];\n    let count = 0;\n\n    for await (const chunk of iterable) {\n      const {dataTransform} = this.component ? this.component.props : {};\n      if (dataTransform) {\n        data = dataTransform(chunk, data);\n      } else {\n        data = data.concat(chunk);\n      }\n\n      // Used by the default _dataDiff function\n      Object.defineProperty(data, '__diff', {\n        enumerable: false,\n        value: [{startRow: count, endRow: data.length}]\n      });\n\n      count = data.length;\n      this._setAsyncPropValue(propName, data, loadCount);\n    }\n\n    const onDataLoad = this.layer?.props.onDataLoad;\n    if (onDataLoad) {\n      onDataLoad(data, {propName, layer: this.layer});\n    }\n  }\n\n  // Give the app a chance to post process the loaded data\n  _postProcessValue(asyncProp, value) {\n    const propType = asyncProp.type;\n    if (propType) {\n      if (propType.release) {\n        propType.release(asyncProp.resolvedValue, propType, this.component);\n      }\n      if (propType.transform) {\n        return propType.transform(value, propType, this.component);\n      }\n    }\n    return value;\n  }\n\n  // Creating an asyncProp record if needed\n  _createAsyncPropData(propName, defaultValue) {\n    const asyncProp = this.asyncProps[propName];\n    if (!asyncProp) {\n      const propTypes = this.component && this.component.constructor._propTypes;\n      // assert(defaultValue !== undefined);\n      this.asyncProps[propName] = {\n        type: propTypes && propTypes[propName],\n        lastValue: null, // Supplied prop value (can be url/promise, not visible to layer)\n        resolvedValue: defaultValue, // Resolved prop value (valid data, can be \"shown\" to layer)\n        pendingLoadCount: 0, // How many loads have been issued\n        resolvedLoadCount: 0 // Latest resolved load, (earlier loads will be ignored)\n      };\n    }\n  }\n}\n","import ComponentState from '../lifecycle/component-state';\n\nexport default class LayerState extends ComponentState {\n  constructor({attributeManager, layer}) {\n    super(layer);\n    this.attributeManager = attributeManager;\n    this.model = null;\n    this.needsRedraw = true;\n    this.subLayers = null; // reference to sublayers rendered in a previous cycle\n    this.usesPickingColorCache = false;\n  }\n\n  get layer() {\n    return this.component;\n  }\n\n  set layer(layer) {\n    this.component = layer;\n  }\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\nimport Layer from './layer';\nimport debug from '../debug';\nimport {flatten} from '../utils/flatten';\n\nconst TRACE_RENDER_LAYERS = 'compositeLayer.renderLayers';\n\nexport default class CompositeLayer extends Layer {\n  get isComposite() {\n    return true;\n  }\n\n  get isLoaded() {\n    return super.isLoaded && this.getSubLayers().every(layer => layer.isLoaded);\n  }\n\n  getSubLayers() {\n    return (this.internalState && this.internalState.subLayers) || [];\n  }\n\n  // initializeState is usually not needed for composite layers\n  // Provide empty definition to disable check for missing definition\n  initializeState() {}\n\n  // Updates selected state members and marks the composite layer to need rerender\n  setState(updateObject) {\n    super.setState(updateObject);\n    // Trigger a layer update\n    // Although conceptually layer.draw and compositeLayer.renderLayers are equivalent,\n    // they are executed during different lifecycles.\n    // draw can be called without calling updateState (e.g. most viewport changes),\n    // while renderLayers can only be called during a recursive layer update.\n    this.setNeedsUpdate();\n  }\n\n  // called to augment the info object that is bubbled up from a sublayer\n  // override Layer.getPickingInfo() because decoding / setting uniform do\n  // not apply to a composite layer.\n  // @return null to cancel event\n  getPickingInfo({info}) {\n    const {object} = info;\n    const isDataWrapped =\n      object && object.__source && object.__source.parent && object.__source.parent.id === this.id;\n\n    if (!isDataWrapped) {\n      return info;\n    }\n\n    // override object with picked data\n    info.object = object.__source.object;\n    info.index = object.__source.index;\n\n    return info;\n  }\n\n  // Implement to generate subLayers\n  renderLayers() {\n    return null;\n  }\n\n  /**\n   * Filters sub layers at draw time\n   * @param {Layer} context.layer - sub layer instance\n   * @param {Viewport} context.viewport - the viewport being rendered in\n   * @param {Boolean} context.isPicking - whether it is a picking pass\n   * @param {String} context.pass - the current pass\n   * @return {Boolean} true if the sub layer should be drawn\n   */\n  filterSubLayer(context) {\n    return true;\n  }\n\n  // Returns true if sub layer needs to be rendered\n  shouldRenderSubLayer(id, data) {\n    return data && data.length;\n  }\n\n  // Returns sub layer class for a specific sublayer\n  getSubLayerClass(id, DefaultLayerClass) {\n    const {_subLayerProps: overridingProps} = this.props;\n\n    return (\n      (overridingProps && overridingProps[id] && overridingProps[id].type) || DefaultLayerClass\n    );\n  }\n\n  // When casting user data into another format to pass to sublayers,\n  // add reference to the original object and object index\n  getSubLayerRow(row, sourceObject, sourceObjectIndex) {\n    row.__source = {\n      parent: this,\n      object: sourceObject,\n      index: sourceObjectIndex\n    };\n    return row;\n  }\n\n  // Some composite layers cast user data into another format before passing to sublayers\n  // We need to unwrap them before calling the accessor so that they see the original data\n  // objects\n  getSubLayerAccessor(accessor) {\n    if (typeof accessor === 'function') {\n      const objectInfo = {\n        data: this.props.data,\n        target: []\n      };\n      return (x, i) => {\n        if (x && x.__source) {\n          objectInfo.index = x.__source.index;\n          return accessor(x.__source.object, objectInfo);\n        }\n        return accessor(x, i);\n      };\n    }\n    return accessor;\n  }\n\n  // Returns sub layer props for a specific sublayer\n  // eslint-disable-next-line complexity\n  getSubLayerProps(sublayerProps = {}) {\n    const {\n      opacity,\n      pickable,\n      visible,\n      parameters,\n      getPolygonOffset,\n      highlightedObjectIndex,\n      autoHighlight,\n      highlightColor,\n      coordinateSystem,\n      coordinateOrigin,\n      wrapLongitude,\n      positionFormat,\n      modelMatrix,\n      extensions,\n      fetch,\n      _subLayerProps: overridingProps\n    } = this.props;\n    const newProps = {\n      opacity,\n      pickable,\n      visible,\n      parameters,\n      getPolygonOffset,\n      highlightedObjectIndex,\n      autoHighlight,\n      highlightColor,\n      coordinateSystem,\n      coordinateOrigin,\n      wrapLongitude,\n      positionFormat,\n      modelMatrix,\n      extensions,\n      fetch\n    };\n\n    const overridingSublayerProps = overridingProps && overridingProps[sublayerProps.id];\n    const overridingSublayerTriggers =\n      overridingSublayerProps && overridingSublayerProps.updateTriggers;\n    const sublayerId = sublayerProps.id || 'sublayer';\n\n    if (overridingSublayerProps) {\n      const propTypes = this.constructor._propTypes;\n      const subLayerPropTypes = sublayerProps.type ? sublayerProps.type._propTypes : {};\n      for (const key in overridingSublayerProps) {\n        const propType = subLayerPropTypes[key] || propTypes[key];\n        // eslint-disable-next-line\n        if (propType && propType.type === 'accessor') {\n          overridingSublayerProps[key] = this.getSubLayerAccessor(overridingSublayerProps[key]);\n        }\n      }\n    }\n\n    Object.assign(\n      newProps,\n      sublayerProps,\n      // experimental feature that allows users to override sublayer props via parent layer prop\n      overridingSublayerProps\n    );\n    newProps.id = `${this.props.id}-${sublayerId}`;\n    newProps.updateTriggers = {\n      all: this.props.updateTriggers.all,\n      ...sublayerProps.updateTriggers,\n      ...overridingSublayerTriggers\n    };\n\n    // Pass through extension props\n    for (const extension of extensions) {\n      const passThroughProps = extension.getSubLayerProps.call(this, extension);\n      if (passThroughProps) {\n        Object.assign(newProps, passThroughProps, {\n          updateTriggers: Object.assign(newProps.updateTriggers, passThroughProps.updateTriggers)\n        });\n      }\n    }\n\n    return newProps;\n  }\n\n  _updateAutoHighlight(info) {\n    for (const layer of this.getSubLayers()) {\n      layer.updateAutoHighlight(info);\n    }\n  }\n\n  _getAttributeManager() {\n    return null;\n  }\n\n  // Called by layer manager to render subLayers\n  _renderLayers() {\n    let {subLayers} = this.internalState;\n    const shouldUpdate = !subLayers || this.needsUpdate();\n    if (shouldUpdate) {\n      subLayers = this.renderLayers();\n      // Flatten the returned array, removing any null, undefined or false\n      // this allows layers to render sublayers conditionally\n      // (see CompositeLayer.renderLayers docs)\n      subLayers = flatten(subLayers, Boolean);\n      this.internalState.subLayers = subLayers;\n    }\n    debug(TRACE_RENDER_LAYERS, this, shouldUpdate, subLayers);\n\n    // populate reference to parent layer (this layer)\n    // NOTE: needs to be done even when reusing layers as the parent may have changed\n    for (const layer of subLayers) {\n      layer.parent = this;\n    }\n  }\n}\n\nCompositeLayer.layerName = 'CompositeLayer';\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\nimport {deepEqual} from '../utils/deep-equal';\n\nexport default class LayerExtension {\n  constructor(opts = {}) {\n    this.opts = opts;\n  }\n\n  equals(extension) {\n    if (this === extension) {\n      return true;\n    }\n\n    return this.constructor === extension.constructor && deepEqual(this.opts, extension.opts);\n  }\n\n  getShaders(extension) {\n    return null;\n  }\n\n  getSubLayerProps(extension) {\n    const {defaultProps = {}} = extension.constructor;\n    const newProps = {\n      updateTriggers: {}\n    };\n\n    /* eslint-disable max-depth */\n    for (const key in defaultProps) {\n      if (key in this.props) {\n        const propDef = defaultProps[key];\n        const propValue = this.props[key];\n        newProps[key] = propValue;\n        if (propDef && propDef.type === 'accessor') {\n          newProps.updateTriggers[key] = this.props.updateTriggers[key];\n          if (typeof propValue === 'function') {\n            newProps[key] = this.getSubLayerAccessor(propValue, true);\n          }\n        }\n      }\n    }\n    /* eslint-enable max-depth */\n    return newProps;\n  }\n\n  initializeState(context, extension) {}\n\n  updateState(params, extension) {}\n\n  draw(params, extension) {}\n\n  finalizeState(extension) {}\n}\n","import {PointLight} from './point-light';\nimport {getUniformsFromViewport} from '../../shaderlib/project/viewport-uniforms';\n\nexport default class CameraLight extends PointLight {\n  getProjectedLight({layer}) {\n    const {projectedLight} = this;\n    const viewport = layer.context.viewport;\n    const {coordinateSystem, coordinateOrigin, modelMatrix} = layer.props;\n    const {project_uCameraPosition} = getUniformsFromViewport({\n      viewport,\n      modelMatrix,\n      coordinateSystem,\n      coordinateOrigin\n    });\n    projectedLight.color = this.color;\n    projectedLight.intensity = this.intensity;\n    projectedLight.position = project_uCameraPosition;\n    return projectedLight;\n  }\n}\n","import {DirectionalLight} from './directional-light';\nimport {getSunlightDirection} from './suncalc';\n\nexport default class SunLight extends DirectionalLight {\n  constructor({timestamp, ...others}) {\n    super(others);\n\n    this.timestamp = timestamp;\n  }\n\n  getProjectedLight({layer}) {\n    const {viewport} = layer.context;\n    const isGlobe = viewport.resolution > 0;\n\n    if (isGlobe) {\n      // Rotate vector to align with the direction of the globe projection (up at lon:0,lat:0 is [0, -1, 0])\n      const [x, y, z] = getSunlightDirection(this.timestamp, 0, 0);\n      this.direction = [x, -z, y];\n    } else {\n      const {latitude, longitude} = viewport;\n      this.direction = getSunlightDirection(this.timestamp, latitude, longitude);\n    }\n\n    return this;\n  }\n}\n","// sun position calculations are based on http://aa.quae.nl/en/reken/zonpositie.html formulas\n// and inspired by https://github.com/mourner/suncalc/blob/master/suncalc.js\nconst DEGREES_TO_RADIANS = Math.PI / 180;\n\nconst DAY_IN_MS = 1000 * 60 * 60 * 24;\nconst JD1970 = 2440588; // Julian Day year 1970\nconst JD2000 = 2451545; // Julian Day year 2000\n\n// This angle ε [epsilon] is called the obliquity of the ecliptic and its value at the beginning of 2000 was 23.4397°\nconst e = DEGREES_TO_RADIANS * 23.4397; // obliquity of the Earth\n\n// Refer https://www.aa.quae.nl/en/reken/zonpositie.html\n// \"The Mean Anomaly\" section for explanation\nconst M0 = 357.5291; // Earth mean anomaly on start day\nconst M1 = 0.98560028; // Earth angle traverses on average per day seen from the sun\n\nconst THETA0 = 280.147; // The sidereal time (in degrees) at longitude 0° at the instant defined by JD2000\nconst THETA1 = 360.9856235; // The rate of change of the sidereal time, in degrees per day.\n\nexport function getSolarPosition(timestamp, latitude, longitude) {\n  const longitudeWestInRadians = DEGREES_TO_RADIANS * -longitude;\n  const phi = DEGREES_TO_RADIANS * latitude;\n  const d = toDays(timestamp);\n\n  const c = getSunCoords(d);\n  // hour angle\n  const H = getSiderealTime(d, longitudeWestInRadians) - c.rightAscension;\n\n  // https://www.aa.quae.nl/en/reken/zonpositie.html\n  // The altitude is 0° at the horizon, +90° in the zenith (straight over your head), and −90° in the nadir (straight down).\n  // The azimuth is the direction along the horizon, which we measure from south to west.\n  // South has azimuth 0°, west +90°, north +180°, and east +270° (or −90°, that's the same thing).\n  return {\n    azimuth: getAzimuth(H, phi, c.declination),\n    altitude: getAltitude(H, phi, c.declination)\n  };\n}\n\nexport function getSunlightDirection(timestamp, latitude, longitude) {\n  const {azimuth, altitude} = getSolarPosition(timestamp, latitude, longitude);\n\n  // solar position to light direction\n  return [\n    Math.sin(azimuth) * Math.cos(altitude),\n    Math.cos(azimuth) * Math.cos(altitude),\n    -Math.sin(altitude)\n  ];\n}\n\nfunction toJulianDay(timestamp) {\n  return timestamp / DAY_IN_MS - 0.5 + JD1970;\n}\n\nfunction toDays(timestamp) {\n  return toJulianDay(timestamp) - JD2000;\n}\n\nfunction getRightAscension(eclipticLongitude, b) {\n  const lambda = eclipticLongitude;\n  return Math.atan2(Math.sin(lambda) * Math.cos(e) - Math.tan(b) * Math.sin(e), Math.cos(lambda));\n}\n\nfunction getDeclination(eclipticLongitude, b) {\n  const lambda = eclipticLongitude;\n  return Math.asin(Math.sin(b) * Math.cos(e) + Math.cos(b) * Math.sin(e) * Math.sin(lambda));\n}\n\nfunction getAzimuth(hourAngle, latitudeInRadians, declination) {\n  const H = hourAngle;\n  const phi = latitudeInRadians;\n  const delta = declination;\n  return Math.atan2(Math.sin(H), Math.cos(H) * Math.sin(phi) - Math.tan(delta) * Math.cos(phi));\n}\n\nfunction getAltitude(hourAngle, latitudeInRadians, declination) {\n  const H = hourAngle;\n  const phi = latitudeInRadians;\n  const delta = declination;\n  return Math.asin(Math.sin(phi) * Math.sin(delta) + Math.cos(phi) * Math.cos(delta) * Math.cos(H));\n}\n\n// https://www.aa.quae.nl/en/reken/zonpositie.html\n// \"The Observer section\"\nfunction getSiderealTime(dates, longitudeWestInRadians) {\n  return DEGREES_TO_RADIANS * (THETA0 + THETA1 * dates) - longitudeWestInRadians;\n}\n\nfunction getSolarMeanAnomaly(days) {\n  return DEGREES_TO_RADIANS * (M0 + M1 * days);\n}\n\nfunction getEclipticLongitude(meanAnomaly) {\n  const M = meanAnomaly;\n  // equation of center\n  const C =\n    DEGREES_TO_RADIANS * (1.9148 * Math.sin(M) + 0.02 * Math.sin(2 * M) + 0.0003 * Math.sin(3 * M));\n  // perihelion of the Earth\n  const P = DEGREES_TO_RADIANS * 102.9372;\n\n  return M + C + P + Math.PI;\n}\n\nfunction getSunCoords(dates) {\n  const M = getSolarMeanAnomaly(dates);\n  const L = getEclipticLongitude(M);\n\n  return {\n    declination: getDeclination(L, 0),\n    rightAscension: getRightAscension(L, 0)\n  };\n}\n","import Effect from '../lib/effect';\nimport ScreenPass from '../passes/screen-pass';\nimport {normalizeShaderModule} from '@luma.gl/core';\n\nexport default class PostProcessEffect extends Effect {\n  constructor(module, props = {}) {\n    super(props);\n    this.id = `${module.name}-pass`;\n    normalizeShaderModule(module);\n    this.module = module;\n  }\n\n  postRender(gl, params) {\n    if (!this.passes) {\n      this.passes = createPasses(gl, this.module, this.id, this.props);\n    }\n\n    const {target} = params;\n    let inputBuffer = params.inputBuffer;\n    let outputBuffer = params.swapBuffer;\n\n    for (let index = 0; index < this.passes.length; index++) {\n      if (target && index === this.passes.length - 1) {\n        outputBuffer = target;\n      }\n      this.passes[index].render({inputBuffer, outputBuffer});\n      const switchBuffer = outputBuffer;\n      outputBuffer = inputBuffer;\n      inputBuffer = switchBuffer;\n    }\n    return inputBuffer;\n  }\n\n  cleanup() {\n    if (this.passes) {\n      for (const pass of this.passes) {\n        pass.delete();\n      }\n      this.passes = null;\n    }\n  }\n}\n\nfunction createPasses(gl, module, id, moduleSettings) {\n  if (module.filter || module.sampler) {\n    const fs = getFragmentShaderForRenderPass(module);\n    const pass = new ScreenPass(gl, {\n      id,\n      module,\n      fs,\n      moduleSettings\n    });\n    return [pass];\n  }\n\n  const passes = module.passes || [];\n  return passes.map((pass, index) => {\n    const fs = getFragmentShaderForRenderPass(module, pass);\n    const idn = `${id}-${index}`;\n\n    return new ScreenPass(gl, {\n      id: idn,\n      module,\n      fs,\n      moduleSettings\n    });\n  });\n}\n\nconst FILTER_FS_TEMPLATE = func => `\\\nuniform sampler2D texture;\nuniform vec2 texSize;\n\nvarying vec2 position;\nvarying vec2 coordinate;\nvarying vec2 uv;\n\nvoid main() {\n  vec2 texCoord = coordinate;\n\n  gl_FragColor = texture2D(texture, texCoord);\n  gl_FragColor = ${func}(gl_FragColor, texSize, texCoord);\n}\n`;\n\nconst SAMPLER_FS_TEMPLATE = func => `\\\nuniform sampler2D texture;\nuniform vec2 texSize;\n\nvarying vec2 position;\nvarying vec2 coordinate;\nvarying vec2 uv;\n\nvoid main() {\n  vec2 texCoord = coordinate;\n\n  gl_FragColor = ${func}(texture, texSize, texCoord);\n}\n`;\n\nfunction getFragmentShaderForRenderPass(module, pass = module) {\n  if (pass.filter) {\n    const func = typeof pass.filter === 'string' ? pass.filter : `${module.name}_filterColor`;\n    return FILTER_FS_TEMPLATE(func);\n  }\n\n  if (pass.sampler) {\n    const func = typeof pass.sampler === 'string' ? pass.sampler : `${module.name}_sampleColor`;\n    return SAMPLER_FS_TEMPLATE(func);\n  }\n\n  // console.error(`${module.name} no fragment shader generated`);\n  return null;\n}\n","//\n// A base render pass.\n//\n// Attribution: This class and the multipass system were inspired by\n// the THREE.js EffectComposer and *Pass classes\n\nimport {ClipSpace, setParameters, withParameters, clear} from '@luma.gl/core';\nimport Pass from './pass';\n\nexport default class ScreenPass extends Pass {\n  constructor(gl, props = {}) {\n    super(gl, props);\n    const {module, fs, id} = props;\n    this.model = new ClipSpace(gl, {id, fs, modules: [module]});\n  }\n\n  render(params) {\n    const gl = this.gl;\n\n    setParameters(gl, {viewport: [0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight]});\n\n    withParameters(gl, {framebuffer: params.outputBuffer, clearColor: [0, 0, 0, 0]}, () =>\n      this._renderPass(gl, params)\n    );\n  }\n\n  delete() {\n    this.model.delete();\n    this.model = null;\n  }\n\n  // Private methods\n\n  /**\n   * Renders the pass.\n   * This is an abstract method that should be overridden.\n   * @param {Framebuffer} inputBuffer - Frame buffer that contains the result of the previous pass\n   * @param {Framebuffer} outputBuffer - Frame buffer that serves as the output render target\n   */\n  _renderPass(gl, {inputBuffer, outputBuffer}) {\n    clear(gl, {color: true});\n    this.model.draw({\n      moduleSettings: this.props.moduleSettings,\n      uniforms: {\n        texture: inputBuffer,\n        texSize: [inputBuffer.width, inputBuffer.height]\n      },\n      parameters: {\n        depthWrite: false,\n        depthTest: false\n      }\n    });\n  }\n}\n","import {Matrix4} from 'math.gl';\nimport Viewport from './viewport';\nimport {PROJECTION_MODE} from '../lib/constants';\n\nimport * as vec3 from 'gl-matrix/vec3';\nimport * as vec4 from 'gl-matrix/vec4';\n\nconst DEGREES_TO_RADIANS = Math.PI / 180;\nconst RADIANS_TO_DEGREES = 180 / Math.PI;\nconst EARTH_RADIUS = 6370972;\nconst GLOBE_RADIUS = 256;\n\nfunction getDistanceScales() {\n  const unitsPerMeter = GLOBE_RADIUS / EARTH_RADIUS;\n  const unitsPerDegree = (Math.PI / 180) * GLOBE_RADIUS;\n\n  return {\n    unitsPerMeter: [unitsPerMeter, unitsPerMeter, unitsPerMeter],\n    unitsPerMeter2: [0, 0, 0],\n    metersPerUnit: [1 / unitsPerMeter, 1 / unitsPerMeter, 1 / unitsPerMeter],\n    unitsPerDegree: [unitsPerDegree, unitsPerDegree, unitsPerMeter],\n    unitsPerDegree2: [0, 0, 0],\n    degreesPerUnit: [1 / unitsPerDegree, 1 / unitsPerDegree, 1 / unitsPerMeter]\n  };\n}\n\nexport default class GlobeViewport extends Viewport {\n  constructor(opts = {}) {\n    const {\n      latitude = 0,\n      longitude = 0,\n      zoom = 11,\n      nearZMultiplier = 0.1,\n      farZMultiplier = 2,\n      resolution = 10\n    } = opts;\n\n    let {width, height, altitude = 1.5} = opts;\n\n    width = width || 1;\n    height = height || 1;\n    altitude = Math.max(0.75, altitude);\n\n    // Calculate view matrix\n    const viewMatrix = new Matrix4().lookAt({eye: [0, -altitude, 0], up: [0, 0, 1]});\n    const scale = Math.pow(2, zoom);\n    viewMatrix.rotateX(latitude * DEGREES_TO_RADIANS);\n    viewMatrix.rotateZ(-longitude * DEGREES_TO_RADIANS);\n    viewMatrix.scale(scale / height);\n\n    const halfFov = Math.atan(0.5 / altitude);\n    const relativeScale = (GLOBE_RADIUS * 2 * scale) / height;\n\n    super({\n      ...opts,\n      // x, y,\n      width,\n      height,\n\n      // view matrix\n      viewMatrix,\n      longitude,\n      latitude,\n      zoom,\n\n      // projection matrix parameters\n      fovyRadians: halfFov * 2,\n      aspect: width / height,\n      focalDistance: altitude,\n      near: nearZMultiplier,\n      far: Math.min(2, 1 / relativeScale + 1) * altitude * farZMultiplier\n    });\n\n    this.resolution = resolution;\n    this.distanceScales = getDistanceScales();\n  }\n\n  get projectionMode() {\n    return PROJECTION_MODE.GLOBE;\n  }\n\n  getDistanceScales() {\n    return this.distanceScales;\n  }\n\n  getBounds(options = {}) {\n    const unprojectOption = {targetZ: options.z || 0};\n\n    const left = this.unproject([0, this.height / 2], unprojectOption);\n    const top = this.unproject([this.width / 2, 0], unprojectOption);\n    const right = this.unproject([this.width, this.height / 2], unprojectOption);\n    const bottom = this.unproject([this.width / 2, this.height], unprojectOption);\n\n    if (right[0] < this.longitude) right[0] += 360;\n    if (left[0] > this.longitude) left[0] -= 360;\n\n    return [\n      Math.min(left[0], right[0], top[0], bottom[0]),\n      Math.min(left[1], right[1], top[1], bottom[1]),\n      Math.max(left[0], right[0], top[0], bottom[0]),\n      Math.max(left[1], right[1], top[1], bottom[1])\n    ];\n  }\n\n  unproject(xyz, {topLeft = true, targetZ} = {}) {\n    const [x, y, z] = xyz;\n\n    const y2 = topLeft ? y : this.height - y;\n    const {pixelUnprojectionMatrix} = this;\n\n    let coord;\n    if (Number.isFinite(z)) {\n      // Has depth component\n      coord = transformVector(pixelUnprojectionMatrix, [x, y2, z, 1]);\n    } else {\n      // since we don't know the correct projected z value for the point,\n      // unproject two points to get a line and then find the point on that line that intersects with the sphere\n      const coord0 = transformVector(pixelUnprojectionMatrix, [x, y2, -1, 1]);\n      const coord1 = transformVector(pixelUnprojectionMatrix, [x, y2, 1, 1]);\n\n      const lt = ((targetZ || 0) / EARTH_RADIUS + 1) * GLOBE_RADIUS;\n      const lSqr = vec3.sqrLen(vec3.sub([], coord0, coord1));\n      const l0Sqr = vec3.sqrLen(coord0);\n      const l1Sqr = vec3.sqrLen(coord1);\n      const sSqr = (4 * l0Sqr * l1Sqr - (lSqr - l0Sqr - l1Sqr) ** 2) / 16;\n      const dSqr = (4 * sSqr) / lSqr;\n      const r0 = Math.sqrt(l0Sqr - dSqr);\n      const dr = Math.sqrt(Math.max(0, lt * lt - dSqr));\n      const t = (r0 - dr) / Math.sqrt(lSqr);\n\n      coord = vec3.lerp([], coord0, coord1, t);\n    }\n    const [X, Y, Z] = this.unprojectPosition(coord);\n\n    if (Number.isFinite(z)) {\n      return [X, Y, Z];\n    }\n    return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y];\n  }\n\n  projectPosition(xyz) {\n    const [lng, lat, Z = 0] = xyz;\n    const lambda = lng * DEGREES_TO_RADIANS;\n    const phi = lat * DEGREES_TO_RADIANS;\n    const cosPhi = Math.cos(phi);\n    const D = (Z / EARTH_RADIUS + 1) * GLOBE_RADIUS;\n\n    return [Math.sin(lambda) * cosPhi * D, -Math.cos(lambda) * cosPhi * D, Math.sin(phi) * D];\n  }\n\n  unprojectPosition(xyz) {\n    const [x, y, z] = xyz;\n    const D = vec3.len(xyz);\n    const phi = Math.asin(z / D);\n    const lambda = Math.atan2(x, -y);\n\n    const lng = lambda * RADIANS_TO_DEGREES;\n    const lat = phi * RADIANS_TO_DEGREES;\n    const Z = (D / GLOBE_RADIUS - 1) * EARTH_RADIUS;\n    return [lng, lat, Z];\n  }\n\n  projectFlat(xyz) {\n    return xyz;\n  }\n\n  unprojectFlat(xyz) {\n    return xyz;\n  }\n\n  panByPosition(coords, pixel) {\n    const fromPosition = this.unproject(pixel);\n    return {\n      longitude: coords[0] - fromPosition[0] + this.longitude,\n      latitude: coords[1] - fromPosition[1] + this.latitude\n    };\n  }\n}\n\nfunction transformVector(matrix, vector) {\n  const result = vec4.transformMat4([], vector, matrix);\n  vec4.scale(result, result, 1 / result[3]);\n  return result;\n}\n","import View from './view';\nimport Viewport from '../viewports/viewport';\nimport {getMeterZoom} from '@math.gl/web-mercator';\nimport {Matrix4, _SphericalCoordinates as SphericalCoordinates} from 'math.gl';\nimport FirstPersonController from '../controllers/first-person-controller';\n\nfunction getDirectionFromBearingAndPitch({bearing, pitch}) {\n  const spherical = new SphericalCoordinates({bearing, pitch});\n  const direction = spherical.toVector3().normalize();\n  return direction;\n}\n\nclass FirstPersonViewport extends Viewport {\n  constructor(props) {\n    // TODO - push direction handling into Matrix4.lookAt\n    const {\n      // view matrix arguments\n      modelMatrix = null,\n      bearing = 0,\n      pitch = 0,\n      up = [0, 0, 1] // Defines up direction, default positive z axis,\n    } = props;\n\n    // Always calculate direction from bearing and pitch\n    const dir = getDirectionFromBearingAndPitch({\n      bearing,\n      // Avoid \"pixel project matrix not invertible\" error\n      pitch: pitch === -90 ? 0.0001 : 90 + pitch\n    });\n\n    // Direction is relative to model coordinates, of course\n    const center = modelMatrix ? modelMatrix.transformDirection(dir) : dir;\n\n    // Just the direction. All the positioning is done in viewport.js\n    const zoom = getMeterZoom(props);\n    const scale = Math.pow(2, zoom);\n    const viewMatrix = new Matrix4().lookAt({eye: [0, 0, 0], center, up}).scale(scale);\n\n    super({\n      ...props,\n      zoom,\n      viewMatrix\n    });\n  }\n}\n\nexport default class FirstPersonView extends View {\n  constructor(props) {\n    super({\n      ...props,\n      type: FirstPersonViewport\n    });\n  }\n\n  get controller() {\n    return this._getControllerProps({\n      type: FirstPersonController\n    });\n  }\n}\n\nFirstPersonView.displayName = 'FirstPersonView';\n","import Controller from './controller';\nimport ViewState from './view-state';\nimport {mod} from '../utils/math-utils';\n\nimport {Vector3, _SphericalCoordinates as SphericalCoordinates, clamp} from 'math.gl';\n\nconst MOVEMENT_SPEED = 20;\nconst DEFAULT_STATE = {\n  position: [0, 0, 0],\n  pitch: 0,\n  bearing: 0,\n  maxPitch: 90,\n  minPitch: -90\n};\n\nclass FirstPersonState extends ViewState {\n  constructor({\n    /* Viewport arguments */\n    width, // Width of viewport\n    height, // Height of viewport\n\n    // Position and orientation\n    position = DEFAULT_STATE.position, // typically in meters from anchor point\n\n    bearing = DEFAULT_STATE.bearing, // Rotation around y axis\n    pitch = DEFAULT_STATE.pitch, // Rotation around x axis\n\n    // Geospatial anchor\n    longitude,\n    latitude,\n\n    maxPitch = DEFAULT_STATE.maxPitch,\n    minPitch = DEFAULT_STATE.minPitch,\n\n    // Model state when the rotate operation first started\n    startRotatePos,\n    startBearing,\n    startPitch,\n    startZoomPosition,\n    startZoom\n  }) {\n    super({\n      width,\n      height,\n      position,\n      bearing,\n      pitch,\n      longitude,\n      latitude,\n      maxPitch,\n      minPitch\n    });\n\n    this._state = {\n      startRotatePos,\n      startBearing,\n      startPitch,\n      startZoomPosition,\n      startZoom\n    };\n  }\n\n  /* Public API */\n\n  getDirection(use2D = false) {\n    const spherical = new SphericalCoordinates({\n      bearing: this._viewportProps.bearing,\n      pitch: use2D ? 90 : 90 + this._viewportProps.pitch\n    });\n    const direction = spherical.toVector3().normalize();\n    return direction;\n  }\n\n  /**\n   * Start panning\n   * @param {[Number, Number]} pos - position on screen where the pointer grabs\n   */\n  panStart() {\n    return this;\n  }\n\n  /**\n   * Pan\n   * @param {[Number, Number]} pos - position on screen where the pointer is\n   */\n  pan() {\n    return this;\n  }\n\n  /**\n   * End panning\n   * Must call if `panStart()` was called\n   */\n  panEnd() {\n    return this;\n  }\n\n  /**\n   * Start rotating\n   * @param {[Number, Number]} pos - position on screen where the pointer grabs\n   */\n  rotateStart({pos}) {\n    return this._getUpdatedState({\n      startRotatePos: pos,\n      startBearing: this._viewportProps.bearing,\n      startPitch: this._viewportProps.pitch\n    });\n  }\n\n  /**\n   * Rotate\n   * @param {[Number, Number]} pos - position on screen where the pointer is\n   */\n  rotate({pos, deltaAngleX = 0, deltaAngleY = 0}) {\n    const {startRotatePos, startBearing, startPitch} = this._state;\n    const {width, height} = this._viewportProps;\n\n    if (!startRotatePos || !Number.isFinite(startBearing) || !Number.isFinite(startPitch)) {\n      return this;\n    }\n\n    let newRotation;\n    if (pos) {\n      const deltaScaleX = (pos[0] - startRotatePos[0]) / width;\n      const deltaScaleY = (pos[1] - startRotatePos[1]) / height;\n      newRotation = {\n        bearing: startBearing - deltaScaleX * 180,\n        pitch: startPitch - deltaScaleY * 90\n      };\n    } else {\n      newRotation = {\n        bearing: startBearing - deltaAngleX,\n        pitch: startPitch - deltaAngleY\n      };\n    }\n\n    return this._getUpdatedState(newRotation);\n  }\n\n  /**\n   * End rotating\n   * Must call if `rotateStart()` was called\n   */\n  rotateEnd() {\n    return this._getUpdatedState({\n      startRotatePos: null,\n      startBearing: null,\n      startPitch: null\n    });\n  }\n\n  /**\n   * Start zooming\n   * @param {[Number, Number]} pos - position on screen where the pointer grabs\n   */\n  zoomStart() {\n    return this._getUpdatedState({\n      startZoomPosition: this._viewportProps.position,\n      startZoom: this._viewportProps.zoom\n    });\n  }\n\n  /**\n   * Zoom\n   * @param {[Number, Number]} pos - position on screen where the current center is\n   * @param {[Number, Number]} startPos - the center position at\n   *   the start of the operation. Must be supplied of `zoomStart()` was not called\n   * @param {Number} scale - a number between [0, 1] specifying the accumulated\n   *   relative scale.\n   */\n  zoom({scale}) {\n    let {startZoomPosition} = this._state;\n    if (!startZoomPosition) {\n      startZoomPosition = this._viewportProps.position;\n    }\n\n    const direction = this.getDirection();\n    return this._move(direction, Math.log2(scale) * MOVEMENT_SPEED, startZoomPosition);\n  }\n\n  /**\n   * End zooming\n   * Must call if `zoomStart()` was called\n   */\n  zoomEnd() {\n    return this._getUpdatedState({\n      startZoomPosition: null,\n      startZoom: null\n    });\n  }\n\n  moveLeft(speed = MOVEMENT_SPEED) {\n    const direction = this.getDirection(true);\n    return this._move(direction.rotateZ({radians: Math.PI / 2}), speed);\n  }\n\n  moveRight(speed = MOVEMENT_SPEED) {\n    const direction = this.getDirection(true);\n    return this._move(direction.rotateZ({radians: -Math.PI / 2}), speed);\n  }\n\n  // forward\n  moveUp(speed = MOVEMENT_SPEED) {\n    const direction = this.getDirection(true);\n    return this._move(direction, speed);\n  }\n\n  // backward\n  moveDown(speed = MOVEMENT_SPEED) {\n    const direction = this.getDirection(true);\n    return this._move(direction.negate(), speed);\n  }\n\n  rotateLeft(speed = 15) {\n    return this._getUpdatedState({\n      bearing: this._viewportProps.bearing - speed\n    });\n  }\n\n  rotateRight(speed = 15) {\n    return this._getUpdatedState({\n      bearing: this._viewportProps.bearing + speed\n    });\n  }\n\n  rotateUp(speed = 10) {\n    return this._getUpdatedState({\n      pitch: this._viewportProps.pitch + speed\n    });\n  }\n\n  rotateDown(speed = 10) {\n    return this._getUpdatedState({\n      pitch: this._viewportProps.pitch - speed\n    });\n  }\n\n  zoomIn(speed = 2) {\n    return this.zoom({scale: speed});\n  }\n\n  zoomOut(speed = 2) {\n    return this.zoom({scale: 1 / speed});\n  }\n\n  // shortest path between two view states\n  shortestPathFrom(viewState) {\n    const fromProps = viewState.getViewportProps();\n    const props = {...this._viewportProps};\n    const {bearing, longitude} = props;\n\n    if (Math.abs(bearing - fromProps.bearing) > 180) {\n      props.bearing = bearing < 0 ? bearing + 360 : bearing - 360;\n    }\n    if (Math.abs(longitude - fromProps.longitude) > 180) {\n      props.longitude = longitude < 0 ? longitude + 360 : longitude - 360;\n    }\n    return props;\n  }\n\n  /* Private methods */\n  _move(direction, speed, fromPosition = this._viewportProps.position) {\n    const delta = direction.scale(speed);\n    return this._getUpdatedState({\n      position: new Vector3(fromPosition).add(delta)\n    });\n  }\n\n  _getUpdatedState(newProps) {\n    // Update _viewportProps\n    return new FirstPersonState({...this._viewportProps, ...this._state, ...newProps});\n  }\n\n  // Apply any constraints (mathematical or defined by _viewportProps) to map state\n  _applyConstraints(props) {\n    // Ensure pitch and zoom are within specified range\n    const {pitch, maxPitch, minPitch, longitude, bearing} = props;\n    props.pitch = clamp(pitch, minPitch, maxPitch);\n\n    // Normalize degrees\n    if (longitude < -180 || longitude > 180) {\n      props.longitude = mod(longitude + 180, 360) - 180;\n    }\n    if (bearing < -180 || bearing > 180) {\n      props.bearing = mod(bearing + 180, 360) - 180;\n    }\n\n    return props;\n  }\n}\n\nexport default class FirstPersonController extends Controller {\n  constructor(props) {\n    super(FirstPersonState, props);\n  }\n\n  get linearTransitionProps() {\n    return ['position', 'pitch', 'bearing'];\n  }\n}\n","import View from './view';\nimport Viewport from '../viewports/viewport';\n\nimport {Matrix4} from 'math.gl';\nimport {pixelsToWorld, fovyToAltitude} from '@math.gl/web-mercator';\nimport OrbitController from '../controllers/orbit-controller';\n\nconst DEGREES_TO_RADIANS = Math.PI / 180;\n\nfunction getViewMatrix({height, focalDistance, orbitAxis, rotationX, rotationOrbit, zoom}) {\n  // We position the camera so that one common space unit (world space unit scaled by zoom)\n  // at the target maps to one screen pixel.\n  // This is a similar technique to that used in web mercator projection\n  // By doing so we are able to convert between common space and screen space sizes efficiently\n  // in the vertex shader.\n  const up = orbitAxis === 'Z' ? [0, 0, 1] : [0, 1, 0];\n  const eye = orbitAxis === 'Z' ? [0, -focalDistance, 0] : [0, 0, focalDistance];\n\n  const viewMatrix = new Matrix4().lookAt({eye, up});\n\n  viewMatrix.rotateX(rotationX * DEGREES_TO_RADIANS);\n  if (orbitAxis === 'Z') {\n    viewMatrix.rotateZ(rotationOrbit * DEGREES_TO_RADIANS);\n  } else {\n    viewMatrix.rotateY(rotationOrbit * DEGREES_TO_RADIANS);\n  }\n\n  // When height increases, we need to increase the distance from the camera to the target to\n  // keep the 1:1 mapping. However, this also changes the projected depth of each position by\n  // moving them further away between the near/far plane.\n  // Without modifying the default near/far planes, we instead scale down the common space to\n  // remove the distortion to the depth field.\n  const projectionScale = Math.pow(2, zoom) / (height || 1);\n  viewMatrix.scale(projectionScale);\n\n  return viewMatrix;\n}\n\nclass OrbitViewport extends Viewport {\n  constructor(props) {\n    const {\n      height,\n\n      projectionMatrix,\n\n      fovy = 50, // For setting camera position\n      orbitAxis, // Orbit axis with 360 degrees rotating freedom, can only be 'Y' or 'Z'\n      target = [0, 0, 0], // Which point is camera looking at, default origin\n\n      rotationX = 0, // Rotating angle around X axis\n      rotationOrbit = 0, // Rotating angle around orbit axis\n\n      zoom = 0\n    } = props;\n\n    const focalDistance = projectionMatrix ? projectionMatrix[5] / 2 : fovyToAltitude(fovy);\n\n    super({\n      ...props,\n      // in case viewState contains longitude/latitude values,\n      // make sure that the base Viewport class does not treat this as a geospatial viewport\n      longitude: null,\n      viewMatrix: getViewMatrix({\n        height,\n        focalDistance,\n        orbitAxis,\n        rotationX,\n        rotationOrbit,\n        zoom\n      }),\n      fovy,\n      focalDistance,\n      position: target,\n      zoom\n    });\n\n    this.projectedCenter = this.project(this.center);\n  }\n\n  unproject(xyz, {topLeft = true} = {}) {\n    const [x, y, z = this.projectedCenter[2]] = xyz;\n\n    const y2 = topLeft ? y : this.height - y;\n    const [X, Y, Z] = pixelsToWorld([x, y2, z], this.pixelUnprojectionMatrix);\n    return [X, Y, Z];\n  }\n\n  panByPosition(coords, pixel) {\n    const p0 = this.project(coords);\n    const nextCenter = [\n      this.width / 2 + p0[0] - pixel[0],\n      this.height / 2 + p0[1] - pixel[1],\n      this.projectedCenter[2]\n    ];\n    return {\n      target: this.unproject(nextCenter)\n    };\n  }\n}\n\nexport default class OrbitView extends View {\n  constructor(props = {}) {\n    const {orbitAxis = 'Z'} = props;\n\n    super({\n      ...props,\n      orbitAxis,\n      type: OrbitViewport\n    });\n  }\n\n  get controller() {\n    return this._getControllerProps({\n      type: OrbitController\n    });\n  }\n}\n\nOrbitView.displayName = 'OrbitView';\n","import {clamp} from 'math.gl';\nimport Controller from './controller';\nimport ViewState from './view-state';\nimport {mod} from '../utils/math-utils';\n\nconst DEFAULT_STATE = {\n  rotationX: 0,\n  rotationOrbit: 0,\n  zoom: 0,\n  target: [0, 0, 0],\n  minRotationX: -90,\n  maxRotationX: 90,\n  minZoom: -Infinity,\n  maxZoom: Infinity\n};\n\n/* Helpers */\n\nexport class OrbitState extends ViewState {\n  constructor({\n    makeViewport,\n\n    /* Viewport arguments */\n    width, // Width of viewport\n    height, // Height of viewport\n    rotationX = DEFAULT_STATE.rotationX, // Rotation around x axis\n    rotationOrbit = DEFAULT_STATE.rotationOrbit, // Rotation around orbit axis\n    target = DEFAULT_STATE.target,\n    zoom = DEFAULT_STATE.zoom,\n\n    /* Viewport constraints */\n    minRotationX = DEFAULT_STATE.minRotationX,\n    maxRotationX = DEFAULT_STATE.maxRotationX,\n    minZoom = DEFAULT_STATE.minZoom,\n    maxZoom = DEFAULT_STATE.maxZoom,\n\n    /** Interaction states, required to calculate change during transform */\n    // Model state when the pan operation first started\n    startPanPosition,\n    // Model state when the rotate operation first started\n    startRotatePos,\n    startRotationX,\n    startRotationOrbit,\n    // Model state when the zoom operation first started\n    startZoomPosition,\n    startZoom\n  }) {\n    super({\n      width,\n      height,\n      rotationX,\n      rotationOrbit,\n      target,\n      zoom,\n      minRotationX,\n      maxRotationX,\n      minZoom,\n      maxZoom\n    });\n\n    this._state = {\n      startPanPosition,\n      startRotatePos,\n      startRotationX,\n      startRotationOrbit,\n      startZoomPosition,\n      startZoom\n    };\n\n    this.makeViewport = makeViewport;\n  }\n\n  /**\n   * Start panning\n   * @param {[Number, Number]} pos - position on screen where the pointer grabs\n   */\n  panStart({pos}) {\n    return this._getUpdatedState({\n      startPanPosition: this._unproject(pos)\n    });\n  }\n\n  /**\n   * Pan\n   * @param {[Number, Number]} pos - position on screen where the pointer is\n   */\n  pan({pos, startPosition}) {\n    const startPanPosition = this._state.startPanPosition || startPosition;\n\n    if (!startPanPosition) {\n      return this;\n    }\n\n    const viewport = this.makeViewport(this._viewportProps);\n    const newProps = viewport.panByPosition(startPanPosition, pos);\n\n    return this._getUpdatedState(newProps);\n  }\n\n  /**\n   * End panning\n   * Must call if `panStart()` was called\n   */\n  panEnd() {\n    return this._getUpdatedState({\n      startPanPosition: null\n    });\n  }\n\n  /**\n   * Start rotating\n   * @param {[Number, Number]} pos - position on screen where the pointer grabs\n   */\n  rotateStart({pos}) {\n    return this._getUpdatedState({\n      startRotatePos: pos,\n      startRotationX: this._viewportProps.rotationX,\n      startRotationOrbit: this._viewportProps.rotationOrbit\n    });\n  }\n\n  /**\n   * Rotate\n   * @param {[Number, Number]} pos - position on screen where the pointer is\n   */\n  rotate({pos, deltaAngleX = 0, deltaAngleY = 0}) {\n    const {startRotatePos, startRotationX, startRotationOrbit} = this._state;\n    const {width, height} = this._viewportProps;\n\n    if (\n      !startRotatePos ||\n      !Number.isFinite(startRotationX) ||\n      !Number.isFinite(startRotationOrbit)\n    ) {\n      return this;\n    }\n\n    let newRotation;\n    if (pos) {\n      let deltaScaleX = (pos[0] - startRotatePos[0]) / width;\n      const deltaScaleY = (pos[1] - startRotatePos[1]) / height;\n\n      if (startRotationX < -90 || startRotationX > 90) {\n        // When looking at the \"back\" side of the scene, invert horizontal drag\n        // so that the camera movement follows user input\n        deltaScaleX *= -1;\n      }\n      newRotation = {\n        rotationX: startRotationX + deltaScaleY * 180,\n        rotationOrbit: startRotationOrbit + deltaScaleX * 180\n      };\n    } else {\n      newRotation = {\n        rotationX: startRotationX + deltaAngleY,\n        rotationOrbit: startRotationOrbit + deltaAngleX\n      };\n    }\n\n    return this._getUpdatedState(newRotation);\n  }\n\n  /**\n   * End rotating\n   * Must call if `rotateStart()` was called\n   */\n  rotateEnd() {\n    return this._getUpdatedState({\n      startRotationX: null,\n      startRotationOrbit: null\n    });\n  }\n\n  // shortest path between two view states\n  shortestPathFrom(viewState) {\n    const fromProps = viewState.getViewportProps();\n    const props = {...this._viewportProps};\n    const {rotationOrbit} = props;\n\n    if (Math.abs(rotationOrbit - fromProps.rotationOrbit) > 180) {\n      props.rotationOrbit = rotationOrbit < 0 ? rotationOrbit + 360 : rotationOrbit - 360;\n    }\n\n    return props;\n  }\n\n  /**\n   * Start zooming\n   * @param {[Number, Number]} pos - position on screen where the pointer grabs\n   */\n  zoomStart({pos}) {\n    return this._getUpdatedState({\n      startZoomPosition: this._unproject(pos),\n      startZoom: this._viewportProps.zoom\n    });\n  }\n\n  /**\n   * Zoom\n   * @param {[Number, Number]} pos - position on screen where the current target is\n   * @param {[Number, Number]} startPos - the target position at\n   *   the start of the operation. Must be supplied of `zoomStart()` was not called\n   * @param {Number} scale - a number between [0, 1] specifying the accumulated\n   *   relative scale.\n   */\n  zoom({pos, startPos, scale}) {\n    const {zoom} = this._viewportProps;\n    let {startZoom, startZoomPosition} = this._state;\n    if (!Number.isFinite(startZoom)) {\n      // We have two modes of zoom:\n      // scroll zoom that are discrete events (transform from the current zoom level),\n      // and pinch zoom that are continuous events (transform from the zoom level when\n      // pinch started).\n      // If startZoom state is defined, then use the startZoom state;\n      // otherwise assume discrete zooming\n      startZoom = zoom;\n      startZoomPosition = this._unproject(startPos) || this._unproject(pos);\n    }\n\n    const newZoom = this._calculateNewZoom({scale, startZoom});\n    const zoomedViewport = this.makeViewport({...this._viewportProps, zoom: newZoom});\n\n    return this._getUpdatedState({\n      zoom: newZoom,\n      ...zoomedViewport.panByPosition(startZoomPosition, pos)\n    });\n  }\n\n  /**\n   * End zooming\n   * Must call if `zoomStart()` was called\n   */\n  zoomEnd() {\n    return this._getUpdatedState({\n      startZoomPosition: null,\n      startZoom: null\n    });\n  }\n\n  zoomIn(speed = 2) {\n    return this._getUpdatedState({\n      zoom: this._calculateNewZoom({scale: speed})\n    });\n  }\n\n  zoomOut(speed = 2) {\n    return this._getUpdatedState({\n      zoom: this._calculateNewZoom({scale: 1 / speed})\n    });\n  }\n\n  moveLeft(speed = 50) {\n    return this._panFromCenter([-speed, 0]);\n  }\n\n  moveRight(speed = 50) {\n    return this._panFromCenter([speed, 0]);\n  }\n\n  moveUp(speed = 50) {\n    return this._panFromCenter([0, -speed]);\n  }\n\n  moveDown(speed = 50) {\n    return this._panFromCenter([0, speed]);\n  }\n\n  rotateLeft(speed = 15) {\n    return this._getUpdatedState({\n      rotationOrbit: this._viewportProps.rotationOrbit - speed\n    });\n  }\n\n  rotateRight(speed = 15) {\n    return this._getUpdatedState({\n      rotationOrbit: this._viewportProps.rotationOrbit + speed\n    });\n  }\n\n  rotateUp(speed = 10) {\n    return this._getUpdatedState({\n      rotationX: this._viewportProps.rotationX - speed\n    });\n  }\n\n  rotateDown(speed = 10) {\n    return this._getUpdatedState({\n      rotationX: this._viewportProps.rotationX + speed\n    });\n  }\n\n  /* Private methods */\n\n  _unproject(pos) {\n    const viewport = this.makeViewport(this._viewportProps);\n    return pos && viewport.unproject(pos);\n  }\n\n  // Calculates new zoom\n  _calculateNewZoom({scale, startZoom}) {\n    const {maxZoom, minZoom} = this._viewportProps;\n    if (!Number.isFinite(startZoom)) {\n      startZoom = this._viewportProps.zoom;\n    }\n    const zoom = startZoom + Math.log2(scale);\n    return clamp(zoom, minZoom, maxZoom);\n  }\n\n  _panFromCenter(offset) {\n    const {width, height, target} = this._viewportProps;\n    return this.pan({\n      startPosition: target,\n      pos: [width / 2 + offset[0], height / 2 + offset[1]]\n    });\n  }\n\n  _getUpdatedState(newProps) {\n    // Update _viewportProps\n    return new this.constructor({...this._viewportProps, ...this._state, ...newProps});\n  }\n\n  // Apply any constraints (mathematical or defined by _viewportProps) to map state\n  _applyConstraints(props) {\n    // Ensure zoom is within specified range\n    const {maxZoom, minZoom, zoom, maxRotationX, minRotationX, rotationOrbit} = props;\n\n    props.zoom = clamp(zoom, minZoom, maxZoom);\n    props.rotationX = clamp(props.rotationX, minRotationX, maxRotationX);\n    if (rotationOrbit < -180 || rotationOrbit > 180) {\n      props.rotationOrbit = mod(rotationOrbit + 180, 360) - 180;\n    }\n\n    return props;\n  }\n}\n\nexport default class OrbitController extends Controller {\n  constructor(props) {\n    super(OrbitState, props);\n  }\n\n  get linearTransitionProps() {\n    return ['target', 'zoom', 'rotationX', 'rotationOrbit'];\n  }\n}\n","import View from './view';\nimport Viewport from '../viewports/viewport';\n\nimport {Matrix4} from 'math.gl';\nimport {pixelsToWorld} from '@math.gl/web-mercator';\nimport * as vec2 from 'gl-matrix/vec2';\nimport OrthographicController from '../controllers/orthographic-controller';\n\nconst viewMatrix = new Matrix4().lookAt({eye: [0, 0, 1]});\n\nfunction getProjectionMatrix({width, height, near, far}) {\n  // Make sure Matrix4.ortho doesn't crash on 0 width/height\n  width = width || 1;\n  height = height || 1;\n\n  return new Matrix4().ortho({\n    left: -width / 2,\n    right: width / 2,\n    bottom: -height / 2,\n    top: height / 2,\n    near,\n    far\n  });\n}\n\nclass OrthographicViewport extends Viewport {\n  constructor(props) {\n    const {\n      width,\n      height,\n      near = 0.1,\n      far = 1000,\n      zoom = 0,\n      target = [0, 0, 0],\n      flipY = true\n    } = props;\n    const zoomX = Array.isArray(zoom) ? zoom[0] : zoom;\n    const zoomY = Array.isArray(zoom) ? zoom[1] : zoom;\n    const zoom_ = Math.min(zoomX, zoomY);\n    const scale = Math.pow(2, zoom_);\n\n    super({\n      ...props,\n      // in case viewState contains longitude/latitude values,\n      // make sure that the base Viewport class does not treat this as a geospatial viewport\n      longitude: null,\n      position: target,\n      viewMatrix: viewMatrix.clone().scale([scale, scale * (flipY ? -1 : 1), scale]),\n      projectionMatrix: getProjectionMatrix({width, height, near, far}),\n      zoom: zoom_\n    });\n\n    if (zoomX !== zoomY) {\n      const scaleX = Math.pow(2, zoomX);\n      const scaleY = Math.pow(2, zoomY);\n\n      this.distanceScales = {\n        unitsPerMeter: [scaleX / scale, scaleY / scale, 1],\n        metersPerUnit: [scale / scaleX, scale / scaleY, 1]\n      };\n    }\n  }\n\n  projectFlat([X, Y]) {\n    const {unitsPerMeter} = this.distanceScales;\n    return [X * unitsPerMeter[0], Y * unitsPerMeter[1]];\n  }\n\n  unprojectFlat([x, y]) {\n    const {metersPerUnit} = this.distanceScales;\n    return [x * metersPerUnit[0], y * metersPerUnit[1]];\n  }\n\n  /* Needed by LinearInterpolator */\n  panByPosition(coords, pixel) {\n    const fromLocation = pixelsToWorld(pixel, this.pixelUnprojectionMatrix);\n    const toLocation = this.projectFlat(coords);\n\n    const translate = vec2.add([], toLocation, vec2.negate([], fromLocation));\n    const newCenter = vec2.add([], this.center, translate);\n\n    return {target: newCenter};\n  }\n}\n\nexport default class OrthographicView extends View {\n  constructor(props) {\n    super({\n      ...props,\n      type: OrthographicViewport\n    });\n  }\n\n  get controller() {\n    return this._getControllerProps({\n      type: OrthographicController\n    });\n  }\n}\n\nOrthographicView.displayName = 'OrthographicView';\n","import {clamp} from 'math.gl';\nimport Controller from './controller';\nimport {OrbitState} from './orbit-controller';\n\nclass OrthographicState extends OrbitState {\n  constructor(props) {\n    super(props);\n\n    this.zoomAxis = props.zoomAxis || 'all';\n  }\n\n  _applyConstraints(props) {\n    const {maxZoom, minZoom, zoom} = props;\n    props.zoom = Array.isArray(zoom)\n      ? [clamp(zoom[0], minZoom, maxZoom), clamp(zoom[1], minZoom, maxZoom)]\n      : clamp(zoom, minZoom, maxZoom);\n    return props;\n  }\n\n  _calculateNewZoom({scale, startZoom}) {\n    const {maxZoom, minZoom} = this._viewportProps;\n    if (!startZoom && startZoom !== 0) {\n      startZoom = this._viewportProps.zoom;\n    }\n    let deltaZoom = Math.log2(scale);\n    if (Array.isArray(startZoom)) {\n      let [newZoomX, newZoomY] = startZoom;\n      switch (this.zoomAxis) {\n        case 'X':\n          // Scale x only\n          newZoomX = clamp(newZoomX + deltaZoom, minZoom, maxZoom);\n          break;\n        case 'Y':\n          // Scale y only\n          newZoomY = clamp(newZoomY + deltaZoom, minZoom, maxZoom);\n          break;\n        default:\n          // Lock aspect ratio\n          let z = Math.min(newZoomX + deltaZoom, newZoomY + deltaZoom);\n          if (z < minZoom) {\n            deltaZoom += minZoom - z;\n          }\n          z = Math.max(newZoomX + deltaZoom, newZoomY + deltaZoom);\n          if (z > maxZoom) {\n            deltaZoom += maxZoom - z;\n          }\n          newZoomX += deltaZoom;\n          newZoomY += deltaZoom;\n      }\n      return [newZoomX, newZoomY];\n    }\n    // Ignore `zoomAxis`\n    // `LinearTransitionInterpolator` does not support interpolation between a number and an array\n    // So if zoom is a number (legacy use case), new zoom still has to be a number\n    return clamp(startZoom + deltaZoom, minZoom, maxZoom);\n  }\n}\n\nexport default class OrthographicController extends Controller {\n  constructor(props) {\n    props.dragMode = props.dragMode || 'pan';\n    super(OrthographicState, props);\n  }\n\n  _onPanRotate(event) {\n    // No rotation in orthographic view\n    return false;\n  }\n\n  get linearTransitionProps() {\n    return ['target', 'zoom'];\n  }\n}\n","import View from './view';\nimport GlobeViewport from '../viewports/globe-viewport';\nimport GlobeController from '../controllers/globe-controller';\n\nexport default class GlobeView extends View {\n  constructor(props) {\n    super({...props, type: GlobeViewport});\n  }\n\n  get controller() {\n    return this._getControllerProps({\n      type: GlobeController\n    });\n  }\n}\n\nGlobeView.displayName = 'GlobeView';\n","import {clamp} from 'math.gl';\nimport Controller from './controller';\n\nimport {MapState} from './map-controller';\nimport {mod} from '../utils/math-utils';\n\nclass GlobeState extends MapState {\n  // Apply any constraints (mathematical or defined by _viewportProps) to map state\n  _applyConstraints(props) {\n    // Ensure zoom is within specified range\n    const {maxZoom, minZoom, zoom} = props;\n    props.zoom = clamp(zoom, minZoom, maxZoom);\n\n    const {longitude, latitude} = props;\n    if (longitude < -180 || longitude > 180) {\n      props.longitude = mod(longitude + 180, 360) - 180;\n    }\n    props.latitude = clamp(latitude, -89, 89);\n\n    return props;\n  }\n}\n\nexport default class GlobeController extends Controller {\n  constructor(props) {\n    props.dragMode = props.dragMode || 'pan';\n    super(GlobeState, props);\n  }\n\n  setProps(props) {\n    super.setProps(props);\n\n    // TODO - support pitching?\n    this.dragRotate = false;\n    this.touchRotate = false;\n  }\n\n  get linearTransitionProps() {\n    return ['longitude', 'latitude', 'zoom'];\n  }\n}\n","import TransitionInterpolator from './transition-interpolator';\nimport {lerp} from 'math.gl';\n\nimport {flyToViewport, getFlyToDuration} from '@math.gl/web-mercator';\n\nconst LINEARLY_INTERPOLATED_PROPS = ['bearing', 'pitch'];\nconst DEFAULT_OPTS = {\n  speed: 1.2,\n  curve: 1.414\n  // screenSpeed and maxDuration are used only if specified\n};\n\n/**\n * This class adapts mapbox-gl-js Map#flyTo animation so it can be used in\n * react/redux architecture.\n * mapbox-gl-js flyTo : https://www.mapbox.com/mapbox-gl-js/api/#map#flyto.\n * It implements “Smooth and efficient zooming and panning.” algorithm by\n * \"Jarke J. van Wijk and Wim A.A. Nuij\"\n */\nexport default class FlyToInterpolator extends TransitionInterpolator {\n  /**\n   * @param props {Object}\n    - `props.curve` (Number, optional, default: 1.414) - The zooming \"curve\" that will occur along the flight path.\n    - `props.speed` (Number, optional, default: 1.2) - The average speed of the animation defined in relation to `options.curve`, it linearly affects the duration, higher speed returns smaller durations and vice versa.\n    - `props.screenSpeed` (Number, optional) - The average speed of the animation measured in screenfuls per second. Similar to `opts.speed` it linearly affects the duration,  when specified `opts.speed` is ignored.\n    - `props.maxDuration` (Number, optional) - Maximum duration in milliseconds, if calculated duration exceeds this value, `0` is returned.\n   */\n  constructor(props = {}) {\n    super({\n      compare: ['longitude', 'latitude', 'zoom', 'bearing', 'pitch'],\n      extract: ['width', 'height', 'longitude', 'latitude', 'zoom', 'bearing', 'pitch'],\n      required: ['width', 'height', 'latitude', 'longitude', 'zoom']\n    });\n    this.props = {...DEFAULT_OPTS, ...props};\n  }\n\n  interpolateProps(startProps, endProps, t) {\n    const viewport = flyToViewport(startProps, endProps, t, this.props);\n\n    // Linearly interpolate 'bearing' and 'pitch'.\n    // If pitch/bearing are not supplied, they are interpreted as zeros in viewport calculation\n    // (fallback defined in WebMercatorViewport)\n    // Because there is no guarantee that the current controller's ViewState normalizes\n    // these props, safe guard is needed to avoid generating NaNs\n    for (const key of LINEARLY_INTERPOLATED_PROPS) {\n      viewport[key] = lerp(startProps[key] || 0, endProps[key] || 0, t);\n    }\n\n    return viewport;\n  }\n\n  // computes the transition duration\n  getDuration(startProps, endProps) {\n    let {transitionDuration} = endProps;\n    if (transitionDuration === 'auto') {\n      // auto calculate duration based on start and end props\n      transitionDuration = getFlyToDuration(startProps, endProps, this.props);\n    }\n    return transitionDuration;\n  }\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\nimport {createIterable, getAccessorFromBuffer} from './iterable-utils';\nimport defaultTypedArrayManager from './typed-array-manager';\nimport assert from './assert';\n\nimport {Buffer} from '@luma.gl/core';\n\nexport default class Tesselator {\n  constructor(opts = {}) {\n    const {attributes = {}} = opts;\n\n    this.typedArrayManager = defaultTypedArrayManager;\n    this.indexStarts = null;\n    this.vertexStarts = null;\n    this.vertexCount = 0;\n    this.instanceCount = 0;\n    this.attributes = {};\n    this._attributeDefs = attributes;\n    this.opts = opts;\n\n    this.updateGeometry(opts);\n\n    Object.seal(this);\n  }\n\n  /* Public methods */\n  updateGeometry(opts) {\n    Object.assign(this.opts, opts);\n    const {\n      data,\n      buffers = {},\n      getGeometry,\n      geometryBuffer,\n      positionFormat,\n      dataChanged,\n      normalize = true\n    } = this.opts;\n    this.data = data;\n    this.getGeometry = getGeometry;\n    this.positionSize =\n      (geometryBuffer && geometryBuffer.size) || (positionFormat === 'XY' ? 2 : 3);\n    this.buffers = buffers;\n    this.normalize = normalize;\n\n    // Handle external logical value\n    if (geometryBuffer) {\n      assert(data.startIndices); // binary data missing startIndices\n      this.getGeometry = this.getGeometryFromBuffer(geometryBuffer);\n\n      if (!normalize) {\n        // skip packing and set attribute value directly\n        // TODO - avoid mutating user-provided object\n        buffers.positions = geometryBuffer;\n      }\n    }\n    this.geometryBuffer = buffers.positions;\n\n    if (Array.isArray(dataChanged)) {\n      // is partial update\n      for (const dataRange of dataChanged) {\n        this._rebuildGeometry(dataRange);\n      }\n    } else {\n      this._rebuildGeometry();\n    }\n  }\n\n  updatePartialGeometry({startRow, endRow}) {\n    this._rebuildGeometry({startRow, endRow});\n  }\n\n  /* Subclass interface */\n  normalizeGeometry(geometry) {\n    return geometry;\n  }\n\n  // Update the positions of a single geometry\n  updateGeometryAttributes(geometry, startIndex, size) {\n    throw new Error('Not implemented');\n  }\n\n  // Returns the number of vertices in a geometry\n  getGeometrySize(geometry) {\n    throw new Error('Not implemented');\n  }\n\n  getGeometryFromBuffer(geometryBuffer) {\n    const value = geometryBuffer.value || geometryBuffer;\n    assert(ArrayBuffer.isView(value)); // invalid binary geometries\n\n    return getAccessorFromBuffer(value, {\n      size: this.positionSize,\n      offset: geometryBuffer.offset,\n      stride: geometryBuffer.stride,\n      startIndices: this.data.startIndices\n    });\n  }\n\n  /* Private utility methods */\n  _allocate(instanceCount, copy) {\n    // allocate attributes\n    const {attributes, buffers, _attributeDefs, typedArrayManager} = this;\n    for (const name in _attributeDefs) {\n      if (name in buffers) {\n        // Use external buffer\n        typedArrayManager.release(attributes[name]);\n        attributes[name] = null;\n      } else {\n        const def = _attributeDefs[name];\n        // If dataRange is supplied, this is a partial update.\n        // In case we need to reallocate the typed array, it will need the old values copied\n        // before performing partial update.\n        def.copy = copy;\n\n        attributes[name] = typedArrayManager.allocate(attributes[name], instanceCount, def);\n      }\n    }\n  }\n\n  /**\n   * Visit all objects\n   * `data` is expected to be an iterable consistent with the base Layer expectation\n   */\n  _forEachGeometry(visitor, startRow, endRow) {\n    const {data, getGeometry} = this;\n    const {iterable, objectInfo} = createIterable(data, startRow, endRow);\n    for (const object of iterable) {\n      objectInfo.index++;\n      const geometry = getGeometry(object, objectInfo);\n      visitor(geometry, objectInfo.index);\n    }\n  }\n\n  /* eslint-disable complexity,max-statements */\n  _rebuildGeometry(dataRange) {\n    if (!this.data || !this.getGeometry) {\n      return;\n    }\n\n    let {indexStarts, vertexStarts, instanceCount} = this;\n    const {data, geometryBuffer} = this;\n    const {startRow = 0, endRow = Infinity} = dataRange || {};\n\n    const normalizedData = {};\n\n    if (!dataRange) {\n      // Full update - regenerate buffer layout from scratch\n      indexStarts = [0];\n      vertexStarts = [0];\n    }\n    if (this.normalize || !geometryBuffer) {\n      this._forEachGeometry(\n        (geometry, dataIndex) => {\n          geometry = this.normalizeGeometry(geometry);\n          normalizedData[dataIndex] = geometry;\n          vertexStarts[dataIndex + 1] = vertexStarts[dataIndex] + this.getGeometrySize(geometry);\n        },\n        startRow,\n        endRow\n      );\n      // count instances\n      instanceCount = vertexStarts[vertexStarts.length - 1];\n    } else if (geometryBuffer.buffer instanceof Buffer) {\n      const byteStride = geometryBuffer.stride || this.positionSize * 4;\n      // assume user provided data is already normalized\n      vertexStarts = data.startIndices;\n      instanceCount = vertexStarts[data.length] || geometryBuffer.buffer.byteLength / byteStride;\n    } else {\n      const bufferValue = geometryBuffer.value || geometryBuffer;\n      const elementStride =\n        geometryBuffer.stride / bufferValue.BYTES_PER_ELEMENT || this.positionSize;\n      // assume user provided data is already normalized\n      vertexStarts = data.startIndices;\n      instanceCount = vertexStarts[data.length] || bufferValue.length / elementStride;\n    }\n\n    // allocate attributes\n    this._allocate(instanceCount, Boolean(dataRange));\n\n    this.indexStarts = indexStarts;\n    this.vertexStarts = vertexStarts;\n    this.instanceCount = instanceCount;\n\n    const context = {};\n\n    this._forEachGeometry(\n      (geometry, dataIndex) => {\n        geometry = normalizedData[dataIndex] || geometry;\n        context.vertexStart = vertexStarts[dataIndex];\n        context.indexStart = indexStarts[dataIndex];\n        const vertexEnd =\n          dataIndex < vertexStarts.length - 1 ? vertexStarts[dataIndex + 1] : instanceCount;\n        context.geometrySize = vertexEnd - vertexStarts[dataIndex];\n        context.geometryIndex = dataIndex;\n        this.updateGeometryAttributes(geometry, context);\n      },\n      startRow,\n      endRow\n    );\n\n    this.vertexCount = indexStarts[indexStarts.length - 1];\n  }\n}\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {Layer, project32, picking, UNIT} from '@deck.gl/core';\nimport GL from '@luma.gl/constants';\nimport {Model, Geometry} from '@luma.gl/core';\n\nimport vs from './scatterplot-layer-vertex.glsl';\nimport fs from './scatterplot-layer-fragment.glsl';\n\nconst DEFAULT_COLOR = [0, 0, 0, 255];\n\nconst defaultProps = {\n  radiusUnits: 'meters',\n  radiusScale: {type: 'number', min: 0, value: 1},\n  radiusMinPixels: {type: 'number', min: 0, value: 0}, //  min point radius in pixels\n  radiusMaxPixels: {type: 'number', min: 0, value: Number.MAX_SAFE_INTEGER}, // max point radius in pixels\n\n  lineWidthUnits: 'meters',\n  lineWidthScale: {type: 'number', min: 0, value: 1},\n  lineWidthMinPixels: {type: 'number', min: 0, value: 0},\n  lineWidthMaxPixels: {type: 'number', min: 0, value: Number.MAX_SAFE_INTEGER},\n\n  stroked: false,\n  filled: true,\n  billboard: false,\n  antialiasing: true,\n\n  getPosition: {type: 'accessor', value: x => x.position},\n  getRadius: {type: 'accessor', value: 1},\n  getFillColor: {type: 'accessor', value: DEFAULT_COLOR},\n  getLineColor: {type: 'accessor', value: DEFAULT_COLOR},\n  getLineWidth: {type: 'accessor', value: 1},\n\n  // deprecated\n  strokeWidth: {deprecatedFor: 'getLineWidth'},\n  outline: {deprecatedFor: 'stroked'},\n  getColor: {deprecatedFor: ['getFillColor', 'getLineColor']}\n};\n\nexport default class ScatterplotLayer extends Layer {\n  getShaders() {\n    return super.getShaders({vs, fs, modules: [project32, picking]});\n  }\n\n  initializeState() {\n    this.getAttributeManager().addInstanced({\n      instancePositions: {\n        size: 3,\n        type: GL.DOUBLE,\n        fp64: this.use64bitPositions(),\n        transition: true,\n        accessor: 'getPosition'\n      },\n      instanceRadius: {\n        size: 1,\n        transition: true,\n        accessor: 'getRadius',\n        defaultValue: 1\n      },\n      instanceFillColors: {\n        size: this.props.colorFormat.length,\n        transition: true,\n        normalized: true,\n        type: GL.UNSIGNED_BYTE,\n        accessor: 'getFillColor',\n        defaultValue: [0, 0, 0, 255]\n      },\n      instanceLineColors: {\n        size: this.props.colorFormat.length,\n        transition: true,\n        normalized: true,\n        type: GL.UNSIGNED_BYTE,\n        accessor: 'getLineColor',\n        defaultValue: [0, 0, 0, 255]\n      },\n      instanceLineWidths: {\n        size: 1,\n        transition: true,\n        accessor: 'getLineWidth',\n        defaultValue: 1\n      }\n    });\n  }\n\n  updateState({props, oldProps, changeFlags}) {\n    super.updateState({props, oldProps, changeFlags});\n    if (changeFlags.extensionsChanged) {\n      const {gl} = this.context;\n      this.state.model?.delete();\n      this.state.model = this._getModel(gl);\n      this.getAttributeManager().invalidateAll();\n    }\n  }\n\n  draw({uniforms}) {\n    const {\n      radiusUnits,\n      radiusScale,\n      radiusMinPixels,\n      radiusMaxPixels,\n      stroked,\n      filled,\n      billboard,\n      antialiasing,\n      lineWidthUnits,\n      lineWidthScale,\n      lineWidthMinPixels,\n      lineWidthMaxPixels\n    } = this.props;\n\n    this.state.model\n      .setUniforms(uniforms)\n      .setUniforms({\n        stroked: stroked ? 1 : 0,\n        filled,\n        billboard,\n        antialiasing,\n        radiusUnits: UNIT[radiusUnits],\n        radiusScale,\n        radiusMinPixels,\n        radiusMaxPixels,\n        lineWidthUnits: UNIT[lineWidthUnits],\n        lineWidthScale,\n        lineWidthMinPixels,\n        lineWidthMaxPixels\n      })\n      .draw();\n  }\n\n  _getModel(gl) {\n    // a square that minimally cover the unit circle\n    const positions = [-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0];\n\n    return new Model(gl, {\n      ...this.getShaders(),\n      id: this.props.id,\n      geometry: new Geometry({\n        drawMode: GL.TRIANGLE_FAN,\n        vertexCount: 4,\n        attributes: {\n          positions: {size: 3, value: new Float32Array(positions)}\n        }\n      }),\n      isInstanced: true\n    });\n  }\n}\n\nScatterplotLayer.layerName = 'ScatterplotLayer';\nScatterplotLayer.defaultProps = defaultProps;\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nexport default `\\\n#define SHADER_NAME scatterplot-layer-vertex-shader\n\nattribute vec3 positions;\n\nattribute vec3 instancePositions;\nattribute vec3 instancePositions64Low;\nattribute float instanceRadius;\nattribute float instanceLineWidths;\nattribute vec4 instanceFillColors;\nattribute vec4 instanceLineColors;\nattribute vec3 instancePickingColors;\n\nuniform float opacity;\nuniform float radiusScale;\nuniform float radiusMinPixels;\nuniform float radiusMaxPixels;\nuniform float lineWidthScale;\nuniform float lineWidthMinPixels;\nuniform float lineWidthMaxPixels;\nuniform float stroked;\nuniform bool filled;\nuniform bool billboard;\nuniform int radiusUnits;\nuniform int lineWidthUnits;\n\nvarying vec4 vFillColor;\nvarying vec4 vLineColor;\nvarying vec2 unitPosition;\nvarying float innerUnitRadius;\nvarying float outerRadiusPixels;\n\nvoid main(void) {\n  geometry.worldPosition = instancePositions;\n\n  // Multiply out radius and clamp to limits\n  outerRadiusPixels = clamp(\n    project_size_to_pixel(radiusScale * instanceRadius, radiusUnits),\n    radiusMinPixels, radiusMaxPixels\n  );\n  \n  // Multiply out line width and clamp to limits\n  float lineWidthPixels = clamp(\n    project_size_to_pixel(lineWidthScale * instanceLineWidths, lineWidthUnits),\n    lineWidthMinPixels, lineWidthMaxPixels\n  );\n\n  // outer radius needs to offset by half stroke width\n  outerRadiusPixels += stroked * lineWidthPixels / 2.0;\n\n  // position on the containing square in [-1, 1] space\n  unitPosition = positions.xy;\n  geometry.uv = unitPosition;\n  geometry.pickingColor = instancePickingColors;\n\n  innerUnitRadius = 1.0 - stroked * lineWidthPixels / outerRadiusPixels;\n  \n  if (billboard) {\n    gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position);\n    vec3 offset = positions * outerRadiusPixels;\n    DECKGL_FILTER_SIZE(offset, geometry);\n    gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);\n  } else {\n    vec3 offset = positions * project_pixel_size(outerRadiusPixels);\n    DECKGL_FILTER_SIZE(offset, geometry);\n    gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset, geometry.position);\n  }\n\n  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n\n  // Apply opacity to instance color, or return instance picking color\n  vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * opacity);\n  DECKGL_FILTER_COLOR(vFillColor, geometry);\n  vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * opacity);\n  DECKGL_FILTER_COLOR(vLineColor, geometry);\n}\n`;\n","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nexport default `\\\n#define SHADER_NAME scatterplot-layer-fragment-shader\n\nprecision highp float;\n\nuniform bool filled;\nuniform float stroked;\nuniform bool antialiasing;\n\nvarying vec4 vFillColor;\nvarying vec4 vLineColor;\nvarying vec2 unitPosition;\nvarying float innerUnitRadius;\nvarying float outerRadiusPixels;\n\nvoid main(void) {\n  geometry.uv = unitPosition;\n\n  float distToCenter = length(unitPosition) * outerRadiusPixels;\n  float inCircle = antialiasing ? \n    smoothedge(distToCenter, outerRadiusPixels) : \n    step(distToCenter, outerRadiusPixels);\n\n  if (inCircle == 0.0) {\n    discard;\n  }\n\n  if (stroked > 0.5) {\n    float isLine = antialiasing ? \n      smoothedge(innerUnitRadius * outerRadiusPixels, distToCenter) :\n      step(innerUnitRadius * outerRadiusPixels, distToCenter);\n\n    if (filled) {\n      gl_FragColor = mix(vFillColor, vLineColor, isLine);\n    } else {\n      if (isLine == 0.0) {\n        discard;\n      }\n      gl_FragColor = vec4(vLineColor.rgb, vLineColor.a * isLine);\n    }\n  } else if (filled) {\n    gl_FragColor = vFillColor;\n  } else {\n    discard;\n  }\n\n  gl_FragColor.a *= inCircle;\n  DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n`;\n","// Note: This file will either be moved back to deck.gl or reformatted to web-monorepo standards\n// Disabling lint temporarily to facilitate copying code in and out of this repo\n/* eslint-disable */\n\n// Copyright (c) 2015 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {Layer, project32, phongLighting, picking, COORDINATE_SYSTEM, log} from '@deck.gl/core';\nimport GL from '@luma.gl/constants';\nimport {Model, Geometry, Texture2D, isWebGL2} from '@luma.gl/core';\nimport {hasFeature, FEATURES} from '@luma.gl/webgl';\n\nimport {MATRIX_ATTRIBUTES, shouldComposeModelMatrix} from '../utils/matrix';\n\nimport vs from './simple-mesh-layer-vertex.glsl';\nimport fs from './simple-mesh-layer-fragment.glsl';\n\nfunction validateGeometryAttributes(attributes, useMeshColors) {\n  const hasColorAttribute = attributes.COLOR_0 || attributes.colors;\n  const useColorAttribute = hasColorAttribute && useMeshColors;\n  if (!useColorAttribute) {\n    attributes.colors = {constant: true, value: new Float32Array([1, 1, 1])};\n  }\n  log.assert(\n    attributes.positions || attributes.POSITION,\n    'no \"postions\" or \"POSITION\" attribute in mesh'\n  );\n}\n\n/*\n * Convert mesh data into geometry\n * @returns {Geometry} geometry\n */\nfunction getGeometry(data, useMeshColors) {\n  if (data.attributes) {\n    validateGeometryAttributes(data.attributes, useMeshColors);\n    if (data instanceof Geometry) {\n      return data;\n    } else {\n      return new Geometry(data);\n    }\n  } else if (data.positions || data.POSITION) {\n    validateGeometryAttributes(data, useMeshColors);\n    return new Geometry({\n      attributes: data\n    });\n  }\n  throw Error('Invalid mesh');\n}\n\nconst DEFAULT_COLOR = [0, 0, 0, 255];\n\nconst defaultProps = {\n  mesh: {value: null, type: 'object', async: true},\n  texture: {type: 'image', value: null, async: true},\n  sizeScale: {type: 'number', value: 1, min: 0},\n  // Whether the color attribute in a mesh will be used\n  // This prop will be removed and set to true in next major release\n  _useMeshColors: {type: 'boolean', value: false},\n\n  // _instanced is a hack to use world position instead of meter offsets in mesh\n  // TODO - formalize API\n  _instanced: true,\n  // NOTE(Tarek): Quick and dirty wireframe. Just draws\n  // the same mesh with LINE_STRIPS. Won't follow edges\n  // of the original mesh.\n  wireframe: false,\n  // Optional material for 'lighting' shader module\n  material: true,\n  getPosition: {type: 'accessor', value: x => x.position},\n  getColor: {type: 'accessor', value: DEFAULT_COLOR},\n\n  // yaw, pitch and roll are in degrees\n  // https://en.wikipedia.org/wiki/Euler_angles\n  // [pitch, yaw, roll]\n  getOrientation: {type: 'accessor', value: [0, 0, 0]},\n  getScale: {type: 'accessor', value: [1, 1, 1]},\n  getTranslation: {type: 'accessor', value: [0, 0, 0]},\n  // 4x4 matrix\n  getTransformMatrix: {type: 'accessor', value: []}\n};\n\nexport default class SimpleMeshLayer extends Layer {\n  getShaders() {\n    const transpileToGLSL100 = !isWebGL2(this.context.gl);\n\n    const defines = {};\n\n    if (hasFeature(this.context.gl, FEATURES.GLSL_DERIVATIVES)) {\n      defines.DERIVATIVES_AVAILABLE = 1;\n    }\n\n    return super.getShaders({\n      vs,\n      fs,\n      modules: [project32, phongLighting, picking],\n      transpileToGLSL100,\n      defines\n    });\n  }\n\n  initializeState() {\n    const attributeManager = this.getAttributeManager();\n\n    attributeManager.addInstanced({\n      instancePositions: {\n        transition: true,\n        type: GL.DOUBLE,\n        fp64: this.use64bitPositions(),\n        size: 3,\n        accessor: 'getPosition'\n      },\n      instanceColors: {\n        type: GL.UNSIGNED_BYTE,\n        transition: true,\n        size: this.props.colorFormat.length,\n        normalized: true,\n        accessor: 'getColor',\n        defaultValue: [0, 0, 0, 255]\n      },\n      instanceModelMatrix: MATRIX_ATTRIBUTES\n    });\n\n    this.setState({\n      // Avoid luma.gl's missing uniform warning\n      // TODO - add feature to luma.gl to specify ignored uniforms?\n      emptyTexture: new Texture2D(this.context.gl, {\n        data: new Uint8Array(4),\n        width: 1,\n        height: 1\n      })\n    });\n  }\n\n  updateState({props, oldProps, changeFlags}) {\n    super.updateState({props, oldProps, changeFlags});\n\n    if (props.mesh !== oldProps.mesh || changeFlags.extensionsChanged) {\n      this.state.model?.delete();\n      if (props.mesh) {\n        this.state.model = this.getModel(props.mesh);\n\n        const attributes = props.mesh.attributes || props.mesh;\n        this.setState({\n          hasNormals: Boolean(attributes.NORMAL || attributes.normals)\n        });\n      }\n      this.getAttributeManager().invalidateAll();\n    }\n\n    if (props.texture !== oldProps.texture) {\n      this.setTexture(props.texture);\n    }\n\n    if (this.state.model) {\n      this.state.model.setDrawMode(this.props.wireframe ? GL.LINE_STRIP : GL.TRIANGLES);\n    }\n  }\n\n  finalizeState() {\n    super.finalizeState();\n\n    this.state.emptyTexture.delete();\n  }\n\n  draw({uniforms}) {\n    if (!this.state.model) {\n      return;\n    }\n\n    const {viewport} = this.context;\n    const {sizeScale, coordinateSystem, _instanced} = this.props;\n\n    this.state.model\n      .setUniforms(uniforms)\n      .setUniforms({\n        sizeScale,\n        composeModelMatrix: !_instanced || shouldComposeModelMatrix(viewport, coordinateSystem),\n        flatShading: !this.state.hasNormals\n      })\n      .draw();\n  }\n\n  getModel(mesh) {\n    const model = new Model(this.context.gl, {\n      ...this.getShaders(),\n      id: this.props.id,\n      geometry: getGeometry(mesh, this.props._useMeshColors),\n      isInstanced: true\n    });\n\n    const {texture} = this.props;\n    const {emptyTexture} = this.state;\n    model.setUniforms({\n      sampler: texture || emptyTexture,\n      hasTexture: Boolean(texture)\n    });\n\n    return model;\n  }\n\n  setTexture(texture) {\n    const {emptyTexture, model} = this.state;\n\n    // props.mesh may not be ready at this time.\n    // The sampler will be set when `getModel` is called\n    model?.setUniforms({\n      sampler: texture || emptyTexture,\n      hasTexture: Boolean(texture)\n    });\n  }\n}\n\nSimpleMeshLayer.layerName = 'SimpleMeshLayer';\nSimpleMeshLayer.defaultProps = defaultProps;\n","import {COORDINATE_SYSTEM, createIterable} from '@deck.gl/core';\n\n/* eslint-disable max-statements, complexity */\nconst RADIAN_PER_DEGREE = Math.PI / 180;\nconst modelMatrix = new Float32Array(16);\nconst valueArray = new Float32Array(12);\n\nfunction calculateTransformMatrix(targetMatrix, orientation, scale) {\n  const pitch = orientation[0] * RADIAN_PER_DEGREE;\n  const yaw = orientation[1] * RADIAN_PER_DEGREE;\n  const roll = orientation[2] * RADIAN_PER_DEGREE;\n\n  const sr = Math.sin(roll);\n  const sp = Math.sin(pitch);\n  const sw = Math.sin(yaw);\n\n  const cr = Math.cos(roll);\n  const cp = Math.cos(pitch);\n  const cw = Math.cos(yaw);\n\n  const scx = scale[0];\n  const scy = scale[1];\n  const scz = scale[2];\n\n  targetMatrix[0] = scx * cw * cp; // 0,0\n  targetMatrix[1] = scx * sw * cp; // 1,0\n  targetMatrix[2] = scx * -sp; // 2,0\n  targetMatrix[3] = scy * (-sw * cr + cw * sp * sr); // 0,1\n  targetMatrix[4] = scy * (cw * cr + sw * sp * sr); // 1,1\n  targetMatrix[5] = scy * cp * sr; // 2,1\n  targetMatrix[6] = scz * (sw * sr + cw * sp * cr); // 0,2\n  targetMatrix[7] = scz * (-cw * sr + sw * sp * cr); // 1,2\n  targetMatrix[8] = scz * cp * cr; // 2,2\n}\n\nfunction getExtendedMat3FromMat4(mat4) {\n  mat4[0] = mat4[0];\n  mat4[1] = mat4[1];\n  mat4[2] = mat4[2];\n  mat4[3] = mat4[4];\n  mat4[4] = mat4[5];\n  mat4[5] = mat4[6];\n  mat4[6] = mat4[8];\n  mat4[7] = mat4[9];\n  mat4[8] = mat4[10];\n  mat4[9] = mat4[12];\n  mat4[10] = mat4[13];\n  mat4[11] = mat4[14];\n\n  return mat4.subarray(0, 12);\n}\n\nexport const MATRIX_ATTRIBUTES = {\n  size: 12,\n  accessor: ['getOrientation', 'getScale', 'getTranslation', 'getTransformMatrix'],\n  shaderAttributes: {\n    instanceModelMatrix__LOCATION_0: {\n      size: 3,\n      elementOffset: 0\n    },\n    instanceModelMatrix__LOCATION_1: {\n      size: 3,\n      elementOffset: 3\n    },\n    instanceModelMatrix__LOCATION_2: {\n      size: 3,\n      elementOffset: 6\n    },\n    instanceTranslation: {\n      size: 3,\n      elementOffset: 9\n    }\n  },\n\n  update(attribute, {startRow, endRow}) {\n    // NOTE(Tarek): \"this\" will be bound to a layer!\n    const {data, getOrientation, getScale, getTranslation, getTransformMatrix} = this.props;\n\n    const arrayMatrix = Array.isArray(getTransformMatrix);\n    const constantMatrix = arrayMatrix && getTransformMatrix.length === 16;\n    const constantScale = Array.isArray(getScale);\n    const constantOrientation = Array.isArray(getOrientation);\n    const constantTranslation = Array.isArray(getTranslation);\n\n    const hasMatrix = constantMatrix || (!arrayMatrix && Boolean(getTransformMatrix(data[0])));\n\n    if (hasMatrix) {\n      attribute.constant = constantMatrix;\n    } else {\n      attribute.constant = constantOrientation && constantScale && constantTranslation;\n    }\n\n    const instanceModelMatrixData = attribute.value;\n\n    if (attribute.constant) {\n      let matrix;\n\n      if (hasMatrix) {\n        modelMatrix.set(getTransformMatrix);\n        matrix = getExtendedMat3FromMat4(modelMatrix);\n      } else {\n        matrix = valueArray;\n\n        const orientation = getOrientation;\n        const scale = getScale;\n\n        calculateTransformMatrix(matrix, orientation, scale);\n        matrix.set(getTranslation, 9);\n      }\n\n      attribute.value = new Float32Array(matrix);\n    } else {\n      let i = startRow * attribute.size;\n      const {iterable, objectInfo} = createIterable(data, startRow, endRow);\n      for (const object of iterable) {\n        objectInfo.index++;\n        let matrix;\n\n        if (hasMatrix) {\n          modelMatrix.set(\n            constantMatrix ? getTransformMatrix : getTransformMatrix(object, objectInfo)\n          );\n          matrix = getExtendedMat3FromMat4(modelMatrix);\n        } else {\n          matrix = valueArray;\n\n          const orientation = constantOrientation\n            ? getOrientation\n            : getOrientation(object, objectInfo);\n          const scale = constantScale ? getScale : getScale(object, objectInfo);\n\n          calculateTransformMatrix(matrix, orientation, scale);\n          matrix.set(constantTranslation ? getTranslation : getTranslation(object, objectInfo), 9);\n        }\n\n        instanceModelMatrixData[i++] = matrix[0];\n        instanceModelMatrixData[i++] = matrix[1];\n        instanceModelMatrixData[i++] = matrix[2];\n        instanceModelMatrixData[i++] = matrix[3];\n        instanceModelMatrixData[i++] = matrix[4];\n        instanceModelMatrixData[i++] = matrix[5];\n        instanceModelMatrixData[i++] = matrix[6];\n        instanceModelMatrixData[i++] = matrix[7];\n        instanceModelMatrixData[i++] = matrix[8];\n        instanceModelMatrixData[i++] = matrix[9];\n        instanceModelMatrixData[i++] = matrix[10];\n        instanceModelMatrixData[i++] = matrix[11];\n      }\n    }\n  }\n};\n\n// only apply composeModelMatrix when in cartesian or meter_offsets coordinate system\n// with `composeModelMatrix` enabled, the rotation part of the layer's modelMatrix will be composed to instance's transformations\n// since rotating latitude and longitude can not provide meaningful results, hence `composeModelMatrix` is disabled\n// when in LNGLAT and LNGLAT_OFFSET coordinates.\nexport function shouldComposeModelMatrix(viewport, coordinateSystem) {\n  return (\n    coordinateSystem === COORDINATE_SYSTEM.CARTESIAN ||\n    coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS ||\n    (coordinateSystem === COORDINATE_SYSTEM.DEFAULT && !viewport.isGeospatial)\n  );\n}\n","export default `#version 300 es\n#define SHADER_NAME simple-mesh-layer-vs\n\n// Scale the model\nuniform float sizeScale;\nuniform bool composeModelMatrix;\n\n// Primitive attributes\nin vec3 positions;\nin vec3 normals;\nin vec3 colors;\nin vec2 texCoords;\n\n// Instance attributes\nin vec3 instancePositions;\nin vec3 instancePositions64Low;\nin vec4 instanceColors;\nin vec3 instancePickingColors;\nin mat3 instanceModelMatrix;\nin vec3 instanceTranslation;\n\n// Outputs to fragment shader\nout vec2 vTexCoord;\nout vec3 cameraPosition;\nout vec3 normals_commonspace;\nout vec4 position_commonspace;\nout vec4 vColor;\n\nvoid main(void) {\n  geometry.worldPosition = instancePositions;\n  geometry.uv = texCoords;\n  geometry.pickingColor = instancePickingColors;\n\n  vTexCoord = texCoords;\n  cameraPosition = project_uCameraPosition;\n  normals_commonspace = project_normal(instanceModelMatrix * normals);\n  vColor = vec4(colors * instanceColors.rgb, instanceColors.a);\n  geometry.normal = normals_commonspace;\n\n  vec3 pos = (instanceModelMatrix * positions) * sizeScale + instanceTranslation;\n\n  if (composeModelMatrix) {\n    DECKGL_FILTER_SIZE(pos, geometry);\n    gl_Position = project_position_to_clipspace(pos + instancePositions, instancePositions64Low, vec3(0.0), position_commonspace);\n  }\n  else {\n    pos = project_size(pos);\n    DECKGL_FILTER_SIZE(pos, geometry);\n    gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, pos, position_commonspace);\n  }\n\n  geometry.position = position_commonspace;\n  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n\n  DECKGL_FILTER_COLOR(vColor, geometry);\n}\n`;\n","export default `#version 300 es\n#define SHADER_NAME simple-mesh-layer-fs\n\nprecision highp float;\n\nuniform bool hasTexture;\nuniform sampler2D sampler;\nuniform bool flatShading;\nuniform float opacity;\n\nin vec2 vTexCoord;\nin vec3 cameraPosition;\nin vec3 normals_commonspace;\nin vec4 position_commonspace;\nin vec4 vColor;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  geometry.uv = vTexCoord;\n\n  vec3 normal;\n  if (flatShading) {\n\n// NOTE(Tarek): This is necessary because\n// headless.gl reports the extension as\n// available but does not support it in\n// the shader.\n#ifdef DERIVATIVES_AVAILABLE\n    normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));\n#else\n    normal = vec3(0.0, 0.0, 1.0);\n#endif\n  } else {\n    normal = normals_commonspace;\n  }\n\n  vec4 color = hasTexture ? texture(sampler, vTexCoord) : vColor;\n  vec3 lightColor = lighting_getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);\n  fragColor = vec4(lightColor, color.a * opacity);\n\n  DECKGL_FILTER_COLOR(fragColor, geometry);\n}\n`;\n","'use strict';\n\n/**\n * Based off of [the offical Google document](https://developers.google.com/maps/documentation/utilities/polylinealgorithm)\n *\n * Some parts from [this implementation](http://facstaff.unca.edu/mcmcclur/GoogleMaps/EncodePolyline/PolylineEncoder.js)\n * by [Mark McClure](http://facstaff.unca.edu/mcmcclur/)\n *\n * @module polyline\n */\n\nvar polyline = {};\n\nfunction py2_round(value) {\n    // Google's polyline algorithm uses the same rounding strategy as Python 2, which is different from JS for negative values\n    return Math.floor(Math.abs(value) + 0.5) * (value >= 0 ? 1 : -1);\n}\n\nfunction encode(current, previous, factor) {\n    current = py2_round(current * factor);\n    previous = py2_round(previous * factor);\n    var coordinate = current - previous;\n    coordinate <<= 1;\n    if (current - previous < 0) {\n        coordinate = ~coordinate;\n    }\n    var output = '';\n    while (coordinate >= 0x20) {\n        output += String.fromCharCode((0x20 | (coordinate & 0x1f)) + 63);\n        coordinate >>= 5;\n    }\n    output += String.fromCharCode(coordinate + 63);\n    return output;\n}\n\n/**\n * Decodes to a [latitude, longitude] coordinates array.\n *\n * This is adapted from the implementation in Project-OSRM.\n *\n * @param {String} str\n * @param {Number} precision\n * @returns {Array}\n *\n * @see https://github.com/Project-OSRM/osrm-frontend/blob/master/WebContent/routing/OSRM.RoutingGeometry.js\n */\npolyline.decode = function(str, precision) {\n    var index = 0,\n        lat = 0,\n        lng = 0,\n        coordinates = [],\n        shift = 0,\n        result = 0,\n        byte = null,\n        latitude_change,\n        longitude_change,\n        factor = Math.pow(10, Number.isInteger(precision) ? precision : 5);\n\n    // Coordinates have variable length when encoded, so just keep\n    // track of whether we've hit the end of the string. In each\n    // loop iteration, a single coordinate is decoded.\n    while (index < str.length) {\n\n        // Reset shift, result, and byte\n        byte = null;\n        shift = 0;\n        result = 0;\n\n        do {\n            byte = str.charCodeAt(index++) - 63;\n            result |= (byte & 0x1f) << shift;\n            shift += 5;\n        } while (byte >= 0x20);\n\n        latitude_change = ((result & 1) ? ~(result >> 1) : (result >> 1));\n\n        shift = result = 0;\n\n        do {\n            byte = str.charCodeAt(index++) - 63;\n            result |= (byte & 0x1f) << shift;\n            shift += 5;\n        } while (byte >= 0x20);\n\n        longitude_change = ((result & 1) ? ~(result >> 1) : (result >> 1));\n\n        lat += latitude_change;\n        lng += longitude_change;\n\n        coordinates.push([lat / factor, lng / factor]);\n    }\n\n    return coordinates;\n};\n\n/**\n * Encodes the given [latitude, longitude] coordinates array.\n *\n * @param {Array.<Array.<Number>>} coordinates\n * @param {Number} precision\n * @returns {String}\n */\npolyline.encode = function(coordinates, precision) {\n    if (!coordinates.length) { return ''; }\n\n    var factor = Math.pow(10, Number.isInteger(precision) ? precision : 5),\n        output = encode(coordinates[0][0], 0, factor) + encode(coordinates[0][1], 0, factor);\n\n    for (var i = 1; i < coordinates.length; i++) {\n        var a = coordinates[i], b = coordinates[i - 1];\n        output += encode(a[0], b[0], factor);\n        output += encode(a[1], b[1], factor);\n    }\n\n    return output;\n};\n\nfunction flipped(coords) {\n    var flipped = [];\n    for (var i = 0; i < coords.length; i++) {\n        var coord = coords[i].slice();\n        flipped.push([coord[1], coord[0]]);\n    }\n    return flipped;\n}\n\n/**\n * Encodes a GeoJSON LineString feature/geometry.\n *\n * @param {Object} geojson\n * @param {Number} precision\n * @returns {String}\n */\npolyline.fromGeoJSON = function(geojson, precision) {\n    if (geojson && geojson.type === 'Feature') {\n        geojson = geojson.geometry;\n    }\n    if (!geojson || geojson.type !== 'LineString') {\n        throw new Error('Input must be a GeoJSON LineString');\n    }\n    return polyline.encode(flipped(geojson.coordinates), precision);\n};\n\n/**\n * Decodes to a GeoJSON LineString geometry.\n *\n * @param {String} str\n * @param {Number} precision\n * @returns {Object}\n */\npolyline.toGeoJSON = function(str, precision) {\n    var coords = polyline.decode(str, precision);\n    return {\n        type: 'LineString',\n        coordinates: flipped(coords)\n    };\n};\n\nif (typeof module === 'object' && module.exports) {\n    module.exports = polyline;\n}\n","\nimport sort from './sort';\nimport range from './range';\nimport within from './within';\n\nconst defaultGetX = p => p[0];\nconst defaultGetY = p => p[1];\n\nexport default class KDBush {\n    constructor(points, getX = defaultGetX, getY = defaultGetY, nodeSize = 64, ArrayType = Float64Array) {\n        this.nodeSize = nodeSize;\n        this.points = points;\n\n        const IndexArrayType = points.length < 65536 ? Uint16Array : Uint32Array;\n\n        const ids = this.ids = new IndexArrayType(points.length);\n        const coords = this.coords = new ArrayType(points.length * 2);\n\n        for (let i = 0; i < points.length; i++) {\n            ids[i] = i;\n            coords[2 * i] = getX(points[i]);\n            coords[2 * i + 1] = getY(points[i]);\n        }\n\n        sort(ids, coords, nodeSize, 0, ids.length - 1, 0);\n    }\n\n    range(minX, minY, maxX, maxY) {\n        return range(this.ids, this.coords, minX, minY, maxX, maxY, this.nodeSize);\n    }\n\n    within(x, y, r) {\n        return within(this.ids, this.coords, x, y, r, this.nodeSize);\n    }\n}\n","\nexport default function sortKD(ids, coords, nodeSize, left, right, depth) {\n    if (right - left <= nodeSize) return;\n\n    const m = (left + right) >> 1;\n\n    select(ids, coords, m, left, right, depth % 2);\n\n    sortKD(ids, coords, nodeSize, left, m - 1, depth + 1);\n    sortKD(ids, coords, nodeSize, m + 1, right, depth + 1);\n}\n\nfunction select(ids, coords, k, left, right, inc) {\n\n    while (right > left) {\n        if (right - left > 600) {\n            const n = right - left + 1;\n            const m = k - left + 1;\n            const z = Math.log(n);\n            const s = 0.5 * Math.exp(2 * z / 3);\n            const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);\n            const newLeft = Math.max(left, Math.floor(k - m * s / n + sd));\n            const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));\n            select(ids, coords, k, newLeft, newRight, inc);\n        }\n\n        const t = coords[2 * k + inc];\n        let i = left;\n        let j = right;\n\n        swapItem(ids, coords, left, k);\n        if (coords[2 * right + inc] > t) swapItem(ids, coords, left, right);\n\n        while (i < j) {\n            swapItem(ids, coords, i, j);\n            i++;\n            j--;\n            while (coords[2 * i + inc] < t) i++;\n            while (coords[2 * j + inc] > t) j--;\n        }\n\n        if (coords[2 * left + inc] === t) swapItem(ids, coords, left, j);\n        else {\n            j++;\n            swapItem(ids, coords, j, right);\n        }\n\n        if (j <= k) left = j + 1;\n        if (k <= j) right = j - 1;\n    }\n}\n\nfunction swapItem(ids, coords, i, j) {\n    swap(ids, i, j);\n    swap(coords, 2 * i, 2 * j);\n    swap(coords, 2 * i + 1, 2 * j + 1);\n}\n\nfunction swap(arr, i, j) {\n    const tmp = arr[i];\n    arr[i] = arr[j];\n    arr[j] = tmp;\n}\n","\nexport default function range(ids, coords, minX, minY, maxX, maxY, nodeSize) {\n    const stack = [0, ids.length - 1, 0];\n    const result = [];\n    let x, y;\n\n    while (stack.length) {\n        const axis = stack.pop();\n        const right = stack.pop();\n        const left = stack.pop();\n\n        if (right - left <= nodeSize) {\n            for (let i = left; i <= right; i++) {\n                x = coords[2 * i];\n                y = coords[2 * i + 1];\n                if (x >= minX && x <= maxX && y >= minY && y <= maxY) result.push(ids[i]);\n            }\n            continue;\n        }\n\n        const m = Math.floor((left + right) / 2);\n\n        x = coords[2 * m];\n        y = coords[2 * m + 1];\n\n        if (x >= minX && x <= maxX && y >= minY && y <= maxY) result.push(ids[m]);\n\n        const nextAxis = (axis + 1) % 2;\n\n        if (axis === 0 ? minX <= x : minY <= y) {\n            stack.push(left);\n            stack.push(m - 1);\n            stack.push(nextAxis);\n        }\n        if (axis === 0 ? maxX >= x : maxY >= y) {\n            stack.push(m + 1);\n            stack.push(right);\n            stack.push(nextAxis);\n        }\n    }\n\n    return result;\n}\n","\nexport default function within(ids, coords, qx, qy, r, nodeSize) {\n    const stack = [0, ids.length - 1, 0];\n    const result = [];\n    const r2 = r * r;\n\n    while (stack.length) {\n        const axis = stack.pop();\n        const right = stack.pop();\n        const left = stack.pop();\n\n        if (right - left <= nodeSize) {\n            for (let i = left; i <= right; i++) {\n                if (sqDist(coords[2 * i], coords[2 * i + 1], qx, qy) <= r2) result.push(ids[i]);\n            }\n            continue;\n        }\n\n        const m = Math.floor((left + right) / 2);\n\n        const x = coords[2 * m];\n        const y = coords[2 * m + 1];\n\n        if (sqDist(x, y, qx, qy) <= r2) result.push(ids[m]);\n\n        const nextAxis = (axis + 1) % 2;\n\n        if (axis === 0 ? qx - r <= x : qy - r <= y) {\n            stack.push(left);\n            stack.push(m - 1);\n            stack.push(nextAxis);\n        }\n        if (axis === 0 ? qx + r >= x : qy + r >= y) {\n            stack.push(m + 1);\n            stack.push(right);\n            stack.push(nextAxis);\n        }\n    }\n\n    return result;\n}\n\nfunction sqDist(ax, ay, bx, by) {\n    const dx = ax - bx;\n    const dy = ay - by;\n    return dx * dx + dy * dy;\n}\n","'use strict';\n\nvar tinyqueue = require('tinyqueue');\n\nexports.around = around;\nexports.distance = distance;\n\nvar earthRadius = 6371;\nvar earthCircumference = 40007;\n\nvar rad = Math.PI / 180;\n\nfunction around(index, lng, lat, maxResults, maxDistance, predicate) {\n    var result = [];\n\n    if (maxResults === undefined) maxResults = Infinity;\n    if (maxDistance === undefined) maxDistance = Infinity;\n\n    var cosLat = Math.cos(lat * rad);\n    var sinLat = Math.sin(lat * rad);\n\n    // a distance-sorted priority queue that will contain both points and kd-tree nodes\n    var q = tinyqueue(null, compareDist);\n\n    // an object that represents the top kd-tree node (the whole Earth)\n    var node = {\n        left: 0, // left index in the kd-tree array\n        right: index.ids.length - 1, // right index\n        axis: 0, // 0 for longitude axis and 1 for latitude axis\n        dist: 0, // will hold the lower bound of children's distances to the query point\n        minLng: -180, // bounding box of the node\n        minLat: -90,\n        maxLng: 180,\n        maxLat: 90\n    };\n\n    while (node) {\n        var right = node.right;\n        var left = node.left;\n\n        if (right - left <= index.nodeSize) { // leaf node\n\n            // add all points of the leaf node to the queue\n            for (var i = left; i <= right; i++) {\n                var item = index.points[index.ids[i]];\n                if (!predicate || predicate(item)) {\n                    q.push({\n                        item: item,\n                        dist: greatCircleDist(lng, lat, index.coords[2 * i], index.coords[2 * i + 1], cosLat, sinLat)\n                    });\n                }\n            }\n\n        } else { // not a leaf node (has child nodes)\n\n            var m = (left + right) >> 1; // middle index\n\n            var midLng = index.coords[2 * m];\n            var midLat = index.coords[2 * m + 1];\n\n            // add middle point to the queue\n            item = index.points[index.ids[m]];\n            if (!predicate || predicate(item)) {\n                q.push({\n                    item: item,\n                    dist: greatCircleDist(lng, lat, midLng, midLat, cosLat, sinLat)\n                });\n            }\n\n            var nextAxis = (node.axis + 1) % 2;\n\n            // first half of the node\n            var leftNode = {\n                left: left,\n                right: m - 1,\n                axis: nextAxis,\n                minLng: node.minLng,\n                minLat: node.minLat,\n                maxLng: node.axis === 0 ? midLng : node.maxLng,\n                maxLat: node.axis === 1 ? midLat : node.maxLat,\n                dist: 0\n            };\n            // second half of the node\n            var rightNode = {\n                left: m + 1,\n                right: right,\n                axis: nextAxis,\n                minLng: node.axis === 0 ? midLng : node.minLng,\n                minLat: node.axis === 1 ? midLat : node.minLat,\n                maxLng: node.maxLng,\n                maxLat: node.maxLat,\n                dist: 0\n            };\n\n            leftNode.dist = boxDist(lng, lat, leftNode, cosLat, sinLat);\n            rightNode.dist = boxDist(lng, lat, rightNode, cosLat, sinLat);\n\n            // add child nodes to the queue\n            q.push(leftNode);\n            q.push(rightNode);\n        }\n\n        // fetch closest points from the queue; they're guaranteed to be closer\n        // than all remaining points (both individual and those in kd-tree nodes),\n        // since each node's distance is a lower bound of distances to its children\n        while (q.length && q.peek().item) {\n            var candidate = q.pop();\n            if (candidate.dist > maxDistance) return result;\n            result.push(candidate.item);\n            if (result.length === maxResults) return result;\n        }\n\n        // the next closest kd-tree node\n        node = q.pop();\n    }\n\n    return result;\n}\n\n// lower bound for distance from a location to points inside a bounding box\nfunction boxDist(lng, lat, node, cosLat, sinLat) {\n    var minLng = node.minLng;\n    var maxLng = node.maxLng;\n    var minLat = node.minLat;\n    var maxLat = node.maxLat;\n\n    // query point is between minimum and maximum longitudes\n    if (lng >= minLng && lng <= maxLng) {\n        if (lat <= minLat) return earthCircumference * (minLat - lat) / 360; // south\n        if (lat >= maxLat) return earthCircumference * (lat - maxLat) / 360; // north\n        return 0; // inside the bbox\n    }\n\n    // query point is west or east of the bounding box;\n    // calculate the extremum for great circle distance from query point to the closest longitude\n    var closestLng = (minLng - lng + 360) % 360 <= (lng - maxLng + 360) % 360 ? minLng : maxLng;\n    var cosLngDelta = Math.cos((closestLng - lng) * rad);\n    var extremumLat = Math.atan(sinLat / (cosLat * cosLngDelta)) / rad;\n\n    // calculate distances to lower and higher bbox corners and extremum (if it's within this range);\n    // one of the three distances will be the lower bound of great circle distance to bbox\n    var d = Math.max(\n        greatCircleDistPart(minLat, cosLat, sinLat, cosLngDelta),\n        greatCircleDistPart(maxLat, cosLat, sinLat, cosLngDelta));\n\n    if (extremumLat > minLat && extremumLat < maxLat) {\n        d = Math.max(d, greatCircleDistPart(extremumLat, cosLat, sinLat, cosLngDelta));\n    }\n\n    return earthRadius * Math.acos(d);\n}\n\nfunction compareDist(a, b) {\n    return a.dist - b.dist;\n}\n\n// distance using spherical law of cosines; should be precise enough for our needs\nfunction greatCircleDist(lng, lat, lng2, lat2, cosLat, sinLat) {\n    var cosLngDelta = Math.cos((lng2 - lng) * rad);\n    return earthRadius * Math.acos(greatCircleDistPart(lat2, cosLat, sinLat, cosLngDelta));\n}\n\n// partial greatCircleDist to reduce trigonometric calculations\nfunction greatCircleDistPart(lat, cosLat, sinLat, cosLngDelta) {\n    var d = sinLat * Math.sin(lat * rad) +\n            cosLat * Math.cos(lat * rad) * cosLngDelta;\n    return Math.min(d, 1);\n}\n\nfunction distance(lng, lat, lng2, lat2) {\n    return greatCircleDist(lng, lat, lng2, lat2, Math.cos(lat * rad), Math.sin(lat * rad));\n}\n","'use strict';\n\nmodule.exports = TinyQueue;\nmodule.exports.default = TinyQueue;\n\nfunction TinyQueue(data, compare) {\n    if (!(this instanceof TinyQueue)) return new TinyQueue(data, compare);\n\n    this.data = data || [];\n    this.length = this.data.length;\n    this.compare = compare || defaultCompare;\n\n    if (this.length > 0) {\n        for (var i = (this.length >> 1) - 1; i >= 0; i--) this._down(i);\n    }\n}\n\nfunction defaultCompare(a, b) {\n    return a < b ? -1 : a > b ? 1 : 0;\n}\n\nTinyQueue.prototype = {\n\n    push: function (item) {\n        this.data.push(item);\n        this.length++;\n        this._up(this.length - 1);\n    },\n\n    pop: function () {\n        if (this.length === 0) return undefined;\n\n        var top = this.data[0];\n        this.length--;\n\n        if (this.length > 0) {\n            this.data[0] = this.data[this.length];\n            this._down(0);\n        }\n        this.data.pop();\n\n        return top;\n    },\n\n    peek: function () {\n        return this.data[0];\n    },\n\n    _up: function (pos) {\n        var data = this.data;\n        var compare = this.compare;\n        var item = data[pos];\n\n        while (pos > 0) {\n            var parent = (pos - 1) >> 1;\n            var current = data[parent];\n            if (compare(item, current) >= 0) break;\n            data[pos] = current;\n            pos = parent;\n        }\n\n        data[pos] = item;\n    },\n\n    _down: function (pos) {\n        var data = this.data;\n        var compare = this.compare;\n        var halfLength = this.length >> 1;\n        var item = data[pos];\n\n        while (pos < halfLength) {\n            var left = (pos << 1) + 1;\n            var right = left + 1;\n            var best = data[left];\n\n            if (right < this.length && compare(data[right], best) < 0) {\n                left = right;\n                best = data[right];\n            }\n            if (compare(best, item) >= 0) break;\n\n            data[pos] = best;\n            pos = left;\n        }\n\n        data[pos] = item;\n    }\n};\n","module.exports = throttle;\n\nfunction throttle(fn, interval, options) {\n  var timeoutId = null;\n  var throttledFn = null;\n  var leading = (options && options.leading);\n  var trailing = (options && options.trailing);\n\n  if (leading == null) {\n    leading = true; // default\n  }\n\n  if (trailing == null) {\n    trailing = !leading; //default\n  }\n\n  if (leading == true) {\n    trailing = false; // forced because there should be invocation per call\n  }\n\n  var cancel = function() {\n    if (timeoutId) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  var flush = function() {\n    var call = throttledFn;\n    cancel();\n\n    if (call) {\n      call();\n    }\n  };\n\n  var throttleWrapper = function() {\n    var callNow = leading && !timeoutId;\n    var context = this;\n    var args = arguments;\n\n    throttledFn = function() {\n      return fn.apply(context, args);\n    };\n\n    if (!timeoutId) {\n      timeoutId = setTimeout(function() {\n        timeoutId = null;\n\n        if (trailing) {\n          return throttledFn();\n        }\n      }, interval);\n    }\n\n    if (callNow) {\n      callNow = false;\n      return throttledFn();\n    }\n  };\n\n  throttleWrapper.cancel = cancel;\n  throttleWrapper.flush = flush;\n\n  return throttleWrapper;\n}\n"],"names":["_mapboxLayer","require","_ambientLight","_sunLight","_lightingEffect","_scatterplotLayer","_simpleMeshLayer","_truncatedConeGeometry","_sphereGeometry","_polyline","_kdbush","_geokdbush","_justThrottle","_deckUtils","props","id","Error","this","type","renderingMode","map","deck","onAdd","gl","getDeckInstance","onRemove","setProps","Object","assign","updateLayer","render","matrix","addLayer","removeLayer","drawLayer","_core","__deck","customRender","_customRender","deckProps","useDevicePixels","triggerRepaint","parameters","depthMask","depthTest","blendFunc","blendEquation","userData","isExternal","mapboxLayers","Set","width","height","touchAction","viewState","getViewState","Deck","on","needsRedraw","clearRedrawFlags","onMapMove","finalize","mapboxVersion","major","minor","version","split","slice","Number","getMapboxVersion","layerManager","mapboxLayerIds","Array","from","layer","layers","some","includes","_drawLayers","viewports","getViewport","layerFilter","clearCanvas","currentViewport","afterRender","add","updateLayers","delete","deckLayer","lng","lat","getCenter","longitude","latitude","zoom","getZoom","bearing","getBearing","pitch","getPitch","useMapboxProjection","WebMercatorViewport","x","y","repeat","nearZMultiplier","forEach","LayerType","push","_shaderlib","_constants","_directionalLight","_pointLight","_cameraLight","_postProcessEffect","_layersPass","_deck","_layerManager","_attributeManager","_layer","_compositeLayer","_deckRenderer","_viewport","_webMercatorViewport","_globeViewport","_view","_mapView","_firstPersonView","_orbitView","_orthographicView","_globeView","_controller","_mapController","_globeController","_firstPersonController","_orbitController","_orthographicController","_effect","_layerExtension","_transitionManager","_transitionInterpolator","_linearInterpolator","_viewportFlyToInterpolator","_log","_iterableUtils","_mathUtils","_tesselator","_flatten","_count","_memoize","_shader","_props","_images","_env","_debug","_jsonLoader","existingVersion","global","VERSION","concat","log","_registerLoggers","register","jsonLoader","ImageLoader","imagebitmap","premultiplyAlpha","_fetchFile","_readArrayBuffer","_readFile","_writeFile","_setLoaderOptions","_registerLoaders","_selectLoader","_parse","_parseSync","_parseInBatches","_load","_loadInBatches","_encode","_save","_loaderUtils","_makeIterator","_makeStream","_makeDomStream","_makeNodeStream","_nullLoader","_fetchProgress","_browserFilesystem","_isType","fetchFile","_responseUtils","url","options","resolvePath","fetchOptions","fetch","makeResponse","path","util","fs","_path","_util","_fs","_assert","_globals","_createLoaderWorker","_parseWithWorker","_parseJson","_arrayBufferUtils","_memoryCopyUtils","_binaryCopyUtils","_encodeUtils","_getFirstCharacters","_textIterators","_asyncIteration","_requestScheduler","_fileAliases","_bufferUtils","_nodeFilesystem","assert","condition","message","exports","interopDefault","a","__esModule","default","defineInteropFlag","defineProperty","value","exportAll","source","dest","keys","key","hasOwnProperty","enumerable","get","export","destName","self_","window_","global_","document_","isBrowser","isWorker","nodeVersion","globals","self","window","document","process","String","importScripts","matches","exec","parseFloat","cachedSetTimeout","cachedClearTimeout","module","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","e","call","clearTimeout","e1","currentQueue","queue","draining","queueIndex","cleanUpNextTick","length","drainQueue","timeout","len","run","marker","runClearTimeout","Item","array","noop","nextTick","args","arguments","i","prototype","apply","title","browser","env","argv","versions","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","name","binding","cwd","chdir","dir","umask","createLoaderWorker","_workerUtils","requestId","loader","onmessage","async","payload","input","result","arrayBuffer","context","data","parser","parseSync","parse","parseTextSync","TextDecoder","decode","modules","worker","parseData","parseOnMainThread","postMessage","error","Promise","resolve","reject","onMessage","removeEventListener","addEventListener","NullWorker","_version","_workerJob","_workerThread","_workerFarm","_workerPool","_workerBody","_processOnWorker","_createWorker","_getWorkerUrl","_validateWorkerVersion","_getTransferList","_libraryUtils","_asyncQueue","_childProcessProxy","null","isMobile","orientation","jobName","workerThread","isRunning","_resolve","_reject","done","obj","configurable","writable","_getLoadableWorkerUrl","NOOP","Worker","onError","console","_createBrowserWorker","destroy","terminate","terminated","Boolean","transferList","getTransferList","_getErrorFromErrorEvent","event","lineno","colno","_loadableURL","getLoadableWorkerURL","onerror","onmessageerror","workerURLCache","Map","workerURL","startsWith","getLoadableWorkerURLFromSource","workerUrl","getLoadableWorkerURLFromURL","set","workerSource","blob","Blob","URL","createObjectURL","object","recursive","transfers","transfersSet","isTransferable","buffer","ArrayBuffer","isView","undefined","MessagePort","ImageBitmap","OffscreenCanvas","DEFAULT_PROPS","maxConcurrency","maxMobileConcurrency","onDebug","reuseWorkers","WorkerFarm","_workerThreadDefault","isSupported","workerPools","workerPool","values","_getWorkerPoolProps","getWorkerPool","_workerPoolDefault","idleQueue","isDestroyed","job","startPromise","onStart","jobQueue","_startQueuedJob","_getAvailableWorker","queuedJob","shift","backlog","_workerJobDefault","returnWorkerToQueue","count","_getMaxConcurrency","toLowerCase","onMessageWrapperMap","isKnownMessage","onMessageWrapper","canProcessOnWorker","processOnWorker","_removeNontransferableOptions","_workerFarmDefault","getWorkerName","getWorkerURL","getWorkerFarm","startJob","bind","transferableOptions","removeNontransferableOptions","warn","JSON","v","cache","stringify","has","err","stringifyJSON","warning","workerOptions","workerFile","_workerType","versionTag","createWorker","inputBatches","processInBatches","processOnMainThread","_asyncQueueDefault","resultIterator","batch","_workerBodyDefault","close","Symbol","asyncIterator","_values","_settlers","_closed","_Symbol$asyncIterator","enqueue","settler","next","validateWorkerVersion","coreVersion","workerVersion","loadLibrary","getLibraryUrl","_requireUtilsNode","loadLibraryPromises","libraryUrl","moduleName","endsWith","response","node","requireFromFile","scriptSource","requireFromString","eval","script","createElement","appendChild","createTextNode","text","body","loadLibraryFromString","loadLibraryFromFile","library","CDN","canParseWithWorker","parseWithWorker","parseJSON","string","_","getFirstCharacters","getMagicString","byteOffset","byteLength","dataView","DataView","magic","fromCharCode","getUint8","toArrayBuffer","compareArrayBuffers","concatenateArrayBuffers","concatenateTypedArrays","sliceArrayBuffer","isBuffer","bufferToArrayBuffer","TextEncoder","encode","_toArrayBuffer","arrayBuffer1","arrayBuffer2","array1","Uint8Array","array2","sources","sourceArrays","source2","reduce","typedArray","offset","sourceArray","typedArrays","arrays","TypedArrayConstructor","constructor","acc","subArray","subarray","toBuffer","_buffer","padToNBytes","copyArrayBuffer","copyToArray","padding","targetBuffer","sourceBuffer","targetArray","target","targetOffset","srcByteOffset","srcByteLength","copyPaddedArrayBufferToDataView","copyPaddedStringToDataView","paddedLength","padLength","setUint8","padStringToByteAlignment","byteAlignment","Math","ceil","whitespace","copyStringToDataView","charCodeAt","copyBinaryToDataView","binary","makeTextDecoderIterator","arrayBufferIterator","textDecoder","stream","makeTextEncoderIterator","textIterator","textEncoder","makeLineIterator","previous","textChunk","eolIndex","indexOf","line","makeNumberedLineIterator","lineIterator","counter","concatenateArrayBuffersAsync","concatenateStringsAsync","iterator","visitor","return","arrayBuffers","chunk","strings","join","_stats","throttleRequests","maxRequests","stats","Stats","scheduleRequest","handle","getPriority","requestMap","request","priority","promise","requestQueue","_issueNewRequests","_issueRequest","isDone","activeRequestCount","deferredUpdate","_issueNewRequestsAsync","freeSlots","max","_updateAllRequests","_updateRequest","splice","sort","b","_stat","_hiResTimestamp","_initializeStats","seal","_getOrCreate","size","reset","fn","getTable","table","stat","time","average","getAverageTime","hz","getHz","_statDefault","sampleSize","setSampleSize","samples","incrementCount","addCount","decrementCount","subtractCount","_samples","_checkSampling","addTime","_time","lastTiming","timeStart","_startTime","_hiResTimestampDefault","_timerPending","timeEnd","getSampleAverageCount","lastSampleCount","getSampleAverageTime","lastSampleTime","getSampleHz","getAverageCount","timestamp","performance","now","hrtime","timeParts","Date","setPathPrefix","getPathPrefix","addAliases","pathPrefix","fileAliases","prefix","aliases","filename","alias","replacement","replace","JSONLoader","_typecheckJSONLoader","extensions","mimeTypes","category","dirname","slashIndex","lastIndexOf","substr","parts","part","index","RegExp","_fetch","readdir","info","isDirectory","flags","mode","open","fd","fstat","position","totalBytesRead","bytesRead","read","checkResponse","checkResponseSync","_resourceUtils","resource","isResponse","headers","contentLength","getResourceContentLength","getResourceUrlAndType","initialDataUrl","INITIAL_DATA_LENGTH","blobSlice","reader","FileReader","onload","_event$target","readAsDataURL","bytes","btoa","arrayBufferToBase64","getInitialDataUrl","Response","ok","status","contentType","statusText","getResponseError","isObject","isPureObject","isPromise","isIterable","isAsyncIterable","isIterator","isFile","isBlob","isWritableDOMStream","isReadableDOMStream","isWritableNodeStream","isReadableNodeStream","isReadableStream","isWritableStream","isBoolean","isFunction","then","json","File","abort","getWriter","ReadableStream","tee","cancel","getReader","end","write","pipe","readable","_mimeTypeUtils","QUERY_STRING_PATTERN","stripQueryString","contentTypeHeader","parseMIMEType","parseMIMETypeFromURL","DATA_URL_PATTERN","MIME_TYPE_PATTERN","mimeString","readArrayBuffer","readBlob","file","start","_readToArrayBuffer","fileReader","readAsArrayBuffer","readFileSync","nothrow","writeFile","writeFileSync","filePath","arrayBufferOrString","flag","setLoaderOptions","_optionUtils","getGlobalLoaderState","setGlobalOptions","normalizeOptions","getFetchFunction","_loggers","_optionDefaults","loaders","_state","getGlobalLoaderOptions","state","globalOptions","normalizeOptionsInternal","validateOptionsObject","DEFAULT_LOADER_OPTIONS","REMOVED_LOADER_OPTIONS","idOptions","loaderOptions","deprecatedOptions","validateOptions","isArray","defaultOptions","loaderName","isSubOptions","isBaseUriOption","isWorkerUrlOption","probeLog","suggestion","findSimilarOption","optionKey","lowerCaseOptionKey","bestSuggestion","lowerCaseKey","mergedOptions","baseUri","addUrlOptions","NullLog","mergeNestedFields","ConsoleLog","Log","_globals1","_globals2","_isBrowser","_getBrowser","_isElectron","_color","_formatters","_autobind","_localStorage","_logDefault","probe","__VERSION__","_isBrowserDefault","isBrowserMainThread","_isElectronDefault","mockUserAgent","electron","realUserAgent","navigator","userAgent","process_","console_","normalizeArguments","originalConsole","debug","DEFAULT_SETTINGS","enabled","level","ONCE","getTableHeader","_startTs","_deltaTs","LOG_THROTTLE_TIMEOUT","_storage","_localStorageDefault","timeStamp","newLevel","setLevel","getLevel","isEnabled","config","getTotal","toPrecision","getDelta","newPriority","enable","updateConfiguration","_getLogFunction","deprecated","oldUsage","newUsage","removed","logLevel","columns","tag","image","scale","_shouldLog","img","Image","formatImage","src","element","nodeName","toDataURL","logImageInBrowser","asciify","fit","round","logImageInNode","settings","setting","group","opts","collapsed","method","groupCollapsed","groupEnd","withGroup","func","trace","normalizeLogLevel","total","delta","leftPad","formatTime","addColor","color","background","decorateMessage","resolvedLevel","isFinite","unshift","messageType","defaultSettings","storage","setItem","removeItem","getStorage","_loadConfiguration","getConfiguration","setConfiguration","configuration","serialized","serializedConfiguration","getItem","ms","formatted","toFixed","rightPad","formatValue","isInteger","maxElts","terminator","formatArrayValue","abs","maxWidth","imageUrl","min","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","toUpperCase","autobind","predefined","proto","getPrototypeOf","propNames","getOwnPropertyNames","find","navigator_","isMSIE","isTrident","chrome","safari","mozInnerScreenX","mimeType","limit","_limitMB","batchSize","batchDebounceMs","metadata","transforms","throws","dataType","uri","credentials","redirect","referrer","referrerPolicy","integrity","keepalive","signal","registerLoaders","getRegisteredLoaders","_unregisterLoaders","_normalizeLoader","getGlobalLoaderRegistry","loaderRegistry","normalizedLoader","normalizeLoader","registeredLoader","isLoaderObject","_loader","_loader2","_loader3","parseText","selectLoader","selectLoaderSync","EXT_PATTERN","validHTTPResponse","getNoValidLoaderMessage","candidateLoaders","ignoreRegisteredLoaders","normalizeLoaders","testUrl","findLoaderByMIMEType","match","extension","loaderExtension","findLoaderByExtension","findLoaderByUrl","testDataAgainstText","testDataAgainstBinary","findLoaderByInitialBytes","fallbackMimeType","selectLoaderInternal","testText","tests","test","testBinary","_getData","_loaderContext","typedLoaders","getLoadersFromContext","getLoaderContext","getArrayBufferOrStringFromData","parseWithLoader","getArrayBufferOrStringFromDataSync","getAsyncIterableFromData","getReadableStream","ERR_DATA","isArrayBuffer","makeIterator","getIterableFromData","_makeStringIterator","_makeArrayBufferIterator","_makeBlobIterator","_makeStreamIterator","makeStringIterator","makeArrayBufferIterator","makeBlobIterator","makeStreamIterator","chunkSize","chunkLength","DEFAULT_CHUNK_SIZE","chunkByteLength","nextBatchPromise","currentBatchPromise","_streamReadAhead","releaseLock","makeBrowserStreamIterator","makeNodeStreamIterator","previousContext","resolvedContext","contextLoaders","parseWithLoaderSync","parseInBatches","outputIterator","inputIterator","transformedIterator","iteratorChain","transformBatches","applyInputTransforms","parseChunkInBatches","parsedData","shape","batchType","parseToOutputIterator","metadataBatch","_context","bytesUsed","makeMetadataBatchIterator","parseWithLoaderInBatches","load","loadInBatches","files","loadOneFileInBatches","encodeSync","encodeText","encodeInBatches","encodeURLtoURL","writer","batches","chunks","tmpInputFilename","getTemporaryFilename","tmpOutputFilename","outputFilename","dataIterator","getIterator","inputUrl","outputUrl","save","saveSync","encodedData","makeStream","makeDOMStream","_makeNodeStreamDefault","controller","_iterator$return","highWaterMark","NullWorkerLoader","NullLoader","loadedBytes","totalBytes","onProgress","onDone","parseInt","progressStream","lowerCaseFiles","usedFiles","range","Headers","pathname","_getFile","used","_imageLoader","_imageWriter","_binaryImageApi","_imageType","_parsedImageApi","_loadImage","_typecheckImageLoader","_parseImage","_parseImageDefault","getBinaryImageMetadata","_parseToImage","_parseToImageBitmap","_parseToNodeImage","imageType","getDefaultImageType","getLoadableImageType","_parseToImageBitmapDefault","_parseToImageDefault","_parseToNodeImageDefault","getImageData","isImageTypeSupported","_parseImageNode","IMAGE_SUPPORTED","IMAGE_BITMAP_SUPPORTED","NODE_IMAGE_SUPPORTED","DATA_SUPPORTED","isImage","getImageTypeOrNull","deleteImage","getImageType","format","getImageSize","canvas","getContext","drawImage","loadToImage","_svgUtils","blobOrDataUrl","getBlobOrSVGDataUrl","webkitURL","objectUrl","revokeObjectURL","isSVG","getBlob","SVG_DATA_URL_PATTERN","SVG_URL_PATTERN","xmlText","unescape","encodeURIComponent","EMPTY_OBJECT","imagebitmapOptionsSupported","imagebitmapOptions","isEmptyObject","createImageBitmap","safeCreateImageBitmap","getBmpMetadata","BIG_ENDIAN","LITTLE_ENDIAN","binaryData","toDataView","getUint32","getPngMetadata","getUint16","tableMarkers","sofMarkers","getJpegMarkers","getJpegMetadata","getGifMetadata","ImageWriter","_encodeImage","jpegQuality","encodeImage","_encodeImageNode","transferFromImageBitmap","clampedArray","Uint8ClampedArray","imageData","ImageData","putImageData","drawImageToCanvas","qualityParamSupported","toBlob","encodeImageInBrowser","loadImage","getImageUrls","getMipLevels","_generateUrl","_deepLoad","getUrl","imageUrls","deepLoad","urlOptions","mipLevels","urls","generateUrl","lod","shallowLoad","mipLevel","getMipmappedImageUrls","log2","baseUrl","_asyncDeepMap","urlTree","asyncDeepMap","mapSubtree","tree","urlArray","promises","all","mapArray","mapObject","_interopRequireWildcard","_interopRequireDefault","_typeof","_typeof2","_probeGl","loggers","handlers","eventType","getLoggers","logState","attributeUpdateMessages","needsUpdate","getChangeFlags","filter","changed","updated","subLayers","viewport","attributeManager","trigger","attributeNames","attributeManagerUpdateStart","numInstances","timeMs","updateMessage","attribute","attributeUpdateStart","deckRenderer","renderStats","pass","redrawReason","totalCount","visibleCount","compositeCount","pickableCount","hiddenCount","renderCount","firstChar","lastChar","createProgramManager","_project","_project32","_shadow","_picking","DEFAULT_MODULES","project","SHADER_HOOKS","programManager","ProgramManager","getDefaultProgramManager","shaderModule","addDefaultModule","shaderHook","addShaderHook","_gltools","_webgl","_engine","_shadertools","_webglChecks","_polyfillContext","_unifiedParameterApi","_trackContextState","_devicePixels","ERR_WEBGL","ERR_WEBGL2","isWebGL","isWebGL2","getWebGL2Context","assertWebGLContext","assertWebGL2Context","ERR_CONTEXT","WebGLRenderingContext","WebGL2RenderingContext","polyfillContext","_polyfillVertexArrayObject","_polyfillTable","luma","polyfilled","initializeExtensions","installPolyfills","WEBGL2_CONTEXT_POLYFILLS","installOverrides","target2","EXTENSIONS","getSupportedExtensions","getExtension","WEBGL2_CONTEXT_OVERRIDES","originalFunc","polyfill","polyfills","polyfillExtension","defaults","meta","suffix","ext","extKey","polyfillVertexArrayObject","glErrorShadow","synthesizeGLError","opt_msg","msg","WebGLVertexArrayObjectOES","isAlive","hasBeenBound","elementArrayBuffer","attribs","maxVertexAttribs","n","attrib","VertexAttrib","maxAttrib","normalized","stride","cached","recache","OESVertexArrayObject","f","getError","wrapGLError","original","getParameter","enableVertexAttribArray","disableVertexAttribArray","bindBuffer","getVertexAttrib","vertexAttribPointer","pname","VERTEX_ARRAY_BINDING_OES","currentVertexArrayObject","defaultVertexArrayObject","vao","currentArrayBuffer","indx","instrumentExtension","reset_","createVertexArray","original_getSupportedExtensions","list","original_getExtension","__OESVertexArrayObject","vertexArrayObjects","ii","bindVertexArrayOES","createVertexArrayOES","arrayObject","deleteVertexArrayOES","isVertexArrayOES","oldVAO","newVAO","currentBinding","oldAttrib","bufferChanged","_getParameterPolyfill","ANGLE_instanced_arrays","deleteVertexArray","bindVertexArray","isVertexArray","vertexAttribDivisor","location","divisor","drawElementsInstanced","drawArraysInstanced","drawBuffers","createQuery","deleteQuery","beginQuery","endQuery","getQuery","getQueryObject","getQueryParameter","readBuffer","attachment","webgl2","getExtensionData","getProgramParameter","program","getInternalformatParameter","Int32Array","getTexParameter","TEXTURE_MAX_ANISOTROPY_EXT","getParameterPolyfill","hint","OES_element_index","WEBGL_draw_buffers","WEBGL_debug_renderer_info","getWebGL2ValueOrZero","WEBGL_PARAMETERS","GPU_DISJOINT_EXT","UNMASKED_VENDOR_WEBGL","UNMASKED_RENDERER_WEBGL","MAX_TEXTURE_MAX_ANISOTROPY_EXT","MAX_COLOR_ATTACHMENTS_WEBGL","MAX_DRAW_BUFFERS_WEBGL","originalGetParameter","setParameters","getParameters","resetParameters","withParameters","_webglParameterTables","_utils","isObjectEmpty","compositeSetters","glConstant","setter","GL_PARAMETER_SETTERS","compositeSetter","GL_COMPOSITE_PARAMETER_SETTERS","GL_PARAMETER_DEFAULTS","getter","GL_PARAMETER_GETTERS","parameterKeys","nocatch","GL_HOOKED_SETTERS","Float32Array","disable","pixelStorei","blendColor","clearColor","colorMask","cullFace","clearDepth","depthFunc","depthRange","bindFramebuffer","frontFace","lineWidth","scissor","clearStencil","stencilMaskSeparate","framebuffer","blend","blendEquationSeparate","blendFuncSeparate","cull","dither","derivativeHint","mipmapHint","polygonOffsetFill","polygonOffset","sampleCoverage","scissorTest","stencilTest","stencilMask","mask","backMask","stencilFunc","ref","backFunc","backRef","stencilFuncSeparate","stencilOp","sfail","dpfail","dppass","backSfail","backDpfail","backDppass","stencilOpSeparate","getValue","glEnum","stencilFuncFront","stencilFuncBack","stencilOpFront","stencilOpBack","update","capability","r","g","modeRGB","modeAlpha","dst","srcRGB","dstRGB","srcAlpha","dstAlpha","depth","s","zNear","zFar","face","factor","units","invert","fail","zfail","zpass","trackContextState","pushContextState","popContextState","installGetterOverride","functionName","originalGetterFunc","params","installSetterSpy","originalSetterFunc","valueChanged","oldValue","_updateCache","installProgramSpy","originalUseProgram","useProgram","GLState","copyState","stateStack","pop","oldValues","deepArrayEqual","isArrayX","isArrayY","createGLContext","instrumentGLContext","getContextDebugInfo","resizeGLContext","isPage","CONTEXT_DEFAULTS","webgl1","throwOnError","manageState","targetCanvas","readyState","getElementById","insertBefore","firstChild","getCanvas","errorMessage","onCreateError","statusMessage","onContextLost","onContextRestored","createBrowserContext","webGL","driver","vendor","renderer","logInfo","_instrumented","getVersion","canvasSizeInfo","makeDebugContext","vendorMasked","rendererMasked","shadingLanguageVersion","devicePixelRatio","clientWidth","clientHeight","cachedSize","clampedPixelRatio","canvasWidth","canvasHeight","drawingBufferWidth","drawingBufferHeight","setDevicePixelRatio","getDevicePixelRatio","resize","cssToDeviceRatio","cssToDevicePixels","cssPixel","yInvert","pixel","ratio","scaleX","scaleY","t","xHigh","yHigh","scalePixels","windowRatio","_init","_requestAnimationFrame","_textureUtils","_constantsToKeys","_limits","_webglFeaturesTable","_features","_checkGlslExtension","_accessor","_program","_framebuffer","_renderbuffer","_texture2D","_textureCube","_clear","_copyAndBlit","_query","_texture3D","_transformFeedback","_vertexArrayObject","_vertexArray","_uniformBufferLayout","_loadFile","_getShaderName","_getShaderVersion","_uniforms","_debugUniforms","_debugVertexArray","_debugProgramConfiguration","lumaStats","nodeIO","requestAnimationFrame","callback","cancelAnimationFrame","timerId","cloneTextureFrom","toFramebuffer","refTexture","overrides","_texture2DDefault","_textureCubeDefault","_texture3DDefault","TextureType","dataFormat","border","mipmaps","texture","_framebufferDefault","attachments","_texture","Texture2D","_textureDefault","super","initialize","_resource","_textureFormats","NPOT_MIN_FILTERS","WebGLBuffer","Texture","_resourceDefault","linearFiltering","supported","isFormatSupported","isLinearFilteringSupported","uid","textureUnit","loaded","toString","resolvedImageData","pixels","isVideo","HTMLVideoElement","HAVE_METADATA","_video","recreate","pixelStore","compressed","_deduceParameters","activeTexture","bindTexture","_isNPOT","_updateForNPOT","setImageData","generateMipmap","video","lastTime","HAVE_CURRENT_DATA","currentTime","setSubImageData","_trackDeallocatedMemory","gl2","_getDataType","texImage2D","levelIndex","levelData","entries","compressedTexImage2D","_trackAllocatedMemory","channels","DATA_FORMAT_CHANNELS","channelSize","TYPE_SIZES","ndarray","_bufferDefault","compressedTexSubImage2D","texSubImage2D","copyFramebuffer","getActiveUnit","unbind","textureFormat","TEXTURE_FORMATS","types","_deduceImageSize","HTMLImageElement","naturalWidth","naturalHeight","HTMLCanvasElement","videoWidth","videoHeight","_createHandle","createTexture","_deleteHandle","deleteTexture","_getParameter","_setParameter","param","_getNPOTParam","texParameterf","texParameteri","isPowerOfTwo","TEXTURE_MIN_FILTER","LINEAR","TEXTURE_WRAP_S","CLAMP_TO_EDGE","TEXTURE_WRAP_T","_stubMethods","ERR_RESOURCE_METHOD_UNDEFINED","_bound","_handle","_addStats","deleteChildren","children","_removeStats","child","funcOrHandle","_bindHandle","getKeyValue","parameter","PARAMETERS","isWebgl2","webgl1Default","webgl2Default","getKey","setParameter","stubRemovedMethods","className","methodNames","_getOptsFromHandle","getKeyType","number","isNaN","uidCounters","isEmpty","instance","upgradeMessage","methodName","_typedArrayUtils","_checkProps","DEPRECATED_PROPS","integer","instanced","isInstanced","PROP_CHECKS_INITIALIZE","removedProps","replacedProps","deprecatedProps","PROP_CHECKS_SET_PROPS","Buffer","getElementCount","accessor","_accessorDefault","getBytesPerElement","getVertexCount","getBytesPerVertex","checkProps","usage","debugData","setAccessor","_setData","_setByteLength","reallocate","setData","subData","srcOffset","bufferSubData","_inferType","copyData","readOffset","writeOffset","copyBufferSubData","getData","dstData","dstOffset","ArrayType","getTypedArrayFromGLType","clamped","sourceAvailableElementCount","_getAvailableElementCount","dstElementOffset","dstAvailableElementCount","dstElementCount","copyElementCount","getBufferSubData","bindBufferRange","bindBufferBase","getDebugData","invalidateDebugData","_getTarget","bufferData","getGLTypeFromTypedArray","sourceElementOffset","BYTES_PER_ELEMENT","createBuffer","deleteBuffer","getBufferParameter","setByteLength","updateAccessor","DEFAULT_ACCESSOR_VALUES","PROP_CHECKS","Accessor","accessors","_assign","freeze","BYTES_PER_VERTEX","flipRows","arrayOrType","Uint16Array","Uint32Array","Int8Array","Int16Array","glType","bytesPerPixel","temp","bytesPerRow","topOffset","bottomOffset","copyWithin","newWidth","newHeight","newData","c","propChecks","propName","replacementProp","newProps","gl1","loadFile","res","crossOrigin","FACES","TextureCube","setCubeMapImageData","subImage","mipmapLevel","_subImage","imageDataMap","resolvedFaces","facePixels","lodLevel","setImageDataForFace","Texture3D","unpackFlipY","texImage3D","FRAMEBUFFER_ATTACHMENT_PARAMETERS","_copyAndBlitJs","ERR_MULTIPLE_RENDERTARGETS","Framebuffer","colorBufferFloat","colorBufferHalfFloat","defaultFramebuffer","MAX_COLOR_ATTACHMENTS","MAX_DRAW_BUFFERS","ownResources","stencil","check","_createDefaultAttachments","clearAttachments","checkStatus","resizeAttachments","attach","prevHandle","_setReadBuffer","_setDrawBuffers","attachmentPoint","newAttachments","descriptor","_renderbufferDefault","_attachRenderbuffer","renderbuffer","_attachTexture","_unattach","getStatus","STATUS","_getFrameBufferStatus","checkFramebufferStatus","clear","drawBuffer","readPixels","readPixelsToBuffer","copyToDataUrl","copyToImage","copyToTexture","blit","invalidate","invalidateFramebuffer","getAttachmentParameter","_getAttachmentParameterFallback","getFramebufferAttachmentParameter","getAttachmentParameters","ATTACHMENT_PARAMETERS","attachmentName","show","targetMaxHeight","defaultAttachments","oldAttachment","framebufferRenderbuffer","framebufferTexture2D","framebufferTextureLayer","mapIndexToCubeMapFace","drawBuffersWEBGL","caps","getFeatures","WEBGL2","EXT_sRGB","createFramebuffer","deleteFramebuffer","_renderbufferFormats","Renderbuffer","formats","_renderbufferFormatsDefault","bindRenderbuffer","renderbufferStorageMultisample","renderbufferStorage","bpp","createRenderbuffer","deleteRenderbuffer","_syncHandle","getRenderbufferParameter","EXT_FLOAT_WEBGL2","clearBuffer","ERR_ARGUMENTS","clearFlags","clearBufferiv","clearBufferuiv","clearBufferfv","clearBufferfi","readPixelsToArray","_formatUtils","sourceX","sourceY","sourceFormat","sourceAttachment","sourceWidth","sourceHeight","sourceType","getFramebuffer","pixelArray","components","glFormatToComponents","getPixelArray","targetByteOffset","byteCount","glTypeToBytes","MAX_SAFE_INTEGER","createImageData","targetImage","dataUrl","targetMipmaplevel","targetInternalFormat","targetX","targetY","targetZ","isSubCopy","copyTexSubImage2D","copyTexSubImage3D","copyTexImage2D","sourceX0","sourceY0","targetX0","targetY0","sourceX1","sourceY1","targetX1","targetY1","srcFramebuffer","deleteSrcFramebuffer","dstFramebuffer","deleteDstFramebuffer","prevDrawHandle","prevReadHandle","blitFramebuffer","getContextLimits","getGLContextInfo","getContextInfo","_webglLimitsTable","limits","webgl1MinLimits","webgl2MinLimits","_webglLimitsTableDefault","webgl1MinLimit","webgl2MinLimit","minLimit","negative","FEATURES","VERTEX_ARRAY_OBJECT","TIMER_QUERY","INSTANCED_RENDERING","MULTIPLE_RENDER_TARGETS","ELEMENT_INDEX_UINT32","BLEND_EQUATION_MINMAX","FLOAT_BLEND","COLOR_ENCODING_SRGB","TEXTURE_DEPTH","TEXTURE_FLOAT","TEXTURE_HALF_FLOAT","TEXTURE_FILTER_LINEAR_FLOAT","TEXTURE_FILTER_LINEAR_HALF_FLOAT","TEXTURE_FILTER_ANISOTROPIC","COLOR_ATTACHMENT_RGBA32F","COLOR_ATTACHMENT_FLOAT","COLOR_ATTACHMENT_HALF_FLOAT","GLSL_FRAG_DATA","GLSL_FRAG_DEPTH","GLSL_DERIVATIVES","GLSL_TEXTURE_LOD","testTexture","testFb","hasFeature","hasFeatures","feature","features","every","isFeatureSupported","cap","_webglFeaturesTableDefault","featureDefinition","queryFeature","_checkOldIe","compiledGlslExtensions","_checkOldIeDefault","shader","createShader","shaderSource","compileShader","canCompile","getShaderParameter","deleteShader","Shader","VertexShader","FragmentShader","_glslUtils","shaderType","getShaderName","getTypeName","shaderName","_compile","getName","getSource","getShaderSource","getTranslatedSource","getTranslatedShaderSource","infoLog","getShaderInfoLog","errors","warnings","parseGLSLCompilerError","_formatGlslError","_getShaderTypeName","errLog","errorStrings","_getShaderNameDefault","shaderDescription","_getShaderTypeNameDefault","errorString","segments","lines","delim","maxDigits","lineNumber","digits","padLeft","addLineNumbers","formatErrors","column","substring","trim","defaultName","words","_programConfiguration","_attributeUtils","GL_SEPARATE_ATTRIBS","V6_DEPRECATED_METHODS","Program","_isCached","_setId","hash","vs","varyings","bufferMode","uniforms","_textureUniforms","transformFeedbackVaryings","_compileAndLink","_readUniformLocationsFromLinkedProgram","_programConfigurationDefault","setUniforms","draw","logPriority","drawMode","vertexCount","isIndexed","indexType","instanceCount","vertexArray","transformFeedback","samplers","fb","_areTexturesRenderable","bindForDraw","primitiveMode","getPrimitiveDrawMode","begin","_bindTextures","drawRangeElements","drawElements","drawArrays","checkUniformValues","_uniformSetters","uniformName","uniform","uniformSetter","textureUpdate","textureIndex","_textureIndexCounter","copyUniform","texturesRenderable","createProgram","deleteProgram","_getOptionsFromHandle","shaderHandles","getAttachedShaders","shaderHandle","programName","_getName","attachShader","linkProgram","getProgramInfoLog","validateProgram","_uniformCount","getActiveUniform","parseUniformName","getUniformLocation","getUniformSetter","l","getActiveUniforms","uniformIndices","getUniformBlockIndex","blockName","getActiveUniformBlockParameter","blockIndex","uniformBlockBinding","blockBinding","UNIFORM_SETTERS","getArraySetter","toFloatArray","setVectorUniform","toIntArray","setMatrixUniform","getSamplerSetter","toUIntArray","FLOAT_ARRAY","INT_ARRAY","UINT_ARRAY","toTypedArray","uniformLength","Type","uniformMap","checkUniformValue","checkLength","checkUniformArray","uniform1i","toArray","cacheLength","arrayValue","attributeInfos","attributeInfosByName","attributeInfosByLocation","varyingInfos","varyingInfosByName","_readAttributesFromProgram","_readVaryingsFromProgram","getAttributeInfo","locationOrName","getAttributeLocation","attributeInfo","getAttributeAccessor","getVaryingInfo","getVaryingIndex","varying","getVaryingAccessor","getActiveAttrib","getAttribLocation","_addAttribute","getTransformFeedbackVarying","_addVarying","compositeType","decomposeCompositeGLType","_inferProperties","getPrimitiveCount","getCompositeGLType","GL_FLOAT","GL_INT","GL_UNSIGNED_INT","COMPOSITE_GL_TYPES","primitiveCount","compositeGLType","typeAndSize","compType","compComponents","Query","hasTimerQuery","_queryPending","_pollingPromise","beginTimeElapsedQuery","beginOcclusionQuery","conservative","beginTransformFeedbackQuery","isResultAvailable","resultAvailable","isTimerDisjoint","getResult","getTimerMilliseconds","createPoll","POSITIVE_INFINITY","poll","TransformFeedback","buffers","unused","bindOnUse","_unbindBuffers","setBuffers","bufferName","setBuffer","bufferOrParams","_getVaryingIndex","byteSize","_getBufferParams","_bindBuffer","bindTransformFeedback","_bindBuffers","beginTransformFeedback","endTransformFeedback","_getVaryingInfo","bufferIndex","createTransformFeedback","deleteTransformFeedback","_arrayUtilsFlat","VertexArrayObject","constantAttributeZero","getBrowser","defaultVertexArray","isDefaultArray","MAX_ATTRIBUTES","_setConstantFloatArray","_setConstantIntArray","_setConstantUintArray","bufferValue","getMaxAttributes","setElementBuffer","elementBuffer","vertexAttribIPointer","getConstantBuffer","elementCount","constantValue","_normalizeConstantArrayValue","updateNeeded","_compareConstantArrayValues","getScratchArray","v1","v2","vertexAttrib1fv","vertexAttrib2fv","vertexAttrib3fv","vertexAttrib4fv","vertexAttribI1iv","vertexAttribI2iv","vertexAttribI3iv","vertexAttribI4iv","vertexAttribI1uiv","vertexAttribI2uiv","vertexAttribI3uiv","vertexAttribI4uiv","elements","getVertexAttribOffset","getScratchArrayBuffer","fillArray","copied","MULTI_LOCATION_ATTRIBUTE_REGEXP","DEPRECATIONS_V6","elementsAccessor","drawParams","attributes","vertexArrayObject","_vertexArrayObjectDefault","fill","setAttributes","clearDrawParams","getDrawParams","_updateDrawParams","_setAttribute","appAccessor","_resolveLocationAndAccessor","setConstant","unbindBuffers","bindBuffers","_setConstantAttributes","valueAccessor","INVALID_RESULT","_getAttributeIndex","accessInfo","_getAttributeInfo","currentAccessor","attributeName","multiLocation","locationOffset","constant","_setConstantAttributeZero","_setConstantAttribute","indexCount","Infinity","_updateDrawParamsForLocation","indexOffset","setElements","layout","_addUniform","getBytes","getSubData","offsets","sizes","_setValue","uniformType","typeAndComponents","_alignTo","getDebugTableForUniforms","_formatValue","header","undefinedOnly","PROJECT_MODULE_UNIFORM_REGEXP","uniformLocations","uniformNames","addUniformToTable","unusedCount","unusedTable","isDefined","isUniformDefined","getDebugTableForVertexArray","ELEMENT_ARRAY_BUFFER","getDebugTableRow","attributeLocation","rowHeader","getGLSLDeclaration","verts","typeAndName","getDebugTableForProgramConfiguration","varyingInfo","_animationLoop","_model","_programManager","_transform","_geometry","_coneGeometry","_cubeGeometry","_cylinderGeometry","_icoSphereGeometry","_planeGeometry","_timeline","_keyFrames","_clipSpace","statIdCounter","onCreateContext","onAddHTML","onInitialize","onRender","onFinalize","glOptions","autoResizeViewport","autoResizeDrawingBuffer","useDevicePixelRatio","timeline","cpuTime","gpuTime","frameRate","_initialized","_running","_animationFrameId","_nextFramePromise","_resolveNextFrame","_cpuStartTime","stop","_pageLoadPromise","_onMousemove","_onMouseleave","_setDisplay","setNeedsRedraw","reason","_getPageLoadPromise","_createWebGLContext","_createFramebuffer","_startEventHandling","_initializeCallbackData","_updateCallbackData","_resizeCanvasDrawingBuffer","_resizeViewport","_gpuTimeQuery","animationProps","appContext","_addCallbackData","_startLoop","catch","redraw","isContextLost","_beginTimers","_setupFrame","_renderFrame","_clearNeedsRedraw","offScreen","commit","_endTimers","_finalizeCallbackData","_cancelAnimationFrame","attachTimeline","detachTimeline","waitForRender","getHTMLControlValue","defaultValue","setViewParameters","renderFrame","display","animationLoop","animationFrameId","renderFrameCallback","_resizeFramebuffer","startTime","engineTime","tick","tock","_loop","_mousePosition","aspect","_getSizeAndAspect","getTime","_offScreen","_createInfoDiv","wrapperDiv","div","left","bottom","html","innerHTML","offsetX","offsetY","_modelUtils","DRAW_PARAMS","lastLogTime","animated","_programManagerDefault","_programManagerState","_managedProgram","defines","inject","transpileToGLSL100","programProps","_programDirty","_attributes","pickable","_checkProgram","getModuleUniforms","moduleSettings","geometryBuffers","_setModelProps","geometry","release","_deleteGeometryBuffers","getDrawMode","getInstanceCount","getAttributes","getProgram","setProgram","getUniforms","setDrawMode","setVertexCount","setInstanceCount","setGeometry","getBuffersFromGeometry","normalizedAttributes","updateModuleSettings","_logDrawCallStart","vertexArrayInstanced","onBeforeRender","onAfterRender","didDraw","_logDrawCallEnd","transform","discard","feedbackBuffers","unbindModels","_setFeedbackBuffers","model","_feedbackBuffers","stateHash","VertexArray","_setAnimationProps","logDrawTimeout","attributeTable","uniformTable","missingTable","missingCount","configTable","defaultProgramManager","_programCache","_getUniforms","_registeredModules","_hookFunctions","_defaultModules","_hashes","_hashCounter","_useCounts","m","removeDefaultModule","hook","_getModuleList","vsHash","_getHash","fsHash","moduleHashes","varyingHashes","defineKeys","injectKeys","defineHashes","injectHashes","assembled","assembleShaders","hookFunctions","appModules","seen","_assembleShaders","_injectShader","_shaderModule","_shaderUtils","_modules","_resolveModules","_platformDefines","_transpileShader","INJECT_SHADER_DECLARATIONS","DECLARATION_INJECT_MARKER","SHADER_TYPE","assembleShader","VERTEX_SHADER","assembleGetUniforms","prologue","glslVersion","versionLine","coreSource","sourceLines","allDefines","assembledSource","getDefines","sourceText","getHookFunctions","define","declInjections","getPlatformShaderDefines","getVersionDefines","isVertex","hookFunction","signature","hookInjections","injections","footer","injection","hookFunctionMap","mainInjections","moduleSource","getModuleSource","injectionType","moduleUniforms","normalizeHookFunctions","hookName","order","_transpileShaderDefault","injectShaderName","getApplicationDefines","FRAGMENT_SHADER","resolveModules","TEST_EXPORTS","getShaderDependencies","instantiateModules","moduleMap","moduleDepth","getDependencyGraph","dependencies","_shaderModuleDefault","normalizeShaderModule","_propTypes","ShaderModule","deprecations","vertexShader","fragmentShader","_parseDeprecationDefinitions","stage","normalizeInjections","parsePropTypes","_defaultGetUniforms","def","regex","old","propTypes","propDef","private","validate","TYPE_DEFINITIONS","propType","propDefs","parsePropType","getTypeOf","_webglInfo","gpuVendor","versionDefines","canCompileGLGSExtension","_isOldIe","WEBGL_FEATURES","identifyGPUVendor","_isOldIeDefault","behavior","getFeature","extensionName","combineInjects","_moduleInjectors","MODULE_INJECTORS","REGEX_START_OF_MAIN","REGEX_END_OF_MAIN","fragments","injects","injectStandardStubs","fragmentData","fragmentString","MODULE_INJECTORS_VS","MODULE_INJECTORS_FS","testVariable","qualifier","ES300_REPLACEMENTS","ES300_VERTEX_REPLACEMENTS","ES300_FRAGMENT_REPLACEMENTS","ES100_REPLACEMENTS","ES100_VERTEX_REPLACEMENTS","ES100_FRAGMENT_REPLACEMENTS","ES100_FRAGMENT_OUTPUT_NAME","ES300_FRAGMENT_OUTPUT_REGEX","convertShader","replacements","pattern","targetGLSLVersion","outputMatch","outputName","convertFragmentShaderTo300","convertFragmentShaderTo100","getQualifierDetails","getPassthroughFS","typeToChannelSuffix","typeToChannelCount","convertToVec4","FS_GLES","FS300","qualifiers","definition","inputType","output","outputValue","variable","_random","_fp32","_fp64","_lights","_dirlight","_phongLighting","_pbr","_tiltshift","_triangleblur","_zoomblur","_brightnesscontrast","_denoise","_huesaturation","_noise","_sepia","_vibrance","_vignette","_colorhalftone","_dotscreen","_edgework","_hexagonalpixelate","_ink","_magnify","_bulgepinch","_swirl","_warp","_fxaa","random","fp32","fp64arithmetic","fp64","_fp64Utils","_fp64ArithmeticGlsl","_fp64FunctionsGlsl","CONST_UNIFORMS","ONE","_fp64ArithmeticGlslDefault","_fp64FunctionsGlslDefault","fp64ify","out","startIndex","hiPart","fround","loPart","fp64LowPart","fp64ifyMatrix4","matrixFP64","j","IDENTITY_MATRIX","DEFAULT_MODULE_OPTIONS","modelMatrix","viewMatrix","projectionMatrix","cameraPositionWorld","common","prevUniforms","viewProjectionMatrix","Matrix4","multiplyRight","_common","_vector2","_vector3","_vector4","_matrix3","_matrix4","_quaternion","_validators","_sphericalCoordinates","_pose","_euler","mathgl","configure","clone","toRadians","toDegrees","radians","degrees","sin","cos","tan","asin","acos","atan","clamp","lerp","equals","exactEquals","withEpsilon","RADIANS_TO_DEGREES","PI","DEGREES_TO_RADIANS","precision","EPSILON","angle","ai","epsilon","oldEpsilon","oldPrecision","printTypes","printDegrees","printRowMajor","_vector","_vec2","_glMatrixExtras","Vector2","_vectorDefault","copy","fromObject","toObject","ELEMENTS","horizontalAngle","atan2","verticalAngle","matrix4","transformAsPoint","vec2","transformMat4","transformAsVector","transformByMatrix3","matrix3","transformMat3","transformByMatrix2x3","matrix2x3","transformMat2d","transformByMatrix2","matrix2","transformMat2","_mathArray","Vector","_mathArrayDefault","vector","checkNumber","sqrt","lengthSquared","magnitude","magnitudeSquared","distance","mathArray","distanceSquared","dist","dot","product","normalize","multiply","vectors","divide","lengthSq","distanceTo","distanceToSquared","getComponent","setComponent","addVectors","subVectors","subtract","multiplyVectors","addScaledVector","multiplyScalar","MathArray","_extendableBuiltin","arrayOrObject","fromArray","to","toTarget","toFloat32Array","formatString","negate","minVector","maxVector","sub","setScalar","addScalar","subScalar","scalar","divideScalar","clampScalar","multiplyByScalar","valid","validateVector","checkVector","callerName","parcelHelpers","fromValues","scaleAndAdd","squaredDistance","squaredLength","inverse","cross","rotate","zero","str","ARRAY_TYPE","RANDOM","setMatrixArrayType","toRadian","vec2_transformMat4AsVector","w","vec3_transformMat4AsVector","z","vec3_transformMat2","vec4_transformMat2","vec4_transformMat3","_vec3","ORIGIN","constants","Vector3","ZERO","vec3","rotateX","origin","rotateY","rotateZ","transformByQuaternion","quaternion","transformQuat","hermite","bezier","mul","sqrDist","sqrLen","_commonJs","create","hypot","Vector4","vec4","applyMatrix4","_matrix","_mat3","IDENTITY","INDICES","COL0ROW0","COL0ROW1","COL0ROW2","COL1ROW0","COL1ROW1","COL1ROW2","COL2ROW0","COL2ROW1","COL2ROW2","Matrix3","_matrixDefault","RANK","identity","m00","m10","m20","m01","m11","m21","m02","m12","m22","setRowMajor","determinant","mat3","fromQuaternion","q","fromQuat","transpose","multiplyLeft","translate","vec","transformVector","transformVector2","transformVector3","Matrix","row","col","getElementIndex","getElement","setElement","getColumn","columnIndex","firstIndex","setColumn","columnVector","adjoint","fromTranslation","fromRotation","fromScaling","fromMat2d","normalFromMat4","projection","frob","multiplyScalarAndAdd","fromMat4","a01","a02","a12","a10","a11","a20","a21","a22","b11","b21","a00","b01","det","b00","b02","b10","b12","b20","b22","_mat4","_vec4","COL0ROW3","COL1ROW3","COL2ROW3","COL3ROW0","COL3ROW1","COL3ROW2","COL3ROW3","m30","m31","m32","m03","m13","m23","m33","toRowMajor","mat4","frustum","right","top","near","far","_computeInfinitePerspectiveOffCenter","column0Row0","column1Row1","column2Row0","column2Row1","column3Row2","lookAt","eye","center","up","ortho","orthographic","fovy","focalDistance","halfY","perspective","fov","getScale","getTranslation","getRotation","scaleResult","inverseScale0","inverseScale1","inverseScale2","getRotationMatrix3","rotateXYZ","rx","ry","rz","rotateAxis","axis","makeRotationX","makeTranslation","transformPoint","transformDirection","fromXRotation","fromYRotation","fromZRotation","fromRotationTranslation","fromQuat2","getScaling","fromRotationTranslationScale","fromRotationTranslationScaleOrigin","perspectiveFromFieldOfView","targetTo","a03","a13","a23","a30","a31","a32","a33","b03","b04","b05","b06","b07","b08","b09","b0","b1","b2","b3","rad","x2","y2","z2","xx","xy","xz","yy","yz","zz","wx","wy","wz","bx","by","bz","bw","ax","ay","az","aw","translation","mat","scaling","is1","is2","sm11","sm12","sm13","is3","sm21","sm22","sm23","sm31","sm32","sm33","S","_quat","IDENTITY_QUATERNION","Quaternion","fromMatrix3","quat","fromMat3","fromAxisRotation","setAxisAngle","rotationTo","vectorA","vectorB","calculateW","conjugate","slerp","transformVector4","setFromAxisAngle","premultiply","getAxisAngle","getAngle","exp","ln","pow","fromEuler","sqlerp","setAxes","out_axis","dotproduct","et","cosom","sinom","scale0","scale1","omega","u1","u2","u3","EPSILON1","EPSILON2","EPSILON3","EPSILON4","EPSILON5","EPSILON6","EPSILON7","EPSILON8","EPSILON9","EPSILON10","EPSILON11","EPSILON12","EPSILON13","EPSILON14","EPSILON15","EPSILON16","EPSILON17","EPSILON18","EPSILON19","EPSILON20","PI_OVER_TWO","PI_OVER_FOUR","PI_OVER_SIX","TWO_PI","SphericalCoordinates","phi","theta","radius","altitude","radiusScale","other","_vector3Default","roll","yaw","_eulerDefault","RollPitchYaw","getPosition","getOrientation","pose","getTransformationMatrix","sr","sp","sw","cr","cp","cw","_matrix4Default","getTransformationMatrixFromPose","getTransformationMatrixToPose","ERR_UNKNOWN_ORDER","ALMOST_ONE","Euler","ZYX","YXZ","XZY","ZXY","YZX","XYZ","DefaultOrder","RotationOrders","fromVector3","ysqr","t0","t1","t2","t3","t4","toArray4","toVector3","alpha","beta","gamma","psi","checkOrder","fromRollPitchYaw","fromRotationMatrix","_fromRotationMatrix","getRotationMatrix","_getRotationMatrix","getQuaternion","_quaternionDefault","te","d","ae","af","be","bf","ce","cf","de","df","ac","ad","bc","bd","toQuaternion","cy","sy","lights","_lightsGlsl","INITIAL_MODULE_OPTIONS","lightSources","convertColor","intensity","component","_lightsGlslDefault","ambientLight","pointLights","directionalLights","lightSourceUniforms","pointLight","attenuation","lighting_uPointLightCount","directionalLight","direction","lighting_uDirectionalLightCount","getLightSourceUniforms","lighting_uEnabled","light","MAX_LIGHTS","dirlight","lightDirection","dirlight_uLightDirection","picking","pickingSelectedColor","pickingHighlightColor","pickingActive","pickingAttribute","selectedColor","picking_uSelectedColorValid","picking_uSelectedColor","picking_uHighlightColor","picking_uActive","picking_uAttribute","gouraudLighting","phongLighting","_phongLightingGlsl","material","ambient","diffuse","shininess","specularColor","lighting_uAmbient","lighting_uDiffuse","lighting_uShininess","lighting_uSpecularColor","getMaterialUniforms","_phongLightingGlslDefault","LIGHTING_VERTEX","LIGHTING_FRAGMENT","pbr","_pbrVertexGlsl","_pbrFragmentGlsl","tiltShift","sampler","gradientRadius","triangleBlur","zoomBlur","brightnessContrast","passes","denoise","hueSaturation","noise","sepia","vibrance","amount","vignette","colorHalftone","dotScreen","edgeWork","hexagonalPixelate","ink","magnify","radiusPixels","bulgePinch","warp","swirl","fxaa","inferAttributeAccessor","GLTF_TO_LUMA_ATTRIBUTE_MAP","POSITION","NORMAL","COLOR_0","TEXCOORD_0","TEXCOORD_1","TEXCOORD_2","indices","remappedName","mapAttributeName","attributeMap","_bufferTransform","_textureTransform","bufferTransform","textureTransform","elementIDBuffer","_initialize","clearRenderTarget","updatedOpts","_updateDrawOptions","swap","swapped","resourceTransforms","resourceTransform","getBuffer","varyingName","_buildResourceTransforms","_updateModelProps","_modelDefault","getShaderVersion","setupResources","updatedProps","updateModelProps","feedbackMap","canCreateBufferTransform","_bufferTransformDefault","_sourceTextures","_targetTexture","_targetTextureVarying","canCreateTextureTransform","_textureTransformDefault","getDrawOptions","currentIndex","bindings","resources","_setupTransformFeedback","sourceBuffers","_getNextIndex","_setupBuffers","_getFeedbackBuffers","sourceName","feedbackName","bufferOrRef","_createNewBuffer","_updateBindings","_updateBinding","_swapBuffers","nextIndex","srcName","dstName","_transformShaderUtils","SRC_TEX_PARAMETER_OVERRIDES","_swapTexture","targetTextureVarying","targetTextureType","samplerTextureMap","updatedModelProps","_processVertexShader","sourceTextures","targetTexture","hasSourceTextures","hasTargetTexture","transform_elementID","textureName","_setSourceTextureParameters","sizeUniforms","getSizeUniforms","sourceTextureMap","_setupTextures","getTargetTexture","packed","channelCount","packedPixels","packCount","ownTexture","_createTargetTexture","textureOrReference","_targetRefTexName","_createNewTexture","_updateElementIDBuffer","elementIds","_swapTextures","updateForTextures","combinedInject","transformModule","getVaryingType","processAttributeDefinition","sourceCount","updatedVs","finalInject","vsLines","updateVsLines","updatedLine","sizeName","SIZE_UNIFORM_PREFIX","getAttributeDefinition","qualaiferDetails","attributeData","textureMap","samplerName","sampleInstruction","uniformDeclerations","getSamplerDeclerations","DRAW_MODE","POINTS","LINES","LINE_LOOP","LINE_STRIP","TRIANGLES","TRIANGLE_STRIP","TRIANGLE_FAN","_setAttributes","_calculateVertexCount","_print","ConeGeometry","_truncatedConeGeometryDefault","topRadius","topCap","bottomCap","bottomRadius","INDEX_OFFSETS","TruncatedConeGeometry","_geometryDefault","nradial","nvertical","verticalAxis","extra","numVertices","slant","msin","mcos","mpi","cosSlant","sinSlant","vertsAroundEdge","positions","normals","texCoords","i3","i2","ringRadius","tesselateTruncatedCone","CUBE_INDICES","CUBE_POSITIONS","CUBE_NORMALS","CUBE_TEX_COORDS","ATTRIBUTES","CubeGeometry","CylinderGeometry","ICO_POSITIONS","ICO_INDICES","IcoSphereGeometry","iterations","PI2","getMiddlePoint","pointMemo","i1","x1","y1","z1","xm","ym","zm","indices2","in1","in2","in3","iu1","iu2","iu3","x3","y3","z3","v3","vec1","normal","newIndex","tesselateIcosaHedron","_geometryUtils","PlaneGeometry","flipCull","unpack","coords","c1len","c2len","subdivisions1","subdivisions2","u","numVertsAcross","unpackIndexedGeometry","tesselatePlane","unpackedAttributes","unpackedValue","SphereGeometry","nlat","nlong","startLat","latRange","startLong","longRange","n1","n2","n3","sinTheta","cosTheta","sinPhi","ux","uy","uz","numVertsAround","tesselateSphere","Timeline","channelHandles","animationHandles","animations","playing","lastEngineTime","addChannel","delay","duration","rate","channel","_setChannelTime","removeChannel","animationHandle","animation","detachAnimation","isFinished","setTime","animationData","play","pause","attachAnimation","channelHandle","offsetTime","KeyFrames","keyFrames","_lastTime","endIndex","times","setKeyFrames","numKeys","_calculateKeys","getStartTime","getEndTime","getStartData","getEndData","endTime","aTexCoord","TEX_COORDS","coord","aCoordinate","_projectGlsl","_viewportUniforms","_projectGlslDefault","getUniformsFromViewport","COORDINATE_SYSTEM_GLSL_CONSTANTS","COORDINATE_SYSTEM","PROJECTION_MODE_GLSL_CONSTANTS","PROJECTION_MODE","UNIT_GLSL_CONSTANTS","UNIT","EVENTS","DEFAULT","LNGLAT","METER_OFFSETS","LNGLAT_OFFSETS","CARTESIAN","WEB_MERCATOR","GLOBE","WEB_MERCATOR_AUTO_OFFSET","meters","click","handler","panstart","panmove","panend","getOffsetOrigin","ZERO_VECTOR","VECTOR_TO_POINT_MATRIX","DEFAULT_PIXELS_PER_UNIT2","DEFAULT_COORDINATE_ORIGIN","getMemoizedViewportUniforms","_memoizeDefault","coordinateSystem","coordinateOrigin","projectionCenter","originCommon","cameraPosCommon","shaderCoordinateOrigin","geospatialOrigin","viewMatrixUncentered","cameraPosition","offsetMode","projectPosition","calculateMatrixAndOffset","distanceScales","getDistanceScales","viewportSize","project_uCoordinateSystem","project_uProjectionMode","projectionMode","project_uCoordinateOrigin","project_uCommonOrigin","project_uCenter","project_uPseudoMeters","_pseudoMeters","project_uViewportSize","project_uDevicePixelRatio","project_uFocalDistance","project_uCommonUnitsPerMeter","unitsPerMeter","project_uCommonUnitsPerWorldUnit","project_uCommonUnitsPerWorldUnit2","project_uScale","project_uViewProjectionMatrix","project_uCameraPosition","distanceScalesAtOrigin","unitsPerMeter2","unitsPerDegree","unitsPerDegree2","isGeospatial","unprojectPosition","autoWrapLongitude","project_uWrapLongitude","project_uModelMatrix","isEqual","compute","cachedResult","cachedArgs","_mathGl","_webMercator","getMemoizedViewportCenterPosition","getMemoizedViewProjectionMatrices","shadowMatrices","projectionMatrices","pixelUnprojectionMatrix","farZ","corners","xyz","pixelsToWorld","screenToCommonSpace","shadowMatrix","corner","DEFAULT_SHADOW_COLOR","drawToShadowMap","shadowMaps","shadowEnabled","shadow_uDrawShadowMap","shadow_uUseShadowMap","shadow_uColor","shadowColor","shadow_uLightId","shadowLightId","shadow_uLightCount","projectCenters","viewProjectionMatrices","viewProjectionMatrixCentered","dummyShadowMap","createShadowUniforms","_getBounds","_fitBounds","_normalizeViewportProps","_flyToViewport","_webMercatorUtils","farZMultiplier","DEFAULT_ALTITUDE","altitudeToFovy","fovyToAltitude","zoomToScale","lngLatToWorld","getProjectionMatrix","getViewMatrix","meterOffset","_initMatrices","unproject","vpm","createMat4","mInverse","pixelProjectionMatrix","topLeft","worldPosition","worldToPixels","targetZWorld","X","Y","Z","worldToLngLat","metersPerUnit","projectFlat","lngLat","unprojectFlat","getMapCenterByLngLatPosition","pos","fromLocation","toLocation","newCenter","getLocationAtPoint","fitBounds","bounds","_fitBoundsDefault","getBounds","getBoundingRegion","west","p","east","_getBoundsDefault","mod","modulus","step","LOG2E","scaleToZoom","getMeterZoom","addMetersToLngLat","getProjectionParameters","PI_4","TILE_SIZE","EARTH_CIRCUMFERENCE","phi2","lambda2","latCosine","highPrecision","unitsPerDegreeX","unitsPerDegreeY","altUnitsPerMeter","worldSize","degreesPerUnit","latCosine2","unitsPerDegreeY2","altUnitsPerDegree2","altUnitsPerMeter2","lngLatZ","z0","worldspace","newLngLat","newZ","vm","halfFov","pitchRadians","topHalfSurfaceDistance","coord0","coord1","minExtent","maxZoom","south","north","_assertDefault","_webMercatorViewportDefault","nw","se","targetSize","centerLngLat","unprojectOnFarPlane","unprojectOps","bottomLeft","bottomRight","topRight","minZoom","halfHeightPixels","minLatitude","maxLatitude","getFlyToDuration","VIEWPORT_TRANSITION_PROPS","DEFAULT_OPTS","curve","speed","startProps","endProps","screenSpeed","maxDuration","rho","getFlyToTransitionParams","startZoom","startCenter","startScale","endZoom","endCenter","startCenterXY","endCenterXY","uDelta","w0","w1","_u1","rho2","r0","r1","startValue","endValue","cosh","tanh","sinh","scaleIncrement","newZoom","newCenterWorld","_shadowPass","DEFAULT_AMBIENT_LIGHT_PROPS","DEFAULT_DIRECTIONAL_LIGHT_PROPS","LightingEffect","_effectDefault","shadowPasses","shadow","lightSource","_applyDefaultLights","preRender","onViewportActive","views","_createLightMatrix","_createShadowPasses","_shadowDefault","moduleParameters","getModuleParameters","getProjectedLight","cleanup","shadowPass","lightMatrices","_shadowPassDefault","shadowMap","AmbientLight","DirectionalLight","DEFAULT_LIGHT_COLOR","DEFAULT_LIGHT_INTENSITY","idCount","DEFAULT_LIGHT_DIRECTION","ShadowPass","_layersPassDefault","depthBuffer","fbo","pixelRatio","shouldDrawLayer","layerIndexResolver","_pass","LayersPass","_passDefault","clearGLCanvas","viewportOrDescriptor","view","drawLayerParams","_getDrawLayerParams","subViewports","subViewport","_drawLayersInViewport","effects","indexResolver","drawContext","isPicking","renderPass","layerFilterCache","layerIndex","_shouldDrawLayer","layerParam","layerRenderIndex","_getModuleParameters","layerParameters","getLayerParameters","glViewport","dimensions","getGLViewport","clearOpts","renderStatus","isComposite","raiseError","visible","parent","filterSubLayer","rootLayerId","activateViewport","wrapLongitude","mousePosition","effect","layerIndices","resolvers","resolveLayerIndex","isDrawn","indexOverride","_offset","layerId","parentId","resolver","PointLight","_projectFunctions","_lib","DEFAULT_ATTENUATION","DEFAULT_LIGHT_POSITION","getAttenuation","projectedLight","fromCoordinateSystem","fromCoordinateOrigin","getWorldPosition","lngLatZToWorldPosition","normalizedParams","normalizeParameters","positionCommonSpace","_viewportDefault","worldOffset","legacyMeterSizes","projectionParameters","_subViewports","minOffset","maxOffset","offsetViewport","panByPosition","displayName","DEFAULT_DISTANCE_SCALES","Viewport","_frustumPlanes","_initViewMatrix","_initProjectionMatrix","_initPixelMatrices","metersPerPixel","unprojectOption","containsPixel","getFrustumPlanes","getCameraPosition","getCameraDirection","cameraDirection","getCameraUp","cameraUp","_createProjectionMatrix","fovyRadians","_getCenterInWorld","commonPosition","viewMatrixInverse","viewportMatrix","toDoublePrecisionArray","_typedArrayManager","planes","getFrustumPlane","scratchVector","L","scratchArray","_typedArrayManagerDefault","allocate","sourceIndex","targetIndex","TypedArrayManager","_pool","overAlloc","poolSize","maxCount","newSize","maxSize","newArray","_allocate","_release","sizeToAllocate","pool","findIndex","_viewManager","_effectManager","_deckPicker","_tooltip","_deepEqual","_mjolnirJs","defaultProps","pickingRadius","eventRecognizerOptions","_animate","_pickable","_typedArrayManagerProps","onWebGLInitialized","onResize","onViewStateChange","onInteractionStateChange","onLoad","_onMetrics","getCursor","isDragging","drawPickingColors","viewManager","effectManager","deckPicker","_needsRedraw","_pickRequest","_lastPointerDownInfo","interactiveState","isHovering","_onEvent","_onPointerDown","_onPointerMove","initialViewState","_createCanvas","_createAnimationLoop","metrics","fps","setPropsTime","updateAttributesTime","framesRedrawn","pickTime","pickCount","gpuTimePerFrame","cpuTimePerFrame","bufferMemory","textureMemory","renderbufferMemory","gpuMemory","_metricsCounter","eventManager","tooltip","remove","parentElement","removeChild","deepEqual","_setCanvasSize","resolvedProps","_getViews","_getViewState","getViewports","viewManagerNeedsRedraw","layerManagerNeedsRedraw","effectManagerNeedsRedraw","deckRendererNeedsRedraw","force","getViews","rect","pickObject","infos","_pick","pickMultipleObjects","pickObjects","_addResources","forceUpdate","resourceManager","resourceId","_removeResources","resourceIds","statKey","getLayers","_updateCanvasSize","_checkForCanvasSizeChange","AnimationLoop","_onContextLost","_setGLContext","_onRenderFrame","_mapViewDefault","leftButton","rightButton","offsetCenter","_pickAndCallback","emptyInfo","pickedInfo","handled","onHover","getTooltip","displayInfo","setTooltip","_updateCursor","container","cursor","_tooltipDefault","EventManager","recognizerOptions","events","pointerdown","pointermove","pointerleave","_viewManagerDefault","_onViewStateChange","_onInteractionStateChange","_layerManagerDefault","_effectManagerDefault","_deckRendererDefault","_deckPickerDefault","renderOptions","renderLayers","getEffects","_getFrameStats","_getMetrics","isVisible","updateViewStates","viewId","interactionState","eventOptions","getLastPickedObject","layerHandler","rootHandler","animationLoopStats","memoryStats","getPropTypes","PropTypes","oneOfType","arrayOf","instanceOf","bool","_initDefault","_resourceManager","INITIAL_CONTEXT","shaderCache","pickingFBO","lastRenderedLayers","_resourceManagerDefault","protocol","_nextLayers","_needsUpdate","_finalizeLayer","layerNeedsRedraw","getNeedsRedraw","setNeedsUpdate","layerIds","setLayers","newLayers","flatten","_updateLayers","_handleError","oldLayers","oldLayerMap","oldLayer","generatedLayers","_updateSublayersRecursively","_finalizeOldLayers","hasUniformTransition","newLayer","sublayers","validateProps","_transferLayerState","_updateLayer","_initializeLayer","getSubLayers","lifecycle","LIFECYCLE","INITIALIZED","_transferState","MATCHED","AWAITING_GC","_update","AWAITING_FINALIZATION","_finalize","FINALIZED","PROP_SYMBOLS","NO_STATE","COMPONENT","for","ASYNC_DEFAULTS","ASYNC_ORIGINAL","ASYNC_RESOLVED","flattenArray","_resources","_consumers","_pruneRequest","contains","persistent","unsubscribe","consumerId","consumer","prune","subscribe","onChange","_track","_prune","consumers","inUse","_loadCount","_subscribers","isLoaded","_error","_content","_data","loadCount","subscriber","controllers","_viewports","_viewportMap","_isUpdating","_eventManager","_eventCallbacks","updateTransition","viewMap","getView","viewOrViewId","getViewStateId","filterViewState","_setViews","_setViewState","_setSize","_rebuildViewports","_diffViews","_createController","Controller","onStateChange","makeViewport","_getViewport","_updateController","controllerProps","oldControllers","invalidateControllers","oldController","_buildViewportMap","newViews","oldViews","aValue","bValue","MapView","_viewDefault","_getControllerProps","_mapControllerDefault","_positions","viewportInstance","_parseDimensions","viewportDimensions","getDimensions","newViewState","_x","_y","_width","_height","defaultOpts","ViewportType","parsePosition","PERCENT_OR_PIXELS_REGEX","relative","extent","MapState","_viewState","DEFAULT_STATE","_viewStateDefault","maxPitch","minPitch","startPanLngLat","startZoomLngLat","startRotatePos","startBearing","startPitch","panStart","_getUpdatedState","_unproject","pan","startPos","_viewportProps","panEnd","rotateStart","deltaAngleX","deltaAngleY","newRotation","_calculateNewPitchAndBearing","_getRotationParams","rotateEnd","zoomStart","_calculateNewZoom","zoomedViewport","zoomEnd","zoomIn","_zoomFromCenter","zoomOut","moveLeft","_panFromCenter","moveRight","moveUp","moveDown","rotateLeft","rotateRight","rotateUp","rotateDown","shortestPathFrom","fromProps","getViewportProps","_applyConstraints","normalizeViewportProps","deltaScaleX","deltaScaleY","deltaX","deltaY","centerY","startY","MapController","_controllerDefault","dragMode","oldProps","controllerStateProps","updateViewport","ControllerState","linearTransitionProps","NO_TRANSITION_PROPS","transitionDuration","LINEAR_TRANSITION_PROPS","transitionEasing","transitionInterruption","TRANSITION_EVENTS","BREAK","INERTIA_EASING","EVENT_TYPES","controllerState","transitionManager","_transitionManagerDefault","_onTransition","_setInteractionState","_transition","transitionInterpolator","_linearInterpolatorDefault","transitionProps","_events","_interactionState","_customEvents","handleEvent","customEvents","toggleEvents","eventName","eventStartBlocked","_eventStartBlocked","_onPanStart","_onPan","_onPanEnd","_onPinchStart","_onPinch","_onPinchEnd","_onTriplePanStart","_onTriplePan","_onTriplePanEnd","_onDoubleTap","_onWheel","_onKeyDown","isPointInBounds","inside","stopPropagation","isFunctionKeyPressed","srcEvent","metaKey","altKey","ctrlKey","shiftKey","blockEvents","timer","_getTransitionProps","processViewStateChange","inertia","scrollZoom","dragPan","dragRotate","doubleClickZoom","touchZoom","touchRotate","keyboard","isInteractive","eventNames","newControllerState","extraProps","getState","oldViewState","newStates","alternateMode","invertPan","_panMove","_onPanMove","_onPanRotate","_onPanMoveEnd","_onPanRotateEnd","isPanning","velocity","endPos","velocityX","velocityY","isRotating","preventDefault","smooth","around","isZooming","_startPinchRotation","rotation","_lastPinchEvent","velocityZ","deltaTime","endScale","isZoomOut","funcKey","zoomSpeed","moveSpeed","rotateSpeedX","rotateSpeedY","code","SNAP_TO_END","IGNORE","onTransitionStart","onTransitionInterrupt","onTransitionEnd","propsInTransition","transition","_transitionDefault","_onTransitionUpdate","getViewportInTransition","nextProps","transitionTriggered","currentProps","_shouldIgnoreViewportChange","_isTransitionEnabled","interruption","_triggerTransition","_isUpdateDueToCurrentTransition","inProgress","interpolator","arePropsEqual","startViewstate","endViewStateProps","getDuration","initialProps","initializeProps","easing","onUpdate","onInterrupt","_onTransitionEnd","onEnd","inTransition","interpolateProps","_inProgress","_onUpdate","DEFAULT_REQUIRED_PROPS","LinearInterpolator","_transitionInterpolatorDefault","compare","extract","required","startViewport","endViewport","aroundPosition","_propsToExtract","_propsToCompare","_requiredProps","startViewStateProps","_checkRequiredProps","DEFAULT_LIGHTING_EFFECT","_lightingEffectDefault","_internalEffects","setEffects","_createInternalEffects","_drawLayersPass","_pickLayersPass","drawLayersPass","_drawLayersPassDefault","pickLayersPass","_pickLayersPassDefault","renderBuffers","lastPostProcessEffect","layerPass","getDefaultFramebuffer","_preRender","outputBuffer","_postRender","postRender","_resizeRenderBuffers","inputBuffer","swapBuffer","DrawLayersPass","PICKING_PARAMETERS","PickLayersPass","_drawPickingBuffer","deviceRect","pickZ","encodedColors","byLayer","byAlpha","_colors","decodePickingColor","decodeColor","pickParameters","encoded","entry","encodeColor","pickedColor","pickedLayer","pickedViewports","pickedObjectIndex","_queryObject","_pickInfo","lastPickedInfo","depthFBO","_pickClosestObject","_pickVisibleObjects","lastPickedLayerId","lastPickedViewportId","coordinate","_resizeBuffer","_getPickable","pickableLayers","isPickable","unproject3D","getEmptyPickingInfo","devicePixelRange","devicePixel","deviceRadius","_getPickingRect","deviceX","deviceY","deviceWidth","deviceHeight","affectedLayers","pickedResult","_drawAndSample","pickInfo","getClosestObject","pickedX","pickedY","pickedColors","disablePickingIndex","processPickInfo","restorePickingColors","maxObjects","leftTop","deviceLeft","deviceTop","rightBottom","deviceRight","deviceBottom","pickInfos","getUniqueObjects","uniqueInfos","isMaxObjects","picked","getLayerPickingInfo","NO_PICKED_OBJECT","minSquareDistanceToCenter","closestPixelIndex","dy","dy2","dx","d2","pickedObject","uniqueColors","colorKey","pickedViewport","getViewportFromCoordinates","lastPickedObjectIndex","pickedLayerId","lastPickedLayer","baseInfo","updateAutoHighlight","sourceLayer","getPickingInfo","defaultStyle","zIndex","pointerEvents","backgroundColor","canvasParent","el","innerText","_hammer","_wheelInput","_moveInput","_keyInput","_contextmenuInput","_eventRegistrar","DEFAULT_OPTIONS","recognizers","Manager","tabIndex","_onBasicInput","_onOtherEvent","_this","ManagerClass","recognizerName","manager","RECOGNIZERS","RECOGNIZER_COMPATIBLE_MAP","recognizer","otherName","recognizeWith","recognizerOption","wheelInput","_wheelInputDefault","moveInput","_moveInputDefault","keyInput","_keyInputDefault","contextmenuInput","_contextmenuInputDefault","_step","_iterator","_createForOfIteratorHelper","_step$value","_slicedToArrayDefault","eventAlias","eventRegistrar","_toggleRecognizer","_addEventHandler","_removeEventHandler","fallbackRecognizers","RECOGNIZER_FALLBACK_MAP","otherRecognizer","requireFailure","dropRequireFailure","enableEventType","passive","GESTURE_EVENT_ALIASES","_eventRegistrarDefault","EVENT_RECOGNIZER_MAP","_step2","isRecognizerUsed","_iterator2","eh","BASIC_EVENT_ALIASES","_arrayWithHolesJs","_iterableToArrayLimitJs","_unsupportedIterableToArrayJs","_nonIterableRestJs","arr","_arrayWithHolesJsDefault","_iterableToArrayLimitJsDefault","_unsupportedIterableToArrayJsDefault","_nonIterableRestJsDefault","_arr","_n","_d","_e","_s","_i","_arrayLikeToArrayJs","o","minLen","_arrayLikeToArrayJsDefault","arr2","TypeError","Constructor","_defineProperties","protoProps","staticProps","_hammerjs","_hammerOverrides","PointerEventInput","MouseInput","_hammerjsDefault","exportName","VENDOR_PREFIXES","TEST_ELEMENT","setTimeoutContext","bindFn","invokeArrayArg","arg","each","deprecate","deprecationMessage","stack","nextKey","extend","merge","inherit","base","properties","childP","baseP","_super","boolOrFn","val","ifUndefined","val1","val2","addEventListeners","splitStr","removeEventListeners","hasParent","parentNode","inStr","inArray","findByKey","uniqueArray","results","prefixed","property","prop","camelProp","_uniqueId","getWindowForElement","doc","ownerDocument","defaultView","parentWindow","SUPPORT_TOUCH","SUPPORT_POINTER_EVENTS","SUPPORT_ONLY_TOUCH","INPUT_TYPE_TOUCH","INPUT_TYPE_MOUSE","DIRECTION_VERTICAL","DIRECTION_UP","PROPS_XY","PROPS_CLIENT_XY","Input","inputTarget","domHandler","ev","init","inputHandler","pointersLen","pointers","changedPointersLen","changedPointers","isFirst","isFinal","session","pointersLength","firstInput","simpleCloneInputData","firstMultiple","getDistance","offsetDelta","prevDelta","prevInput","computeDeltaXY","offsetDirection","getDirection","overallVelocity","getVelocity","overallVelocityX","overallVelocityY","maxPointers","last","lastInterval","computeIntervalInputData","computeInputData","recognize","clientX","clientY","p1","p2","evEl","evTarget","evWin","MOUSE_INPUT_MAP","mousedown","mousemove","mouseup","MOUSE_ELEMENT_EVENTS","MOUSE_WINDOW_EVENTS","pressed","button","which","pointerType","POINTER_INPUT_MAP","pointerup","pointercancel","pointerout","IE10_POINTER_TYPE_ENUM","POINTER_ELEMENT_EVENTS","POINTER_WINDOW_EVENTS","store","MSPointerEvent","PointerEvent","removePointer","eventTypeNormalized","isTouch","storeIndex","pointerId","SINGLE_TOUCH_INPUT_MAP","touchstart","touchmove","touchend","touchcancel","SINGLE_TOUCH_TARGET_EVENTS","SINGLE_TOUCH_WINDOW_EVENTS","SingleTouchInput","started","normalizeSingleTouches","touches","changedTouches","TOUCH_INPUT_MAP","TOUCH_TARGET_EVENTS","TouchInput","targetIds","getTouches","allTouches","identifier","targetTouches","changedTargetTouches","touch","TouchMouseInput","mouse","primaryTouch","lastTouches","recordTouches","eventData","setLastTouch","lastTouch","lts","isSyntheticEvent","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","PREFIXED_TOUCH_ACTION","NATIVE_TOUCH_ACTION","TOUCH_ACTION_COMPUTE","TOUCH_ACTION_AUTO","TOUCH_ACTION_MANIPULATION","TOUCH_ACTION_NONE","TOUCH_ACTION_PAN_X","TOUCH_ACTION_PAN_Y","TOUCH_ACTION_MAP","touchMap","cssSupports","CSS","supports","getTouchActionProps","TouchAction","actions","getTouchAction","hasPanX","hasPanY","cleanTouchActions","preventDefaults","prevented","hasNone","isTapPointer","isTapMovement","isTapTouchTime","DIRECTION_LEFT","preventSrc","STATE_FAILED","Recognizer","simultaneous","requireFail","stateStr","directionStr","getRecognizerByNameIfManager","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","Hammer","preset","dropRecognizeWith","hasRequireFailures","canRecognizeWith","additionalEvent","tryEmit","canEmit","inputDataClone","attrTest","optionPointers","isRecognized","isValid","threshold","DIRECTION_HORIZONTAL","directionTest","hasMoved","inOut","validPointers","validMovement","validTime","taps","interval","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","domEvents","inputClass","cssProps","userSelect","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","oldCssProps","toggleCssProps","item","stopped","curRecognizer","existing","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","triggerDomEvent","INPUT_START","INPUT_MOVE","INPUT_END","INPUT_CANCEL","STATE_POSSIBLE","STATE_BEGAN","STATE_CHANGED","STATE_ENDED","STATE_RECOGNIZED","STATE_CANCELLED","DIRECTION_NONE","DIRECTION_RIGHT","DIRECTION_DOWN","DIRECTION_ALL","Tap","Pan","Swipe","Pinch","Rotate","Press","amd","enhancePointerEventInput","enhanceMouseInput","oldHandler","predict","WheelInput","firefox","WHEEL_EVENTS","EVENT_TYPE","WHEEL_DELTA_MAGIC_SCALER","passiveSupported","_this2","WheelEvent","deltaMode","DOM_DELTA_PIXEL","DOM_DELTA_LINE","wheelPosition","INPUT_EVENT_TYPES","_hammerDefault","tripan","pinch","doubletap","anytap","KEY_EVENTS","MOUSE_EVENTS","tap","press","pinchin","pinchout","pinchstart","pinchmove","pinchend","pinchcancel","rotatestart","rotatemove","rotateend","rotatecancel","tripanstart","tripanmove","tripanup","tripandown","tripanleft","tripanright","tripanend","tripancancel","panup","pandown","panleft","panright","pancancel","swipe","swipeleft","swiperight","swipeup","swipedown","anyclick","dblclick","mouseover","mouseout","mouseleave","MoveInput","MOVE_EVENT_TYPE","OVER_EVENT_TYPE","OUT_EVENT_TYPE","LEAVE_EVENT_TYPE","enableMoveEvent","enableLeaveEvent","enableOutEvent","enableOverEvent","handleOverEvent","handleOutEvent","handleLeaveEvent","handleMoveEvent","KeyInput","DOWN_EVENT_TYPE","UP_EVENT_TYPE","enableDownEvent","enableUpEvent","outline","targetElement","srcElement","tagName","ContextmenuInput","EventRegistrar","_eventUtils","handlersByElement","_active","_typeofDefault","insertPosition","mjolnirEvent","_normalizeEvent","rootElement","_emit","immediatePropagationStopped","stopImmediatePropagation","entriesToRemove","_entries$i","_entriesToRemove$_i","whichButtons","getOffsetPosition","_event$srcEvent","buttons","middleButton","getBoundingClientRect","offsetWidth","offsetHeight","clientLeft","clientTop","_uniformTransitionManager","_component","_layerState","_core1","MAX_PICKING_COLOR_CACHE_SIZE","EMPTY_ARRAY","areViewportsEqual","oldViewport","pickingColorCache","dataComparator","_dataDiff","__diff","optional","dataTransform","onDataLoad","loadOptions","_loadOptions","getLoadOptions","inResourceManager","internalState","reloadAsyncProp","updateTriggers","opacity","onClick","onDragStart","onDrag","onDragEnd","positionFormat","colorFormat","transitions","getPolygonOffset","highlightedObjectIndex","autoHighlight","highlightColor","Layer","_componentDefault","layerName","_this$props$onError","_this$props","_this$context","_this$context$onError","setState","updateObject","setChangeFlags","stateChanged","_getNeedsRedraw","shouldUpdateState","_getUpdateParams","uniformTransitions","active","isAsyncPropLoading","getModels","models","getAttributeManager","getCurrentLayer","use64bitPositions","pickingEvent","nullPickingColor","encodePickingColor","initializeState","getShaders","shaders","mergeShaders","changeFlags","propsOrDataChanged","updateState","dataChanged","dataRange","invalidateAll","neededPickingBuffer","needPickingBuffer","pickingColors","instancePickingColors","pickingColorsAttribute","finalizeState","viewportChanged","invalidateAttribute","diffReason","updateAttributes","changedAttributes","_setModelAttributes","_updateAttributes","getNumInstances","startIndices","getStartIndices","ignoreUnknownAttributes","getChangedAttributes","clearChangedFlags","_updateAttributeTransition","_updateUniformTransition","calculateInstancePickingColors","cacheSize","usesPickingColorCache","newCacheSize","pickingColor","excludeAttributes","shaderAttributes","getShaderAttributes","objectIndex","_disablePickingIndex","colors","getVertexOffset","updateSubBuffer","startOffset","_initState","propsChanged","extensionsChanged","_updateState","stateNeedsUpdate","updateParams","oldModels","modelChanged","_updateModules","_renderLayers","clearChangeFlags","resetOldProps","setModuleParameters","flagChanged","_debugDefault","updateTriggersChanged","somethingChanged","diffProps","transitionsChanged","_updateAutoHighlight","pickingModuleParameters","getOldProps","attributeManagerNeedsRedraw","_getAttributeManager","_attributeManagerDefault","addInstanced","noAlloc","_layerStateDefault","_uniformTransitionManagerDefault","onAsyncPropUpdated","_onAsyncPropUpdated","setAsyncProps","_attribute","_attributeTransitionManager","TRACE_INVALIDATE","attributeTransitionManager","_attributeTransitionManagerDefault","updaters","_add","attributeNameArray","triggerName","invalidatedAttributes","_invalidateTrigger","accessorName","setExternalBuffer","setBinaryValue","setConstantValue","_updateAttribute","transitionUpdated","hasAttribute","getAccessors","_createAttribute","_mapUpdateTriggersToAttributes","_attributeDefault","triggers","getUpdateTriggers","updateBuffer","_dataColumn","_range","_attributeTransitionUtils","Attribute","_dataColumnDefault","_autoUpdater","lastExternalBuffer","binaryValue","binaryAccessor","updateRanges","FULL","_validateAttributeUpdaters","supportsTransition","getTransitionSetting","layerSettings","userSettings","normalizeTransitionSettings","startRow","endRow","clearNeedsUpdate","EMPTY","endOffset","_checkAttributeArray","needsNormalize","getAccessorFromBuffer","nested","shaderAttributeDefs","shaderAttributeName","accessorFunc","iterable","objectInfo","createIterable","objectValue","_normalizeValue","_shaderAttribute","_glUtils","getStride","bytesPerElement","resolveShaderAttribute","baseAccessor","shaderAttributeOptions","vertexOffset","elementOffset","logicalType","doublePrecision","bufferType","defaultType","glArrayFromType","externalBuffer","bufferAccessor","allocatedValue","getAccessor","isBuffer64Bit","Float64Array","doubleShaderAttributeDefs","resolvedOptions","high","low","resolveDoublePrecisionShaderAttributes","_shaderAttributeDefault","shaderAttributeDef","_normalizeConstant","_areValuesEqual","_checkExternalBuffer","requiredBufferSize","illegalArrayType","value1","value2","dataColumn","placeholderArray","elementStride","rangeList","newRangeList","range0","getSourceBufferAttribute","getAttributeTypeFromSize","cycleBuffers","getAttributeBufferLength","padBuffer","_arrayUtils","DEFAULT_TRANSITION_SETTINGS","interpolation","spring","stiffness","damping","multiplier","fromLength","fromStartIndices","precisionMultiplier","toStartIndices","hasStartIndices","toLength","isConstant","toData","getMissingData","sourceStartIndices","targetStartIndices","padArrayChunk","sourceLength","targetLength","datum","padArray","getChunkData","nextSourceIndex","nextTargetIndex","_gpuInterpolationTransition","_gpuSpringTransition","TRANSITION_TYPES","_gpuInterpolationTransitionDefault","_gpuSpringTransitionDefault","Transform","_removeTransition","animatedAttributes","attributeInTransition","isNew","TransitionType","currentStartIndices","currentLength","attributeType","ATTRIBUTE_TYPE","getTransform","bufferOpts","transitionSettings","padBufferOpts","enter","aFrom","aTo","vCurrent","getTexture","aPrev","aCur","vNext","_cpuInterpolationTransition","_cpuSpringTransition","_cpuInterpolationTransitionDefault","_cpuSpringTransitionDefault","fromValue","toValue","CPUInterpolationTransition","_value","updateSpringElement","prev","cur","distanceSquare","CPUSpringTransition","_currValue","_prevValue","nextValue","updateSpring","compareProps","propsChangedReason","ignoreProps","dataChangedReason","diffDataProps","updateTriggersChangedReason","diffUpdateTrigger","triggerChanged","diffUpdateTriggers","diffExtensions","diffTransitions","comparePropValues","newProp","oldProp","equal","oldExtensions","newTriggers","oldTriggers","isPlainObject","mergedInjection","_createProps","_constants1","_componentState","Component","createProps","root","asyncProps","_componentStateDefault","componentName","propsPrototype","getPropsPrototype","propsInstance","componentClass","getOwnProperty","parentClass","parentDefaultProps","componentDefaultProps","componentPropDefs","parentProps","getComponentName","defineProperties","createPropsPrototype","defaultValues","descriptors","getDescriptorForAsyncProp","addAsyncPropsToPropPrototype","_deprecatedProps","newValue","nameStr","newPropName","addDeprecatedPropsToPropPrototype","_mergedDefaultProps","createPropsPrototypeAndTypes","hasAsyncProp","getAsyncProp","boolean","arrayEqual","valueType","function","deprecatedFor","normalizePropDefinition","destroyTexture","DEFAULT_TEXTURE_PARAMETERS","internalTextures","specialTextureParameters","textureParameters","EMPTY_PROPS","oldAsyncProps","asyncProp","resolvedValue","freezeAsyncOldProps","pendingLoadCount","resolvedLoadCount","_watchPromise","resolvedValues","originalValues","_createAsyncPropData","_updateAsyncProp","_didAsyncInputValueChange","_this$layer","_resolveAsyncIterable","_setPropValue","lastValue","_postProcessValue","_setAsyncPropValue","_this$layer2","_this$layer3","_this$layer4","LayerState","CompositeLayer","_layerDefault","__source","shouldRenderSubLayer","getSubLayerClass","DefaultLayerClass","_subLayerProps","overridingProps","getSubLayerRow","sourceObject","sourceObjectIndex","getSubLayerAccessor","getSubLayerProps","sublayerProps","overridingSublayerProps","overridingSublayerTriggers","sublayerId","subLayerPropTypes","passThroughProps","shouldUpdate","propValue","CameraLight","_suncalc","SunLight","others","resolution","getSunlightDirection","getSolarPosition","DAY_IN_MS","JD1970","JD2000","M0","M1","THETA0","THETA1","longitudeWestInRadians","toJulianDay","toDays","dates","meanAnomaly","M","C","getEclipticLongitude","days","declination","getDeclination","rightAscension","getRightAscension","getSunCoords","H","getSiderealTime","azimuth","getAzimuth","getAltitude","eclipticLongitude","lambda","hourAngle","latitudeInRadians","_screenPass","PostProcessEffect","getFragmentShaderForRenderPass","_screenPassDefault","idn","createPasses","switchBuffer","FILTER_FS_TEMPLATE","SAMPLER_FS_TEMPLATE","ScreenPass","ClipSpace","_renderPass","texSize","depthWrite","EARTH_RADIUS","GLOBE_RADIUS","GlobeViewport","relativeScale","lt","lSqr","l0Sqr","l1Sqr","dSqr","cosPhi","D","fromPosition","FirstPersonViewport","_SphericalCoordinates","getDirectionFromBearingAndPitch","FirstPersonView","_firstPersonControllerDefault","FirstPersonState","startZoomPosition","use2D","_move","FirstPersonController","orbitAxis","rotationX","rotationOrbit","projectionScale","OrbitViewport","projectedCenter","p0","nextCenter","OrbitView","_orbitControllerDefault","OrbitState","minRotationX","maxRotationX","startPanPosition","startRotationX","startRotationOrbit","startPosition","OrbitController","OrthographicViewport","flipY","zoomX","zoomY","zoom_","OrthographicView","_orthographicControllerDefault","OrthographicState","zoomAxis","deltaZoom","newZoomX","newZoomY","OrthographicController","GlobeView","_globeViewportDefault","_globeControllerDefault","GlobeState","GlobeController","LINEARLY_INTERPOLATED_PROPS","FlyToInterpolator","flyToViewport","typedArrayManager","indexStarts","vertexStarts","_attributeDefs","updateGeometry","getGeometry","geometryBuffer","positionSize","getGeometryFromBuffer","_rebuildGeometry","updatePartialGeometry","normalizeGeometry","updateGeometryAttributes","getGeometrySize","_forEachGeometry","normalizedData","dataIndex","byteStride","vertexStart","indexStart","vertexEnd","geometrySize","geometryIndex","_scatterplotLayerVertexGlsl","_scatterplotLayerFragmentGlsl","DEFAULT_COLOR","radiusUnits","radiusMinPixels","radiusMaxPixels","lineWidthUnits","lineWidthScale","lineWidthMinPixels","lineWidthMaxPixels","stroked","filled","billboard","antialiasing","getRadius","getFillColor","getLineColor","getLineWidth","strokeWidth","ScatterplotLayer","project32","instancePositions","instanceRadius","instanceFillColors","instanceLineColors","instanceLineWidths","_this$state$model","_getModel","Model","Geometry","_simpleMeshLayerVertexGlsl","_simpleMeshLayerFragmentGlsl","validateGeometryAttributes","useMeshColors","mesh","sizeScale","_useMeshColors","_instanced","wireframe","getTransformMatrix","SimpleMeshLayer","DERIVATIVES_AVAILABLE","instanceColors","instanceModelMatrix","MATRIX_ATTRIBUTES","emptyTexture","getModel","hasNormals","setTexture","composeModelMatrix","shouldComposeModelMatrix","flatShading","hasTexture","RADIAN_PER_DEGREE","valueArray","calculateTransformMatrix","targetMatrix","scx","scy","scz","getExtendedMat3FromMat4","instanceModelMatrix__LOCATION_0","instanceModelMatrix__LOCATION_1","instanceModelMatrix__LOCATION_2","instanceTranslation","arrayMatrix","constantMatrix","constantScale","constantOrientation","constantTranslation","hasMatrix","instanceModelMatrixData","polyline","py2_round","current","flipped","latitude_change","coordinates","byte","fromGeoJSON","geojson","toGeoJSON","_sort","_within","defaultGetX","defaultGetY","points","getX","getY","nodeSize","IndexArrayType","ids","minX","minY","maxX","maxY","_rangeDefault","within","_withinDefault","select","k","inc","sd","swapItem","tmp","sortKD","nextAxis","sqDist","qx","qy","r2","tinyqueue","maxResults","maxDistance","predicate","cosLat","sinLat","compareDist","minLng","minLat","maxLng","maxLat","greatCircleDist","midLng","midLat","leftNode","rightNode","boxDist","peek","candidate","lng2","lat2","closestLng","cosLngDelta","extremumLat","greatCircleDistPart","TinyQueue","defaultCompare","_down","_up","halfLength","best","timeoutId","throttledFn","leading","trailing","throttleWrapper","callNow","flush"],"version":3,"file":"hq.bundle.1b43c99b.js.map"}