feat: utf8fromString never returns pooled Uint8Arrays

Author: ChALkeR

fallback/_utils.js

@@ -19,6 +19,7 @@ export const toBuf = (x) =>
 export const E_STRING = 'Input is not a string'
 export const E_STRICT_UNICODE = 'Input is not well-formed Unicode'
 
+// Input is never pooled
 export function fromUint8(arr, format) {
   switch (format) {
     case 'uint8':
@@ -31,3 +32,21 @@ export function fromUint8(arr, format) {
 
   throw new TypeError('Unexpected format')
 }
+
+// Input can be pooled
+export function fromBuffer(arr, format) {
+  switch (format) {
+    case 'uint8':
+      // byteOffset check is slightly faster and covers most pooling, so it comes first
+      if (arr.length <= 64 || arr.byteOffset !== 0 || arr.byteLength !== arr.buffer.byteLength) {
+        return new Uint8Array(arr)
+      }
+
+      return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength)
+    case 'buffer':
+      if (arr.constructor !== Buffer) throw new Error('Unexpected')
+      return arr
+  }
+
+  throw new TypeError('Unexpected format')
+}

fallback/encoding.js

@@ -214,9 +214,7 @@ export class TextEncoder {
 
   encode(str = '') {
     if (typeof str !== 'string') str = `${str}`
-    const res = utf8fromStringLoose(str)
-    // match new Uint8Array (per spec), which is non-pooled
-    return res.byteOffset === 0 && res.length === res.buffer.byteLength ? res : res.slice(0)
+    return utf8fromStringLoose(str) // non-pooled
   }
 
   encodeInto(str, target) {

utf8.node.js

@@ -1,5 +1,4 @@
-import { typedView } from './array.js'
-import { assertU8, E_STRING, E_STRICT_UNICODE } from './fallback/_utils.js'
+import { assertU8, fromBuffer, E_STRING, E_STRICT_UNICODE } from './fallback/_utils.js'
 import { E_STRICT } from './fallback/utf8.js'
 import { isAscii } from 'node:buffer'
 
@@ -16,26 +15,27 @@ try {
   // Without ICU, Node.js doesn't support fatal option for utf-8
 }
 
-function encode(str, loose = false) {
+function encode(str, loose, format) {
   if (typeof str !== 'string') throw new TypeError(E_STRING)
   const strLength = str.length
   if (strLength === 0) return new Uint8Array() // faster than Uint8Array.of
   let res
   if (strLength > 0x4_00 && !isDeno) {
     // Faster for large strings
     const byteLength = Buffer.byteLength(str)
-    res = Buffer.allocUnsafe(byteLength)
-    const ascii = byteLength === strLength
-    const written = ascii ? res.latin1Write(str) : res.utf8Write(str)
+    res = format === 'buffer' ? Buffer.allocUnsafe(byteLength) : Buffer.allocUnsafeSlow(byteLength)
+    const written = byteLength === strLength ? res.latin1Write(str) : res.utf8Write(str)
     if (written !== byteLength) throw new Error('Failed to write all bytes') // safeguard just in case
-    if (ascii || loose) return res // no further checks needed
   } else {
     res = Buffer.from(str)
-    if (res.length === strLength || loose) return res
   }
 
-  if (!isWellFormed.call(str)) throw new TypeError(E_STRICT_UNICODE)
-  return res
+  // Loose and ascii do not need the check
+  if (!loose && res.length !== strLength && !isWellFormed.call(str)) {
+    throw new TypeError(E_STRICT_UNICODE)
+  }
+
+  return fromBuffer(res, format)
 }
 
 function decode(arr, loose = false) {
@@ -61,7 +61,7 @@ function decode(arr, loose = false) {
   return str
 }
 
-export const utf8fromString = (str, format = 'uint8') => typedView(encode(str, false), format)
-export const utf8fromStringLoose = (str, format = 'uint8') => typedView(encode(str, true), format)
+export const utf8fromString = (str, format = 'uint8') => encode(str, false, format)
+export const utf8fromStringLoose = (str, format = 'uint8') => encode(str, true, format)
 export const utf8toString = (arr) => decode(arr, false)
 export const utf8toStringLoose = (arr) => decode(arr, true)