Use polyfill for TypedArray.slice

src/core/TypedArrayUtils.test.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 import { assert } from 'chai';
-import { fill } from './TypedArrayUtils';
+import { fill, sliceFallback } from './TypedArrayUtils';
 
 type TypedArray = Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray
   | Int8Array | Int16Array | Int32Array
@@ -29,7 +29,7 @@ function loopFill(array: TypedArray, value: number, start: number = 0, end?: num
   return array;
 }
 
-describe('polyfill conformance tests', function(): void {
+describe('polyfill conformance tests', () => {
 
   function deepEquals(a: TypedArray, b: TypedArray): void {
     assert.equal(a.length, b.length);
@@ -38,8 +38,8 @@ describe('polyfill conformance tests', function(): void {
     }
   }
 
-  describe('TypedArray.fill', function(): void {
-    it('should work with all typed array types', function(): void {
+  describe('TypedArray.fill', () => {
+    it('should work with all typed array types', () => {
       const u81 = new Uint8Array(5);
       const u82 = new Uint8Array(5);
       deepEquals(fill(u81, 2), u82.fill(2));
@@ -79,7 +79,7 @@ describe('polyfill conformance tests', function(): void {
       deepEquals(fill(u8Clamped1, 2), u8Clamped2.fill(2));
       deepEquals(fill(u8Clamped1, 257), u8Clamped2.fill(257));
     });
-    it('should work with all typed array types - explicit looping', function(): void {
+    it('should work with all typed array types - explicit looping', () => {
       const u81 = new Uint8Array(5);
       const u82 = new Uint8Array(5);
       deepEquals(loopFill(u81, 2), u82.fill(2));
@@ -119,7 +119,7 @@ describe('polyfill conformance tests', function(): void {
       deepEquals(loopFill(u8Clamped1, 2), u8Clamped2.fill(2));
       deepEquals(loopFill(u8Clamped1, 257), u8Clamped2.fill(257));
     });
-    it('start offset', function(): void {
+    it('start offset', () => {
       for (let i = -2; i < 10; ++i) {
         const u81 = new Uint8Array(5);
         const u82 = new Uint8Array(5);
@@ -130,7 +130,7 @@ describe('polyfill conformance tests', function(): void {
         deepEquals(loopFill(u82, -1, i), u83.fill(-1, i));
       }
     });
-    it('end offset', function(): void {
+    it('end offset', () => {
       for (let i = -2; i < 10; ++i) {
         const u81 = new Uint8Array(5);
         const u82 = new Uint8Array(5);
@@ -141,7 +141,7 @@ describe('polyfill conformance tests', function(): void {
         deepEquals(loopFill(u82, -1, 0, i), u83.fill(-1, 0, i));
       }
     });
-    it('start/end offset', function(): void {
+    it('start/end offset', () => {
       for (let i = -2; i < 10; ++i) {
         for (let j = -2; j < 10; ++j) {
           const u81 = new Uint8Array(5);
@@ -155,4 +155,110 @@ describe('polyfill conformance tests', function(): void {
       }
     });
   });
+
+  describe('TypedArray.slice', () => {
+    describe('should work with all typed array types', () => {
+      it('Uint8Array', () => {
+        const a = new Uint8Array(5);
+        console.log(a);
+        console.log(a.slice(65535));
+        console.log(sliceFallback(a, 65535));
+        deepEquals(sliceFallback(a, 2), a.slice(2));
+        deepEquals(sliceFallback(a, 65535), a.slice(65535));
+        deepEquals(sliceFallback(a, -1), a.slice(-1));
+      });
+      it('Uint16Array', () => {
+        const u161 = new Uint16Array(5);
+        const u162 = new Uint16Array(5);
+        deepEquals(sliceFallback(u161, 2), u162.slice(2));
+        deepEquals(sliceFallback(u161, 65535), u162.slice(65535));
+        deepEquals(sliceFallback(u161, -1), u162.slice(-1));
+      });
+      it('Uint32Array', () => {
+        const u321 = new Uint32Array(5);
+        const u322 = new Uint32Array(5);
+        deepEquals(sliceFallback(u321, 2), u322.slice(2));
+        deepEquals(sliceFallback(u321, 65537), u322.slice(65537));
+        deepEquals(sliceFallback(u321, -1), u322.slice(-1));
+      });
+      it('Int8Array', () => {
+          const i81 = new Int8Array(5);
+          const i82 = new Int8Array(5);
+          deepEquals(sliceFallback(i81, 2), i82.slice(2));
+          deepEquals(sliceFallback(i81, 65537), i82.slice(65537));
+          deepEquals(sliceFallback(i81, -1), i82.slice(-1));
+        });
+      it('Int16Array', () => {
+          const i161 = new Int16Array(5);
+          const i162 = new Int16Array(5);
+          deepEquals(sliceFallback(i161, 2), i162.slice(2));
+          deepEquals(sliceFallback(i161, 65535), i162.slice(65535));
+          deepEquals(sliceFallback(i161, -1), i162.slice(-1));
+        });
+      it('Int32Array', () => {
+        const i321 = new Int32Array(5);
+        const i322 = new Int32Array(5);
+        deepEquals(sliceFallback(i321, 2), i322.slice(2));
+        deepEquals(sliceFallback(i321, 65537), i322.slice(65537));
+        deepEquals(sliceFallback(i321, -1), i322.slice(-1));
+      });
+      it('Float32Array', () => {
+        const f321 = new Float32Array(5);
+        const f322 = new Float32Array(5);
+        deepEquals(sliceFallback(f321, 2), f322.slice(2));
+        deepEquals(sliceFallback(f321, 65537), f322.slice(65537));
+        deepEquals(sliceFallback(f321, -1), f322.slice(-1));
+      });
+      it('Float64Array', () => {
+        const f641 = new Float64Array(5);
+        const f642 = new Float64Array(5);
+        deepEquals(sliceFallback(f641, 2), f642.slice(2));
+        deepEquals(sliceFallback(f641, 65537), f642.slice(65537));
+        deepEquals(sliceFallback(f641, -1), f642.slice(-1));
+      });
+      it('Uint8ClampedArray', () => {
+        const u8Clamped1 = new Uint8ClampedArray(5);
+        const u8Clamped2 = new Uint8ClampedArray(5);
+        deepEquals(sliceFallback(u8Clamped1, 2), u8Clamped2.slice(2));
+        deepEquals(sliceFallback(u8Clamped1, 65537), u8Clamped2.slice(65537));
+        deepEquals(sliceFallback(u8Clamped1, -1), u8Clamped2.slice(-1));
+      });
+    });
+    it('start', () => {
+      const arr = new Uint32Array([1, 2, 3, 4, 5]);
+      deepEquals(sliceFallback(arr, -1), arr.slice(-1));
+      deepEquals(sliceFallback(arr, 0), arr.slice(0));
+      deepEquals(sliceFallback(arr, 1), arr.slice(1));
+      deepEquals(sliceFallback(arr, 2), arr.slice(2));
+      deepEquals(sliceFallback(arr, 3), arr.slice(3));
+      deepEquals(sliceFallback(arr, 4), arr.slice(4));
+      deepEquals(sliceFallback(arr, 5), arr.slice(5));
+    });
+    it('end', () => {
+      const arr = new Uint32Array([1, 2, 3, 4, 5]);
+      deepEquals(sliceFallback(arr, -1, -2), arr.slice(-1, -2));
+      deepEquals(sliceFallback(arr, 0, -2), arr.slice(0, -2));
+      deepEquals(sliceFallback(arr, 1, -2), arr.slice(1, -2));
+      deepEquals(sliceFallback(arr, 2, -2), arr.slice(2, -2));
+      deepEquals(sliceFallback(arr, 3, -2), arr.slice(3, -2));
+      deepEquals(sliceFallback(arr, 4, -2), arr.slice(4, -2));
+      deepEquals(sliceFallback(arr, 5, -2), arr.slice(5, -2));
+
+      deepEquals(sliceFallback(arr, -1, 3), arr.slice(-1, 3));
+      deepEquals(sliceFallback(arr, 0, 3), arr.slice(0, 3));
+      deepEquals(sliceFallback(arr, 1, 3), arr.slice(1, 3));
+      deepEquals(sliceFallback(arr, 2, 3), arr.slice(2, 3));
+      deepEquals(sliceFallback(arr, 3, 3), arr.slice(3, 3));
+      deepEquals(sliceFallback(arr, 4, 3), arr.slice(4, 3));
+      deepEquals(sliceFallback(arr, 5, 3), arr.slice(5, 3));
+
+      deepEquals(sliceFallback(arr, -1, 8), arr.slice(-1, 8));
+      deepEquals(sliceFallback(arr, 0, 8), arr.slice(0, 8));
+      deepEquals(sliceFallback(arr, 1, 8), arr.slice(1, 8));
+      deepEquals(sliceFallback(arr, 2, 8), arr.slice(2, 8));
+      deepEquals(sliceFallback(arr, 3, 8), arr.slice(3, 8));
+      deepEquals(sliceFallback(arr, 4, 8), arr.slice(4, 8));
+      deepEquals(sliceFallback(arr, 5, 8), arr.slice(5, 8));
+    });
+  });
 });

src/core/TypedArrayUtils.ts

@@ -38,3 +38,29 @@ export function fill(array: TypedArray, value: number, start: number = 0, end?:
   }
   return array;
 }
+
+export function slice<T extends TypedArray>(array: T, start?: number, end?: number): T {
+  // all modern engines that support .slice
+  if (array.slice) {
+    return array.slice(start, end) as T;
+  }
+  return sliceFallback(array, start, end);
+}
+
+export function sliceFallback<T extends TypedArray>(array: T, start: number = 0, end: number = array.length): T {
+  if (start < 0) {
+    start = (array.length + start) % array.length;
+  }
+  if (end >= array.length) {
+    end = array.length;
+  } else {
+    end = (array.length + end) % array.length;
+  }
+  start = Math.min(start, end);
+
+  const result: T = new (<any>array).__proto__.constructor(end - start);
+  for (let i = 0; i < end - start; ++i) {
+    result[i] = array[i + start];
+  }
+  return result;
+}

src/renderer/webgl/GlyphRenderer.ts

@@ -11,7 +11,7 @@ import WebglCharAtlas from './WebglCharAtlas';
 import { IWebGL2RenderingContext, IWebGLVertexArrayObject, IRenderModel, IRasterizedGlyph } from './Types';
 import { INDICIES_PER_CELL } from './WebglRenderer';
 import { COMBINED_CHAR_BIT_MASK } from './RenderModel';
-import { fill } from '../../core/TypedArrayUtils';
+import { fill, slice } from '../../core/TypedArrayUtils';
 
 interface IVertices {
   attributes: Float32Array;
@@ -210,7 +210,7 @@ export class GlyphRenderer {
   public updateSelection(model: IRenderModel, columnSelectMode: boolean): void {
     const terminal = this._terminal;
 
-    this._vertices.selectionAttributes = this._vertices.attributes.slice(0);
+    this._vertices.selectionAttributes = slice(this._vertices.attributes, 0);
 
     // TODO: Make fg and bg configurable, currently since the buffer doesn't
     // support truecolor the char atlas cannot store it.