@exodus/bytes 1.7.0 → 1.9.0

package/single-byte.js

@@ -1,16 +1,17 @@
 import { assertUint8 } from './assert.js'
-import { canDecoders, nativeEncoder } from './fallback/_utils.js'
-import { encodeAscii } from './fallback/latin1.js'
+import { canDecoders, nativeEncoder, skipWeb, E_STRING } from './fallback/_utils.js'
+import { encodeAscii, encodeAsciiPrefix, encodeLatin1 } from './fallback/latin1.js'
 import { assertEncoding, encodingDecoder, encodeMap, E_STRICT } from './fallback/single-byte.js'
 
-const { TextDecoder } = globalThis
+const { TextDecoder, btoa } = globalThis
 
 let windows1252works
 
 // prettier-ignore
 const skipNative = new Set([
-  'iso-8859-16', // iso-8859-16 is somehow broken in WebKit, at least on CI
+  'iso-8859-1', 'iso-8859-9', 'iso-8859-11', // non-WHATWG
   'iso-8859-6', 'iso-8859-8', 'iso-8859-8-i', // slow in all 3 engines
+  'iso-8859-16', // iso-8859-16 is somehow broken in WebKit, at least on CI
 ])
 
 function shouldUseNative(enc) {
@@ -63,7 +64,20 @@ const NON_LATIN = /[^\x00-\xFF]/ // eslint-disable-line no-control-regex
 function encode(s, m) {
   const len = s.length
   const x = new Uint8Array(len)
-  for (let i = 0; i < len; i++) {
+  let i = nativeEncoder ? 0 : encodeAsciiPrefix(x, s)
+
+  for (const len3 = len - 3; i < len3; i += 4) {
+    const x0 = s.charCodeAt(i), x1 = s.charCodeAt(i + 1), x2 = s.charCodeAt(i + 2), x3 = s.charCodeAt(i + 3) // prettier-ignore
+    const c0 = m[x0], c1 = m[x1], c2 = m[x2], c3 = m[x3] // prettier-ignore
+    if ((!c0 && x0) || (!c1 && x1) || (!c2 && x2) || (!c3 && x3)) return null
+
+    x[i] = c0
+    x[i + 1] = c1
+    x[i + 2] = c2
+    x[i + 3] = c3
+  }
+
+  for (; i < len; i++) {
     const x0 = s.charCodeAt(i)
     const c0 = m[x0]
     if (!c0 && x0) return null
@@ -73,16 +87,33 @@ function encode(s, m) {
   return x
 }
 
+// fromBase64+btoa path is faster on everything where fromBase64 is fast
+const useLatin1btoa = Uint8Array.fromBase64 && btoa && !skipWeb
+
 export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
   // TODO: replacement, truncate (replacement will need varying length)
   if (mode !== 'fatal') throw new Error('Unsupported mode')
   const m = encodeMap(encoding) // asserts
+  const isLatin1 = encoding === 'iso-8859-1'
 
   // No single-byte encoder produces surrogate pairs, so any surrogate is invalid
   // This needs special treatment only to decide how many replacement chars to output, one or two
   // Not much use in running isWellFormed, most likely cause of error is unmapped chars, not surrogate pairs
   return (s) => {
-    if (typeof s !== 'string') throw new TypeError('Input is not a string')
+    if (typeof s !== 'string') throw new TypeError(E_STRING)
+    if (isLatin1) {
+      // max limit is to not produce base64 strings that are too long
+      if (useLatin1btoa && s.length >= 1024 && s.length < 1e8) {
+        try {
+          return Uint8Array.fromBase64(btoa(s)) // fails on non-latin1
+        } catch {
+          throw new TypeError(E_STRICT)
+        }
+      }
+
+      if (NON_LATIN.test(s)) throw new TypeError(E_STRICT)
+      return encodeLatin1(s)
+    }
 
     // Instead of an ASCII regex check, encode optimistically - this is faster
     // Check for 8-bit string with a regex though, this is instant on 8-bit strings so doesn't hurt the ASCII fast path
@@ -98,5 +129,7 @@ export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
   }
 }
 
+export const latin1toString = createSinglebyteDecoder('iso-8859-1')
+export const latin1fromString = createSinglebyteEncoder('iso-8859-1')
 export const windows1252toString = createSinglebyteDecoder('windows-1252')
 export const windows1252fromString = createSinglebyteEncoder('windows-1252')

package/single-byte.node.js

@@ -1,6 +1,6 @@
 import { assertUint8 } from './assert.js'
 import { isAscii } from 'node:buffer'
-import { isDeno, isLE, toBuf } from './fallback/_utils.js'
+import { isDeno, isLE, toBuf, E_STRING } from './fallback/_utils.js'
 import { asciiPrefix } from './fallback/latin1.js'
 import { encodingMapper, encodingDecoder, encodeMap, E_STRICT } from './fallback/single-byte.js'
 
@@ -23,7 +23,6 @@ function latin1Prefix(arr, start) {
 
 export function createSinglebyteDecoder(encoding, loose = false) {
   if (typeof loose !== 'boolean') throw new TypeError('loose option should be boolean')
-  const latin1path = encoding === 'windows-1252'
   if (isDeno) {
     const jsDecoder = encodingDecoder(encoding) // asserts
     return (arr) => {
@@ -34,11 +33,13 @@ export function createSinglebyteDecoder(encoding, loose = false) {
     }
   }
 
+  const isLatin1 = encoding === 'iso-8859-1'
+  const latin1path = encoding === 'windows-1252'
   const { incomplete, mapper } = encodingMapper(encoding) // asserts
   return (arr) => {
     assertUint8(arr)
     if (arr.byteLength === 0) return ''
-    if (isAscii(arr)) return toBuf(arr).latin1Slice(0, arr.byteLength) // .latin1Slice is faster than .asciiSlice
+    if (isLatin1 || isAscii(arr)) return toBuf(arr).latin1Slice() // .latin1Slice is faster than .asciiSlice
 
     // Node.js TextDecoder is broken, so we can't use it. It's also slow anyway
 
@@ -60,13 +61,45 @@ export function createSinglebyteDecoder(encoding, loose = false) {
 
 const NON_LATIN = /[^\x00-\xFF]/ // eslint-disable-line no-control-regex
 
+function encode(s, m) {
+  const len = s.length
+  let i = 0
+  const b = Buffer.from(s, 'utf-16le') // aligned
+  if (!isLE) b.swap16()
+  const x = new Uint16Array(b.buffer, b.byteOffset, b.byteLength / 2)
+  for (const len3 = len - 3; i < len3; i += 4) {
+    const x0 = x[i], x1 = x[i + 1], x2 = x[i + 2], x3 = x[i + 3] // prettier-ignore
+    const c0 = m[x0], c1 = m[x1], c2 = m[x2], c3 = m[x3] // prettier-ignore
+    if (!(c0 && c1 && c2 && c3) && ((!c0 && x0) || (!c1 && x1) || (!c2 && x2) || (!c3 && x3))) return null // prettier-ignore
+    x[i] = c0
+    x[i + 1] = c1
+    x[i + 2] = c2
+    x[i + 3] = c3
+  }
+
+  for (; i < len; i++) {
+    const x0 = x[i]
+    const c0 = m[x0]
+    if (!c0 && x0) return null
+    x[i] = c0
+  }
+
+  return new Uint8Array(x)
+}
+
 export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
   // TODO: replacement, truncate (replacement will need varying length)
   if (mode !== 'fatal') throw new Error('Unsupported mode')
   const m = encodeMap(encoding) // asserts
+  const isLatin1 = encoding === 'iso-8859-1'
 
   return (s) => {
-    if (typeof s !== 'string') throw new TypeError('Input is not a string')
+    if (typeof s !== 'string') throw new TypeError(E_STRING)
+    if (isLatin1) {
+      if (NON_LATIN.test(s)) throw new TypeError(E_STRICT)
+      const b = Buffer.from(s, 'latin1')
+      return new Uint8Array(b.buffer, b.byteOffset, b.byteLength)
+    }
 
     // Instead of an ASCII regex check, encode optimistically - this is faster
     // Check for 8-bit string with a regex though, this is instant on 8-bit strings so doesn't hurt the ASCII fast path
@@ -75,34 +108,13 @@ export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
       if (b.length === s.length) return new Uint8Array(b.buffer, b.byteOffset, b.byteLength)
     }
 
-    const len = s.length
-    let i = 0
-    const b = Buffer.from(s, 'utf-16le') // aligned
-    if (!isLE) b.swap16()
-    const x = new Uint16Array(b.buffer, b.byteOffset, b.byteLength / 2)
-    for (const len3 = len - 3; i < len3; i += 4) {
-      const x0 = x[i], x1 = x[i + 1], x2 = x[i + 2], x3 = x[i + 3] // prettier-ignore
-      const c0 = m[x0], c1 = m[x1], c2 = m[x2], c3 = m[x3] // prettier-ignore
-      if (!(c0 && c1 && c2 && c3) && ((!c0 && x0) || (!c1 && x1) || (!c2 && x2) || (!c3 && x3))) {
-        throw new TypeError(E_STRICT)
-      }
-
-      x[i] = c0
-      x[i + 1] = c1
-      x[i + 2] = c2
-      x[i + 3] = c3
-    }
-
-    for (; i < len; i++) {
-      const x0 = x[i]
-      const c0 = m[x0]
-      if (!c0 && x0) throw new TypeError(E_STRICT)
-      x[i] = c0
-    }
-
-    return new Uint8Array(x)
+    const res = encode(s, m)
+    if (!res) throw new TypeError(E_STRICT)
+    return res
   }
 }
 
+export const latin1toString = createSinglebyteDecoder('iso-8859-1')
+export const latin1fromString = createSinglebyteEncoder('iso-8859-1')
 export const windows1252toString = createSinglebyteDecoder('windows-1252')
 export const windows1252fromString = createSinglebyteEncoder('windows-1252')

package/utf16.js

@@ -1,5 +1,5 @@
 import * as js from './fallback/utf16.js'
-import { canDecoders, isLE } from './fallback/_utils.js'
+import { canDecoders, isLE, E_STRING } from './fallback/_utils.js'
 
 const { TextDecoder } = globalThis // Buffer is optional
 const ignoreBOM = true
@@ -18,7 +18,7 @@ const { E_STRICT, E_STRICT_UNICODE } = js
 const to8 = (a) => new Uint8Array(a.buffer, a.byteOffset, a.byteLength)
 
 function encode(str, loose = false, format = 'uint16') {
-  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  if (typeof str !== 'string') throw new TypeError(E_STRING)
   if (format !== 'uint16' && format !== 'uint8-le' && format !== 'uint8-be') {
     throw new TypeError('Unknown format')
   }
@@ -34,6 +34,7 @@ function encode(str, loose = false, format = 'uint16') {
 
   if (format === 'uint8-le' || format === 'uint8-be') return to8(u16) // Already swapped
   if (format === 'uint16') return u16
+  /* c8 ignore next */
   throw new Error('Unreachable')
 }
 

package/utf16.node.js

@@ -1,4 +1,4 @@
-import { isDeno, isLE } from './fallback/_utils.js'
+import { isDeno, isLE, E_STRING } from './fallback/_utils.js'
 import { E_STRICT, E_STRICT_UNICODE } from './fallback/utf16.js'
 
 if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
@@ -9,7 +9,7 @@ const to8 = (a) => new Uint8Array(a.buffer, a.byteOffset, a.byteLength)
 // Unlike utf8, operates on Uint16Arrays by default
 
 function encode(str, loose = false, format = 'uint16') {
-  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  if (typeof str !== 'string') throw new TypeError(E_STRING)
   if (format !== 'uint16' && format !== 'uint8-le' && format !== 'uint8-be') {
     throw new TypeError('Unknown format')
   }
@@ -30,11 +30,15 @@ function encode(str, loose = false, format = 'uint16') {
     return new Uint16Array(b.buffer, b.byteOffset, b.byteLength / 2)
   }
 
+  /* c8 ignore next */
   throw new Error('Unreachable')
 }
 
-const swapped = (x, swap) =>
-  swap ? Buffer.from(x).swap16() : Buffer.from(x.buffer, x.byteOffset, x.byteLength)
+// Convert to Buffer view or a swapped Buffer copy
+const swapped = (x, swap) => {
+  const b = Buffer.from(x.buffer, x.byteOffset, x.byteLength)
+  return swap ? Buffer.from(b).swap16() : b
+}
 
 // We skip TextDecoder on Node.js, as it's is somewhy significantly slower than Buffer for utf16
 // Also, it incorrectly misses replacements with Node.js is built without ICU, we fix that

package/utf8.js

@@ -1,6 +1,6 @@
 import { assertUint8 } from './assert.js'
 import { typedView } from './array.js'
-import { isHermes, nativeDecoder, nativeEncoder } from './fallback/_utils.js'
+import { isHermes, nativeDecoder, nativeEncoder, E_STRING } from './fallback/_utils.js'
 import { asciiPrefix, decodeLatin1 } from './fallback/latin1.js'
 import * as js from './fallback/utf8.js'
 
@@ -44,7 +44,7 @@ function deLoose(str, loose, res) {
 }
 
 function encode(str, loose = false) {
-  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  if (typeof str !== 'string') throw new TypeError(E_STRING)
   if (str.length === 0) return new Uint8Array() // faster than Uint8Array.of
   if (nativeEncoder) return deLoose(str, loose, nativeEncoder.encode(str))
   // No reason to use unescape + encodeURIComponent: it's slower than JS on normal engines, and modern Hermes already has TextEncoder

package/utf8.node.js

@@ -1,5 +1,6 @@
 import { assertUint8 } from './assert.js'
 import { typedView } from './array.js'
+import { E_STRING } from './fallback/_utils.js'
 import { E_STRICT, E_STRICT_UNICODE } from './fallback/utf8.js'
 import { isAscii } from 'node:buffer'
 
@@ -17,7 +18,7 @@ try {
 }
 
 function encode(str, loose = false) {
-  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  if (typeof str !== 'string') throw new TypeError(E_STRING)
   const strLength = str.length
   if (strLength === 0) return new Uint8Array() // faster than Uint8Array.of
   let res