refactor: move basic utf16 API impl to ./fallback dir

Author: ChALkeR

fallback/utf16.js

@@ -1,13 +1,47 @@
 import { decodeUCS2, encodeCharcodes } from './latin1.js'
-import { isLE, E_STRICT_UNICODE } from './_utils.js'
+import { isLE, E_STRING, E_STRICT_UNICODE } from './_utils.js'
 
 export const E_STRICT = 'Input is not well-formed utf16'
+const { TextDecoder } = globalThis
+const isWellFormedStr = String.prototype.isWellFormed
 
 const replacementCodepoint = 0xff_fd
 const replacementCodepointSwapped = 0xfd_ff
 
 const to16 = (a) => new Uint16Array(a.buffer, a.byteOffset, a.byteLength / 2) // Requires checked length and alignment!
 
+export function encodeApi(str, loose, format) {
+  if (typeof str !== 'string') throw new TypeError(E_STRING)
+  if (format !== 'uint16' && format !== 'uint8-le' && format !== 'uint8-be') {
+    throw new TypeError('Unknown format')
+  }
+
+  // On v8 and SpiderMonkey, check via isWellFormed is faster than js
+  // On JSC, check during loop is faster than isWellFormed
+  // If isWellFormed is available, we skip check during decoding and recheck after
+  // If isWellFormed is unavailable, we check in js during decoding
+  if (!loose && isWellFormedStr && !isWellFormedStr.call(str)) throw new TypeError(E_STRICT_UNICODE)
+  const shouldSwap = (isLE && format === 'uint8-be') || (!isLE && format === 'uint8-le')
+  const u16 = encode(str, loose, !loose && isWellFormedStr, shouldSwap)
+
+  // Bytes are already swapped and format is already checked, we need to just cast the view
+  return format === 'uint16' ? u16 : new Uint8Array(u16.buffer, u16.byteOffset, u16.byteLength)
+}
+
+export function decodeApiDecoders(input, loose, format) {
+  if (format === 'uint16') {
+    if (!(input instanceof Uint16Array)) throw new TypeError('Expected an Uint16Array')
+  } else if (format === 'uint8-le' || format === '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')
+  } else {
+    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)
+}
+
 export function to16input(u8, le) {
   // Assume even number of bytes
   if (le === isLE) return to16(u8.byteOffset % 2 === 0 ? u8 : Uint8Array.from(u8))

utf16.native.js

@@ -1,5 +1,5 @@
 import * as js from './fallback/utf16.js'
-import { nativeDecoder, isLE, E_STRING, E_STRICT_UNICODE } from './fallback/_utils.js'
+import { nativeDecoder, isLE } from './fallback/_utils.js'
 
 function checkDecoders() {
   // Not all barebone engines with TextDecoder support something except utf-8
@@ -28,24 +28,6 @@ const { E_STRICT } = js
 
 // Unlike utf8, operates on Uint16Arrays by default
 
-function encode(str, loose = false, format = 'uint16') {
-  if (typeof str !== 'string') throw new TypeError(E_STRING)
-  if (format !== 'uint16' && format !== 'uint8-le' && format !== 'uint8-be') {
-    throw new TypeError('Unknown format')
-  }
-
-  // On v8 and SpiderMonkey, check via isWellFormed is faster than js
-  // On JSC, check during loop is faster than isWellFormed
-  // If isWellFormed is available, we skip check during decoding and recheck after
-  // If isWellFormed is unavailable, we check in js during decoding
-  if (!loose && isWellFormed && !isWellFormed.call(str)) throw new TypeError(E_STRICT_UNICODE)
-  const shouldSwap = (isLE && format === 'uint8-be') || (!isLE && format === 'uint8-le')
-  const u16 = js.encode(str, loose, !loose && isWellFormed, shouldSwap)
-
-  // Bytes are already swapped and format is already checked, we need to just cast the view
-  return format === 'uint16' ? u16 : new Uint8Array(u16.buffer, u16.byteOffset, u16.byteLength)
-}
-
 function decode(input, loose = false, format = 'uint16') {
   let u16
   switch (format) {
@@ -77,7 +59,7 @@ function decode(input, loose = false, format = 'uint16') {
   return str
 }
 
-export const utf16fromString = (str, format = 'uint16') => encode(str, false, format)
-export const utf16fromStringLoose = (str, format = 'uint16') => encode(str, true, format)
+export const utf16fromString = (str, format = 'uint16') => js.encodeApi(str, false, format)
+export const utf16fromStringLoose = (str, format = 'uint16') => js.encodeApi(str, true, format)
 export const utf16toString = (arr, format = 'uint16') => decode(arr, false, format)
 export const utf16toStringLoose = (arr, format = 'uint16') => decode(arr, true, format)

utf16.node.js

@@ -1,9 +1,8 @@
 import { isDeno, isLE, E_STRING, E_STRICT_UNICODE } from './fallback/_utils.js'
-import { E_STRICT } from './fallback/utf16.js'
+import { E_STRICT, decodeApiDecoders } from './fallback/utf16.js'
 
 if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
 
-const { TextDecoder } = globalThis
 const { isWellFormed, toWellFormed } = String.prototype
 const to8 = (a) => new Uint8Array(a.buffer, a.byteOffset, a.byteLength)
 
@@ -62,21 +61,7 @@ function decodeNode(input, loose = false, format = 'uint16') {
   throw new TypeError(E_STRICT)
 }
 
-function decodeDecoder(input, loose = false, format = 'uint16') {
-  if (format === 'uint16') {
-    if (!(input instanceof Uint16Array)) throw new TypeError('Expected an Uint16Array')
-  } else if (format === 'uint8-le' || format === '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')
-  } else {
-    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) // TODO: cache decoder?
-}
-
-const decode = isDeno ? decodeDecoder : decodeNode
+const decode = isDeno ? decodeApiDecoders : decodeNode
 
 export const utf16fromString = (str, format = 'uint16') => encode(str, false, format)
 export const utf16fromStringLoose = (str, format = 'uint16') => encode(str, true, format)