@gjsify/webgl 0.0.2

package/lib/cjs/linkable.js

@@ -0,0 +1,69 @@
+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);
+var linkable_exports = {};
+__export(linkable_exports, {
+  Linkable: () => Linkable
+});
+module.exports = __toCommonJS(linkable_exports);
+class Linkable {
+  constructor(_) {
+    this._ = 0;
+    this._references = [];
+    this._refCount = 0;
+    this._pendingDelete = false;
+    this._binding = 0;
+    this._ = _;
+    this._references = [];
+    this._refCount = 0;
+    this._pendingDelete = false;
+    this._binding = 0;
+  }
+  _link(b) {
+    this._references.push(b);
+    b._refCount += 1;
+    return true;
+  }
+  _unlink(b) {
+    let idx = this._references.indexOf(b);
+    if (idx < 0) {
+      return false;
+    }
+    while (idx >= 0) {
+      this._references[idx] = this._references[this._references.length - 1];
+      this._references.pop();
+      b._refCount -= 1;
+      b._checkDelete();
+      idx = this._references.indexOf(b);
+    }
+    return true;
+  }
+  _linked(b) {
+    return this._references.indexOf(b) >= 0;
+  }
+  _checkDelete() {
+    if (this._refCount <= 0 && this._pendingDelete && this._ !== 0) {
+      while (this._references.length > 0) {
+        this._unlink(this._references[0]);
+      }
+      this._performDelete();
+      this._ = 0;
+    }
+  }
+  _performDelete() {
+  }
+}

package/lib/cjs/test.js

@@ -0,0 +1,25 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_unit = require("@gjsify/unit");
+var import_index_spec = __toESM(require("./index.spec.js"), 1);
+(0, import_unit.run)({ testSuite: import_index_spec.default });

package/lib/cjs/types/constructor.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var constructor_exports = {};
+module.exports = __toCommonJS(constructor_exports);

package/lib/cjs/types/extension.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var extension_exports = {};
+module.exports = __toCommonJS(extension_exports);

package/lib/cjs/types/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./constructor.js"), module.exports);
+__reExport(types_exports, require("./extension.js"), module.exports);
+__reExport(types_exports, require("./typed-array.js"), module.exports);
+__reExport(types_exports, require("./webgl-constants.js"), module.exports);
+__reExport(types_exports, require("./webgl-context-attribute-options.js"), module.exports);

package/lib/cjs/types/typed-array.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var typed_array_exports = {};
+module.exports = __toCommonJS(typed_array_exports);

package/lib/cjs/types/webgl-constants.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var webgl_constants_exports = {};
+module.exports = __toCommonJS(webgl_constants_exports);

package/lib/cjs/types/webgl-context-attribute-options.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var webgl_context_attribute_options_exports = {};
+module.exports = __toCommonJS(webgl_context_attribute_options_exports);

package/lib/cjs/utils.js

