react-native-ble-mesh 2.0.0 → 2.1.0

package/src/protocol/header.js

@@ -16,6 +16,12 @@ const { randomBytes } = require('../utils/bytes');
  */
 const HEADER_SIZE = 48;
 
+// Pre-computed hex lookup table (avoids Array.from().map().join() per call)
+const HEX_TABLE = new Array(256);
+for (let i = 0; i < 256; i++) {
+  HEX_TABLE[i] = (i < 16 ? '0' : '') + i.toString(16);
+}
+
 /**
  * Message header class representing the 48-byte header structure.
  * @class MessageHeader
@@ -43,7 +49,6 @@ class MessageHeader {
     this.flags = options.flags ?? MESSAGE_FLAGS.NONE;
     this.hopCount = options.hopCount ?? 0;
     this.maxHops = options.maxHops ?? MESH_CONFIG.MAX_HOPS;
-    this.reserved = new Uint8Array(3);
     this.messageId = options.messageId;
     this.timestamp = options.timestamp;
     this.expiresAt = options.expiresAt;
@@ -143,9 +148,8 @@ class MessageHeader {
     view.setUint16(40, header.payloadLength, false);
     buffer[42] = header.fragmentIndex;
     buffer[43] = header.fragmentTotal;
-    // Calculate checksum over header without checksum field
-    const checksumData = buffer.slice(0, 44);
-    const checksum = crc32(checksumData);
+    // Calculate checksum over header without checksum field (subarray = zero-copy view)
+    const checksum = crc32(buffer.subarray(0, 44));
     view.setUint32(44, checksum, false);
     header.checksum = checksum;
 
@@ -204,9 +208,11 @@ function writeUint64BE(view, offset, value) {
  * @returns {string} Hex string
  */
 function bytesToHex(bytes) {
-  return Array.from(bytes)
-    .map(b => b.toString(16).padStart(2, '0'))
-    .join('');
+  let hex = '';
+  for (let i = 0; i < bytes.length; i++) {
+    hex += HEX_TABLE[bytes[i]];
+  }
+  return hex;
 }
 
 module.exports = {

package/src/protocol/message.js

@@ -9,6 +9,18 @@ const { MessageHeader, HEADER_SIZE, generateUuid } = require('./header');
 const { MESSAGE_FLAGS, MESH_CONFIG } = require('../constants');
 const { MessageError } = require('../errors');
 
+// Cached TextEncoder/TextDecoder singletons (avoids per-call allocation)
+let _encoder = null;
+let _decoder = null;
+function _getEncoder() {
+  if (!_encoder) { _encoder = new TextEncoder(); }
+  return _encoder;
+}
+function _getDecoder() {
+  if (!_decoder) { _decoder = new TextDecoder(); }
+  return _decoder;
+}
+
 /**
  * Message class representing a complete mesh network message.
  * @class Message
@@ -44,7 +56,7 @@ class Message {
 
     // Convert string payload to bytes
     if (typeof payload === 'string') {
-      payload = new TextEncoder().encode(payload);
+      payload = _getEncoder().encode(payload);
     }
 
     if (!(payload instanceof Uint8Array)) {
@@ -99,7 +111,7 @@ class Message {
       });
     }
 
-    const payload = data.slice(HEADER_SIZE, HEADER_SIZE + header.payloadLength);
+    const payload = data.subarray(HEADER_SIZE, HEADER_SIZE + header.payloadLength);
 
     return new Message(header, payload);
   }
@@ -171,7 +183,7 @@ class Message {
    * @returns {string} Decoded payload content
    */
   getContent() {
-    return new TextDecoder().decode(this.payload);
+    return _getDecoder().decode(this.payload);
   }
 
   /**

package/src/protocol/serializer.js

@@ -71,9 +71,8 @@ function serializeHeader(header) {
   // Byte 43: fragmentTotal
   buffer[43] = header.fragmentTotal ?? 1;
 
-  // Bytes 44-47: checksum (calculated over bytes 0-43)
-  const checksumData = buffer.slice(0, 44);
-  const checksum = crc32(checksumData);
+  // Bytes 44-47: checksum (calculated over bytes 0-43, subarray = zero-copy view)
+  const checksum = crc32(buffer.subarray(0, 44));
   view.setUint32(44, checksum, false);
 
   return buffer;
@@ -110,7 +109,8 @@ function serialize(message) {
 
   // Convert string payload to bytes
   if (typeof payload === 'string') {
-    payload = new TextEncoder().encode(payload);
+    if (!serialize._encoder) { serialize._encoder = new TextEncoder(); }
+    payload = serialize._encoder.encode(payload);
   }
 
   // Default to empty payload
@@ -122,13 +122,10 @@ function serialize(message) {
     throw MessageError.invalidFormat(null, { reason: 'Payload must be Uint8Array or string' });
   }
 
-  // Update payloadLength in header
-  const headerWithLength = {
-    ...header,
-    payloadLength: payload.length
-  };
+  // Update payloadLength directly (avoids object spread allocation)
+  header.payloadLength = payload.length;
 
-  const headerBytes = serializeHeader(headerWithLength);
+  const headerBytes = serializeHeader(header);
   const result = new Uint8Array(headerBytes.length + payload.length);
 
   result.set(headerBytes, 0);

package/src/protocol/validator.js

@@ -15,6 +15,12 @@ const { PROTOCOL_VERSION, MESSAGE_TYPE, MESH_CONFIG } = require('../constants');
  */
 const VALID_MESSAGE_TYPES = new Set(Object.values(MESSAGE_TYPE));
 
+/**
+ * Cached frozen result for valid validations to avoid repeated allocations.
+ * @type {{ valid: boolean, errors: string[] }}
+ */
+const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
+
 /**
  * Validates a message header.
  *
@@ -102,8 +108,12 @@ function validateHeader(header) {
     errors.push(`Fragment index (${header.fragmentIndex}) >= total (${header.fragmentTotal})`);
   }
 
+  if (errors.length === 0) {
+    return VALID_RESULT;
+  }
+
   return {
-    valid: errors.length === 0,
+    valid: false,
     errors
   };
 }
@@ -152,8 +162,12 @@ function validateMessage(message) {
     }
   }
 
+  if (errors.length === 0) {
+    return VALID_RESULT;
+  }
+
   return {
-    valid: errors.length === 0,
+    valid: false,
     errors
   };
 }
@@ -171,7 +185,7 @@ function validateChecksum(headerBytes) {
 
   const view = new DataView(headerBytes.buffer, headerBytes.byteOffset, HEADER_SIZE);
   const storedChecksum = view.getUint32(44, false);
-  const checksumData = headerBytes.slice(0, 44);
+  const checksumData = headerBytes.subarray(0, 44);
   const calculatedChecksum = crc32(checksumData);
 
   return {
@@ -242,7 +256,7 @@ function validateRawMessage(data) {
   }
 
   // Validate checksum
-  const checksumResult = validateChecksum(data.slice(0, HEADER_SIZE));
+  const checksumResult = validateChecksum(data.subarray(0, HEADER_SIZE));
   if (!checksumResult.valid) {
     errors.push(
       `Checksum mismatch: expected 0x${checksumResult.expected.toString(16)}, ` +
@@ -259,8 +273,12 @@ function validateRawMessage(data) {
     errors.push(`Incomplete message: expected ${expectedTotal} bytes, got ${data.length}`);
   }
 
+  if (errors.length === 0) {
+    return VALID_RESULT;
+  }
+
   return {
-    valid: errors.length === 0,
+    valid: false,
     errors
   };
 }

package/src/service/BatteryOptimizer.js

@@ -23,6 +23,9 @@ const BATTERY_MODE = Object.freeze({
   AUTO: 'auto'
 });
 
+/** Pre-computed Set of valid battery modes for O(1) lookup */
+const BATTERY_MODE_SET = new Set(Object.values(BATTERY_MODE));
+
 /**
  * Battery profile configuration
  * @typedef {Object} BatteryProfile
@@ -224,7 +227,7 @@ class BatteryOptimizer extends EventEmitter {
      * @returns {Promise<void>}
      */
   async setMode(mode) {
-    if (!Object.values(BATTERY_MODE).includes(mode)) {
+    if (!BATTERY_MODE_SET.has(mode)) {
       throw new Error(`Invalid battery mode: ${mode}`);
     }
 

package/src/service/HandshakeManager.js

@@ -177,32 +177,28 @@ class HandshakeManager extends EventEmitter {
         let sendNonce = 0;
         let recvNonce = 0;
 
+        // Pre-allocate nonce buffers per direction to avoid per-call allocation
+        const sendNonceBuf = new Uint8Array(24);
+        const sendNonceView = new DataView(sendNonceBuf.buffer);
+        const recvNonceBuf = new Uint8Array(24);
+        const recvNonceView = new DataView(recvNonceBuf.buffer);
+
         return {
           encrypt: (plaintext) => {
             if (provider && typeof provider.encrypt === 'function') {
-              // Use proper AEAD encryption with nonce
-              const nonce = new Uint8Array(24); // tweetnacl uses 24-byte nonces
-              const view = new DataView(nonce.buffer);
               // Store counter in last 8 bytes of nonce
-              if (nonce.byteLength >= 8) {
-                view.setUint32(nonce.byteLength - 8, 0, true);
-                view.setUint32(nonce.byteLength - 4, sendNonce++, true);
-              }
-              return provider.encrypt(sendKey, nonce, plaintext);
+              sendNonceView.setUint32(16, 0, true);
+              sendNonceView.setUint32(20, sendNonce++, true);
+              return provider.encrypt(sendKey, sendNonceBuf, plaintext);
             }
             throw new Error('Crypto provider required for encryption');
           },
 
           decrypt: (ciphertext) => {
             if (provider && typeof provider.decrypt === 'function') {
-              // Use proper AEAD decryption with nonce
-              const nonce = new Uint8Array(24);
-              const view = new DataView(nonce.buffer);
-              if (nonce.byteLength >= 8) {
-                view.setUint32(nonce.byteLength - 8, 0, true);
-                view.setUint32(nonce.byteLength - 4, recvNonce++, true);
-              }
-              return provider.decrypt(recvKey, nonce, ciphertext);
+              recvNonceView.setUint32(16, 0, true);
+              recvNonceView.setUint32(20, recvNonce++, true);
+              return provider.decrypt(recvKey, recvNonceBuf, ciphertext);
             }
             throw new Error('Crypto provider required for encryption');
           },

package/src/service/SessionManager.js

@@ -120,24 +120,26 @@ class SessionManager {
       // No crypto provider available
     }
 
+    // Pre-allocate nonce buffers per direction to avoid per-call allocation
+    const sendNonceBuf = new Uint8Array(24);
+    const sendNonceView = new DataView(sendNonceBuf.buffer);
+    const recvNonceBuf = new Uint8Array(24);
+    const recvNonceView = new DataView(recvNonceBuf.buffer);
+
     const session = {
       encrypt: (plaintext) => {
         if (provider && typeof provider.encrypt === 'function') {
-          const nonce = new Uint8Array(24);
-          const view = new DataView(nonce.buffer);
-          view.setUint32(nonce.byteLength - 8, 0, true);
-          view.setUint32(nonce.byteLength - 4, sendNonce++, true);
-          return provider.encrypt(sendKey, nonce, plaintext);
+          sendNonceView.setUint32(16, 0, true);
+          sendNonceView.setUint32(20, sendNonce++, true);
+          return provider.encrypt(sendKey, sendNonceBuf, plaintext);
         }
         return plaintext;
       },
       decrypt: (ciphertext) => {
         if (provider && typeof provider.decrypt === 'function') {
-          const nonce = new Uint8Array(24);
-          const view = new DataView(nonce.buffer);
-          view.setUint32(nonce.byteLength - 8, 0, true);
-          view.setUint32(nonce.byteLength - 4, recvNonce++, true);
-          return provider.decrypt(recvKey, nonce, ciphertext);
+          recvNonceView.setUint32(16, 0, true);
+          recvNonceView.setUint32(20, recvNonce++, true);
+          return provider.decrypt(recvKey, recvNonceBuf, ciphertext);
         }
         return ciphertext;
       },

package/src/service/text/TextManager.js

@@ -12,6 +12,13 @@ const TextMessage = require('./message/TextMessage');
 const { ChannelManager } = require('./channel');
 const { BroadcastManager } = require('./broadcast');
 
+/**
+ * Cached TextEncoder/TextDecoder instances to avoid per-call allocation
+ * @private
+ */
+const cachedEncoder = new TextEncoder();
+const cachedDecoder = new TextDecoder();
+
 /**
  * Text manager states
  * @constant {Object}
@@ -420,8 +427,8 @@ class TextManager extends EventEmitter {
   _handleChannelMessagePayload(peerId, payload) {
     // First byte is channel ID length
     const channelIdLength = payload[0];
-    const channelId = new TextDecoder().decode(payload.slice(1, 1 + channelIdLength));
-    const messagePayload = payload.slice(1 + channelIdLength);
+    const channelId = cachedDecoder.decode(payload.subarray(1, 1 + channelIdLength));
+    const messagePayload = payload.subarray(1 + channelIdLength);
 
     this.handleChannelMessage(peerId, channelId, messagePayload);
   }
@@ -435,7 +442,7 @@ class TextManager extends EventEmitter {
     while (offset < payload.length) {
       const length = payload[offset];
       offset += 1;
-      const messageId = new TextDecoder().decode(payload.slice(offset, offset + length));
+      const messageId = cachedDecoder.decode(payload.subarray(offset, offset + length));
       messageIds.push(messageId);
       offset += length;
     }
@@ -456,21 +463,20 @@ class TextManager extends EventEmitter {
     const messageIds = Array.from(this._pendingReadReceipts);
     this._pendingReadReceipts.clear();
 
-    // Build read receipt payload
-    const parts = messageIds.map(id => {
-      const bytes = new TextEncoder().encode(id);
-      const part = new Uint8Array(1 + bytes.length);
-      part[0] = bytes.length;
-      part.set(bytes, 1);
-      return part;
-    });
+    // Pre-calculate total size and allocate once
+    const encodedIds = messageIds.map(id => cachedEncoder.encode(id));
+    let totalLength = 0;
+    for (let i = 0; i < encodedIds.length; i++) {
+      totalLength += 1 + encodedIds[i].length;
+    }
 
-    const totalLength = parts.reduce((sum, p) => sum + p.length, 0);
     const payload = new Uint8Array(totalLength);
     let offset = 0;
-    for (const part of parts) {
-      payload.set(part, offset);
-      offset += part.length;
+    for (let i = 0; i < encodedIds.length; i++) {
+      payload[offset] = encodedIds[i].length;
+      offset += 1;
+      payload.set(encodedIds[i], offset);
+      offset += encodedIds[i].length;
     }
 
     this.emit('read-receipts-sent', { messageIds, count: messageIds.length });

package/src/storage/MessageStore.js

@@ -8,6 +8,52 @@
 const MemoryStorage = require('./MemoryStorage');
 const { MESH_CONFIG } = require('../constants');
 
+/**
+ * Base64 encoding/decoding for compact Uint8Array serialization
+ * @private
+ */
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+function uint8ArrayToBase64(bytes) {
+  let result = '';
+  const len = bytes.length;
+  for (let i = 0; i < len; i += 3) {
+    const b0 = bytes[i];
+    const b1 = i + 1 < len ? bytes[i + 1] : 0;
+    const b2 = i + 2 < len ? bytes[i + 2] : 0;
+    result += BASE64_CHARS[b0 >> 2];
+    result += BASE64_CHARS[((b0 & 3) << 4) | (b1 >> 4)];
+    result += (i + 1 < len) ? BASE64_CHARS[((b1 & 15) << 2) | (b2 >> 6)] : '=';
+    result += (i + 2 < len) ? BASE64_CHARS[b2 & 63] : '=';
+  }
+  return result;
+}
+
+const BASE64_LOOKUP = new Uint8Array(128);
+for (let i = 0; i < BASE64_CHARS.length; i++) {
+  BASE64_LOOKUP[BASE64_CHARS.charCodeAt(i)] = i;
+}
+
+function base64ToUint8Array(str) {
+  const len = str.length;
+  let padding = 0;
+  if (str[len - 1] === '=') { padding++; }
+  if (str[len - 2] === '=') { padding++; }
+  const byteLen = (len * 3 / 4) - padding;
+  const bytes = new Uint8Array(byteLen);
+  let j = 0;
+  for (let i = 0; i < len; i += 4) {
+    const a = BASE64_LOOKUP[str.charCodeAt(i)];
+    const b = BASE64_LOOKUP[str.charCodeAt(i + 1)];
+    const c = BASE64_LOOKUP[str.charCodeAt(i + 2)];
+    const d = BASE64_LOOKUP[str.charCodeAt(i + 3)];
+    bytes[j++] = (a << 2) | (b >> 4);
+    if (j < byteLen) { bytes[j++] = ((b & 15) << 4) | (c >> 2); }
+    if (j < byteLen) { bytes[j++] = ((c & 3) << 6) | d; }
+  }
+  return bytes;
+}
+
 /**
  * Message store for persisting and retrieving mesh network messages.
  * Provides message caching, deduplication support, and cleanup functionality.
@@ -69,8 +115,9 @@ class MessageStore {
     const storedMessage = {
       ...message,
       payload: message.payload
-        ? Array.from(message.payload)
+        ? uint8ArrayToBase64(message.payload)
         : undefined,
+      payloadEncoding: message.payload ? 'base64' : undefined,
       storedAt: Date.now()
     };
 
@@ -96,7 +143,13 @@ class MessageStore {
 
     // Convert payload back to Uint8Array
     if (message.payload) {
-      message.payload = new Uint8Array(message.payload);
+      if (message.payloadEncoding === 'base64') {
+        message.payload = base64ToUint8Array(message.payload);
+      } else if (Array.isArray(message.payload)) {
+        // Backwards compatibility with old Array.from() format
+        message.payload = new Uint8Array(message.payload);
+      }
+      delete message.payloadEncoding;
     }
 
     return message;

package/src/transport/BLETransport.js

@@ -293,6 +293,15 @@ class BLETransport extends Transport {
       await this._adapter.disconnect(peerId);
     } finally {
       this._peers.delete(peerId);
+
+      // Clean up write queue and writing state
+      const queue = this._writeQueue.get(peerId);
+      if (queue) {
+        queue.forEach(({ reject }) => reject(new Error('Peer disconnected')));
+        this._writeQueue.delete(peerId);
+      }
+      this._writing.delete(peerId);
+
       this.emit('peerDisconnected', { peerId, reason: 'user_request' });
     }
   }
@@ -325,7 +334,7 @@ class BLETransport extends Transport {
 
     // Chunk data for BLE MTU compliance
     for (let offset = 0; offset < data.length; offset += chunkSize) {
-      const chunk = data.slice(offset, Math.min(offset + chunkSize, data.length));
+      const chunk = data.subarray(offset, Math.min(offset + chunkSize, data.length));
       await this._queuedWrite(peerId, chunk);
     }
   }
@@ -414,7 +423,7 @@ class BLETransport extends Transport {
    * @private
    */
   _handleData(peerId, data) {
-    this.emit('message', { peerId, data: new Uint8Array(data) });
+    this.emit('message', { peerId, data: data instanceof Uint8Array ? data : new Uint8Array(data) });
   }
 
   /**

package/src/transport/MultiTransport.js

@@ -54,6 +54,9 @@ class MultiTransport extends Transport {
 
     /** @type {Map<string, string>} peerId → preferred transport name */
     this._peerTransportMap = new Map();
+
+    /** @type {Array<{transport: Transport, event: string, handler: Function}>} */
+    this._wiredHandlers = [];
   }
 
   /**
@@ -122,6 +125,13 @@ class MultiTransport extends Transport {
     if (this._wifiTransport) { stopPromises.push(this._wifiTransport.stop().catch(() => {})); }
 
     await Promise.allSettled(stopPromises);
+
+    // Remove wired event handlers to prevent listener leaks
+    for (const { transport, event, handler } of this._wiredHandlers) {
+      transport.off(event, handler);
+    }
+    this._wiredHandlers = [];
+
     this._peers.clear();
     this._peerTransportMap.clear();
     this._setState(Transport.STATE.STOPPED);
@@ -272,13 +282,13 @@ class MultiTransport extends Transport {
    * @private
    */
   _wireTransport(transport, name) {
-    transport.on('peerConnected', (info) => {
+    const onPeerConnected = (info) => {
       this._peerTransportMap.set(info.peerId, name);
       this._peers.set(info.peerId, { ...info, transport: name });
       this.emit('peerConnected', { ...info, transport: name });
-    });
+    };
 
-    transport.on('peerDisconnected', (info) => {
+    const onPeerDisconnected = (info) => {
       // Only remove if no other transport has this peer
       const otherTransport = this._getFallbackTransport(transport);
       if (!otherTransport || !otherTransport.isConnected(info.peerId)) {
@@ -286,19 +296,34 @@ class MultiTransport extends Transport {
         this._peerTransportMap.delete(info.peerId);
         this.emit('peerDisconnected', { ...info, transport: name });
       }
-    });
+    };
 
-    transport.on('message', (msg) => {
+    const onMessage = (msg) => {
       this.emit('message', { ...msg, transport: name });
-    });
+    };
 
-    transport.on('deviceDiscovered', (info) => {
+    const onDeviceDiscovered = (info) => {
       this.emit('deviceDiscovered', { ...info, transport: name });
-    });
+    };
 
-    transport.on('error', (err) => {
+    const onError = (err) => {
       this.emit('transportError', { transport: name, error: err });
-    });
+    };
+
+    transport.on('peerConnected', onPeerConnected);
+    transport.on('peerDisconnected', onPeerDisconnected);
+    transport.on('message', onMessage);
+    transport.on('deviceDiscovered', onDeviceDiscovered);
+    transport.on('error', onError);
+
+    // Store references for cleanup
+    this._wiredHandlers.push(
+      { transport, event: 'peerConnected', handler: onPeerConnected },
+      { transport, event: 'peerDisconnected', handler: onPeerDisconnected },
+      { transport, event: 'message', handler: onMessage },
+      { transport, event: 'deviceDiscovered', handler: onDeviceDiscovered },
+      { transport, event: 'error', handler: onError }
+    );
   }
 }
 

package/src/transport/WiFiDirectTransport.js

@@ -284,10 +284,11 @@ class WiFiDirectTransport extends Transport {
 
   /** @private */
   _uint8ArrayToBase64(bytes) {
-    let binary = '';
-    for (let i = 0; i < bytes.length; i++) {
-      binary += String.fromCharCode(bytes[i]);
+    const chunks = [];
+    for (let i = 0; i < bytes.length; i += 8192) {
+      chunks.push(String.fromCharCode.apply(null, bytes.subarray(i, Math.min(i + 8192, bytes.length))));
     }
+    const binary = chunks.join('');
     return typeof btoa !== 'undefined' ? btoa(binary) : Buffer.from(bytes).toString('base64');
   }
 }

package/src/utils/EventEmitter.js

@@ -116,10 +116,11 @@ class EventEmitter {
       return false;
     }
 
-    const listeners = this._events.get(event).slice();
-    const toRemove = [];
+    const listeners = this._events.get(event);
+    const hasOnce = listeners.some(e => e.once);
+    const iterList = hasOnce ? listeners.slice() : listeners;
 
-    for (const entry of listeners) {
+    for (const entry of iterList) {
       try {
         entry.listener.apply(this, args);
       } catch (error) {
@@ -130,15 +131,11 @@ class EventEmitter {
           console.error('Error in error handler:', error);
         }
       }
-
-      if (entry.once) {
-        toRemove.push(entry);
-      }
     }
 
     // Remove one-time listeners
-    if (toRemove.length > 0) {
-      const remaining = this._events.get(event).filter(e => !toRemove.includes(e));
+    if (hasOnce) {
+      const remaining = listeners.filter(e => !e.once);
       if (remaining.length === 0) {
         this._events.delete(event);
       } else {

package/src/utils/bytes.js

@@ -11,9 +11,16 @@
  * @returns {Uint8Array} Concatenated array
  */
 function concat(...arrays) {
-  // Filter out undefined/null and calculate total length
-  const validArrays = arrays.filter(arr => arr !== null && arr !== undefined);
-  const totalLength = validArrays.reduce((sum, arr) => sum + arr.length, 0);
+  // Single-pass: filter out undefined/null and calculate total length
+  const validArrays = [];
+  let totalLength = 0;
+  for (let i = 0; i < arrays.length; i++) {
+    const arr = arrays[i];
+    if (arr !== null && arr !== undefined) {
+      validArrays.push(arr);
+      totalLength += arr.length;
+    }
+  }
 
   const result = new Uint8Array(totalLength);
   let offset = 0;
@@ -119,10 +126,7 @@ function xor(a, b) {
  * @returns {Uint8Array} The filled array (same reference)
  */
 function fill(array, value) {
-  const byte = value & 0xff;
-  for (let i = 0; i < array.length; i++) {
-    array[i] = byte;
-  }
+  array.fill(value & 0xff);
   return array;
 }
 
@@ -132,9 +136,7 @@ function fill(array, value) {
  * @returns {Uint8Array} Copy of the array
  */
 function copy(array) {
-  const result = new Uint8Array(array.length);
-  result.set(array);
-  return result;
+  return array.slice();
 }
 
 /**