fix: support cross-context Uint8Array in TextEncoder#encodeInto

Author: ChALkeR

fallback/encoding.js

@@ -47,6 +47,10 @@ export function normalizeEncoding(label) {
 
 const define = (obj, key, value) => Object.defineProperty(obj, key, { value, writable: false })
 
+// TODO: make this more strict against Symbol.toStringTag
+// Is not very significant though, anything faking Symbol.toStringTag could as well override
+// prototypes, which is not something we protect against
+
 function isAnyArrayBuffer(x) {
   if (x instanceof ArrayBuffer) return true
   if (globalThis.SharedArrayBuffer && x instanceof SharedArrayBuffer) return true
@@ -55,6 +59,12 @@ function isAnyArrayBuffer(x) {
   return s === '[object ArrayBuffer]' || s === '[object SharedArrayBuffer]'
 }
 
+function isAnyUint8Array(x) {
+  if (x instanceof Uint8Array) return true
+  if (!x || !ArrayBuffer.isView(x) || x.BYTES_PER_ELEMENT !== 1) return false
+  return Object.prototype.toString.call(x) === '[object Uint8Array]'
+}
+
 const fromSource = (x) => {
   if (x instanceof Uint8Array) return x
   if (ArrayBuffer.isView(x)) return new Uint8Array(x.buffer, x.byteOffset, x.byteLength)
@@ -217,7 +227,7 @@ export class TextEncoder {
 
   encodeInto(str, target) {
     if (typeof str !== 'string') str = `${str}`
-    if (!(target instanceof Uint8Array)) throw new TypeError('Target must be an Uint8Array')
+    if (!isAnyUint8Array(target)) throw new TypeError('Target must be an Uint8Array')
     if (target.buffer.detached) return { read: 0, written: 0 } // Until https://github.com/whatwg/encoding/issues/324 is resolved
 
     const tlen = target.length

tests/encoding/cross-context.test.cjs

@@ -13,13 +13,23 @@ describe('vm', { skip: !vm }, () => {
   const u = Uint8Array.of(0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0xe2, 0x88, 0x80)
   const ctx = { TextDecoder, TextEncoder }
 
-  test('TextEncoder', (t) => {
+  test('TextEncoder.encode', (t) => {
     const outer = new TextEncoder().encode(string)
     const inner = vm.runInNewContext(`new TextEncoder().encode(${JSON.stringify(string)})`, ctx)
     t.assert.deepStrictEqual(outer, u)
     t.assert.deepStrictEqual(inner, u)
   })
 
+  test('TextEncoder.encodeInto', (t) => {
+    const res = vm.runInNewContext(
+      `ua = new Uint8Array(25); [new TextEncoder().encodeInto(${JSON.stringify(string)}, ua), ua]`,
+      ctx
+    )
+    t.assert.deepStrictEqual(res[0], { read: 8, written: 10 })
+    t.assert.deepEqual(res[1].subarray(0, 10), u)
+    t.assert.deepEqual(res[1].subarray(10), new Uint8Array(15))
+  })
+
   test('TextDecoder + Uint8Array', (t) => {
     const outer = new TextDecoder().decode(u)
     const inner = vm.runInNewContext(`new TextDecoder().decode(Uint8Array.of(${u.join(',')}))`, ctx)