feat: single-byte encoder never returns pooled Uint8Arrays

Also, this is a performance improvement

Author: ChALkeR

single-byte.js

@@ -1,6 +1,6 @@
 import { assertU8, E_STRING } from './fallback/_utils.js'
 import { nativeDecoderLatin1, nativeEncoder } from './fallback/platform.js'
-import { encodeAscii, encodeAsciiPrefix, encodeLatin1 } from './fallback/latin1.js'
+import { encodeAsciiPrefix, encodeLatin1 } from './fallback/latin1.js'
 import { assertEncoding, encodingDecoder, encodeMap, E_STRICT } from './fallback/single-byte.js'
 
 const { TextDecoder, btoa } = globalThis
@@ -120,9 +120,8 @@ export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
     // Instead of an ASCII regex check, encode optimistically - this is faster
     // Check for 8-bit string with a regex though, this is instant on 8-bit strings so doesn't hurt the ASCII fast path
     if (nativeEncoder && !NON_LATIN.test(s)) {
-      try {
-        return encodeAscii(s, E_STRICT)
-      } catch {}
+      const u8 = nativeEncoder.encode(str)
+      if (u8.length === str.length) return codes
     }
 
     const res = encode(s, m)

single-byte.node.js

@@ -107,8 +107,13 @@ export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
     // Instead of an ASCII regex check, encode optimistically - this is faster
     // Check for 8-bit string with a regex though, this is instant on 8-bit strings so doesn't hurt the ASCII fast path
     if (!NON_LATIN.test(s)) {
-      const b = Buffer.from(s, 'utf8') // ascii/latin1 coerces, we need to check
-      if (b.length === s.length) return new Uint8Array(b.buffer, b.byteOffset, b.byteLength)
+      const byteLength = Buffer.byteLength(s)
+      // ascii/latin1 coerces, we need to check
+      if (byteLength === s.length) {
+        const ab = new ArrayBuffer(byteLength)
+        Buffer.from(ab).latin1Write(s)
+        return new Uint8Array(ab)
+      }
     }
 
     const res = encode(s, m)

tests/single-byte.test.js

@@ -159,7 +159,9 @@ describe('single-byte encodings index: Unicode', () => {
           t.assert.strictEqual(decoderLoose(Uint8Array.of(byte)), str)
           t.assert.strictEqual(decoder(toShared(Uint8Array.of(byte))), str)
           t.assert.strictEqual(decoderLoose(toShared(Uint8Array.of(byte))), str)
-          t.assert.deepStrictEqual(encoder(str), Uint8Array.of(byte))
+          const u8 = encoder(str)
+          t.assert.deepStrictEqual(u8, Uint8Array.of(byte))
+          t.assert.strictEqual(u8.byteLength, u8.buffer.byteLength)
         }
       }
     })
@@ -214,7 +216,9 @@ describe('single-byte encodings index: WHATWG', () => {
           t.assert.strictEqual(str, decoderLoose(Uint8Array.of(byte)))
           t.assert.strictEqual(decoder(toShared(Uint8Array.of(byte))), str)
           t.assert.strictEqual(decoderLoose(toShared(Uint8Array.of(byte))), str)
-          t.assert.deepStrictEqual(encoder(str), Uint8Array.of(byte))
+          const u8 = encoder(str)
+          t.assert.deepStrictEqual(u8, Uint8Array.of(byte))
+          t.assert.strictEqual(u8.byteLength, u8.buffer.byteLength)
         } else {
           t.assert.throws(() => decoder(Uint8Array.of(byte)))
           t.assert.throws(() => decoder(toShared(Uint8Array.of(byte))))
@@ -263,7 +267,9 @@ describe('single-byte encodings index: WHATWG non-normative indexes.json', () =>
           t.assert.strictEqual(decoderLoose(Uint8Array.of(byte)), str)
           t.assert.strictEqual(decoder(toShared(Uint8Array.of(byte))), str)
           t.assert.strictEqual(decoderLoose(toShared(Uint8Array.of(byte))), str)
-          t.assert.deepStrictEqual(encoder(str), Uint8Array.of(byte))
+          const u8 = encoder(str)
+          t.assert.deepStrictEqual(u8, Uint8Array.of(byte))
+          t.assert.strictEqual(u8.byteLength, u8.buffer.byteLength)
         } else {
           t.assert.throws(() => decoder(Uint8Array.of(byte)))
           t.assert.throws(() => decoder(toShared(Uint8Array.of(byte))))
@@ -294,7 +300,9 @@ describe('x-user-defined', () => {
     const encoder = createSinglebyteEncoder(encoding)
     for (let byte = 0; byte < 256; byte++) {
       const str = String.fromCodePoint(byte >= 0x80 ? 0xf7_80 + byte - 0x80 : byte)
-      t.assert.deepStrictEqual(encoder(str), Uint8Array.of(byte), byte)
+      const u8 = encoder(str)
+      t.assert.deepStrictEqual(u8, Uint8Array.of(byte))
+      t.assert.strictEqual(u8.byteLength, u8.buffer.byteLength)
     }
 
     for (let i = 128; i < 512; i++) {