drop IE11 support: TextEncoder is supported in all the modern JS engines

Author: gfx

.nycrc.json

@@ -1,6 +1,6 @@
 {
-  "include": ["src/**/*.ts"],
-  "extension": [".ts"],
+  "include": ["src/**/*.ts", "src/**/*.mts"],
+  "extension": [".ts", ".mtx"],
   "reporter": [],
   "sourceMap": true,
   "instrument": true

package.json

@@ -16,12 +16,7 @@
     "prepublishOnly": "run-p 'test:dist:*' && npm run test:browser",
     "clean": "rimraf build dist dist.*",
     "test": "mocha 'test/**/*.test.ts'",
-    "test:purejs": "TEXT_ENCODING=never mocha 'test/**/*.test.ts'",
-    "test:te": "TEXT_ENCODING=force mocha 'test/**/*.test.ts'",
-    "test:dist:purejs": "TS_NODE_PROJECT=tsconfig.test-dist-es5-purejs.json npm run test:purejs -- --reporter=dot",
-    "test:cover": "npm run cover:clean && npm-run-all 'test:cover:*' && npm run cover:report",
-    "test:cover:purejs": "npx nyc --no-clean npm run test:purejs",
-    "test:cover:te": "npx nyc --no-clean npm run test:te",
+    "test:cover": "npm run cover:clean && npx nyc --no-clean npm run 'test' && npm run cover:report",
     "test:deno": "deno test test/deno_test.ts",
     "test:fuzz": "npm exec --yes -- jsfuzz@git+https://gitlab.com/gitlab-org/security-products/analyzers/fuzzers/jsfuzz.git --fuzzTime 60 --no-versifier test/decode.jsfuzz.js corpus",
     "cover:clean": "rimraf .nyc_output coverage/",

src/Decoder.ts

@@ -1,7 +1,7 @@
 import { prettyByte } from "./utils/prettyByte";
 import { ExtensionCodec, ExtensionCodecType } from "./ExtensionCodec";
 import { getInt64, getUint64, UINT32_MAX } from "./utils/int";
-import { utf8DecodeJs, TEXT_DECODER_THRESHOLD, utf8DecodeTD } from "./utils/utf8";
+import { utf8Decode } from "./utils/utf8";
 import { createDataView, ensureUint8Array } from "./utils/typedArrays";
 import { CachedKeyDecoder, KeyDecoder } from "./CachedKeyDecoder";
 import { DecodeError } from "./DecodeError";
@@ -507,10 +507,8 @@ export class Decoder<ContextType = undefined> {
     let object: string;
     if (this.stateIsMapKey() && this.keyDecoder?.canBeCached(byteLength)) {
       object = this.keyDecoder.decode(this.bytes, offset, byteLength);
-    } else if (byteLength > TEXT_DECODER_THRESHOLD) {
-      object = utf8DecodeTD(this.bytes, offset, byteLength);
     } else {
-      object = utf8DecodeJs(this.bytes, offset, byteLength);
+      object = utf8Decode(this.bytes, offset, byteLength);
     }
     this.pos += headerOffset + byteLength;
     return object;

src/Encoder.ts

@@ -1,4 +1,4 @@
-import { utf8EncodeJs, utf8Count, TEXT_ENCODER_THRESHOLD, utf8EncodeTE } from "./utils/utf8";
+import { utf8Count, utf8Encode } from "./utils/utf8";
 import { ExtensionCodec, ExtensionCodecType } from "./ExtensionCodec";
 import { setInt64, setUint64 } from "./utils/int";
 import { ensureUint8Array } from "./utils/typedArrays";
@@ -177,21 +177,12 @@ export class Encoder<ContextType = undefined> {
 
   private encodeString(object: string) {
     const maxHeaderSize = 1 + 4;
-    const strLength = object.length;
-
-    if (strLength > TEXT_ENCODER_THRESHOLD) {
-      const byteLength = utf8Count(object);
-      this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
-      this.writeStringHeader(byteLength);
-      utf8EncodeTE(object, this.bytes, this.pos);
-      this.pos += byteLength;
-    } else {
-      const byteLength = utf8Count(object);
-      this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
-      this.writeStringHeader(byteLength);
-      utf8EncodeJs(object, this.bytes, this.pos);
-      this.pos += byteLength;
-    }
+
+    const byteLength = utf8Count(object);
+    this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+    this.writeStringHeader(byteLength);
+    utf8Encode(object, this.bytes, this.pos);
+    this.pos += byteLength;
   }
 
   private encodeObject(object: unknown, depth: number) {

src/utils/utf8.ts

@@ -1,11 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
 import { UINT32_MAX } from "./int";
 
-const TEXT_ENCODING_AVAILABLE =
-  (typeof process === "undefined" || process?.env?.["TEXT_ENCODING"] !== "never") &&
-  typeof TextEncoder !== "undefined" &&
-  typeof TextDecoder !== "undefined";
-
 export function utf8Count(str: string): number {
   const strLength = str.length;
 
@@ -89,22 +84,26 @@ export function utf8EncodeJs(str: string, output: Uint8Array, outputOffset: numb
   }
 }
 
-const sharedTextEncoder = TEXT_ENCODING_AVAILABLE ? new TextEncoder() : undefined;
-export const TEXT_ENCODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE
-  ? UINT32_MAX
-  : typeof process !== "undefined" && process?.env?.["TEXT_ENCODING"] !== "force"
-  ? 200
-  : 0;
+const sharedTextEncoder = new TextEncoder();
+const TEXT_ENCODER_THRESHOLD = 200;
 
 function utf8EncodeTEencode(str: string, output: Uint8Array, outputOffset: number): void {
-  output.set(sharedTextEncoder!.encode(str), outputOffset);
+  output.set(sharedTextEncoder.encode(str), outputOffset);
 }
 
 function utf8EncodeTEencodeInto(str: string, output: Uint8Array, outputOffset: number): void {
-  sharedTextEncoder!.encodeInto(str, output.subarray(outputOffset));
+  sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
 }
 
-export const utf8EncodeTE = sharedTextEncoder?.encodeInto ? utf8EncodeTEencodeInto : utf8EncodeTEencode;
+export const utf8EncodeTE = (sharedTextEncoder.encodeInto as unknown) ? utf8EncodeTEencodeInto : utf8EncodeTEencode;
+
+export function utf8Encode(str: string, output: Uint8Array, outputOffset: number): void {
+  if (str.length > TEXT_ENCODER_THRESHOLD) {
+    utf8EncodeTE(str, output, outputOffset);
+  } else {
+    utf8EncodeJs(str, output, outputOffset);
+  }
+}
 
 const CHUNK_SIZE = 0x1_000;
 
@@ -157,14 +156,18 @@ export function utf8DecodeJs(bytes: Uint8Array, inputOffset: number, byteLength:
   return result;
 }
 
-const sharedTextDecoder = TEXT_ENCODING_AVAILABLE ? new TextDecoder() : null;
-export const TEXT_DECODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE
-  ? UINT32_MAX
-  : typeof process !== "undefined" && process?.env?.["TEXT_DECODER"] !== "force"
-  ? 200
-  : 0;
+const sharedTextDecoder = new TextDecoder();
+const TEXT_DECODER_THRESHOLD = 200;
 
 export function utf8DecodeTD(bytes: Uint8Array, inputOffset: number, byteLength: number): string {
   const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
-  return sharedTextDecoder!.decode(stringBytes);
+  return sharedTextDecoder.decode(stringBytes);
+}
+
+export function utf8Decode(bytes: Uint8Array, inputOffset: number, byteLength: number): string {
+  if (byteLength > TEXT_DECODER_THRESHOLD) {
+    return utf8DecodeTD(bytes, inputOffset, byteLength);
+  } else {
+    return utf8DecodeJs(bytes, inputOffset, byteLength);
+  }
 }