perf: use utf16 slice in shift_jis decoder

Author: ChALkeR

fallback/latin1.js

@@ -5,6 +5,7 @@ import {
   nativeBuffer,
   isHermes,
   isDeno,
+  isLE,
 } from './_utils.js'
 
 // See http://stackoverflow.com/a/22747272/680742, which says that lowest limit is in Chrome, with 0xffff args
@@ -60,6 +61,16 @@ export function decodeLatin1(arr, start = 0, stop = arr.length) {
   return String.fromCharCode.apply(String, sliced)
 }
 
+// Unchecked for well-formedness, raw. Expects Uint16Array input
+export const decodeUCS2 =
+  nativeBuffer && isLE && !isDeno
+    ? (u16, stop = u16.length) => {
+        // TODO: fast path for BE, perhaps faster path for Deno. Note that decoder replaces, this function doesn't
+        if (stop > 32) return nativeBuffer.from(u16.buffer, u16.byteOffset, stop * 2).ucs2Slice() // from 64 bytes, below are in heap
+        return decodeLatin1(u16, 0, stop)
+      }
+    : (u16, stop = u16.length) => decodeLatin1(u16, 0, stop)
+
 // Does not check input, uses best available method
 // Building an array for this is only faster than proper string concatenation when TextDecoder or native Buffer are available
 export const decodeAscii = nativeBuffer

fallback/multi-byte.js

@@ -1,4 +1,4 @@
-import { asciiPrefix, decodeLatin1 } from './latin1.js'
+import { asciiPrefix, decodeLatin1, decodeUCS2 } from './latin1.js'
 import { getTable } from './multi-byte.table.js'
 
 export const E_STRICT = 'Input is not well-formed for this encoding'
@@ -281,45 +281,56 @@ const mappers = {
   shift_jis: (err) => {
     const jis0208 = getTable('jis0208')
     let lead = 0
+    let oi = 0
+    let out
 
     const decodeLead = (b) => {
       const l = lead
       lead = 0
       if (b >= 0x40 && b <= 0xfc && b !== 0x7f) {
         const p = (l - (l < 0xa0 ? 0x81 : 0xc1)) * 188 + b - (b < 0x7f ? 0x40 : 0x41)
-        if (p >= 8836 && p <= 10_715) return String.fromCharCode(0xe0_00 - 8836 + p)
+        if (p >= 8836 && p <= 10_715) {
+          out[oi++] = 0xe0_00 - 8836 + p
+          return
+        }
+
         const cp = jis0208[p]
-        if (cp !== undefined && cp !== REP) return String.fromCharCode(cp)
+        if (cp !== undefined && cp !== REP) {
+          out[oi++] = cp
+          return
+        }
       }
 
-      return b < 128 ? String.fromCharCode(err(), b) : String.fromCharCode(err())
+      out[oi++] = err()
+      if (b < 128) out[oi++] = b
     }
 
     const decode = (arr, start, end, stream) => {
-      let res = ''
+      out = new Uint16Array(end - start)
+      oi = 0
       let i = start
 
-      if (lead && i < end) res += decodeLead(arr[i++])
+      if (lead && i < end) decodeLead(arr[i++])
       while (i < end) {
         const b = arr[i++]
         if (b <= 0x80) {
-          res += String.fromCharCode(b) // 0x80 is allowed
+          out[oi++] = b // 0x80 is allowed
         } else if (b >= 0xa1 && b <= 0xdf) {
-          res += String.fromCharCode(0xfe_c0 + b)
+          out[oi++] = 0xfe_c0 + b
         } else if (b === 0xa0 || b > 0xfc) {
-          res += String.fromCharCode(err())
+          out[oi++] = err()
         } else {
           lead = b
-          if (i < end) res += decodeLead(arr[i++])
+          if (i < end) decodeLead(arr[i++])
         }
       }
 
       if (lead && !stream) {
         lead = 0
-        res += String.fromCharCode(err())
+        out[oi++] = err()
       }
 
-      return res
+      return decodeUCS2(out, oi)
     }
 
     return { decode, isAscii: () => lead === 0 }

fallback/utf16.js

@@ -1,4 +1,4 @@
-import { decodeLatin1, encodeCharcodes } from './latin1.js'
+import { decodeUCS2, encodeCharcodes } from './latin1.js'
 import { isLE } from './_utils.js'
 
 export const E_STRICT = 'Input is not well-formed utf16'
@@ -38,9 +38,9 @@ export function to16input(u8, le) {
 }
 
 export const decode = (u16, loose = false, checked = false) => {
-  if (checked || isWellFormed(u16)) return decodeLatin1(u16, 0, u16.length) // it's capable of decoding Uint16Array to UTF-16 as well
+  if (checked || isWellFormed(u16)) return decodeUCS2(u16)
   if (!loose) throw new TypeError(E_STRICT)
-  return decodeLatin1(toWellFormed(Uint16Array.from(u16)), 0, u16.length) // cloned for replacement
+  return decodeUCS2(toWellFormed(Uint16Array.from(u16))) // cloned for replacement
 }
 
 export function encode(str, loose = false, checked = false, swapped = false) {