@luma.gl/webgl 8.5.10 → 8.6.0-alpha.1

package/dist/es5/index.js

@@ -7,313 +7,367 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "lumaStats", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _init.lumaStats;
   }
 });
 Object.defineProperty(exports, "requestAnimationFrame", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _requestAnimationFrame.requestAnimationFrame;
   }
 });
 Object.defineProperty(exports, "cancelAnimationFrame", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _requestAnimationFrame.cancelAnimationFrame;
   }
 });
 Object.defineProperty(exports, "cloneTextureFrom", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _textureUtils.cloneTextureFrom;
   }
 });
 Object.defineProperty(exports, "getKeyValue", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _constantsToKeys.getKeyValue;
   }
 });
 Object.defineProperty(exports, "getKey", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _constantsToKeys.getKey;
   }
 });
 Object.defineProperty(exports, "getContextInfo", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _limits.getContextInfo;
   }
 });
 Object.defineProperty(exports, "getGLContextInfo", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _limits.getGLContextInfo;
   }
 });
 Object.defineProperty(exports, "getContextLimits", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _limits.getContextLimits;
   }
 });
 Object.defineProperty(exports, "FEATURES", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _webglFeaturesTable.FEATURES;
   }
 });
 Object.defineProperty(exports, "hasFeature", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _features.hasFeature;
   }
 });
 Object.defineProperty(exports, "hasFeatures", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _features.hasFeatures;
   }
 });
 Object.defineProperty(exports, "getFeatures", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _features.getFeatures;
   }
 });
 Object.defineProperty(exports, "canCompileGLGSExtension", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _checkGlslExtension.default;
   }
 });
 Object.defineProperty(exports, "Accessor", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _accessor.default;
   }
 });
 Object.defineProperty(exports, "Buffer", {
   enumerable: true,
-  get: function get() {
-    return _buffer.default;
+  get: function () {
+    return _webglBuffer.default;
+  }
+});
+Object.defineProperty(exports, "Texture2D", {
+  enumerable: true,
+  get: function () {
+    return _texture2d.default;
+  }
+});
+Object.defineProperty(exports, "Texture2DProps", {
+  enumerable: true,
+  get: function () {
+    return _texture2d.Texture2DProps;
+  }
+});
+Object.defineProperty(exports, "TextureCube", {
+  enumerable: true,
+  get: function () {
+    return _textureCube.default;
+  }
+});
+Object.defineProperty(exports, "TextureCubeProps", {
+  enumerable: true,
+  get: function () {
+    return _textureCube.TextureCubeProps;
   }
 });
 Object.defineProperty(exports, "Shader", {
   enumerable: true,
-  get: function get() {
-    return _shader.Shader;
+  get: function () {
+    return _webglShader.Shader;
   }
 });
 Object.defineProperty(exports, "VertexShader", {
   enumerable: true,
-  get: function get() {
-    return _shader.VertexShader;
+  get: function () {
+    return _webglShader.VertexShader;
   }
 });
 Object.defineProperty(exports, "FragmentShader", {
   enumerable: true,
-  get: function get() {
-    return _shader.FragmentShader;
+  get: function () {
+    return _webglShader.FragmentShader;
+  }
+});
+Object.defineProperty(exports, "ShaderProps", {
+  enumerable: true,
+  get: function () {
+    return _webglShader.ShaderProps;
   }
 });
 Object.defineProperty(exports, "Program", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _program.default;
   }
 });
+Object.defineProperty(exports, "ProgramProps", {
+  enumerable: true,
+  get: function () {
+    return _program.ProgramProps;
+  }
+});
 Object.defineProperty(exports, "Framebuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _framebuffer.default;
   }
 });