@@ -0,0 +1,241 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  Uint8ArrayToVariant: () => Uint8ArrayToVariant,
+  arrayToUint8Array: () => arrayToUint8Array,
+  bindPublics: () => bindPublics,
+  boolArray: () => boolArray,
+  checkFormat: () => checkFormat,
+  checkObject: () => checkObject,
+  checkUniform: () => checkUniform,
+  convertPixels: () => convertPixels,
+  extractImageData: () => extractImageData,
+  flag: () => flag,
+  formatSize: () => formatSize,
+  isTypedArray: () => isTypedArray,
+  isValidString: () => isValidString,
+  listToArray: () => listToArray,
+  typeSize: () => typeSize,
+  uniformTypeSize: () => uniformTypeSize,
+  validCubeTarget: () => validCubeTarget,
+  vertexCount: () => vertexCount
+});
+module.exports = __toCommonJS(utils_exports);
+var import_webgl_uniform_location = require("./webgl-uniform-location.js");
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+function bindPublics(props, wrapper, privateInstance, privateMethods) {
+  for (let i = 0; i < props.length; i++) {
+    const prop = props[i];
+    const value = privateInstance[prop];
+    if (typeof value === "function") {
+      if (privateMethods.indexOf(prop) === -1) {
+        wrapper[prop] = value.bind(privateInstance);
+      }
+    } else {
+      if (prop[0] === "_" || prop[0] === "0" || prop[0] === "1") {
+        continue;
+      }
+      wrapper[prop] = value;
+    }
+  }
+}
+function checkObject(object) {
+  return typeof object === "object" || object === void 0;
+}
+function checkUniform(program, location) {
+  return location instanceof import_webgl_uniform_location.WebGLUniformLocation && location._program === program && location._linkCount === program._linkCount;
+}
+function isTypedArray(data) {
+  return data instanceof Uint8Array || data instanceof Uint8ClampedArray || data instanceof Int8Array || data instanceof Uint16Array || data instanceof Int16Array || data instanceof Uint32Array || data instanceof Int32Array || data instanceof Float32Array || data instanceof Float64Array;
+}
+function isValidString(str) {
+  const c = str.replace(/(?:\/\*(?:[\s\S]*?)\*\/)|(?:([\s;])+\/\/(?:.*)$)/gm, "");
+  return !/["$`@\\'\0]/.test(c);
+}
+function vertexCount(gl, primitive, count) {
+  switch (primitive) {
+    case gl.TRIANGLES:
+      return count - count % 3;
+    case gl.LINES:
+      return count - count % 2;
+    case gl.LINE_LOOP:
+    case gl.POINTS:
+      return count;
+    case gl.TRIANGLE_FAN:
+    case gl.LINE_STRIP:
+      if (count < 2) {
+        return 0;
+      }
+      return count;
+    case gl.TRIANGLE_STRIP:
+      if (count < 3) {
+        return 0;
+      }
+      return count;
+    default:
+      return -1;
+  }
+}
+function typeSize(gl, type) {
+  switch (type) {
+    case gl.UNSIGNED_BYTE:
+    case gl.BYTE:
+      return 1;
+    case gl.UNSIGNED_SHORT:
+    case gl.SHORT:
+      return 2;
+    case gl.UNSIGNED_INT:
+    case gl.INT:
+    case gl.FLOAT:
+      return 4;
+  }
+  return 0;
+}
+function uniformTypeSize(gl, type) {
+  switch (type) {
+    case gl.BOOL_VEC4:
+    case gl.INT_VEC4:
+    case gl.FLOAT_VEC4:
+      return 4;
+    case gl.BOOL_VEC3:
+    case gl.INT_VEC3:
+    case gl.FLOAT_VEC3:
+      return 3;
+    case gl.BOOL_VEC2:
+    case gl.INT_VEC2:
+    case gl.FLOAT_VEC2:
+      return 2;
+    case gl.BOOL:
+    case gl.INT:
+    case gl.FLOAT:
+    case gl.SAMPLER_2D:
+    case gl.SAMPLER_CUBE:
+      return 1;
+    default:
+      return 0;
+  }
+}
+const listToArray = (values) => {
+  const array = [];
+  for (const value of values.values()) {
+    array.push(value);
+  }
+  return array;
+};
+function arrayToUint8Array(array) {
+  if (isTypedArray(array)) {
+    return new Uint8Array(array.buffer).subarray(
+      array.byteOffset,
+      array.byteLength + array.byteOffset
+    );
+  }
+  if (Array.isArray(array) || array instanceof ArrayBuffer) {
+    return new Uint8Array(array);
+  }
+  if (typeof array.values === "function") {
+    return new Uint8Array(listToArray(array));
+  }
+  throw new Error("Can't unpack typed array!");
+}
+function Uint8ArrayToVariant(array) {
+  const variant = new import_glib_2.default.Variant("ay", Array.from(array || []));
+  return variant;
+}
+function boolArray(array) {
+  return Array.from(new Int32Array(array.buffer)).map(
+    (a) => a ? true : false
+  );
+}
+const extractImageData = (pixels) => {
+  const width = pixels.width;
+  const height = pixels.height;
+  if (typeof pixels === "object" && typeof width !== "undefined" && typeof height !== "undefined") {
+    if (typeof pixels.data !== "undefined") {
+      return pixels;
+    }
+    let context = null;
+    if (typeof pixels.getContext === "function") {
+      context = pixels.getContext("2d");
+    } else if (typeof pixels.isPixbuf()) {
+      return pixels.getImageData();
+    } else if (typeof pixels.src !== "undefined" && typeof document === "object" && typeof document.createElement === "function") {
+      const canvas = document.createElement("canvas");
+      if (typeof canvas === "object" && typeof canvas.getContext === "function") {
+        canvas.width = width;
+        canvas.height = height;
+        context = canvas.getContext("2d");
+        if (context !== null) {
+          context.drawImage(pixels, 0, 0);
+        }
+      }
+    }
+    if (context !== null) {
+      return context.getImageData(0, 0, width, height);
+    }
+  }
+  return null;
+};
+function formatSize(gl, internalFormat) {
+  switch (internalFormat) {
+    case gl.ALPHA:
+    case gl.LUMINANCE:
+      return 1;
+    case gl.LUMINANCE_ALPHA:
+      return 2;
+    case gl.RGB:
+      return 3;
+    case gl.RGBA:
+      return 4;
+  }
+  return 0;
+}
+function convertPixels(pixels) {
+  if (typeof pixels === "object" && pixels !== null) {
+    if (pixels instanceof ArrayBuffer) {
+      return new Uint8Array(pixels);
+    } else if (pixels instanceof Uint8Array || pixels instanceof Uint16Array || pixels instanceof Uint8ClampedArray || pixels instanceof Float32Array) {
+      return arrayToUint8Array(pixels);
+    } else if (pixels instanceof Buffer) {
+      return new Uint8Array(pixels);
+    }
+  }
+  return null;
+}
+function checkFormat(gl, format) {
+  return format === gl.ALPHA || format === gl.LUMINANCE_ALPHA || format === gl.LUMINANCE || format === gl.RGB || format === gl.RGBA;
+}
+function validCubeTarget(gl, target) {
+  return target === gl.TEXTURE_CUBE_MAP_POSITIVE_X || target === gl.TEXTURE_CUBE_MAP_NEGATIVE_X || target === gl.TEXTURE_CUBE_MAP_POSITIVE_Y || target === gl.TEXTURE_CUBE_MAP_NEGATIVE_Y || target === gl.TEXTURE_CUBE_MAP_POSITIVE_Z || target === gl.TEXTURE_CUBE_MAP_NEGATIVE_Z;
+}
+function flag(options, name, dflt) {
+  if (!options || !(typeof options === "object") || !(name in options)) {
+    return dflt;
+  }
+  return !!options[name];
+}

package/lib/cjs/webgl-active-info.js

@@ -0,0 +1,29 @@
+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);
+var webgl_active_info_exports = {};
+__export(webgl_active_info_exports, {
+  WebGLActiveInfo: () => GjsifyWebGLActiveInfo
+});
+module.exports = __toCommonJS(webgl_active_info_exports);
+class GjsifyWebGLActiveInfo {
+  constructor(_) {
+    this.size = _.size;
+    this.type = _.type;
+    this.name = _.name;
+  }
+}

