@antv/l7-renderer 2.9.20 → 2.9.22

package/lib/regl/ReglModel.js

@@ -1,328 +1,262 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/regl/ReglModel.ts
+var ReglModel_exports = {};
+__export(ReglModel_exports, {
+  default: () => ReglModel
 });
-exports.default = void 0;
-
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _isTypedArray2 = _interopRequireDefault(require("lodash/isTypedArray"));
-
-var _isPlainObject2 = _interopRequireDefault(require("lodash/isPlainObject"));
-
-var _cloneDeep2 = _interopRequireDefault(require("lodash/cloneDeep"));
-
-var _l7Core = require("@antv/l7-core");
-
-var _constants = require("./constants");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-var ReglModel = function () {
-  function ReglModel(reGl, options) {
-    (0, _classCallCheck2.default)(this, ReglModel);
-    (0, _defineProperty2.default)(this, "reGl", void 0);
-    (0, _defineProperty2.default)(this, "destroyed", false);
-    (0, _defineProperty2.default)(this, "drawCommand", void 0);
-    (0, _defineProperty2.default)(this, "drawPickCommand", void 0);
-    (0, _defineProperty2.default)(this, "drawParams", void 0);
-    (0, _defineProperty2.default)(this, "options", void 0);
-    (0, _defineProperty2.default)(this, "uniforms", {});
+module.exports = __toCommonJS(ReglModel_exports);
+var import_l7_core = require("@antv/l7-core");
+var import_lodash = require("lodash");
+var import_constants = require("./constants");
+var ReglModel = class {
+  constructor(reGl, options) {
+    this.destroyed = false;
+    this.uniforms = {};
     this.reGl = reGl;
-    var vs = options.vs,
-        fs = options.fs,
-        attributes = options.attributes,
-        uniforms = options.uniforms,
-        primitive = options.primitive,
-        count = options.count,
-        elements = options.elements,
-        depth = options.depth,
-        blend = options.blend,
-        stencil = options.stencil,
-        cull = options.cull,
-        instances = options.instances;
-    var reglUniforms = {};
+    const {
+      vs,
+      fs,
+      attributes,
+      uniforms,
+      primitive,
+      count,
+      elements,
+      depth,
+      blend,
+      stencil,
+      cull,
+      instances
+    } = options;
+    const reglUniforms = {};
     this.options = options;
-
     if (uniforms) {
       this.uniforms = this.extractUniforms(uniforms);
-      Object.keys(uniforms).forEach(function (uniformName) {
+      Object.keys(uniforms).forEach((uniformName) => {
         reglUniforms[uniformName] = reGl.prop(uniformName);
       });
     }
-
-    var reglAttributes = {};
-    Object.keys(attributes).forEach(function (name) {
+    const reglAttributes = {};
+    Object.keys(attributes).forEach((name) => {
       reglAttributes[name] = attributes[name].get();
     });
-    var drawParams = {
+    const drawParams = {
       attributes: reglAttributes,
       frag: fs,
       uniforms: reglUniforms,
       vert: vs,
       blend: {},
-      primitive: _constants.primitiveMap[primitive === undefined ? _l7Core.gl.TRIANGLES : primitive]
+      primitive: import_constants.primitiveMap[primitive === void 0 ? import_l7_core.gl.TRIANGLES : primitive]
     };
-
     if (instances) {
       drawParams.instances = instances;
     }
-
     if (count) {
       drawParams.count = count;
     }
-
     if (elements) {
       drawParams.elements = elements.get();
     }
-
-    this.initDepthDrawParams({
-      depth: depth
-    }, drawParams);
-    this.initBlendDrawParams({
-      blend: blend
-    }, drawParams);
-    this.initStencilDrawParams({
-      stencil: stencil
-    }, drawParams);
-    this.initCullDrawParams({
-      cull: cull
-    }, drawParams);
+    this.initDepthDrawParams({ depth }, drawParams);
+    this.initBlendDrawParams({ blend }, drawParams);
+    this.initStencilDrawParams({ stencil }, drawParams);
+    this.initCullDrawParams({ cull }, drawParams);
     this.drawCommand = reGl(drawParams);
-    var pickDrawParams = (0, _cloneDeep2.default)(drawParams);
-    pickDrawParams.blend = _objectSpread(_objectSpread({}, pickDrawParams.blend), {}, {
+    const pickDrawParams = (0, import_lodash.cloneDeep)(drawParams);
+    pickDrawParams.blend = {
+      ...pickDrawParams.blend,
       enable: false
-    });
+    };
     this.drawPickCommand = reGl(pickDrawParams);
     this.drawParams = drawParams;
   }
-
-  (0, _createClass2.default)(ReglModel, [{
-    key: "updateAttributesAndElements",
-    value: function updateAttributesAndElements(attributes, elements) {
-      var reglAttributes = {};
-      Object.keys(attributes).forEach(function (name) {
-        reglAttributes[name] = attributes[name].get();
-      });
-      this.drawParams.attributes = reglAttributes;
-      this.drawParams.elements = elements.get();
-      this.drawCommand = this.reGl(this.drawParams);
-      var pickDrawParams = (0, _cloneDeep2.default)(this.drawParams);
-      pickDrawParams.blend = _objectSpread(_objectSpread({}, pickDrawParams.blend), {}, {
-        enable: false
-      });
-      this.drawPickCommand = this.reGl(pickDrawParams);
-    }
-  }, {
-    key: "updateAttributes",
-    value: function updateAttributes(attributes) {
-      var reglAttributes = {};
-      Object.keys(attributes).forEach(function (name) {
-        reglAttributes[name] = attributes[name].get();
-      });
-      this.drawParams.attributes = reglAttributes;
-      this.drawCommand = this.reGl(this.drawParams);
-      var pickDrawParams = (0, _cloneDeep2.default)(this.drawParams);
-      pickDrawParams.blend = _objectSpread(_objectSpread({}, pickDrawParams.blend), {}, {
-        enable: false
-      });
-      this.drawPickCommand = this.reGl(pickDrawParams);
-    }
-  }, {
-    key: "addUniforms",
-    value: function addUniforms(uniforms) {
-      this.uniforms = _objectSpread(_objectSpread({}, this.uniforms), this.extractUniforms(uniforms));
+  updateAttributesAndElements(attributes, elements) {
+    const reglAttributes = {};
+    Object.keys(attributes).forEach((name) => {
+      reglAttributes[name] = attributes[name].get();
+    });
+    this.drawParams.attributes = reglAttributes;
+    this.drawParams.elements = elements.get();
+    this.drawCommand = this.reGl(this.drawParams);
+    const pickDrawParams = (0, import_lodash.cloneDeep)(this.drawParams);
+    pickDrawParams.blend = {
+      ...pickDrawParams.blend,
+      enable: false
+    };
+    this.drawPickCommand = this.reGl(pickDrawParams);
+  }
+  updateAttributes(attributes) {
+    const reglAttributes = {};
+    Object.keys(attributes).forEach((name) => {
+      reglAttributes[name] = attributes[name].get();
+    });
+    this.drawParams.attributes = reglAttributes;
+    this.drawCommand = this.reGl(this.drawParams);
+    const pickDrawParams = (0, import_lodash.cloneDeep)(this.drawParams);
+    pickDrawParams.blend = {
+      ...pickDrawParams.blend,
+      enable: false
+    };
+    this.drawPickCommand = this.reGl(pickDrawParams);
+  }
+  addUniforms(uniforms) {
+    this.uniforms = {
+      ...this.uniforms,
+      ...this.extractUniforms(uniforms)
+    };
+  }
+  draw(options, pick) {
+    if (this.drawParams.attributes && Object.keys(this.drawParams.attributes).length === 0) {
+      return;
     }
-  }, {
-    key: "draw",
-    value: function draw(options, pick) {
-      if (this.drawParams.attributes && Object.keys(this.drawParams.attributes).length === 0) {
-        return;
-      }
-
-      var uniforms = _objectSpread(_objectSpread({}, this.uniforms), this.extractUniforms(options.uniforms || {}));
-
-      var reglDrawProps = {};
-      Object.keys(uniforms).forEach(function (uniformName) {
-        var type = (0, _typeof2.default)(uniforms[uniformName]);
-
-        if (type === 'boolean' || type === 'number' || Array.isArray(uniforms[uniformName]) || uniforms[uniformName].BYTES_PER_ELEMENT) {
-          reglDrawProps[uniformName] = uniforms[uniformName];
-        } else {
-          reglDrawProps[uniformName] = uniforms[uniformName].get();
-        }
-      });
-
-      if (!pick) {
-        this.drawCommand(reglDrawProps);
+    const uniforms = {
+      ...this.uniforms,
+      ...this.extractUniforms(options.uniforms || {})
+    };
+    const reglDrawProps = {};
+    Object.keys(uniforms).forEach((uniformName) => {
+      const type = typeof uniforms[uniformName];
+      if (type === "boolean" || type === "number" || Array.isArray(uniforms[uniformName]) || uniforms[uniformName].BYTES_PER_ELEMENT) {
+        reglDrawProps[uniformName] = uniforms[uniformName];
       } else {
-        this.drawPickCommand(reglDrawProps);
+        reglDrawProps[uniformName] = uniforms[uniformName].get();
       }
+    });
+    if (!pick) {
+      this.drawCommand(reglDrawProps);
+    } else {
+      this.drawPickCommand(reglDrawProps);
     }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      this.drawParams.elements.destroy();
-
-      if (this.options.attributes) {
-        Object.values(this.options.attributes).forEach(function (attr) {
-          attr.destroy();
-        });
-      }
-
-      this.destroyed = true;
+  }
+  destroy() {
+    this.drawParams.elements.destroy();
+    if (this.options.attributes) {
+      Object.values(this.options.attributes).forEach((attr) => {
+        attr.destroy();
+      });
     }
-  }, {
-    key: "initDepthDrawParams",
-    value: function initDepthDrawParams(_ref, drawParams) {
-      var depth = _ref.depth;
-
-      if (depth) {
-        drawParams.depth = {
-          enable: depth.enable === undefined ? true : !!depth.enable,
-          mask: depth.mask === undefined ? true : !!depth.mask,
-          func: _constants.depthFuncMap[depth.func || _l7Core.gl.LESS],
-          range: depth.range || [0, 1]
-        };
-      }
+    this.destroyed = true;
+  }
+  initDepthDrawParams({ depth }, drawParams) {
+    if (depth) {
+      drawParams.depth = {
+        enable: depth.enable === void 0 ? true : !!depth.enable,
+        mask: depth.mask === void 0 ? true : !!depth.mask,
+        func: import_constants.depthFuncMap[depth.func || import_l7_core.gl.LESS],
+        range: depth.range || [0, 1]
+      };
     }
-  }, {
-    key: "initBlendDrawParams",
-    value: function initBlendDrawParams(_ref2, drawParams) {
-      var blend = _ref2.blend;
-
-      if (blend) {
-        var enable = blend.enable,
-            func = blend.func,
-            equation = blend.equation,
-            _blend$color = blend.color,
-            color = _blend$color === void 0 ? [0, 0, 0, 0] : _blend$color;
-        drawParams.blend = {
-          enable: !!enable,
-          func: {
-            srcRGB: _constants.blendFuncMap[func && func.srcRGB || _l7Core.gl.SRC_ALPHA],
-            srcAlpha: _constants.blendFuncMap[func && func.srcAlpha || _l7Core.gl.SRC_ALPHA],
-            dstRGB: _constants.blendFuncMap[func && func.dstRGB || _l7Core.gl.ONE_MINUS_SRC_ALPHA],
-            dstAlpha: _constants.blendFuncMap[func && func.dstAlpha || _l7Core.gl.ONE_MINUS_SRC_ALPHA]
-          },
-          equation: {
-            rgb: _constants.blendEquationMap[equation && equation.rgb || _l7Core.gl.FUNC_ADD],
-            alpha: _constants.blendEquationMap[equation && equation.alpha || _l7Core.gl.FUNC_ADD]
-          },
-          color: color
-        };
-      }
+  }
+  initBlendDrawParams({ blend }, drawParams) {
+    if (blend) {
+      const { enable, func, equation, color = [0, 0, 0, 0] } = blend;
+      drawParams.blend = {
+        enable: !!enable,
+        func: {
+          srcRGB: import_constants.blendFuncMap[func && func.srcRGB || import_l7_core.gl.SRC_ALPHA],
+          srcAlpha: import_constants.blendFuncMap[func && func.srcAlpha || import_l7_core.gl.SRC_ALPHA],
+          dstRGB: import_constants.blendFuncMap[func && func.dstRGB || import_l7_core.gl.ONE_MINUS_SRC_ALPHA],
+          dstAlpha: import_constants.blendFuncMap[func && func.dstAlpha || import_l7_core.gl.ONE_MINUS_SRC_ALPHA]
+        },
+        equation: {
+          rgb: import_constants.blendEquationMap[equation && equation.rgb || import_l7_core.gl.FUNC_ADD],
+          alpha: import_constants.blendEquationMap[equation && equation.alpha || import_l7_core.gl.FUNC_ADD]
+        },
+        color
+      };
     }
-  }, {
-    key: "initStencilDrawParams",
-    value: function initStencilDrawParams(_ref3, drawParams) {
-      var stencil = _ref3.stencil;
-
-      if (stencil) {
-        var enable = stencil.enable,
-            _stencil$mask = stencil.mask,
-            mask = _stencil$mask === void 0 ? -1 : _stencil$mask,
-            _stencil$func = stencil.func,
-            func = _stencil$func === void 0 ? {
-          cmp: _l7Core.gl.ALWAYS,
+  }
+  initStencilDrawParams({ stencil }, drawParams) {
+    if (stencil) {
+      const {
+        enable,
+        mask = -1,
+        func = {
+          cmp: import_l7_core.gl.ALWAYS,
           ref: 0,
           mask: -1
-        } : _stencil$func,
-            _stencil$opFront = stencil.opFront,
-            opFront = _stencil$opFront === void 0 ? {
-          fail: _l7Core.gl.KEEP,
-          zfail: _l7Core.gl.KEEP,
-          zpass: _l7Core.gl.KEEP
-        } : _stencil$opFront,
-            _stencil$opBack = stencil.opBack,
-            opBack = _stencil$opBack === void 0 ? {
-          fail: _l7Core.gl.KEEP,
-          zfail: _l7Core.gl.KEEP,
-          zpass: _l7Core.gl.KEEP
-        } : _stencil$opBack;
-        drawParams.stencil = {
-          enable: !!enable,
-          mask: mask,
-          func: _objectSpread(_objectSpread({}, func), {}, {
-            cmp: _constants.stencilFuncMap[func.cmp]
-          }),
-          opFront: {
-            fail: _constants.stencilOpMap[opFront.fail],
-            zfail: _constants.stencilOpMap[opFront.zfail],
-            zpass: _constants.stencilOpMap[opFront.zpass]
-          },
-          opBack: {
-            fail: _constants.stencilOpMap[opBack.fail],
-            zfail: _constants.stencilOpMap[opBack.zfail],
-            zpass: _constants.stencilOpMap[opBack.zpass]
-          }
-        };
-      }
+        },
+        opFront = {
+          fail: import_l7_core.gl.KEEP,
+          zfail: import_l7_core.gl.KEEP,
+          zpass: import_l7_core.gl.KEEP
+        },
+        opBack = {
+          fail: import_l7_core.gl.KEEP,
+          zfail: import_l7_core.gl.KEEP,
+          zpass: import_l7_core.gl.KEEP
+        }
+      } = stencil;
+      drawParams.stencil = {
+        enable: !!enable,
+        mask,
+        func: {
+          ...func,
+          cmp: import_constants.stencilFuncMap[func.cmp]
+        },
+        opFront: {
+          fail: import_constants.stencilOpMap[opFront.fail],
+          zfail: import_constants.stencilOpMap[opFront.zfail],
+          zpass: import_constants.stencilOpMap[opFront.zpass]
+        },
+        opBack: {
+          fail: import_constants.stencilOpMap[opBack.fail],
+          zfail: import_constants.stencilOpMap[opBack.zfail],
+          zpass: import_constants.stencilOpMap[opBack.zpass]
+        }
+      };
     }
-  }, {
-    key: "initCullDrawParams",
-    value: function initCullDrawParams(_ref4, drawParams) {
-      var cull = _ref4.cull;
-
-      if (cull) {
-        var enable = cull.enable,
-            _cull$face = cull.face,
-            face = _cull$face === void 0 ? _l7Core.gl.BACK : _cull$face;
-        drawParams.cull = {
-          enable: !!enable,
-          face: _constants.cullFaceMap[face]
-        };
-      }
+  }
+  initCullDrawParams({ cull }, drawParams) {
+    if (cull) {
+      const { enable, face = import_l7_core.gl.BACK } = cull;
+      drawParams.cull = {
+        enable: !!enable,
+        face: import_constants.cullFaceMap[face]
+      };
     }
-  }, {
-    key: "extractUniforms",
-    value: function extractUniforms(uniforms) {
-      var _this = this;
-
-      var extractedUniforms = {};
-      Object.keys(uniforms).forEach(function (uniformName) {
-        _this.extractUniformsRecursively(uniformName, uniforms[uniformName], extractedUniforms, '');
+  }
+  extractUniforms(uniforms) {
+    const extractedUniforms = {};
+    Object.keys(uniforms).forEach((uniformName) => {
+      this.extractUniformsRecursively(uniformName, uniforms[uniformName], extractedUniforms, "");
+    });
+    return extractedUniforms;
+  }
+  extractUniformsRecursively(uniformName, uniformValue, uniforms, prefix) {
+    if (uniformValue === null || typeof uniformValue === "number" || typeof uniformValue === "boolean" || Array.isArray(uniformValue) && typeof uniformValue[0] === "number" || (0, import_lodash.isTypedArray)(uniformValue) || uniformValue === "" || "resize" in uniformValue) {
+      uniforms[`${prefix && prefix + "."}${uniformName}`] = uniformValue;
+      return;
+    }
+    if ((0, import_lodash.isPlainObject)(uniformValue)) {
+      Object.keys(uniformValue).forEach((childName) => {
+        this.extractUniformsRecursively(childName, uniformValue[childName], uniforms, `${prefix && prefix + "."}${uniformName}`);
       });
-      return extractedUniforms;
     }
-  }, {
-    key: "extractUniformsRecursively",
-    value: function extractUniformsRecursively(uniformName, uniformValue, uniforms, prefix) {
-      var _this2 = this;
-
-      if (uniformValue === null || typeof uniformValue === 'number' || typeof uniformValue === 'boolean' || Array.isArray(uniformValue) && typeof uniformValue[0] === 'number' || (0, _isTypedArray2.default)(uniformValue) || uniformValue === '' || 'resize' in uniformValue) {
-        uniforms["".concat(prefix && prefix + '.').concat(uniformName)] = uniformValue;
-        return;
-      }
-
-      if ((0, _isPlainObject2.default)(uniformValue)) {
-        Object.keys(uniformValue).forEach(function (childName) {
-          _this2.extractUniformsRecursively(childName, uniformValue[childName], uniforms, "".concat(prefix && prefix + '.').concat(uniformName));
-        });
-      }
-
-      if (Array.isArray(uniformValue)) {
-        uniformValue.forEach(function (child, idx) {
-          Object.keys(child).forEach(function (childName) {
-            _this2.extractUniformsRecursively(childName, child[childName], uniforms, "".concat(prefix && prefix + '.').concat(uniformName, "[").concat(idx, "]"));
-          });
+    if (Array.isArray(uniformValue)) {
+      uniformValue.forEach((child, idx) => {
+        Object.keys(child).forEach((childName) => {
+          this.extractUniformsRecursively(childName, child[childName], uniforms, `${prefix && prefix + "."}${uniformName}[${idx}]`);
         });
-      }
+      });
     }
-  }]);
-  return ReglModel;
-}();
-
-exports.default = ReglModel;
-//# sourceMappingURL=ReglModel.js.map
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/regl/ReglRenderbuffer.js

@@ -1,54 +1,46 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/regl/ReglRenderbuffer.ts
+var ReglRenderbuffer_exports = {};
+__export(ReglRenderbuffer_exports, {
+  default: () => ReglRenderbuffer
 });
-exports.default = void 0;
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _constants = require("./constants");
-
-var ReglRenderbuffer = function () {
-  function ReglRenderbuffer(reGl, options) {
-    (0, _classCallCheck2.default)(this, ReglRenderbuffer);
-    (0, _defineProperty2.default)(this, "renderbuffer", void 0);
-    var width = options.width,
-        height = options.height,
-        format = options.format;
+module.exports = __toCommonJS(ReglRenderbuffer_exports);
+var import_constants = require("./constants");
+var ReglRenderbuffer = class {
+  constructor(reGl, options) {
+    const { width, height, format } = options;
     this.renderbuffer = reGl.renderbuffer({
-      width: width,
-      height: height,
-      format: _constants.formatMap[format]
+      width,
+      height,
+      format: import_constants.formatMap[format]
     });
   }
-
-  (0, _createClass2.default)(ReglRenderbuffer, [{
-    key: "get",
-    value: function get() {
-      return this.renderbuffer;
-    }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      this.renderbuffer.destroy();
-    }
-  }, {
-    key: "resize",
-    value: function resize(_ref) {
-      var width = _ref.width,
-          height = _ref.height;
-      this.renderbuffer.resize(width, height);
-    }
-  }]);
-  return ReglRenderbuffer;
-}();
-
-exports.default = ReglRenderbuffer;
-//# sourceMappingURL=ReglRenderbuffer.js.map
+  get() {
+    return this.renderbuffer;
+  }
+  destroy() {
+    this.renderbuffer.destroy();
+  }
+  resize({ width, height }) {
+    this.renderbuffer.resize(width, height);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});