-Object.defineProperty(exports, "Renderbuffer", {
+Object.defineProperty(exports, "FramebufferProps", {
   enumerable: true,
-  get: function get() {
-    return _renderbuffer.default;
+  get: function () {
+    return _framebuffer.FramebufferProps;
   }
 });
-Object.defineProperty(exports, "Texture2D", {
+Object.defineProperty(exports, "Renderbuffer", {
   enumerable: true,
-  get: function get() {
-    return _texture2d.default;
+  get: function () {
+    return _renderbuffer.default;
   }
 });
-Object.defineProperty(exports, "TextureCube", {
+Object.defineProperty(exports, "RenderbufferProps", {
   enumerable: true,
-  get: function get() {
-    return _textureCube.default;
+  get: function () {
+    return _renderbuffer.RenderbufferProps;
   }
 });
 Object.defineProperty(exports, "clear", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _clear.clear;
   }
 });
 Object.defineProperty(exports, "clearBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _clear.clearBuffer;
   }
 });
 Object.defineProperty(exports, "readPixelsToArray", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _copyAndBlit.readPixelsToArray;
   }
 });
 Object.defineProperty(exports, "readPixelsToBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _copyAndBlit.readPixelsToBuffer;
   }
 });
 Object.defineProperty(exports, "copyToDataUrl", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _copyAndBlit.copyToDataUrl;
   }
 });
 Object.defineProperty(exports, "copyToImage", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _copyAndBlit.copyToImage;
   }
 });
 Object.defineProperty(exports, "copyToTexture", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _copyAndBlit.copyToTexture;
   }
 });
 Object.defineProperty(exports, "blit", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _copyAndBlit.blit;
   }
 });
 Object.defineProperty(exports, "Query", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _query.default;
   }
 });
+Object.defineProperty(exports, "QueryProps", {
+  enumerable: true,
+  get: function () {
+    return _query.QueryProps;
+  }
+});
 Object.defineProperty(exports, "Texture3D", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _texture3d.default;
   }
 });
+Object.defineProperty(exports, "Texture3DProps", {
+  enumerable: true,
+  get: function () {
+    return _texture3d.Texture3DProps;
+  }
+});
 Object.defineProperty(exports, "TransformFeedback", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _transformFeedback.default;
   }
 });
+Object.defineProperty(exports, "TransformFeedbackProps", {
+  enumerable: true,
+  get: function () {
+    return _transformFeedback.TransformFeedbackProps;
+  }
+});
 Object.defineProperty(exports, "VertexArrayObject", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _vertexArrayObject.default;
   }
 });
+Object.defineProperty(exports, "VertexArrayObjectProps", {
+  enumerable: true,
+  get: function () {
+    return _vertexArrayObject.VertexArrayObjectProps;
+  }
+});
 Object.defineProperty(exports, "VertexArray", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _vertexArray.default;
   }
 });
+Object.defineProperty(exports, "VertexArrayProps", {
+  enumerable: true,
+  get: function () {
+    return _vertexArray.VertexArrayProps;
+  }
+});
 Object.defineProperty(exports, "UniformBufferLayout", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _uniformBufferLayout.default;
   }
 });
 Object.defineProperty(exports, "setPathPrefix", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _loadFile.setPathPrefix;
   }
 });
 Object.defineProperty(exports, "loadFile", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _loadFile.loadFile;
   }
 });
 Object.defineProperty(exports, "loadImage", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _loadFile.loadImage;
   }
 });
-Object.defineProperty(exports, "getShaderName", {
-  enumerable: true,
-  get: function get() {
-    return _getShaderName.default;
-  }
-});
-Object.defineProperty(exports, "getShaderVersion", {
-  enumerable: true,
-  get: function get() {
-    return _getShaderVersion.default;
-  }
-});
 Object.defineProperty(exports, "log", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _gltools.log;
   }
 });
 Object.defineProperty(exports, "assert", {
   enumerable: true,
-  get: function get() {
-    return _assert.assert;
+  get: function () {
+    return _assert.default;
   }
 });
 Object.defineProperty(exports, "uid", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _utils.uid;
   }
 });
 Object.defineProperty(exports, "isObjectEmpty", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _utils.isObjectEmpty;
   }
 });
 Object.defineProperty(exports, "parseUniformName", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _uniforms.parseUniformName;
   }
 });
 Object.defineProperty(exports, "getUniformSetter", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _uniforms.getUniformSetter;
   }
 });
 Object.defineProperty(exports, "getDebugTableForUniforms", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _debugUniforms.getDebugTableForUniforms;
   }
 });
 Object.defineProperty(exports, "getDebugTableForVertexArray", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _debugVertexArray.getDebugTableForVertexArray;
   }
 });
 Object.defineProperty(exports, "getDebugTableForProgramConfiguration", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _debugProgramConfiguration.getDebugTableForProgramConfiguration;
   }
 });
