fromUint8Super -> fromTypedArray

Author: ChALkeR

base64.js

@@ -1,5 +1,5 @@
 import { assert, assertUint8 } from './assert.js'
-import { fromUint8Super } from './convert.js'
+import { fromTypedArray } from './convert.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
 
@@ -54,7 +54,7 @@ export function fromBase64(arg, format = 'uint8') {
   }
 
   assert(!/[^0-9a-z=+/]/ui.test(arg), 'Invalid character in base64 input')
-  return fromUint8Super(fromBase64common(arg, false), format)
+  return fromTypedArray(fromBase64common(arg, false), format)
 }
 
 export function fromBase64url(arg, format = 'uint8') {
@@ -65,7 +65,7 @@ export function fromBase64url(arg, format = 'uint8') {
   assert(!arg.includes('='), 'Did not expect padding in base64url input')
 
   assert(!/[^0-9a-z_-]/ui.test(arg), 'Invalid character in base64url input')
-  return fromUint8Super(fromBase64common(arg, true), format)
+  return fromTypedArray(fromBase64common(arg, true), format)
 }
 
 function checkLastBase64Chunk(s, arr, isBase64url = false) {

convert.js

@@ -1,14 +1,15 @@
-import { assert, assertUint8 } from './assert.js'
+import { assert } from './assert.js'
 
 const { Buffer } = globalThis // Buffer is optional, only used when native
 const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
 
 let hexArray
 let dehexArray
 
-// From Uint8Array or a Buffer, defaults to uint8
-export function fromUint8Super(arr, format = 'uint8') {
-  assertUint8(arr)
+const TypedArray = Object.getPrototypeOf(Uint8Array)
+
+export function fromTypedArray(arr, format = 'uint8') {
+  assert(arr instanceof TypedArray, 'Expected a TypedArray instance')
   switch (format) {
     case 'uint8':
       if (arr.constructor === Uint8Array) return arr // fast path
@@ -17,14 +18,15 @@ export function fromUint8Super(arr, format = 'uint8') {
       if (arr.constructor === Buffer && Buffer.isBuffer(arr)) return arr
       return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength)
     case 'hex':
-      if (Uint8Array.prototype.toHex && arr.toHex === Uint8Array.prototype.toHex) return arr.toHex()
+      const u8 = arr instanceof Uint8Array ? arr : new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength)
+      if (Uint8Array.prototype.toHex && u8.toHex === Uint8Array.prototype.toHex) return u8.toHex()
       if (haveNativeBuffer) {
         if (arr.constructor === Buffer && Buffer.isBuffer(arr)) return arr.toString('hex')
         return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).toString('hex')
       }
       if (!hexArray) hexArray = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'))
       let out = ''
-      for (let i = 0; i < arr.length; i++) out += hexArray[arr[i]]
+      for (let i = 0; i < arr.length; i++) out += hexArray[u8[i]]
       return out
   }
 
@@ -33,12 +35,12 @@ export function fromUint8Super(arr, format = 'uint8') {
 
 // Unlike Buffer.from(), throws on invalid input
 export function fromHex(arg, format = 'uint8') {
-  if (Uint8Array.fromHex) return fromUint8Super(Uint8Array.fromHex(arg), format)
+  if (Uint8Array.fromHex) return fromTypedArray(Uint8Array.fromHex(arg), format)
   if (typeof arg !== 'string') throw new TypeError('Input is not a string')
   assert(arg.length % 2 === 0, 'Input is not a hex string')
   if (haveNativeBuffer) {
     assert(!/[^0-9a-f]/ui.test(arg), 'Input is not a hex string')
-    return fromUint8Super(Buffer.from(arg, 'hex'), format)
+    return fromTypedArray(Buffer.from(arg, 'hex'), format)
   }
 
   if (!dehexArray) {
@@ -57,5 +59,5 @@ export function fromHex(arg, format = 'uint8') {
     arr[i] = a
   }
 
-  return fromUint8Super(arr, format)
+  return fromTypedArray(arr, format)
 }

tests/convert.test.js

@@ -1,4 +1,4 @@
-import { fromUint8Super, fromHex } from '@exodus/bytes/convert.js'
+import { fromTypedArray, fromHex } from '@exodus/bytes/convert.js'
 import { describe, test } from 'node:test'
 
 const raw = [new Uint8Array(), new Uint8Array([0]), new Uint8Array([1]), new Uint8Array([255])]
@@ -12,22 +12,22 @@ const pool = raw.map((uint8) => {
   return { uint8, buffer, hex: buffer.toString('hex') }
 })
 
-describe('fromUint8Super', () => {
+describe('fromTypedArray', () => {
   test('invalid input', (t) => {
-    for (const input of [null, undefined, [], [1,2], new Uint16Array(1), 'string']) {
-      t.assert.throws(() => fromUint8Super(input))
+    for (const input of [null, undefined, [], [1,2], 'string']) {
+      t.assert.throws(() => fromTypedArray(input))
       for (const form of ['uint8', 'buffer', 'hex']) {
-        t.assert.throws(() => fromUint8Super(input, form))
+        t.assert.throws(() => fromTypedArray(input, form))
       }
     }
   })
 
   test('uint8', (t) => {
     for (const { buffer, uint8 } of pool) {
-      t.assert.strictEqual(fromUint8Super(uint8), uint8)
-      t.assert.strictEqual(fromUint8Super(uint8, 'uint8'), uint8)
-      const a = fromUint8Super(buffer)
-      const b = fromUint8Super(buffer, 'uint8')
+      t.assert.strictEqual(fromTypedArray(uint8), uint8)
+      t.assert.strictEqual(fromTypedArray(uint8, 'uint8'), uint8)
+      const a = fromTypedArray(buffer)
+      const b = fromTypedArray(buffer, 'uint8')
       t.assert.deepStrictEqual(a, uint8)
       t.assert.strictEqual(a.buffer, buffer.buffer)
       t.assert.deepStrictEqual(b, uint8)
@@ -37,17 +37,17 @@ describe('fromUint8Super', () => {
 
   test('buffer', (t) => {
     for (const { uint8, buffer } of pool) {
-      t.assert.strictEqual(fromUint8Super(buffer, 'buffer'), buffer)
-      const a = fromUint8Super(uint8, 'buffer')
+      t.assert.strictEqual(fromTypedArray(buffer, 'buffer'), buffer)
+      const a = fromTypedArray(uint8, 'buffer')
       t.assert.deepStrictEqual(a, buffer)
       t.assert.strictEqual(a.buffer, uint8.buffer)
     }
   })
 
   test('hex', (t) => {
     for (const { uint8, buffer, hex} of pool) {
-      t.assert.strictEqual(fromUint8Super(uint8, 'hex'), hex)
-      t.assert.strictEqual(fromUint8Super(buffer, 'hex'), hex)
+      t.assert.strictEqual(fromTypedArray(uint8, 'hex'), hex)
+      t.assert.strictEqual(fromTypedArray(buffer, 'hex'), hex)
     }
   })
 })