package/lib/cjs/webgl-buffer.js

@@ -0,0 +1,37 @@
+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);
+var webgl_buffer_exports = {};
+__export(webgl_buffer_exports, {
+  GjsifyWebGLBuffer: () => GjsifyWebGLBuffer,
+  WebGLBuffer: () => GjsifyWebGLBuffer
+});
+module.exports = __toCommonJS(webgl_buffer_exports);
+var import_linkable = require("./linkable.js");
+class GjsifyWebGLBuffer extends import_linkable.Linkable {
+  constructor(_, ctx) {
+    super(_);
+    this._size = 0;
+    this._elements = new Uint8Array(0);
+    this._ctx = ctx;
+  }
+  _performDelete() {
+    const ctx = this._ctx;
+    delete ctx._buffers[this._ | 0];
+    ctx._native.deleteBuffer(this._);
+  }
+}

package/lib/cjs/webgl-context-attributes.js

@@ -0,0 +1,43 @@
+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);
+var webgl_context_attributes_exports = {};
+__export(webgl_context_attributes_exports, {
+  GjsifyWebGLContextAttributes: () => GjsifyWebGLContextAttributes,
+  WebGLContextAttributes: () => GjsifyWebGLContextAttributes
+});
+module.exports = __toCommonJS(webgl_context_attributes_exports);
+class GjsifyWebGLContextAttributes {
+  constructor(alpha, depth, stencil, antialias, premultipliedAlpha, preserveDrawingBuffer, preferLowPowerToHighPerformance, failIfMajorPerformanceCaveat) {
+    this.alpha = alpha;
+    this.depth = depth;
+    this.stencil = stencil;
+    this.antialias = antialias;
+    this.premultipliedAlpha = premultipliedAlpha;
+    this.preserveDrawingBuffer = preserveDrawingBuffer;
+    this.preferLowPowerToHighPerformance = preferLowPowerToHighPerformance;
+    this.failIfMajorPerformanceCaveat = failIfMajorPerformanceCaveat;
+    this.alpha = alpha;
+    this.depth = depth;
+    this.stencil = stencil;
+    this.antialias = antialias;
+    this.premultipliedAlpha = premultipliedAlpha;
+    this.preserveDrawingBuffer = preserveDrawingBuffer;
+    this.preferLowPowerToHighPerformance = preferLowPowerToHighPerformance;
+    this.failIfMajorPerformanceCaveat = failIfMajorPerformanceCaveat;
+  }
+}

package/lib/cjs/webgl-drawing-buffer-wrapper.js

@@ -0,0 +1,29 @@
+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);
+var webgl_drawing_buffer_wrapper_exports = {};
+__export(webgl_drawing_buffer_wrapper_exports, {
+  WebGLDrawingBufferWrapper: () => WebGLDrawingBufferWrapper
+});
+module.exports = __toCommonJS(webgl_drawing_buffer_wrapper_exports);
+class WebGLDrawingBufferWrapper {
+  constructor(framebuffer, color, depthStencil) {
+    this._framebuffer = framebuffer;
+    this._color = color;
+    this._depthStencil = depthStencil;
+  }
+}