@@ -336,45 +390,41 @@ var _checkGlslExtension = _interopRequireDefault(require("./features/check-glsl-
 
 var _accessor = _interopRequireDefault(require("./classes/accessor"));
 
-var _buffer = _interopRequireDefault(require("./classes/buffer"));
+var _webglBuffer = _interopRequireDefault(require("./classes/webgl-buffer"));
 
-var _shader = require("./classes/shader");
+var _texture2d = _interopRequireWildcard(require("./classes/texture-2d"));
 
-var _program = _interopRequireDefault(require("./classes/program"));
+var _textureCube = _interopRequireWildcard(require("./classes/texture-cube"));
 
-var _framebuffer = _interopRequireDefault(require("./classes/framebuffer"));
+var _webglShader = require("./classes/webgl-shader");
 
-var _renderbuffer = _interopRequireDefault(require("./classes/renderbuffer"));
+var _program = _interopRequireWildcard(require("./classes/program"));
 
-var _texture2d = _interopRequireDefault(require("./classes/texture-2d"));
+var _framebuffer = _interopRequireWildcard(require("./classes/framebuffer"));
 
-var _textureCube = _interopRequireDefault(require("./classes/texture-cube"));
+var _renderbuffer = _interopRequireWildcard(require("./classes/renderbuffer"));
 
 var _clear = require("./classes/clear");
 
 var _copyAndBlit = require("./classes/copy-and-blit");
 
-var _query = _interopRequireDefault(require("./classes/query"));
+var _query = _interopRequireWildcard(require("./classes/query"));
 
-var _texture3d = _interopRequireDefault(require("./classes/texture-3d"));
+var _texture3d = _interopRequireWildcard(require("./classes/texture-3d"));
 
-var _transformFeedback = _interopRequireDefault(require("./classes/transform-feedback"));
+var _transformFeedback = _interopRequireWildcard(require("./classes/transform-feedback"));
 
-var _vertexArrayObject = _interopRequireDefault(require("./classes/vertex-array-object"));
+var _vertexArrayObject = _interopRequireWildcard(require("./classes/vertex-array-object"));
 
-var _vertexArray = _interopRequireDefault(require("./classes/vertex-array"));
+var _vertexArray = _interopRequireWildcard(require("./classes/vertex-array"));
 
 var _uniformBufferLayout = _interopRequireDefault(require("./classes/uniform-buffer-layout"));
 
 var _loadFile = require("./utils/load-file");
 
-var _getShaderName = _interopRequireDefault(require("./glsl-utils/get-shader-name"));
-
-var _getShaderVersion = _interopRequireDefault(require("./glsl-utils/get-shader-version"));
-
 var _gltools = require("@luma.gl/gltools");
 
-var _assert = require("./utils/assert");
+var _assert = _interopRequireDefault(require("./utils/assert"));
 
 var _utils = require("./utils/utils");
 
@@ -385,4 +435,8 @@ var _debugUniforms = require("./debug/debug-uniforms");
 var _debugVertexArray = require("./debug/debug-vertex-array");
 
 var _debugProgramConfiguration = require("./debug/debug-program-configuration");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA;;AAGA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAGA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEA;;AAGA;;AAUA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAIA;;AAGA;;AACA;;AAGA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AACA","sourcesContent":["// 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"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA;;AAGA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAGA;;AAIA;;AACA;;AACA;;AAEA;;AACA;;AACA;;AACA;;AAEA;;AAGA;;AAUA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAIA;;AAGA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AACA","sourcesContent":["// 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\n// export type {BufferProps} from './api/buffer';\nexport {default as Buffer} from './classes/webgl-buffer';\nexport {default as Texture2D, Texture2DProps} from './classes/texture-2d';\nexport {default as TextureCube, TextureCubeProps} from './classes/texture-cube';\n\nexport {Shader, VertexShader, FragmentShader, ShaderProps} from './classes/webgl-shader';\nexport {default as Program, ProgramProps} from './classes/program';\nexport {default as Framebuffer, FramebufferProps} from './classes/framebuffer';\nexport {default as Renderbuffer, RenderbufferProps} from './classes/renderbuffer';\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, QueryProps} from './classes/query';\nexport {default as Texture3D, Texture3DProps} from './classes/texture-3d';\nexport {default as TransformFeedback, TransformFeedbackProps} from './classes/transform-feedback';\nexport {default as VertexArrayObject, VertexArrayObjectProps} from './classes/vertex-array-object';\nexport {default as VertexArray, VertexArrayProps} 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// UTILS\nexport {log} from '@luma.gl/gltools';\nexport {default as 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\n// REMOVED in v8.6\n// getShaderInfo,\n// getShaderName\n// getShaderVersion\n"],"file":"index.js"}

package/dist/es5/init.js

@@ -1,48 +1,24 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.lumaStats = void 0;
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+Object.defineProperty(exports, "lumaStats", {
+  enumerable: true,
+  get: function () {
+    return _api.lumaStats;
+  }
+});
+exports.default = void 0;
 
 var _gltools = require("@luma.gl/gltools");
 
-var _probe = require("probe.gl");
-
 var _env = require("probe.gl/env");
 
-var VERSION = typeof "8.5.10" !== 'undefined' ? "8.5.10" : 'untranspiled source';
-var STARTUP_MESSAGE = 'set luma.log.level=1 (or higher) to trace rendering';
-
-var StatsManager = function () {
-  function StatsManager() {
-    (0, _classCallCheck2.default)(this, StatsManager);
-    this.stats = new Map();
-  }
-
-  (0, _createClass2.default)(StatsManager, [{
-    key: "get",
-    value: function get(name) {
-      if (!this.stats.has(name)) {
-        this.stats.set(name, new _probe.Stats({
-          id: name
-        }));
-      }
-
-      return this.stats.get(name);
-    }
-  }]);
-  return StatsManager;
-}();
+var _api = require("@luma.gl/api");
 
-var lumaStats = new StatsManager();
-exports.lumaStats = lumaStats;
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'untranspiled source';
+const STARTUP_MESSAGE = 'set luma.log.level=1 (or higher) to trace rendering';
 
 if (_env.global.luma && _env.global.luma.VERSION !== VERSION) {
   throw new Error("luma.gl - multiple VERSIONs detected: ".concat(_env.global.luma.VERSION, " vs ").concat(VERSION));
@@ -54,10 +30,10 @@ if (!_env.global.luma) {
   }
 
   _env.global.luma = _env.global.luma || {
-    VERSION: VERSION,
+    VERSION,
     version: VERSION,
     log: _gltools.log,
-    stats: lumaStats,
+    stats: _api.lumaStats,
     globals: {
       modules: {},
       nodeIO: {}

package/dist/es5/init.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/init.js"],"names":["VERSION","STARTUP_MESSAGE","StatsManager","stats","Map","name","has","set","Stats","id","get","lumaStats","global","luma","Error","log","version","globals","modules","nodeIO"],"mappings":";;;;;;;;;;;;;AAAA;;AACA;;AACA;;AAKA,IAAMA,OAAO,GAAG,oBAAuB,WAAvB,cAAmD,qBAAnE;AAEA,IAAMC,eAAe,GAAG,qDAAxB;;IAKMC,Y;AACJ,0BAAc;AAAA;AACZ,SAAKC,KAAL,GAAa,IAAIC,GAAJ,EAAb;AACD;;;;wBAEGC,I,EAAM;AACR,UAAI,CAAC,KAAKF,KAAL,CAAWG,GAAX,CAAeD,IAAf,CAAL,EAA2B;AACzB,aAAKF,KAAL,CAAWI,GAAX,CAAeF,IAAf,EAAqB,IAAIG,YAAJ,CAAU;AAACC,UAAAA,EAAE,EAAEJ;AAAL,SAAV,CAArB;AACD;;AAED,aAAO,KAAKF,KAAL,CAAWO,GAAX,CAAeL,IAAf,CAAP;AACD;;;;;AAGH,IAAMM,SAAS,GAAG,IAAIT,YAAJ,EAAlB;;;AAEA,IAAIU,YAAOC,IAAP,IAAeD,YAAOC,IAAP,CAAYb,OAAZ,KAAwBA,OAA3C,EAAoD;AAClD,QAAM,IAAIc,KAAJ,iDAAmDF,YAAOC,IAAP,CAAYb,OAA/D,iBAA6EA,OAA7E,EAAN;AACD;;AAED,IAAI,CAACY,YAAOC,IAAZ,EAAkB;AAChB,MAAI,qBAAJ,EAAiB;AACfE,iBAAIA,GAAJ,CAAQ,CAAR,oBAAsBf,OAAtB,gBAAmCC,eAAnC;AACD;;AAEDW,cAAOC,IAAP,GAAcD,YAAOC,IAAP,IAAe;AAC3Bb,IAAAA,OAAO,EAAPA,OAD2B;AAE3BgB,IAAAA,OAAO,EAAEhB,OAFkB;AAG3Be,IAAAA,GAAG,EAAHA,YAH2B;AAO3BZ,IAAAA,KAAK,EAAEQ,SAPoB;AAc3BM,IAAAA,OAAO,EAAE;AACPC,MAAAA,OAAO,EAAE,EADF;AAEPC,MAAAA,MAAM,EAAE;AAFD;AAdkB,GAA7B;AAmBD;;eAGcP,YAAOC,I","sourcesContent":["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"],"file":"init.js"}
+{"version":3,"sources":["../../src/init.ts"],"names":["VERSION","__VERSION__","STARTUP_MESSAGE","global","luma","Error","log","version","stats","lumaStats","globals","modules","nodeIO"],"mappings":";;;;;;;;;;;;;AAAA;;AACA;;AACA;;AAIA,MAAMA,OAAO,GAAG,OAAOC,WAAP,KAAuB,WAAvB,GAAqCA,WAArC,GAAmD,qBAAnE;AAEA,MAAMC,eAAe,GAAG,qDAAxB;;AAKA,IAAIC,YAAOC,IAAP,IAAeD,YAAOC,IAAP,CAAYJ,OAAZ,KAAwBA,OAA3C,EAAoD;AAClD,QAAM,IAAIK,KAAJ,iDAAmDF,YAAOC,IAAP,CAAYJ,OAA/D,iBAA6EA,OAA7E,EAAN;AACD;;AAED,IAAI,CAACG,YAAOC,IAAZ,EAAkB;AAChB,MAAI,qBAAJ,EAAiB;AACfE,iBAAIA,GAAJ,CAAQ,CAAR,oBAAsBN,OAAtB,gBAAmCE,eAAnC;AACD;;AAEDC,cAAOC,IAAP,GAAcD,YAAOC,IAAP,IAAe;AAC3BJ,IAAAA,OAD2B;AAE3BO,IAAAA,OAAO,EAAEP,OAFkB;AAG3BM,IAAAA,GAAG,EAAHA,YAH2B;AAO3BE,IAAAA,KAAK,EAAEC,cAPoB;AAc3BC,IAAAA,OAAO,EAAE;AACPC,MAAAA,OAAO,EAAE,EADF;AAEPC,MAAAA,MAAM,EAAE;AAFD;AAdkB,GAA7B;AAmBD;;eAGcT,YAAOC,I","sourcesContent":["import {log} from '@luma.gl/gltools';\nimport {isBrowser, global} from 'probe.gl/env';\nimport {lumaStats} from '@luma.gl/api';\n\n// Version detection using babel plugin\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\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"],"file":"init.js"}

package/dist/es5/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/dist/es5/types.js.map

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

package/dist/es5/utils/array-utils-flat.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.getScratchArrayBuffer = getScratchArrayBuffer;
 exports.getScratchArray = getScratchArray;
 exports.fillArray = fillArray;
-var arrayBuffer = null;
+let arrayBuffer = null;
 
 function getScratchArrayBuffer(byteLength) {
   if (!arrayBuffer || arrayBuffer.byteLength < byteLength) {
@@ -17,22 +17,21 @@ function getScratchArrayBuffer(byteLength) {
 }
 
 function getScratchArray(Type, length) {
-  var scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length);
+  const scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length);
   return new Type(scratchArrayBuffer, 0, length);
 }
 
-function fillArray(_ref) {
-  var target = _ref.target,
-      source = _ref.source,
-      _ref$start = _ref.start,
-      start = _ref$start === void 0 ? 0 : _ref$start,
-      _ref$count = _ref.count,
-      count = _ref$count === void 0 ? 1 : _ref$count;
-  var length = source.length;
-  var total = count * length;
-  var copied = 0;
-
-  for (var i = start; copied < length; copied++) {
+function fillArray({
+  target,
+  source,
+  start = 0,
+  count = 1
+}) {
+  const length = source.length;
+  const total = count * length;
+  let copied = 0;
+
+  for (let i = start; copied < length; copied++) {
     target[i++] = source[copied];
   }