protobufjs 8.6.6 → 8.7.1

package/src/util/minimal.js

@@ -137,36 +137,29 @@ util.isSet = function isSet(obj, prop) {
 util.Buffer = (function() {
     try {
         var Buffer = util.global.Buffer;
-        // refuse to use non-node buffers if not explicitly assigned (perf reasons):
-        return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;
+        // refuse to use non-node buffers if not explicitly assigned (perf reasons)
+        return Buffer.prototype.utf8Write || util.isNode ? Buffer : /* istanbul ignore next */ null;
     } catch (e) {
         /* istanbul ignore next */
         return null;
     }
 })();
 
-// Internal alias of or polyfull for Buffer.from.
-util._Buffer_from = null;
-
-// Internal alias of or polyfill for Buffer.allocUnsafe.
-util._Buffer_allocUnsafe = null;
-
 /**
  * Creates a new buffer of whatever type supported by the environment.
  * @param {number|number[]} [sizeOrArray=0] Buffer size or number array
  * @returns {Uint8Array|Buffer} Buffer
  */
 util.newBuffer = function newBuffer(sizeOrArray) {
+    var Buffer = util.Buffer;
     /* istanbul ignore next */
     return typeof sizeOrArray === "number"
-        ? util.Buffer
-            ? util._Buffer_allocUnsafe(sizeOrArray)
-            : new util.Array(sizeOrArray)
-        : util.Buffer
-            ? util._Buffer_from(sizeOrArray)
-            : typeof Uint8Array === "undefined"
-                ? sizeOrArray
-                : new Uint8Array(sizeOrArray);
+        ? Buffer
+            ? Buffer.allocUnsafe(sizeOrArray)
+            : new Uint8Array(sizeOrArray)
+        : Buffer
+            ? Buffer.from(sizeOrArray)
+            : new Uint8Array(sizeOrArray);
 };
 
 /**
@@ -192,10 +185,11 @@ util.rawField = function rawField(id, wireType, data) {
 };
 
 /**
- * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
+ * Array implementation used in the browser.
  * @type {Constructor<Uint8Array>}
+ * @deprecated Use `Uint8Array` instead.
  */
-util.Array = typeof Uint8Array !== "undefined" ? Uint8Array /* istanbul ignore next */ : Array;
+util.Array = Uint8Array;
 
 /**
  * Any compatible Long instance.
@@ -515,25 +509,3 @@ util.toJSONOptions = {
     bytes: String,
     json: true
 };
-
-// Sets up buffer utility according to the environment (called in index-minimal)
-util._configure = function() {
-    var Buffer = util.Buffer;
-    /* istanbul ignore if */
-    if (!Buffer) {
-        util._Buffer_from = util._Buffer_allocUnsafe = null;
-        return;
-    }
-    // because node 4.x buffers are incompatible & immutable
-    // see: https://github.com/dcodeIO/protobuf.js/pull/665
-    util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||
-        /* istanbul ignore next */
-        function Buffer_from(value, encoding) {
-            return new Buffer(value, encoding);
-        };
-    util._Buffer_allocUnsafe = Buffer.allocUnsafe ||
-        /* istanbul ignore next */
-        function Buffer_allocUnsafe(size) {
-            return new Buffer(size);
-        };
-};

package/src/util/utf8.js

@@ -1,19 +1,21 @@
 "use strict";
 
 /**
- * A minimal UTF8 implementation for number arrays.
+ * A minimal UTF8 implementation.
  * @memberof util
  * @namespace
  */
 var utf8 = exports,
     replacementChar = "\ufffd",
+    looseDecoder = new TextDecoder("utf-8", { ignoreBOM: true }),
     strictDecoder;
+var TEXT_DECODER_MIN_LENGTH = 64;
 
 try {
     strictDecoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 } catch (err) {
     // "fatal" option is not supported on Node.js compiled without ICU
-    strictDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
+    strictDecoder = looseDecoder;
 }
 
 /**
@@ -64,6 +66,13 @@ function utf8_read_js(buffer, start, end, str) {
     return str;
 }
 
+function utf8_read_decoder(decoder, buffer, start, end) {
+    var source = start === 0 && end === buffer.length
+        ? buffer
+        : buffer.subarray(start, end);
+    return decoder.decode(source);
+}
+
 /**
  * Reads UTF8 bytes as a string.
  * @param {Uint8Array} buffer Source buffer
@@ -71,9 +80,11 @@ function utf8_read_js(buffer, start, end, str) {
  * @param {number} end Source end
  * @returns {string} String read
  */
-utf8.read = function utf8_read_ascii(buffer, start, end) {
+utf8.read = function utf8_read_loose(buffer, start, end) {
     if (end - start < 1)
         return "";
+    if (end - start >= TEXT_DECODER_MIN_LENGTH)
+        return utf8_read_decoder(looseDecoder, buffer, start, end);
 
     var str = "",
         i = start,
@@ -103,17 +114,6 @@ utf8.read = function utf8_read_ascii(buffer, start, end) {
     return str;
 };
 
-function utf8_read_strict(buffer, start, end) {
-    var source = start === 0 && end === buffer.length
-        ? buffer
-        : buffer.subarray
-            ? buffer.subarray(start, end)
-            : buffer.slice(start, end);
-    if (Array.isArray(source))
-        source = Uint8Array.from(source);
-    return strictDecoder.decode(source);
-}
-
 /**
  * Reads UTF8 bytes as a string, rejecting invalid UTF8.
  * @param {Uint8Array} buffer Source buffer
@@ -121,9 +121,11 @@ function utf8_read_strict(buffer, start, end) {
  * @param {number} end Source end
  * @returns {string} String read
  */
-utf8.readStrict = function utf8_read_strict_ascii(buffer, start, end) {
+utf8.readStrict = function utf8_read_strict(buffer, start, end) {
     if (end - start < 1)
         return "";
+    if (end - start >= TEXT_DECODER_MIN_LENGTH)
+        return utf8_read_decoder(strictDecoder, buffer, start, end);
 
     var str = "",
         i = start,
@@ -139,14 +141,14 @@ utf8.readStrict = function utf8_read_strict_ascii(buffer, start, end) {
         c7 = buffer[i + 6];
         c8 = buffer[i + 7];
         if ((c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8) & 0x80)
-            return str + utf8_read_strict(buffer, i, end);
+            return str + utf8_read_decoder(strictDecoder, buffer, i, end);
         str += String.fromCharCode(c1, c2, c3, c4, c5, c6, c7, c8);
     }
 
     for (; i < end; ++i) {
         c1 = buffer[i];
         if (c1 & 0x80)
-            return str + utf8_read_strict(buffer, i, end);
+            return str + utf8_read_decoder(strictDecoder, buffer, i, end);
         str += String.fromCharCode(c1);
     }