@nativescript/canvas 0.9.22-v6 → 1.0.0-alpha.10

package/WebGL/WebGLRenderingContext/index.ios.js

@@ -1,237 +1,168 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var common_1 = require("./common");
-var WebGLShader_1 = require("../WebGLShader");
-var WebGLFramebuffer_1 = require("../WebGLFramebuffer");
-var WebGLTexture_1 = require("../WebGLTexture");
-var WebGLProgram_1 = require("../WebGLProgram");
-var WebGLUniformLocation_1 = require("../WebGLUniformLocation");
-var WebGLActiveInfo_1 = require("../WebGLActiveInfo");
-var WebGLRenderbuffer_1 = require("../WebGLRenderbuffer");
-var WebGLShaderPrecisionFormat_1 = require("../WebGLShaderPrecisionFormat");
-var WebGLBuffer_1 = require("../WebGLBuffer");
-var core_1 = require("@nativescript/core");
-var WebGLExtensions_1 = require("../WebGLExtensions");
-var ImageAsset_1 = require("../../ImageAsset");
-var Canvas_1 = require("../../Canvas");
-var utils_1 = require("../../utils");
-var WebGLRenderingContext = /** @class */ (function (_super) {
-    __extends(WebGLRenderingContext, _super);
-    function WebGLRenderingContext(context) {
-        var _this = _super.call(this, context) || this;
-        _this.context = context;
-        return _this;
-    }
-    Object.defineProperty(WebGLRenderingContext.prototype, "native", {
-        get: function () {
-            return this.context;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(WebGLRenderingContext.prototype, "drawingBufferHeight", {
-        get: function () {
-            return this.context.drawingBufferHeight;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(WebGLRenderingContext.prototype, "drawingBufferWidth", {
-        get: function () {
-            return this.context.drawingBufferWidth;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    WebGLRenderingContext.prototype.activeTexture = function (texture) {
+import { WebGLRenderingContextBase } from './common';
+import { WebGLShader } from '../WebGLShader';
+import { WebGLFramebuffer } from '../WebGLFramebuffer';
+import { WebGLTexture } from '../WebGLTexture';
+import { WebGLProgram } from '../WebGLProgram';
+import { WebGLUniformLocation } from '../WebGLUniformLocation';
+import { WebGLActiveInfo } from '../WebGLActiveInfo';
+import { WebGLRenderbuffer } from '../WebGLRenderbuffer';
+import { WebGLShaderPrecisionFormat } from '../WebGLShaderPrecisionFormat';
+import { WebGLBuffer } from '../WebGLBuffer';
+import { ImageSource } from '@nativescript/core';
+import { ANGLE_instanced_arrays, EXT_blend_minmax, EXT_color_buffer_float, EXT_color_buffer_half_float, EXT_shader_texture_lod, EXT_sRGB, EXT_texture_filter_anisotropic, OES_element_index_uint, OES_fbo_render_mipmap, OES_standard_derivatives, OES_texture_float, OES_texture_float_linear, OES_texture_half_float, OES_texture_half_float_linear, OES_vertex_array_object, WEBGL_color_buffer_float, WEBGL_compressed_texture_etc, WEBGL_compressed_texture_etc1, WEBGL_compressed_texture_pvrtc, WEBGL_depth_texture, WEBGL_draw_buffers, WEBGL_lose_context } from '../WebGLExtensions';
+import { ImageAsset } from '../../ImageAsset';
+import { Canvas } from '../../Canvas';
+import { Utils } from '../../utils';
+import { ImageBitmap } from '../../ImageBitmap';
+export class WebGLRenderingContext extends WebGLRenderingContextBase {
+    constructor(context) {
+        super(context);
+        this.context = context;
+    }
+    get native() {
+        return this.context;
+    }
+    get drawingBufferHeight() {
+        return this.context.drawingBufferHeight;
+    }
+    get drawingBufferWidth() {
+        return this.context.drawingBufferWidth;
+    }
+    activeTexture(texture) {
         this._glCheckError('activeTexture');
         this._checkArgs('activeTexture', arguments);
         this.context.activeTexture(texture);
-    };
-    WebGLRenderingContext.prototype.attachShader = function (program, shader) {
-        var value = program ? program.native : 0;
-        var value2 = shader ? shader.native : 0;
+    }
+    attachShader(program, shader) {
+        const value = program ? program.native : 0;
+        const value2 = shader ? shader.native : 0;
         this._glCheckError('attachShader');
         this._checkArgs('attachShader', arguments);
         this.context.attachShader(value, value2);
-    };
-    WebGLRenderingContext.prototype.bindAttribLocation = function (program, index, name) {
+    }
+    bindAttribLocation(program, index, name) {
         this._glCheckError('bindAttribLocation');
         this._checkArgs('bindAttribLocation', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         this.context.bindAttribLocation(value, index, name);
-    };
-    WebGLRenderingContext.prototype.bindBuffer = function (target, buffer) {
+    }
+    bindBuffer(target, buffer) {
         this._glCheckError('bindBuffer');
         this._checkArgs('bindBuffer', arguments);
-        var value = buffer ? buffer.native : 0;
+        const value = buffer ? buffer.native : 0;
         this.context.bindBuffer(target, value);
-    };
-    WebGLRenderingContext.prototype.bindFramebuffer = function (target, framebuffer) {
+    }
+    bindFramebuffer(target, framebuffer) {
         this._glCheckError('bindFramebuffer');
         this._checkArgs('bindFramebuffer', arguments);
-        var value = framebuffer ? framebuffer.native : 0;
+        const value = framebuffer ? framebuffer.native : 0;
         this.context.bindFramebuffer(target, value);
-    };
-    WebGLRenderingContext.prototype.bindRenderbuffer = function (target, renderbuffer) {
+    }
+    bindRenderbuffer(target, renderbuffer) {
         this._glCheckError('bindRenderbuffer');
         this._checkArgs('bindRenderbuffer', arguments);
-        var value = renderbuffer ? renderbuffer.native : 0;
+        const value = renderbuffer ? renderbuffer.native : 0;
         this.context.bindRenderbuffer(target, value);
-    };
-    WebGLRenderingContext.prototype.bindTexture = function (target, texture) {
+    }
+    bindTexture(target, texture) {
         this._glCheckError('bindTexture');
         this._checkArgs('bindTexture', arguments);
-        var value = texture ? texture.native : 0;
+        const value = texture ? texture.native : 0;
         this.context.bindTexture(target, value);
-    };
-    WebGLRenderingContext.prototype.blendColor = function (red, green, blue, alpha) {
+    }
+    blendColor(red, green, blue, alpha) {
         this._glCheckError('blendColor');
         this._checkArgs('blendColor', arguments);
         this.context.blendColor(red, green, blue, alpha);
-    };
-    WebGLRenderingContext.prototype.blendEquationSeparate = function (modeRGB, modeAlpha) {
+    }
+    blendEquationSeparate(modeRGB, modeAlpha) {
         this._glCheckError('blendEquationSeparate');
         this._checkArgs('blendEquationSeparate', arguments);
         this.context.blendEquationSeparate(modeRGB, modeAlpha);
-    };
-    WebGLRenderingContext.prototype.blendEquation = function (mode) {
+    }
+    blendEquation(mode) {
         this._glCheckError('blendEquation');
         this._checkArgs('blendEquation', arguments);
         this.context.blendEquation(mode);
-    };
-    WebGLRenderingContext.prototype.blendFuncSeparate = function (srcRGB, dstRGB, srcAlpha, dstAlpha) {
-        if (srcRGB === void 0) { srcRGB = this.ONE; }
-        if (dstRGB === void 0) { dstRGB = this.ZERO; }
-        if (srcAlpha === void 0) { srcAlpha = this.ONE; }
-        if (dstAlpha === void 0) { dstAlpha = this.ZERO; }
+    }
+    blendFuncSeparate(srcRGB = this.ONE, dstRGB = this.ZERO, srcAlpha = this.ONE, dstAlpha = this.ZERO) {
         this._glCheckError('blendFuncSeparate');
         this._checkArgs('blendFuncSeparate', arguments);
         this.context.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
-    };
-    WebGLRenderingContext.prototype.blendFunc = function (sfactor, dfactor) {
-        if (sfactor === void 0) { sfactor = this.ONE; }
-        if (dfactor === void 0) { dfactor = this.ZERO; }
+    }
+    blendFunc(sfactor = this.ONE, dfactor = this.ZERO) {
         this._glCheckError('blendFunc');
         this._checkArgs('blendFunc', arguments);
         this.context.blendFunc(sfactor, dfactor);
-    };
-    WebGLRenderingContext.prototype.bufferData = function (target, srcData, usage) {
+    }
+    bufferData(target, srcData, usage) {
         this._glCheckError('bufferData');
         this._checkArgs('bufferData', arguments);
         if (typeof srcData === 'number') {
             this.context.bufferDataSize(target, srcData, usage);
         }
         else if (srcData instanceof ArrayBuffer) {
-            // Array.from(srcData as any) bug
-            var array = new Uint8Array(srcData);
-            var data = Array.from(array);
-            this.context.bufferDataU8(target, data, usage);
-        }
-        else if (srcData && srcData.buffer instanceof ArrayBuffer) {
-            if (srcData instanceof Int8Array) {
-                this.context.bufferDataI8(target, Array.from(srcData), usage);
-            }
-            else if (srcData instanceof Uint8Array || srcData instanceof Uint8ClampedArray) {
-                this.context.bufferDataU8(target, Array.from(srcData), usage);
-            }
-            else if (srcData instanceof Int16Array) {
-                this.context.bufferDataI16(target, Array.from(srcData), usage);
-            }
-            else if (srcData instanceof Uint16Array) {
-                this.context.bufferDataU16(target, Array.from(srcData), usage);
-            }
-            else if (srcData instanceof Int32Array) {
-                this.context.bufferDataI32(target, Array.from(srcData), usage);
-            }
-            else if (srcData instanceof Uint32Array) {
-                this.context.bufferDataU32(target, Array.from(srcData), usage);
-            }
-            else if (srcData instanceof Float32Array) {
-                this.context.bufferDataF32(target, Array.from(srcData), usage);
-            }
-            else if (srcData instanceof Float64Array) {
-                this.context.bufferDataF64(target, Array.from(srcData), usage);
-            }
+            this.context.bufferDataSrcDataSize(target, srcData, srcData.byteLength, usage);
+        }
+        else if (Utils.isTypedArray(srcData)) {
+            this.context.bufferDataSrcDataSizeOffset(target, srcData, srcData.byteLength, usage, srcData.byteOffset);
         }
         else {
             this.context.bufferDataSrcData(target, srcData, usage);
         }
-    };
-    WebGLRenderingContext.prototype.bufferSubData = function (target, offset, srcData) {
+    }
+    bufferSubData(target, offset, srcData) {
         this._glCheckError('bufferSubData');
         this._checkArgs('bufferSubData', arguments);
-        if (srcData instanceof Int8Array) {
-            this.context.bufferSubDataI8(target, offset, Array.from(srcData));
-        }
-        else if (srcData instanceof ArrayBuffer) {
-            var array = new Uint8Array(srcData);
-            this.context.bufferSubDataU8(target, offset, Array.from(array));
-        }
-        else if (srcData instanceof Uint8Array || srcData instanceof Uint8ClampedArray) {
-            this.context.bufferSubDataU8(target, offset, Array.from(srcData));
-        }
-        else if (srcData instanceof Int16Array) {
-            this.context.bufferSubDataI16(target, offset, Array.from(srcData));
+        if (Utils.isTypedArray(srcData)) {
+            this.context.bufferSubDataSrcDataSizeOs(target, offset, srcData, srcData.byteLength, srcData.byteOffset);
         }
-        else if (srcData instanceof Uint16Array) {
-            this.context.bufferSubDataU16(target, offset, Array.from(srcData));
-        }
-        else if (srcData instanceof Int32Array) {
-            this.context.bufferSubDataI32(target, offset, Array.from(srcData));
-        }
-        else if (srcData instanceof Uint32Array) {
-            this.context.bufferSubDataU32(target, offset, Array.from(srcData));
-        }
-        else if (srcData instanceof Float32Array) {
-            this.context.bufferSubDataF32(target, offset, Array.from(srcData));
-        }
-        else if (srcData instanceof Float64Array) {
-            this.context.bufferSubDataF64(target, offset, Array.from(srcData));
+        else {
+            this.context.bufferSubDataSrcDataSize(target, offset, srcData, srcData.byteLength);
         }
-    };
-    WebGLRenderingContext.prototype.checkFramebufferStatus = function (target) {
+    }
+    checkFramebufferStatus(target) {
         this._glCheckError('checkFramebufferStatus');
         this._checkArgs('checkFramebufferStatus', arguments);
         return this.context.checkFramebufferStatus(target);
-    };
-    WebGLRenderingContext.prototype.clearColor = function (red, green, blue, alpha) {
+    }
+    clearColor(red, green, blue, alpha) {
         this._glCheckError('clearColor');
         this._checkArgs('clearColor', arguments);
         this.context.clearColor(red, green, blue, alpha);
-    };
-    WebGLRenderingContext.prototype.clearDepth = function (depth) {
+    }
+    clearDepth(depth) {
         this._glCheckError('clearDepth');
         this._checkArgs('clearDepth', arguments);
         this.context.clearDepth(depth);
-    };
-    WebGLRenderingContext.prototype.clearStencil = function (stencil) {
+    }
+    clearStencil(stencil) {
         this._glCheckError('clearStencil');
         this._checkArgs('clearStencil', arguments);
         this.context.clearStencil(stencil);
-    };
-    WebGLRenderingContext.prototype.clear = function (mask) {
+    }
+    clear(mask) {
         this._glCheckError('clear');
         this._checkArgs('clear', arguments);
         this.context.clear(mask);
         this._glCheckError('after clear');
-    };
-    WebGLRenderingContext.prototype.colorMask = function (red, green, blue, alpha) {
+    }
+    colorMask(red, green, blue, alpha) {
         this._glCheckError('colorMask');
         this._checkArgs('colorMask', arguments);
         this.context.colorMask(red, green, blue, alpha);
-    };
-    WebGLRenderingContext.prototype.commit = function () {
+    }
+    commit() {
         // NOOP
         this.context.commit();
-    };
-    WebGLRenderingContext.prototype.compileShader = function (shader) {
+    }
+    compileShader(shader) {
         this._glCheckError('compileShader');
         this._checkArgs('compileShader', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         this.context.compileShader(value);
-    };
-    WebGLRenderingContext.prototype.compressedTexImage2D = function (target, level, internalformat, width, height, border, pixels) {
+    }
+    compressedTexImage2D(target, level, internalformat, width, height, border, pixels) {
         this._glCheckError('compressedTexImage2D');
         this._checkArgs('compressedTexImage2D', arguments);
         if ((pixels && pixels.buffer instanceof ArrayBuffer) || pixels instanceof ArrayBuffer) {
@@ -240,326 +171,326 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
         else {
             this.context.compressedTexImage2D(target, level, internalformat, width, height, border, pixels);
         }
-    };
-    WebGLRenderingContext.prototype.compressedTexSubImage2D = function (target, level, xoffset, yoffset, width, height, format, pixels) {
+    }
+    compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, pixels) {
         this._glCheckError('compressedTexSubImage2D');
         this._checkArgs('compressedTexSubImage2D', arguments);
         if ((pixels && pixels.buffer instanceof ArrayBuffer) || pixels instanceof ArrayBuffer) {
             this.context.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, NSData.dataWithData(pixels));
         }
-    };
-    WebGLRenderingContext.prototype.copyTexImage2D = function (target, level, internalformat, x, y, width, height, border) {
+    }
+    copyTexImage2D(target, level, internalformat, x, y, width, height, border) {
         this._glCheckError('copyTexImage2D');
         this._checkArgs('copyTexImage2D', arguments);
         this.context.copyTexImage2D(target, level, internalformat, x, y, width, height, border);
-    };
-    WebGLRenderingContext.prototype.copyTexSubImage2D = function (target, level, xoffset, yoffset, x, y, width, height) {
+    }
+    copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) {
         this._glCheckError('copyTexSubImage2D');
         this._checkArgs('copyTexSubImage2D', arguments);
         this.context.copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-    };
-    WebGLRenderingContext.prototype.createBuffer = function () {
+    }
+    createBuffer() {
         this._glCheckError('createBuffer');
         this._checkArgs('createBuffer', arguments);
-        var id = this.context.createBuffer();
-        return new WebGLBuffer_1.WebGLBuffer(id);
-    };
-    WebGLRenderingContext.prototype.createFramebuffer = function () {
+        const id = this.context.createBuffer();
+        return new WebGLBuffer(id);
+    }
+    createFramebuffer() {
         this._glCheckError('createFramebuffer');
         this._checkArgs('createFramebuffer', arguments);
-        return new WebGLFramebuffer_1.WebGLFramebuffer(this.context.createFramebuffer());
-    };
-    WebGLRenderingContext.prototype.createProgram = function () {
+        return new WebGLFramebuffer(this.context.createFramebuffer());
+    }
+    createProgram() {
         this._glCheckError('createProgram');
         this._checkArgs('createProgram', arguments);
-        return new WebGLProgram_1.WebGLProgram(this.context.createProgram());
-    };
-    WebGLRenderingContext.prototype.createRenderbuffer = function () {
+        return new WebGLProgram(this.context.createProgram());
+    }
+    createRenderbuffer() {
         this._glCheckError('createRenderbuffer');
         this._checkArgs('createRenderbuffer', arguments);
-        return new WebGLRenderbuffer_1.WebGLRenderbuffer(this.context.createRenderbuffer());
-    };
-    WebGLRenderingContext.prototype.createShader = function (type) {
+        return new WebGLRenderbuffer(this.context.createRenderbuffer());
+    }
+    createShader(type) {
         this._glCheckError('createShader');
         this._checkArgs('createShader', arguments);
-        return new WebGLShader_1.WebGLShader(this.context.createShader(type));
-    };
-    WebGLRenderingContext.prototype.createTexture = function () {
+        return new WebGLShader(this.context.createShader(type));
+    }
+    createTexture() {
         this._glCheckError('createTexture');
         this._checkArgs('createTexture', arguments);
-        var id = this.context.createTexture();
-        return new WebGLTexture_1.WebGLTexture(id);
-    };
-    WebGLRenderingContext.prototype.cullFace = function (mode) {
+        const id = this.context.createTexture();
+        return new WebGLTexture(id);
+    }
+    cullFace(mode) {
         this._glCheckError('cullFace');
         this._checkArgs('cullFace', arguments);
         this.context.cullFace(mode);
-    };
-    WebGLRenderingContext.prototype.deleteBuffer = function (buffer) {
+    }
+    deleteBuffer(buffer) {
         this._glCheckError('deleteBuffer');
         this._checkArgs('deleteBuffer', arguments);
-        var value = buffer ? buffer.native : 0;
+        const value = buffer ? buffer.native : 0;
         this.context.deleteBuffer(value);
-    };
-    WebGLRenderingContext.prototype.deleteFramebuffer = function (frameBuffer) {
+    }
+    deleteFramebuffer(frameBuffer) {
         this._glCheckError('deleteFramebuffer');
         this._checkArgs('deleteFramebuffer', arguments);
-        var value = frameBuffer ? frameBuffer.native : 0;
+        const value = frameBuffer ? frameBuffer.native : 0;
         this.context.deleteFramebuffer(value);
-    };
-    WebGLRenderingContext.prototype.deleteProgram = function (program) {
+    }
+    deleteProgram(program) {
         this._glCheckError('deleteProgram');
         this._checkArgs('deleteProgram', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         this.context.deleteProgram(value);
-    };
-    WebGLRenderingContext.prototype.deleteRenderbuffer = function (renderBuffer) {
+    }
+    deleteRenderbuffer(renderBuffer) {
         this._glCheckError('deleteRenderbuffer');
         this._checkArgs('deleteRenderbuffer', arguments);
-        var value = renderBuffer ? renderBuffer.native : 0;
+        const value = renderBuffer ? renderBuffer.native : 0;
         this.context.deleteRenderbuffer(value);
-    };
-    WebGLRenderingContext.prototype.deleteShader = function (shader) {
+    }
+    deleteShader(shader) {
         this._glCheckError('deleteShader');
         this._checkArgs('deleteShader', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         this.context.deleteShader(value);
-    };
-    WebGLRenderingContext.prototype.deleteTexture = function (texture) {
+    }
+    deleteTexture(texture) {
         this._glCheckError('deleteTexture');
         this._checkArgs('deleteTexture', arguments);
-        var value = texture ? texture.native : 0;
+        const value = texture ? texture.native : 0;
         this.context.deleteTexture(value);
-    };
-    WebGLRenderingContext.prototype.depthFunc = function (func) {
+    }
+    depthFunc(func) {
         this._glCheckError('depthFunc');
         this._checkArgs('depthFunc', arguments);
         this.context.depthFunc(func);
-    };
-    WebGLRenderingContext.prototype.depthMask = function (flag) {
+    }
+    depthMask(flag) {
         this._glCheckError('depthMask');
         this._checkArgs('depthMask', arguments);
         this.context.depthMask(flag);
-    };
-    WebGLRenderingContext.prototype.depthRange = function (zNear, zFar) {
+    }
+    depthRange(zNear, zFar) {
         this._glCheckError('depthRange');
         this._checkArgs('depthRange', arguments);
         this.context.depthRange(zNear, zFar);
-    };
-    WebGLRenderingContext.prototype.detachShader = function (program, shader) {
+    }
+    detachShader(program, shader) {
         this._glCheckError('detachShader');
         this._checkArgs('detachShader', arguments);
-        var value = program ? program.native : 0;
-        var value2 = shader ? shader.native : 0;
+        const value = program ? program.native : 0;
+        const value2 = shader ? shader.native : 0;
         this.context.detachShader(value, value2);
-    };
-    WebGLRenderingContext.prototype.disableVertexAttribArray = function (index) {
+    }
+    disableVertexAttribArray(index) {
         this._checkArgs('disableVertexAttribArray', arguments);
         this._glCheckError('disableVertexAttribArray');
         this.context.disableVertexAttribArray(index);
-    };
-    WebGLRenderingContext.prototype.disable = function (cap) {
+    }
+    disable(cap) {
         this._glCheckError('disable');
         this._checkArgs('disable', arguments);
         this.context.disable(cap);
-    };
-    WebGLRenderingContext.prototype.drawArrays = function (mode, first, count) {
+    }
+    drawArrays(mode, first, count) {
         this._glCheckError('drawArrays');
         this._checkArgs('drawArrays', arguments);
         this.context.drawArrays(mode, first, count);
-    };
-    WebGLRenderingContext.prototype.drawElements = function (mode, count, type, offset) {
+    }
+    drawElements(mode, count, type, offset) {
         this._glCheckError('drawElements');
         this._checkArgs('drawElements', arguments);
         this.context.drawElements(mode, count, type, offset);
-    };
-    WebGLRenderingContext.prototype.enableVertexAttribArray = function (index) {
+    }
+    enableVertexAttribArray(index) {
         this._glCheckError('enableVertexAttribArray');
         this._checkArgs('enableVertexAttribArray', arguments);
         this.context.enableVertexAttribArray(index);
-    };
-    WebGLRenderingContext.prototype.enable = function (cap) {
+    }
+    enable(cap) {
         this._glCheckError('enable');
         this._checkArgs('enable', arguments);
         this.context.enable(cap);
-    };
-    WebGLRenderingContext.prototype.finish = function () {
+    }
+    finish() {
         this._glCheckError('finish');
         this._checkArgs('finish', arguments);
         this.context.finish();
-    };
-    WebGLRenderingContext.prototype.flush = function () {
+    }
+    flush() {
         this._glCheckError('flush');
         this._checkArgs('flush', arguments);
         this.context.flush();
-    };
-    WebGLRenderingContext.prototype.framebufferRenderbuffer = function (target, attachment, renderbuffertarget, renderbuffer) {
+    }
+    framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) {
         this._glCheckError('framebufferRenderbuffer');
         this._checkArgs('framebufferRenderbuffer', arguments);
-        var value = renderbuffer ? renderbuffer.native : 0;
+        const value = renderbuffer ? renderbuffer.native : 0;
         this.context.framebufferRenderbuffer(target, attachment, renderbuffertarget, value);
-    };
-    WebGLRenderingContext.prototype.framebufferTexture2D = function (target, attachment, textarget, texture, level) {
+    }
+    framebufferTexture2D(target, attachment, textarget, texture, level) {
         this._glCheckError('framebufferTexture2D');
         this._checkArgs('framebufferTexture2D', arguments);
-        var value = texture ? texture.native : 0;
+        const value = texture ? texture.native : 0;
         this.context.framebufferTexture2D(target, attachment, textarget, value, level);
-    };
-    WebGLRenderingContext.prototype.frontFace = function (mode) {
+    }
+    frontFace(mode) {
         this._glCheckError('frontFace');
         this._checkArgs('frontFace', arguments);
         this.context.frontFace(mode);
-    };
-    WebGLRenderingContext.prototype.generateMipmap = function (target) {
+    }
+    generateMipmap(target) {
         this._glCheckError('generateMipmap');
         this._checkArgs('generateMipmap', arguments);
         this.context.generateMipmap(target);
-    };
-    WebGLRenderingContext.prototype.getActiveAttrib = function (program, index) {
+    }
+    getActiveAttrib(program, index) {
         this._glCheckError('getActiveAttrib');
         this._checkArgs('getActiveAttrib', arguments);
-        var value = program ? program.native : 0;
-        var attrib = this.context.getActiveAttrib(value, index);
-        return new WebGLActiveInfo_1.WebGLActiveInfo(attrib.name, attrib.size, attrib.type);
-    };
-    WebGLRenderingContext.prototype.getActiveUniform = function (program, index) {
+        const value = program ? program.native : 0;
+        const attrib = this.context.getActiveAttrib(value, index);
+        return new WebGLActiveInfo(attrib.name, attrib.size, attrib.type);
+    }
+    getActiveUniform(program, index) {
         this._glCheckError('getActiveUniform');
         this._checkArgs('getActiveUniform', arguments);
-        var value = program ? program.native : 0;
-        var uniform = this.context.getActiveUniform(value, index);
-        return new WebGLActiveInfo_1.WebGLActiveInfo(uniform.name, uniform.size, uniform.type);
-    };
-    WebGLRenderingContext.prototype.getAttachedShaders = function (program) {
+        const value = program ? program.native : 0;
+        const uniform = this.context.getActiveUniform(value, index);
+        return new WebGLActiveInfo(uniform.name, uniform.size, uniform.type);
+    }
+    getAttachedShaders(program) {
         this._glCheckError('getAttachedShaders');
         this._checkArgs('getAttachedShaders', arguments);
-        var value = program ? program.native : 0;
-        var shaders = this.context.getAttachedShaders(value);
-        var length = shaders.count;
-        var attachedShaders = [];
-        for (var i = 0; i < length; i++) {
-            attachedShaders.push(new WebGLShader_1.WebGLShader(shaders.objectAtIndex(i)));
+        const value = program ? program.native : 0;
+        const shaders = this.context.getAttachedShaders(value);
+        const length = shaders.count;
+        const attachedShaders = [];
+        for (let i = 0; i < length; i++) {
+            attachedShaders.push(new WebGLShader(shaders.objectAtIndex(i)));
         }
         return attachedShaders;
-    };
-    WebGLRenderingContext.prototype.getAttribLocation = function (program, name) {
+    }
+    getAttribLocation(program, name) {
         this._glCheckError('getAttribLocation');
         this._checkArgs('getAttribLocation', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         return this.context.getAttribLocation(value, name);
-    };
-    WebGLRenderingContext.prototype.getBufferParameter = function (target, pname) {
+    }
+    getBufferParameter(target, pname) {
         this._glCheckError('getBufferParameter');
         this._checkArgs('getBufferParameter', arguments);
         return this.context.getBufferParameter(target, pname);
-    };
-    WebGLRenderingContext.prototype.getContextAttributes = function () {
+    }
+    getContextAttributes() {
         this._glCheckError('getContextAttributes');
         this._checkArgs('getContextAttributes', arguments);
-        var attributes = this.context.getContextAttributes();
+        const attributes = this.context.getContextAttributes();
         if (!attributes) {
             return null;
         }
-        var keys = attributes.allKeys;
-        var length = keys.count;
-        var contextAttributes = {};
-        for (var i = 0; i < length; i++) {
-            var key = keys.objectAtIndex(i);
+        const keys = attributes.allKeys;
+        const length = keys.count;
+        const contextAttributes = {};
+        for (let i = 0; i < length; i++) {
+            const key = keys.objectAtIndex(i);
             contextAttributes[key] = attributes.objectForKey(key);
         }
         contextAttributes['stencil'] = true;
         return contextAttributes;
-    };
-    WebGLRenderingContext.prototype.getError = function () {
+    }
+    getError() {
         return this.context.getError();
-    };
-    WebGLRenderingContext.prototype.getExtension = function (name) {
+    }
+    getExtension(name) {
         this._checkArgs('getExtension', arguments);
         this._glCheckError('getExtension');
-        var ext = this.context.getExtension(name);
+        const ext = this.context.getExtension(name);
         if (ext instanceof TNS_ANGLE_instanced_arrays) {
-            return new WebGLExtensions_1.ANGLE_instanced_arrays(ext);
+            return new ANGLE_instanced_arrays(ext);
         }
         else if (ext instanceof TNS_EXT_blend_minmax) {
-            return new WebGLExtensions_1.EXT_blend_minmax(ext);
+            return new EXT_blend_minmax(ext);
         }
         else if (ext instanceof TNS_EXT_color_buffer_float) {
-            return new WebGLExtensions_1.EXT_color_buffer_float(ext);
+            return new EXT_color_buffer_float(ext);
         }
         else if (ext instanceof TNS_EXT_color_buffer_half_float) {
-            return new WebGLExtensions_1.EXT_color_buffer_half_float(ext);
+            return new EXT_color_buffer_half_float(ext);
         }
         else if (ext instanceof TNS_EXT_sRGB) {
-            return new WebGLExtensions_1.EXT_sRGB(ext);
+            return new EXT_sRGB(ext);
         }
         else if (ext instanceof TNS_EXT_shader_texture_lod) {
-            return new WebGLExtensions_1.EXT_shader_texture_lod(ext);
+            return new EXT_shader_texture_lod(ext);
         }
         else if (ext instanceof TNS_EXT_texture_filter_anisotropic) {
-            return new WebGLExtensions_1.EXT_texture_filter_anisotropic(ext);
+            return new EXT_texture_filter_anisotropic(ext);
         }
         else if (ext instanceof TNS_OES_element_index_uint) {
-            return new WebGLExtensions_1.OES_element_index_uint(ext);
+            return new OES_element_index_uint(ext);
         }
         else if (ext instanceof TNS_OES_fbo_render_mipmap) {
-            return new WebGLExtensions_1.OES_fbo_render_mipmap(ext);
+            return new OES_fbo_render_mipmap(ext);
         }
         else if (ext instanceof TNS_OES_standard_derivatives) {
-            return new WebGLExtensions_1.OES_standard_derivatives(ext);
+            return new OES_standard_derivatives(ext);
         }
         else if (ext instanceof TNS_OES_texture_float) {
-            return new WebGLExtensions_1.OES_texture_float(ext);
+            return new OES_texture_float(ext);
         }
         else if (ext instanceof TNS_OES_texture_float_linear) {
-            return new WebGLExtensions_1.OES_texture_float_linear(ext);
+            return new OES_texture_float_linear(ext);
         }
         else if (ext instanceof TNS_OES_texture_half_float) {
-            return new WebGLExtensions_1.OES_texture_half_float(ext);
+            return new OES_texture_half_float(ext);
         }
         else if (ext instanceof TNS_OES_texture_half_float_linear) {
-            return new WebGLExtensions_1.OES_texture_half_float_linear(ext);
+            return new OES_texture_half_float_linear(ext);
         }
         else if (ext instanceof TNS_OES_vertex_array_object) {
-            return new WebGLExtensions_1.OES_vertex_array_object(ext);
+            return new OES_vertex_array_object(ext);
         }
         else if (ext instanceof TNS_WEBGL_color_buffer_float) {
-            return new WebGLExtensions_1.WEBGL_color_buffer_float(ext);
+            return new WEBGL_color_buffer_float(ext);
         }
         else if (ext instanceof TNS_WEBGL_compressed_texture_etc) {
-            return new WebGLExtensions_1.WEBGL_compressed_texture_etc(ext);
+            return new WEBGL_compressed_texture_etc(ext);
         }
         else if (ext instanceof TNS_WEBGL_compressed_texture_etc1) {
-            return new WebGLExtensions_1.WEBGL_compressed_texture_etc1(ext);
+            return new WEBGL_compressed_texture_etc1(ext);
         }
         else if (ext instanceof TNS_WEBGL_compressed_texture_pvrtc) {
-            return new WebGLExtensions_1.WEBGL_compressed_texture_pvrtc(ext);
+            return new WEBGL_compressed_texture_pvrtc(ext);
         }
         else if (ext instanceof TNS_WEBGL_depth_texture) {
-            return new WebGLExtensions_1.WEBGL_depth_texture(ext);
+            return new WEBGL_depth_texture(ext);
         }
         else if (ext instanceof TNS_WEBGL_lose_context) {
-            return new WebGLExtensions_1.WEBGL_lose_context(ext);
+            return new WEBGL_lose_context(ext);
         }
         else if (ext instanceof TNS_WEBGL_draw_buffers) {
-            return new WebGLExtensions_1.WEBGL_draw_buffers(ext);
+            return new WEBGL_draw_buffers(ext);
         }
         return null;
-    };
-    WebGLRenderingContext.prototype.getFramebufferAttachmentParameter = function (target, attachment, pname) {
+    }
+    getFramebufferAttachmentParameter(target, attachment, pname) {
         this._glCheckError('getFramebufferAttachmentParameter');
         this._checkArgs('getFramebufferAttachmentParameter', arguments);
-        var param = this.context.getFramebufferAttachmentParameter(target, attachment, pname);
+        const param = this.context.getFramebufferAttachmentParameter(target, attachment, pname);
         if (param.isRenderbuffer) {
-            return new WebGLRenderbuffer_1.WebGLRenderbuffer(param.value);
+            return new WebGLRenderbuffer(param.value);
         }
         else if (param.isTexture) {
-            return new WebGLTexture_1.WebGLTexture(param.value);
+            return new WebGLTexture(param.value);
         }
         return param.value;
-    };
-    WebGLRenderingContext.prototype.getParameter = function (pname) {
+    }
+    getParameter(pname) {
         this._glCheckError('getParameter');
         this._checkArgs('getParameter', arguments);
-        var value = this.context.getParameter(pname);
+        const value = this.context.getParameter(pname);
         switch (pname) {
             case this.COLOR_WRITEMASK:
             case this.COLOR_CLEAR_VALUE:
@@ -567,122 +498,131 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
             case this.ALIASED_LINE_WIDTH_RANGE:
             case this.ALIASED_POINT_SIZE_RANGE:
             case this.DEPTH_RANGE:
-                return new Float32Array(utils_1.Utils.toJSArray(value));
+                return new Float32Array(Utils.toJSArray(value));
             case this.ARRAY_BUFFER_BINDING:
             case this.ELEMENT_ARRAY_BUFFER_BINDING:
-                return new WebGLBuffer_1.WebGLBuffer(value);
+                if (value) {
+                    return new WebGLBuffer(value);
+                }
+                return null;
             case this.CURRENT_PROGRAM:
-                return new WebGLProgram_1.WebGLProgram(value);
+                if (value) {
+                    return new WebGLProgram(value);
+                }
+                return null;
             case this.COMPRESSED_TEXTURE_FORMATS:
-                return new Uint32Array(utils_1.Utils.toJSArray(value));
+                return new Uint32Array(Utils.toJSArray(value));
             case this.RENDERBUFFER_BINDING:
-                return new WebGLRenderbuffer_1.WebGLRenderbuffer(value);
+                if (value) {
+                    return new WebGLRenderbuffer(value);
+                }
+                return null;
             case this.FRAMEBUFFER_BINDING:
                 if (value) {
-                    return new WebGLFramebuffer_1.WebGLFramebuffer(value);
+                    return new WebGLFramebuffer(value);
                 }
                 return null;
             case this.VIEWPORT:
             case this.SCISSOR_BOX:
             case this.MAX_VIEWPORT_DIMS:
-                return new Int32Array(utils_1.Utils.toJSArray(value));
+                return new Int32Array(Utils.toJSArray(value));
             case this.TEXTURE_BINDING_CUBE_MAP:
             case this.TEXTURE_BINDING_2D:
                 if (value) {
-                    return new WebGLTexture_1.WebGLTexture(value);
+                    return new WebGLTexture(value);
                 }
                 return null;
             case this.VERSION:
-                var isMetal = false;
+                let isMetal = false;
                 if (this._canvas && this._canvas.useMetal) {
                     isMetal = true;
                 }
                 if (this._type === 'webgl2') {
-                    return "WebGL 2.0 (" + (isMetal ? 'Metal' : 'OpenGL ES 3.0') + " NativeScript)";
+                    return `WebGL 2.0 (${isMetal ? 'Metal' : 'OpenGL ES 3.0'} NativeScript)`;
                 }
                 else {
-                    return "WebGL 1.0 (" + (isMetal ? 'Metal' : 'OpenGL ES 3.0') + " NativeScript)";
+                    return `WebGL 1.0 (${isMetal ? 'Metal' : 'OpenGL ES 3.0'} NativeScript)`;
                 }
             default:
                 return value;
         }
-    };
-    WebGLRenderingContext.prototype.getProgramInfoLog = function (program) {
+    }
+    getProgramInfoLog(program) {
         this._glCheckError('getProgramInfoLog');
         this._checkArgs('getProgramInfoLog', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         return this.context.getProgramInfoLog(value);
-    };
-    WebGLRenderingContext.prototype.getProgramParameter = function (program, pname) {
+    }
+    getProgramParameter(program, pname) {
         this._glCheckError('getProgramParameter');
         this._checkArgs('getProgramParameter', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         return this.context.getProgramParameter(value, pname);
-    };
-    WebGLRenderingContext.prototype.getRenderbufferParameter = function (target, pname) {
+    }
+    getRenderbufferParameter(target, pname) {
         this._glCheckError('getRenderbufferParameter');
         this._checkArgs('getRenderbufferParameter', arguments);
         return this.context.getRenderbufferParameter(target, pname);
-    };
-    WebGLRenderingContext.prototype.getShaderInfoLog = function (shader) {
+    }
+    getShaderInfoLog(shader) {
         this._glCheckError('getShaderInfoLog');
         this._checkArgs('getShaderInfoLog', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         return this.context.getShaderInfoLog(value);
-    };
-    WebGLRenderingContext.prototype.getShaderParameter = function (shader, pname) {
+    }
+    getShaderParameter(shader, pname) {
         this._glCheckError('getShaderParameter');
         this._checkArgs('getShaderParameter', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         return this.context.getShaderParameter(value, pname);
-    };
-    WebGLRenderingContext.prototype.getShaderPrecisionFormat = function (shaderType, precisionType) {
+    }
+    getShaderPrecisionFormat(shaderType, precisionType) {
         this._glCheckError('getShaderPrecisionFormat');
         this._checkArgs('getShaderPrecisionFormat', arguments);
-        var precision = this.context.getShaderPrecisionFormat(shaderType, precisionType);
-        return new WebGLShaderPrecisionFormat_1.WebGLShaderPrecisionFormat(precision.rangeMin, precision.rangeMax, precision.precision);
-    };
-    WebGLRenderingContext.prototype.getShaderSource = function (shader) {
+        const precision = this.context.getShaderPrecisionFormat(shaderType, precisionType);
+        return new WebGLShaderPrecisionFormat(precision.rangeMin, precision.rangeMax, precision.precision);
+    }
+    getShaderSource(shader) {
         this._glCheckError('getShaderSource');
         this._checkArgs('getShaderSource', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         return this.context.getShaderSource(value);
-    };
-    WebGLRenderingContext.prototype.getSupportedExtensions = function () {
+    }
+    getSupportedExtensions() {
         this._glCheckError('getSupportedExtensions');
         this._checkArgs('getSupportedExtensions', arguments);
-        var extensions = this.context.getSupportedExtensions();
-        var array = [];
-        var length = extensions.count;
-        for (var i = 0; i < length; i++) {
+        const extensions = this.context.getSupportedExtensions();
+        const array = [];
+        const length = extensions.count;
+        for (let i = 0; i < length; i++) {
             array.push(extensions.objectAtIndex(i));
         }
         return array;
-    };
-    WebGLRenderingContext.prototype.getTexParameter = function (target, pname) {
+    }
+    getTexParameter(target, pname) {
         this._glCheckError('getTexParameter');
         this._checkArgs('getTexParameter', arguments);
         return this.context.getTexParameter(target, pname);
-    };
-    WebGLRenderingContext.prototype.getUniformLocation = function (program, name) {
+    }
+    getUniformLocation(program, name) {
         this._glCheckError('getUniformLocation');
         this._checkArgs('getUniformLocation', arguments);
-        var value = program ? program.native : 0;
-        var id = this.context.getUniformLocation(value, name);
+        const value = program ? program.native : 0;
+        const id = this.context.getUniformLocation(value, name);
         if (id === -1) {
             return null;
         }
-        return new WebGLUniformLocation_1.WebGLUniformLocation(id);
-    };
-    WebGLRenderingContext.prototype.getUniform = function (program, location) {
+        return new WebGLUniformLocation(id);
+    }
+    getUniform(program, location) {
         this._glCheckError('getUniform');
         this._checkArgs('getUniform', arguments);
-        var value = program ? program.native : 0;
-        var value2 = location ? location.native : 0;
-        var type = interop.alloc(interop.sizeof(interop.types.uint32));
+        const value = program ? program.native : 0;
+        const value2 = location ? location.native : 0;
+        const type = interop.alloc(interop.sizeof(interop.types.uint32));
         glGetActiveUniform(value, value2, 0, null, null, type, null);
-        var result = this.context.getUniform(value, value2);
-        var ref = new interop.Reference(interop.types.uint32, type);
+        const result = this.context.getUniform(value, value2);
+        const ref = new interop.Reference(interop.types.uint32, type);
         switch (ref.value) {
             case this.FLOAT_VEC2:
             case this.FLOAT_VEC3:
@@ -690,96 +630,96 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
             case this.FLOAT_MAT2:
             case this.FLOAT_MAT3:
             case this.FLOAT_MAT4:
-                return new Float32Array(utils_1.Utils.toJSArray(result));
+                return new Float32Array(Utils.toJSArray(result));
             case this.INT_VEC2:
             case this.INT_VEC3:
             case this.INT_VEC4:
-                return new Int32Array(utils_1.Utils.toJSArray(result));
+                return new Int32Array(Utils.toJSArray(result));
             default:
                 break;
         }
         if (result instanceof NSArray || Array.isArray(result)) {
-            return utils_1.Utils.toJSArray(result);
+            return Utils.toJSArray(result);
         }
         return result;
-    };
-    WebGLRenderingContext.prototype.getVertexAttribOffset = function (index, pname) {
+    }
+    getVertexAttribOffset(index, pname) {
         this._glCheckError('getVertexAttribOffset');
         this._checkArgs('getVertexAttribOffset', arguments);
         return this.context.getVertexAttribOffset(index, pname);
-    };
-    WebGLRenderingContext.prototype.getVertexAttrib = function (index, pname) {
+    }
+    getVertexAttrib(index, pname) {
         this._glCheckError('getVertexAttrib');
         this._checkArgs('getVertexAttrib', arguments);
-        var value = this.context.getVertexAttrib(index, pname);
+        const value = this.context.getVertexAttrib(index, pname);
         if (pname === this.CURRENT_VERTEX_ATTRIB) {
-            return new Float32Array(utils_1.Utils.toJSArray(value));
+            return new Float32Array(Utils.toJSArray(value));
         }
         return value;
-    };
-    WebGLRenderingContext.prototype.hint = function (target, mode) {
+    }
+    hint(target, mode) {
         this._glCheckError('hint');
         this._checkArgs('hint', arguments);
         this.context.hint(target, mode);
-    };
-    WebGLRenderingContext.prototype.isBuffer = function (buffer) {
+    }
+    isBuffer(buffer) {
         this._glCheckError('isBuffer');
         this._checkArgs('isBuffer', arguments);
-        var value = buffer ? buffer.native : 0;
+        const value = buffer ? buffer.native : 0;
         return this.context.isBuffer(value);
-    };
-    WebGLRenderingContext.prototype.isContextLost = function () {
+    }
+    isContextLost() {
         this._glCheckError('isContextLost');
         this._checkArgs('isContextLost', arguments);
         return this.context.isContextLost();
-    };
-    WebGLRenderingContext.prototype.isEnabled = function (cap) {
+    }
+    isEnabled(cap) {
         this._glCheckError('isEnabled');
         this._checkArgs('isEnabled', arguments);
         return this.context.isEnabled(cap);
-    };
-    WebGLRenderingContext.prototype.isFramebuffer = function (framebuffer) {
+    }
+    isFramebuffer(framebuffer) {
         this._glCheckError('isFramebuffer');
         this._checkArgs('isFramebuffer', arguments);
-        var value = framebuffer ? framebuffer.native : 0;
+        const value = framebuffer ? framebuffer.native : 0;
         return this.context.isFramebuffer(value);
-    };
-    WebGLRenderingContext.prototype.isProgram = function (program) {
+    }
+    isProgram(program) {
         this._glCheckError('isProgram');
         this._checkArgs('isProgram', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         return this.context.isProgram(value);
-    };
-    WebGLRenderingContext.prototype.isRenderbuffer = function (renderbuffer) {
+    }
+    isRenderbuffer(renderbuffer) {
         this._glCheckError('isRenderbuffer');
         this._checkArgs('isRenderbuffer', arguments);
-        var value = renderbuffer ? renderbuffer.native : 0;
+        const value = renderbuffer ? renderbuffer.native : 0;
         return this.context.isRenderbuffer(value);
-    };
-    WebGLRenderingContext.prototype.isShader = function (shader) {
+    }
+    isShader(shader) {
         this._glCheckError('isShader');
         this._checkArgs('isShader', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         return this.context.isShader(value);
-    };
-    WebGLRenderingContext.prototype.isTexture = function (texture) {
+    }
+    isTexture(texture) {
         this._glCheckError('isTexture');
         this._checkArgs('isTexture', arguments);
-        var value = texture ? texture.native : 0;
+        const value = texture ? texture.native : 0;
         return this.context.isTexture(value);
-    };
-    WebGLRenderingContext.prototype.lineWidth = function (width) {
+    }
+    lineWidth(width) {
         this._glCheckError('lineWidth');
         this._checkArgs('lineWidth', arguments);
         this.context.lineWidth(width);
-    };
-    WebGLRenderingContext.prototype.linkProgram = function (program) {
+    }
+    linkProgram(program) {
         this._glCheckError('linkProgram');
         this._checkArgs('linkProgram', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         this.context.linkProgram(value);
-    };
-    WebGLRenderingContext.prototype.pixelStorei = function (pname, param) {
+    }
+    pixelStorei(pname, param) {
         this._glCheckError('pixelStorei');
         this._checkArgs('pixelStorei', arguments);
         // this.context.pixelStoreiWithPnameParam(pname, param);
@@ -798,20 +738,23 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
         else {
             this.context.pixelStorei(pname, param);
         }
-    };
-    WebGLRenderingContext.prototype.polygonOffset = function (factor, units) {
+    }
+    polygonOffset(factor, units) {
         this._glCheckError('polygonOffset');
         this._checkArgs('polygonOffset', arguments);
         this.context.polygonOffset(factor, units);
-    };
-    WebGLRenderingContext.prototype.readPixels = function (x, y, width, height, format, type, pixels) {
+    }
+    readPixels(x, y, width, height, format, type, pixels) {
         this._glCheckError('readPixels');
         this._checkArgs('readPixels', arguments);
-        if ((pixels && pixels.buffer instanceof ArrayBuffer) || pixels instanceof ArrayBuffer) {
-            this.context.readPixels(x, y, width, height, format, type, NSData.dataWithData(pixels));
+        if (Utils.isTypedArray(pixels)) {
+            this.context.readPixelsOffset(x, y, width, height, format, type, pixels, pixels.byteOffset);
+        }
+        else if (pixels instanceof ArrayBuffer) {
+            this.context.readPixels(x, y, width, height, format, type, pixels);
         }
-    };
-    WebGLRenderingContext.prototype.renderbufferStorage = function (target, internalFormat, width, height) {
+    }
+    renderbufferStorage(target, internalFormat, width, height) {
         this._glCheckError('renderbufferStorage');
         this._checkArgs('renderbufferStorage', arguments);
         if (internalFormat === this.DEPTH_STENCIL) {
@@ -821,54 +764,54 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
             internalFormat = 0x88f0;
         }
         this.context.renderbufferStorage(target, internalFormat, width, height);
-    };
-    WebGLRenderingContext.prototype.sampleCoverage = function (value, invert) {
+    }
+    sampleCoverage(value, invert) {
         this._glCheckError('sampleCoverage');
         this._checkArgs('sampleCoverage', arguments);
         this.context.sampleCoverage(value, invert);
-    };
-    WebGLRenderingContext.prototype.scissor = function (x, y, width, height) {
+    }
+    scissor(x, y, width, height) {
         this._glCheckError('scissor');
         this._checkArgs('scissor', arguments);
         this.context.scissor(x, y, width, height);
-    };
-    WebGLRenderingContext.prototype.shaderSource = function (shader, source) {
+    }
+    shaderSource(shader, source) {
         this._glCheckError('shaderSource');
         this._checkArgs('shaderSource', arguments);
-        var value = shader ? shader.native : 0;
+        const value = shader ? shader.native : 0;
         this.context.shaderSource(value, source);
-    };
-    WebGLRenderingContext.prototype.stencilFuncSeparate = function (face, func, ref, mask) {
+    }
+    stencilFuncSeparate(face, func, ref, mask) {
         this._glCheckError('stencilFuncSeparate');
         this._checkArgs('stencilFuncSeparate', arguments);
         this.context.stencilFuncSeparate(face, func, ref, mask);
-    };
-    WebGLRenderingContext.prototype.stencilFunc = function (func, ref, mask) {
+    }
+    stencilFunc(func, ref, mask) {
         this._glCheckError('stencilFunc');
         this._checkArgs('stencilFunc', arguments);
         this.context.stencilFunc(func, ref, mask);
-    };
-    WebGLRenderingContext.prototype.stencilMaskSeparate = function (face, mask) {
+    }
+    stencilMaskSeparate(face, mask) {
         this._glCheckError('stencilMaskSeparate');
         this._checkArgs('stencilMaskSeparate', arguments);
         this.context.stencilMaskSeparate(face, mask);
-    };
-    WebGLRenderingContext.prototype.stencilMask = function (mask) {
+    }
+    stencilMask(mask) {
         this._glCheckError('stencilMask');
         this._checkArgs('stencilMask', arguments);
         this.context.stencilMask(mask);
-    };
-    WebGLRenderingContext.prototype.stencilOpSeparate = function (face, fail, zfail, zpass) {
+    }
+    stencilOpSeparate(face, fail, zfail, zpass) {
         this._glCheckError('stencilOpSeparate');
         this._checkArgs('stencilOpSeparate', arguments);
         this.context.stencilOpSeparate(face, fail, zfail, zpass);
-    };
-    WebGLRenderingContext.prototype.stencilOp = function (fail, zfail, zpass) {
+    }
+    stencilOp(fail, zfail, zpass) {
         this._glCheckError('stencilOp');
         this._checkArgs('stencilOp', arguments);
         this.context.stencilOp(fail, zfail, zpass);
-    };
-    WebGLRenderingContext.prototype.texImage2D = function (target, level, internalformat, width, height, border, format, type, pixels) {
+    }
+    texImage2D(target, level, internalformat, width, height, border, format, type, pixels) {
         this._glCheckError('texImage2D');
         this._checkArgs('texImage2D', arguments);
         /* TODO */
@@ -876,60 +819,51 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
         // this.enable(this.BLEND);
         /* TODO */
         if (arguments.length === 9) {
-            if ((pixels && pixels.buffer) || pixels instanceof ArrayBuffer) {
-                if (pixels instanceof ArrayBuffer) {
-                    var array = new Uint8Array(pixels);
-                    this.context.texImage2DU8(target, level, internalformat, width, height, border, format, type, Array.from(array));
-                }
-                else if (pixels instanceof Uint8Array || pixels instanceof Uint8ClampedArray) {
-                    this.context.texImage2DU8(target, level, internalformat, width, height, border, format, type, Array.from(pixels));
-                }
-                else if (pixels instanceof Uint16Array) {
-                    this.context.texImage2DU16(target, level, internalformat, width, height, border, format, type, Array.from(pixels));
-                }
-                else if (pixels instanceof Uint32Array) {
-                    this.context.texImage2DU32(target, level, internalformat, width, height, border, format, type, Array.from(pixels));
-                }
-                else if (pixels instanceof Float32Array) {
-                    this.context.texImage2DF32(target, level, internalformat, width, height, border, format, type, Array.from(pixels));
-                }
+            if (pixels instanceof ArrayBuffer) {
+                this.context.texImage2DPixelsSize(target, level, internalformat, width, height, border, format, type, pixels, pixels.byteLength);
+            }
+            else if (Utils.isTypedArray(pixels)) {
+                this.context.texImage2DPixelsSizeOffset(target, level, internalformat, width, height, border, format, type, pixels, pixels.byteLength, pixels.byteOffset);
             }
             else {
                 this.context.texImage2D(target, level, internalformat, width, height, border, format, type, pixels);
             }
         }
         else if (arguments.length === 6) {
-            if (border && typeof border.tagName === 'string' && (border.tagName === 'VID' || border.tagName === 'VIDEO') && typeof border._video && typeof border._video.getCurrentFrame === 'function') {
+            if (border && typeof border.tagName === 'string' && (border.tagName === 'VID' || border.tagName === 'VIDEO') && border._video && typeof border._video.getCurrentFrame === 'function') {
                 border._video.getCurrentFrame(this.context, this, target, level, internalformat, width, height);
             }
             else if (border && typeof border.getCurrentFrame === 'function') {
                 border.getCurrentFrame(this.context, this, target, level, internalformat, width, height);
             }
-            else if (border instanceof ImageAsset_1.ImageAsset) {
+            else if (border instanceof ImageAsset) {
                 this.context.texImage2DAsset(target, level, internalformat, width, height, border.native);
             }
-            else if (border instanceof core_1.ImageSource) {
+            else if (border instanceof ImageBitmap || (border === null || border === void 0 ? void 0 : border.native) instanceof TNSImageBitmap) {
+                this.context.texImage2DBitmap(target, level, internalformat, width, height, border.native);
+            }
+            else if (border instanceof ImageSource) {
                 this.context.texImage2DPixels(target, level, internalformat, width, height, border.ios);
             }
             else if (border instanceof UIImage) {
                 this.context.texImage2DPixels(target, level, internalformat, width, height, border);
             }
             else if (border && typeof border.tagName === 'string' && (border.tagName === 'IMG' || border.tagName === 'IMAGE')) {
-                if (border._asset instanceof ImageAsset_1.ImageAsset) {
+                if (border._asset instanceof ImageAsset) {
                     this.context.texImage2DAsset(target, level, internalformat, width, height, border._asset.native);
                 }
-                else if (border._imageSource instanceof core_1.ImageSource) {
+                else if (border._imageSource instanceof ImageSource) {
                     this.context.texImage2DPixels(target, level, internalformat, width, height, border._imageSource.ios);
                 }
                 else if (border._image instanceof UIImage) {
                     this.context.texImage2DPixels(target, level, internalformat, width, height, border._image);
                 }
                 else if (typeof border.src === 'string') {
-                    var asset = core_1.ImageSource.fromFileSync(border.src);
+                    const asset = ImageSource.fromFileSync(border.src);
                     this.context.texImage2DPixels(target, level, internalformat, width, height, asset.ios);
                 }
             }
-            else if (border && typeof border.tagName === 'string' && border.tagName === 'CANVAS' && border._canvas instanceof Canvas_1.Canvas) {
+            else if (border && typeof border.tagName === 'string' && border.tagName === 'CANVAS' && border._canvas instanceof Canvas) {
                 this.context.texImage2DCanvas(target, level, internalformat, width, height, border._canvas.ios);
             }
             else {
@@ -938,289 +872,286 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
         }
         // this.blendFunc(this.SRC_ALPHA, this.ZERO);
         // this.disable(this.BLEND);
-    };
-    WebGLRenderingContext.prototype.texParameterf = function (target, pname, param) {
+    }
+    texParameterf(target, pname, param) {
         this._glCheckError('texParameterf');
         this._checkArgs('texParameterf', arguments);
         this.context.texParameterf(target, pname, param);
-    };
-    WebGLRenderingContext.prototype.texParameteri = function (target, pname, param) {
+    }
+    texParameteri(target, pname, param) {
         this._glCheckError('texParameteri');
         this._checkArgs('texParameteri', arguments);
         this.context.texParameteri(target, pname, param);
-    };
-    WebGLRenderingContext.prototype.texSubImage2D = function (target, level, xoffset, yoffset, width, height, format, type, pixels) {
+    }
+    texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) {
         this._glCheckError('texSubImage2D');
         this._checkArgs('texSubImage2D', arguments);
         if (arguments.length === 9) {
-            if ((pixels && pixels.buffer) || pixels instanceof ArrayBuffer) {
-                if (pixels instanceof ArrayBuffer) {
-                    var array = new Uint8Array(pixels);
-                    this.context.texSubImage2DU8(target, level, xoffset, yoffset, width, height, format, type, Array.from(array));
-                }
-                else if (pixels instanceof Uint8Array || pixels instanceof Uint8ClampedArray) {
-                    this.context.texSubImage2DU8(target, level, xoffset, yoffset, width, height, format, type, Array.from(pixels));
-                }
-                else if (pixels instanceof Uint16Array) {
-                    this.context.texSubImage2DU16(target, level, xoffset, yoffset, width, height, format, type, Array.from(pixels));
-                }
-                else if (pixels instanceof Float32Array) {
-                    this.context.texSubImage2DF32(target, level, xoffset, yoffset, width, height, format, type, Array.from(pixels));
-                }
+            if (pixels instanceof ArrayBuffer) {
+                this.context.texSubImage2DPixelsSize(target, level, xoffset, yoffset, width, height, format, type, pixels, pixels.byteLength);
+            }
+            else if (Utils.isTypedArray(pixels)) {
+                this.context.texSubImage2DPixelsSizeOffset(target, level, xoffset, yoffset, width, height, format, type, pixels, pixels.byteLength, pixels.byteOffset);
             }
             else {
                 this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
             }
         }
         else if (arguments.length === 7) {
-            if (format instanceof ImageAsset_1.ImageAsset) {
+            if (format instanceof ImageAsset) {
                 this.context.texSubImage2DAsset(target, level, xoffset, yoffset, width, height, format.native);
             }
+            if (format instanceof ImageBitmap || (format === null || format === void 0 ? void 0 : format.native) instanceof TNSImageBitmap) {
+                this.context.texSubImage2DBitmap(target, level, xoffset, yoffset, width, height, format.native);
+            }
             else if (format instanceof UIImage) {
                 this.context.texSubImage2DPixels(target, level, xoffset, yoffset, width, height, format);
             }
-            else if (format instanceof core_1.ImageSource) {
+            else if (format instanceof ImageSource) {
                 this.context.texSubImage2DPixels(target, level, xoffset, yoffset, width, height, format.ios);
             }
             else if (format && typeof format.tagName === 'string' && (format.tagName === 'IMG' || format.tagName === 'IMAGE')) {
-                if (format._imageSource instanceof core_1.ImageSource) {
+                if (format._imageSource instanceof ImageSource) {
                     this.context.texSubImage2DPixels(target, level, xoffset, yoffset, width, height, format._imageSource.ios);
                 }
                 else if (format._image instanceof UIImage) {
                     this.context.texSubImage2DPixels(target, level, xoffset, yoffset, width, height, format._image);
                 }
-                else if (format._asset instanceof ImageAsset_1.ImageAsset) {
+                else if (format._asset instanceof ImageAsset) {
                     this.context.texSubImage2DAsset(target, level, xoffset, yoffset, width, height, format._asset.native);
                 }
                 else if (typeof format.src === 'string') {
-                    var result = core_1.ImageSource.fromFileSync(format.src);
+                    const result = ImageSource.fromFileSync(format.src);
                     this.context.texSubImage2DPixels(target, level, xoffset, yoffset, width, height, result ? result.ios : null);
                 }
             }
-            else if (format && typeof format.tagName === 'string' && format.tagName === 'CANVAS' && format._canvas instanceof Canvas_1.Canvas) {
+            else if (format && typeof format.tagName === 'string' && format.tagName === 'CANVAS' && format._canvas instanceof Canvas) {
                 this.context.texSubImage2DCanvas(target, level, xoffset, yoffset, width, height, format._canvas.ios);
             }
             else {
                 this.context.texSubImage2D(target, level, xoffset, yoffset, width, height, format);
             }
         }
-    };
-    WebGLRenderingContext.prototype.uniform1f = function (location, v0) {
+    }
+    uniform1f(location, v0) {
         this._glCheckError('uniform1f');
         this._checkArgs('uniform1f', arguments);
         this.context.uniform1f(location.native, v0);
-    };
-    WebGLRenderingContext.prototype.uniform1iv = function (location, value) {
+    }
+    uniform1iv(location, value) {
         this._glCheckError('uniform1iv');
         this._checkArgs('uniform1iv', arguments);
         if (!(value instanceof Int32Array)) {
             value = new Int32Array(value);
         }
-        this.context.uniform1iv(location.native, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.uniform1fv = function (location, value) {
+        this.context.uniform1ivOffset(location.native, value, value.length, value.byteOffset);
+    }
+    uniform1fv(location, value) {
         this._glCheckError('uniform1fv');
         this._checkArgs('uniform1fv', arguments);
         if (!(value instanceof Float32Array)) {
             value = new Float32Array(value);
         }
-        this.context.uniform1fv(location.native, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.uniform1i = function (location, v0) {
+        this.context.uniform1fvOffset(location.native, value, value.length, value.byteOffset);
+    }
+    uniform1i(location, v0) {
         this._glCheckError('uniform1i');
         this._checkArgs('uniform1i', arguments);
         this.context.uniform1i(location.native, v0);
-    };
-    WebGLRenderingContext.prototype.uniform2f = function (location, v0, v1) {
+    }
+    uniform2f(location, v0, v1) {
         this._glCheckError('uniform2f');
         this._checkArgs('uniform2f', arguments);
         this.context.uniform2f(location.native, v0, v1);
-    };
-    WebGLRenderingContext.prototype.uniform2iv = function (location, value) {
+    }
+    uniform2iv(location, value) {
         this._glCheckError('uniform2iv');
         this._checkArgs('uniform2iv', arguments);
         if (!(value instanceof Int32Array)) {
             value = new Int32Array(value);
         }
-        this.context.uniform2iv(location.native, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.uniform2fv = function (location, value) {
+        this.context.uniform2ivOffset(location.native, value, value.length, value.byteOffset);
+    }
+    uniform2fv(location, value) {
         this._glCheckError('uniform2fv');
         this._checkArgs('uniform2fv', arguments);
         if (!(value instanceof Float32Array)) {
             value = new Float32Array(value);
         }
-        this.context.uniform2fv(location.native, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.uniform2i = function (location, v0, v1) {
+        this.context.uniform2fvOffset(location.native, value, value.length, value.byteOffset);
+    }
+    uniform2i(location, v0, v1) {
         this._glCheckError('uniform2i');
         this._checkArgs('uniform2i', arguments);
         this.context.uniform2i(location.native, v0, v1);
-    };
-    WebGLRenderingContext.prototype.uniform3f = function (location, v0, v1, v2) {
+    }
+    uniform3f(location, v0, v1, v2) {
         this._glCheckError('uniform3f');
         this._checkArgs('uniform3f', arguments);
         this.context.uniform3f(location.native, v0, v1, v2);
-    };
-    WebGLRenderingContext.prototype.uniform3iv = function (location, value) {
+    }
+    uniform3iv(location, value) {
         this._glCheckError('uniform3iv');
         this._checkArgs('uniform3iv', arguments);
         if (!(value instanceof Int32Array)) {
             value = new Int32Array(value);
         }
-        this.context.uniform3iv(location.native, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.uniform3fv = function (location, value) {
+        this.context.uniform3ivOffset(location.native, value, value.length, value.byteOffset);
+    }
+    uniform3fv(location, value) {
         this._glCheckError('uniform3fv');
         this._checkArgs('uniform3fv', arguments);
         if (!(value instanceof Float32Array)) {
             value = new Float32Array(value);
         }
-        this.context.uniform3fv(location.native, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.uniform3i = function (location, v0, v1, v2) {
+        this.context.uniform3fvOffset(location.native, value, value.length, value.byteOffset);
+    }
+    uniform3i(location, v0, v1, v2) {
         this._glCheckError('uniform3i');
         this._checkArgs('uniform3i', arguments);
         this.context.uniform3i(location.native, v0, v1, v2);
-    };
-    WebGLRenderingContext.prototype.uniform4f = function (location, v0, v1, v2, v3) {
+    }
+    uniform4f(location, v0, v1, v2, v3) {
         this._glCheckError('uniform4f');
         this._checkArgs('uniform4f', arguments);
         this.context.uniform4f(location.native, v0, v1, v2, v3);
-    };
-    WebGLRenderingContext.prototype.uniform4iv = function (location, value) {
+    }
+    uniform4iv(location, value) {
         this._glCheckError('uniform4iv');
         this._checkArgs('uniform4iv', arguments);
         if (!(value instanceof Int32Array)) {
             value = new Int32Array(value);
         }
-        this.context.uniform4iv(location.native, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.uniform4fv = function (location, value) {
+        this.context.uniform4ivOffset(location.native, value, value.length, value.byteOffset);
+    }
+    uniform4fv(location, value) {
         this._glCheckError('uniform4fv');
         this._checkArgs('uniform4fv', arguments);
         if (!(value instanceof Float32Array)) {
             value = new Float32Array(value);
         }
-        this.context.uniform4fv(location.native, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.uniform4i = function (location, v0, v1, v2, v3) {
+        this.context.uniform4fvOffset(location.native, value, value.length, value.byteOffset);
+    }
+    uniform4i(location, v0, v1, v2, v3) {
         this._glCheckError('uniform4i');
         this._checkArgs('uniform4i', arguments);
         this.context.uniform4i(location.native, v0, v1, v2, v3);
-    };
-    WebGLRenderingContext.prototype.uniformMatrix2fv = function (location, transpose, value) {
+    }
+    uniformMatrix2fv(location, transpose, value) {
         this._glCheckError('uniformMatrix2fv');
         this._checkArgs('uniformMatrix2fv', arguments);
         if (!(value instanceof Float32Array)) {
             value = new Float32Array(value);
         }
-        this.context.uniformMatrix2fv(location.native, transpose, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.uniformMatrix3fv = function (location, transpose, value) {
+        this.context.uniformMatrix2fvOffset(location.native, transpose, value, value.length, value.byteOffset);
+    }
+    uniformMatrix3fv(location, transpose, value) {
         this._glCheckError('uniformMatrix3fv');
         this._checkArgs('uniformMatrix3fv', arguments);
         if (!(value instanceof Float32Array)) {
             value = new Float32Array(value);
         }
-        this.context.uniformMatrix3fv(location.native, transpose, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.uniformMatrix4fv = function (location, transpose, value) {
+        this.context.uniformMatrix3fvOffset(location.native, transpose, value, value.length, value.byteOffset);
+    }
+    uniformMatrix4fv(location, transpose, value) {
         this._glCheckError('uniformMatrix4fv');
         this._checkArgs('uniformMatrix4fv', arguments);
         if (!(value instanceof Float32Array)) {
             value = new Float32Array(value);
         }
-        this.context.uniformMatrix4fv(location.native, transpose, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.useProgram = function (program) {
+        this.context.uniformMatrix4fvOffset(location.native, transpose, value, value.length, value.byteOffset);
+    }
+    useProgram(program) {
         this._glCheckError('useProgram');
         this._checkArgs('useProgram', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         this.context.useProgram(value);
-    };
-    WebGLRenderingContext.prototype.validateProgram = function (program) {
+    }
+    validateProgram(program) {
         this._glCheckError('validateProgram');
         this._checkArgs('validateProgram', arguments);
-        var value = program ? program.native : 0;
+        const value = program ? program.native : 0;
         this.context.validateProgram(value);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib1f = function (index, v0) {
+    }
+    vertexAttrib1f(index, v0) {
         this._glCheckError('vertexAttrib1f');
         this._checkArgs('vertexAttrib1f', arguments);
         this.context.vertexAttrib1f(index, v0);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib1fv = function (index, value) {
+    }
+    vertexAttrib1fv(index, value) {
         this._glCheckError('vertexAttrib1fv');
         this._checkArgs('vertexAttrib1fv', arguments);
         if (!(value instanceof Float32Array)) {
             value = new Float32Array(value);
         }
-        this.context.vertexAttrib1fv(index, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.vertexAttrib2f = function (index, v0, v1) {
+        this.context.vertexAttrib1fvOffset(index, value, value.byteOffset);
+    }
+    vertexAttrib2f(index, v0, v1) {
         this._glCheckError('vertexAttrib2f');
         this._checkArgs('vertexAttrib2f', arguments);
         this.context.vertexAttrib2f(index, v0, v1);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib2fv = function (index, value) {
+    }
+    vertexAttrib2fv(index, value) {
         this._glCheckError('vertexAttrib2fv');
         this._checkArgs('vertexAttrib2fv', arguments);
-        this.context.vertexAttrib2fv(index, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.vertexAttrib3f = function (index, v0, v1, v2) {
+        if (!(value instanceof Float32Array)) {
+            value = new Float32Array(value);
+        }
+        this.context.vertexAttrib2fvOffset(index, value, value.byteOffset);
+    }
+    vertexAttrib3f(index, v0, v1, v2) {
         this._glCheckError('vertexAttrib3f');
         this._checkArgs('vertexAttrib3f', arguments);
         this.context.vertexAttrib3f(index, v0, v1, v2);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib3fv = function (index, value) {
+    }
+    vertexAttrib3fv(index, value) {
         this._glCheckError('vertexAttrib3fv');
         this._checkArgs('vertexAttrib3fv', arguments);
         if (!(value instanceof Float32Array)) {
             value = new Float32Array(value);
         }
-        this.context.vertexAttrib3fv(index, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.vertexAttrib4f = function (index, v0, v1, v2, v3) {
+        this.context.vertexAttrib3fvOffset(index, value, value.byteOffset);
+    }
+    vertexAttrib4f(index, v0, v1, v2, v3) {
         this._glCheckError('vertexAttrib4f');
         this._checkArgs('vertexAttrib4f', arguments);
         this.context.vertexAttrib4f(index, v0, v1, v2, v3);
-    };
-    WebGLRenderingContext.prototype.vertexAttrib4fv = function (index, value) {
+    }
+    vertexAttrib4fv(index, value) {
         this._glCheckError('vertexAttrib4fv');
         this._checkArgs('vertexAttrib4fv', arguments);
         if (!(value instanceof Float32Array)) {
             value = new Float32Array(value);
         }
-        this.context.vertexAttrib4fv(index, Array.from(value));
-    };
-    WebGLRenderingContext.prototype.vertexAttribPointer = function (index, size, type, normalized, stride, offset) {
+        this.context.vertexAttrib4fvOffset(index, value, value.byteOffset);
+    }
+    vertexAttribPointer(index, size, type, normalized, stride, offset) {
         this._glCheckError('vertexAttribPointer');
         this._checkArgs('vertexAttribPointer', arguments);
         this.context.vertexAttribPointer(index, size, type, normalized, stride, offset);
-    };
-    WebGLRenderingContext.prototype.viewport = function (x, y, width, height) {
+    }
+    viewport(x, y, width, height) {
         this._glCheckError('viewport');
         this._checkArgs('viewport', arguments);
         this.context.viewport(x, y, width, height);
-    };
-    WebGLRenderingContext.prototype.getJSArray = function (value) {
-        var count = value.count;
-        var array = [];
-        for (var i = 0; i < count; i++) {
+    }
+    getJSArray(value) {
+        const count = value.count;
+        const array = [];
+        for (let i = 0; i < count; i++) {
             array.push(value.objectAtIndex(i));
         }
         return array;
-    };
-    WebGLRenderingContext.prototype._glCheckError = function (message) {
+    }
+    _glCheckError(message) {
         if (!WebGLRenderingContext.isDebug) {
             return;
         }
         if (WebGLRenderingContext.filter === 'both' || WebGLRenderingContext.filter === 'error') {
             console.log(message, this.getError());
         }
-    };
-    WebGLRenderingContext.prototype._checkArgs = function (message, args) {
+    }
+    _checkArgs(message, args) {
         if (!WebGLRenderingContext.isDebug) {
             return;
         }
@@ -1229,10 +1160,8 @@ var WebGLRenderingContext = /** @class */ (function (_super) {
             console.dir(args);
             console.log('/**** ', message, ' ****/');
         }
-    };
-    WebGLRenderingContext.isDebug = false;
-    WebGLRenderingContext.filter = 'both';
-    return WebGLRenderingContext;
-}(common_1.WebGLRenderingContextBase));
-exports.WebGLRenderingContext = WebGLRenderingContext;
+    }
+}
+WebGLRenderingContext.isDebug = false;
+WebGLRenderingContext.filter = 'both';
 //# sourceMappingURL=index.ios.js.map