refactor: move js decode api impl to fallback/utf16.js

Author: ChALkeR

fallback/utf16.js

@@ -1,5 +1,5 @@
 import { decodeUCS2, encodeCharcodes } from './latin1.js'
-import { isLE, E_STRING, E_STRICT_UNICODE } from './_utils.js'
+import { nativeDecoder, isLE, E_STRING, E_STRICT_UNICODE } from './_utils.js'
 
 export const E_STRICT = 'Input is not well-formed utf16'
 const { TextDecoder } = globalThis
@@ -28,6 +28,12 @@ export function encodeApi(str, loose, format) {
   return format === 'uint16' ? u16 : new Uint8Array(u16.buffer, u16.byteOffset, u16.byteLength)
 }
 
+const ignoreBOM = true
+const decFatalLE = nativeDecoder ? new TextDecoder('utf-16le', { ignoreBOM, fatal: true }) : null
+const decLooseLE = nativeDecoder ? new TextDecoder('utf-16le', { ignoreBOM }) : null
+const decFatalBE = nativeDecoder ? new TextDecoder('utf-16be', { ignoreBOM, fatal: true }) : null
+const decLooseBE = nativeDecoder ? new TextDecoder('utf-16be', { ignoreBOM }) : null
+
 export function decodeApiDecoders(input, loose, format) {
   if (format === 'uint16') {
     if (!(input instanceof Uint16Array)) throw new TypeError('Expected an Uint16Array')
@@ -38,8 +44,36 @@ export function decodeApiDecoders(input, loose, format) {
     throw new TypeError('Unknown format')
   }
 
-  const encoding = format === 'uint8-le' || (format === 'uint16' && isLE) ? 'utf-16le' : 'utf-16be'
-  return new TextDecoder(encoding, { ignoreBOM: true, fatal: !loose }).decode(input)
+  const le = format === 'uint8-le' || (format === 'uint16' && isLE)
+  return (le ? (loose ? decLooseLE : decFatalLE) : loose ? decLooseBE : decFatalBE).decode(input)
+}
+
+export function decodeApiJS(input, loose, format) {
+  let u16
+  switch (format) {
+    case 'uint16':
+      if (!(input instanceof Uint16Array)) throw new TypeError('Expected an Uint16Array')
+      u16 = input
+      break
+    case 'uint8-le':
+      if (!(input instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
+      if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
+      u16 = to16input(input, true)
+      break
+    case 'uint8-be':
+      if (!(input instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
+      if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
+      u16 = to16input(input, false)
+      break
+    default:
+      throw new TypeError('Unknown format')
+  }
+
+  const str = decode(u16, loose, (!loose && isWellFormedStr) || (loose && isWellFormedStr))
+  if (!loose && isWellFormedStr && !isWellFormedStr.call(str)) throw new TypeError(E_STRICT)
+  if (loose && isWellFormedStr) return isWellFormedStr.call(str)
+
+  return str
 }
 
 export function to16input(u8, le) {

utf16.native.js

@@ -1,5 +1,5 @@
-import * as js from './fallback/utf16.js'
-import { nativeDecoder, isLE } from './fallback/_utils.js'
+import { encodeApi, decodeApiDecoders, decodeApiJS } from './fallback/utf16.js'
+import { nativeDecoder } from './fallback/_utils.js'
 
 function checkDecoders() {
   // Not all barebone engines with TextDecoder support something except utf-8
@@ -14,52 +14,9 @@ function checkDecoders() {
   return false
 }
 
-const canDecoders = checkDecoders()
-const ignoreBOM = true
-const decoderFatalLE = canDecoders ? new TextDecoder('utf-16le', { ignoreBOM, fatal: true }) : null
-const decoderLooseLE = canDecoders ? new TextDecoder('utf-16le', { ignoreBOM }) : null
-const decoderFatalBE = canDecoders ? new TextDecoder('utf-16be', { ignoreBOM, fatal: true }) : null
-const decoderLooseBE = canDecoders ? new TextDecoder('utf-16be', { ignoreBOM }) : null
-const decoderFatal16 = isLE ? decoderFatalLE : decoderFatalBE
-const decoderLoose16 = isLE ? decoderLooseLE : decoderLooseBE
-const { isWellFormed, toWellFormed } = String.prototype
+const decode = checkDecoders() ? decodeApiDecoders : decodeApiJS
 
-const { E_STRICT } = js
-
-// Unlike utf8, operates on Uint16Arrays by default
-
-function decode(input, loose = false, format = 'uint16') {
-  let u16
-  switch (format) {
-    case 'uint16':
-      if (!(input instanceof Uint16Array)) throw new TypeError('Expected an Uint16Array')
-      if (canDecoders) return loose ? decoderLoose16.decode(input) : decoderFatal16.decode(input)
-      u16 = input
-      break
-    case 'uint8-le':
-      if (!(input instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
-      if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
-      if (canDecoders) return loose ? decoderLooseLE.decode(input) : decoderFatalLE.decode(input)
-      u16 = js.to16input(input, true)
-      break
-    case 'uint8-be':
-      if (!(input instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
-      if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
-      if (canDecoders) return loose ? decoderLooseBE.decode(input) : decoderFatalBE.decode(input)
-      u16 = js.to16input(input, false)
-      break
-    default:
-      throw new TypeError('Unknown format')
-  }
-
-  const str = js.decode(u16, loose, (!loose && isWellFormed) || (loose && toWellFormed))
-  if (!loose && isWellFormed && !isWellFormed.call(str)) throw new TypeError(E_STRICT)
-  if (loose && toWellFormed) return toWellFormed.call(str)
-
-  return str
-}
-
-export const utf16fromString = (str, format = 'uint16') => js.encodeApi(str, false, format)
-export const utf16fromStringLoose = (str, format = 'uint16') => js.encodeApi(str, true, format)
+export const utf16fromString = (str, format = 'uint16') => encodeApi(str, false, format)
+export const utf16fromStringLoose = (str, format = 'uint16') => encodeApi(str, true, format)
 export const utf16toString = (arr, format = 'uint16') => decode(arr, false, format)
 export const utf16toStringLoose = (arr, format = 'uint16') => decode(arr, true, format)