@exodus/bytes 1.14.1 → 1.15.1

package/single-byte.js

@@ -1,6 +1,6 @@
 import { assertU8, E_STRING } from './fallback/_utils.js'
 import { nativeDecoderLatin1, nativeEncoder } from './fallback/platform.js'
-import { encodeAscii, encodeAsciiPrefix, encodeLatin1 } from './fallback/latin1.js'
+import { encodeAsciiPrefix, encodeLatin1 } from './fallback/latin1.js'
 import { assertEncoding, encodingDecoder, encodeMap, E_STRICT } from './fallback/single-byte.js'
 
 const { TextDecoder, btoa } = globalThis
@@ -90,37 +90,38 @@ function encode(s, m) {
 // fromBase64+btoa path is faster on everything where fromBase64 is fast
 const useLatin1btoa = Uint8Array.fromBase64 && btoa
 
+export function latin1fromString(s) {
+  if (typeof s !== 'string') throw new TypeError(E_STRING)
+  // 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)
+}
+
 export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
   // TODO: replacement, truncate (replacement will need varying length)
   if (mode !== 'fatal') throw new Error('Unsupported mode')
+  if (encoding === 'iso-8859-1') return latin1fromString
   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(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
     if (nativeEncoder && !NON_LATIN.test(s)) {
-      try {
-        return encodeAscii(s, E_STRICT)
-      } catch {}
+      const u8 = nativeEncoder.encode(s)
+      if (u8.length === s.length) return u8
     }
 
     const res = encode(s, m)
@@ -130,6 +131,5 @@ export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
 }
 
 export const latin1toString = /* @__PURE__ */ createSinglebyteDecoder('iso-8859-1')
-export const latin1fromString = /* @__PURE__ */ createSinglebyteEncoder('iso-8859-1')
 export const windows1252toString = /* @__PURE__ */ createSinglebyteDecoder('windows-1252')
 export const windows1252fromString = /* @__PURE__ */ createSinglebyteEncoder('windows-1252')

package/single-byte.node.js

@@ -39,7 +39,7 @@ export function createSinglebyteDecoder(encoding, loose = false) {
   return (arr) => {
     assertU8(arr)
     if (arr.byteLength === 0) return ''
-    if (isLatin1 || isAscii(arr)) return toBuf(arr).latin1Slice() // .latin1Slice is faster than .asciiSlice
+    if (isLatin1 || isAscii(arr)) return toBuf(arr).latin1Slice(0, arr.byteLength) // .latin1Slice is faster than .asciiSlice
 
     // Node.js TextDecoder is broken, so we can't use it. It's also slow anyway
 
@@ -87,25 +87,33 @@ function encode(s, m) {
   return new Uint8Array(x)
 }
 
+export function latin1fromString(s) {
+  if (typeof s !== 'string') throw new TypeError(E_STRING)
+  if (NON_LATIN.test(s)) throw new TypeError(E_STRICT)
+  const ab = new ArrayBuffer(s.length)
+  Buffer.from(ab).latin1Write(s)
+  return new Uint8Array(ab)
+}
+
 export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
   // TODO: replacement, truncate (replacement will need varying length)
   if (mode !== 'fatal') throw new Error('Unsupported mode')
+  if (encoding === 'iso-8859-1') return latin1fromString
   const m = encodeMap(encoding) // asserts
-  const isLatin1 = encoding === 'iso-8859-1'
 
   return (s) => {
     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
     if (!NON_LATIN.test(s)) {
-      const b = Buffer.from(s, 'utf8') // ascii/latin1 coerces, we need to check
-      if (b.length === s.length) return new Uint8Array(b.buffer, b.byteOffset, b.byteLength)
+      const byteLength = Buffer.byteLength(s)
+      // ascii/latin1 coerces, we need to check
+      if (byteLength === s.length) {
+        const ab = new ArrayBuffer(byteLength)
+        Buffer.from(ab).latin1Write(s)
+        return new Uint8Array(ab)
+      }
     }
 
     const res = encode(s, m)
@@ -115,6 +123,5 @@ export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
 }
 
 export const latin1toString = /* @__PURE__ */ createSinglebyteDecoder('iso-8859-1')
-export const latin1fromString = /* @__PURE__ */ createSinglebyteEncoder('iso-8859-1')
 export const windows1252toString = /* @__PURE__ */ createSinglebyteDecoder('windows-1252')
 export const windows1252fromString = /* @__PURE__ */ createSinglebyteEncoder('windows-1252')

package/utf16.node.js

@@ -21,7 +21,8 @@ function encode(str, loose = false, format = 'uint16') {
     throw new TypeError(E_STRICT_UNICODE)
   }
 
-  const ble = Buffer.from(str, 'utf-16le')
+  const ble = Buffer.allocUnsafeSlow(str.length * 2) // non-pooled
+  ble.ucs2Write(str)
 
   if (format === 'uint8-le') return to8(ble)
   if (format === 'uint8-be') return to8(ble.swap16())

package/utf8.d.ts

@@ -35,8 +35,9 @@ import type { OutputFormat, Uint8ArrayBuffer } from './array.js';
  * @returns The encoded bytes
  */
 export function utf8fromString(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+export function utf8fromString(string: string, format: 'arraybuffer'): ArrayBuffer;
 export function utf8fromString(string: string, format: 'buffer'): Buffer;
-export function utf8fromString(string: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;
+export function utf8fromString(string: string, format?: OutputFormat): Uint8ArrayBuffer | ArrayBuffer | Buffer;
 
 /**
  * Encode a string to UTF-8 bytes (loose mode)
@@ -59,11 +60,12 @@ export function utf8fromString(string: string, format?: OutputFormat): Uint8Arra
  * @returns The encoded bytes
  */
 export function utf8fromStringLoose(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+export function utf8fromStringLoose(string: string, format: 'arraybuffer'): ArrayBuffer;
 export function utf8fromStringLoose(string: string, format: 'buffer'): Buffer;
 export function utf8fromStringLoose(
   string: string,
   format?: OutputFormat
-): Uint8ArrayBuffer | Buffer;
+): Uint8ArrayBuffer | ArrayBuffer | Buffer;
 
 /**
  * Decode UTF-8 bytes to a string (strict mode)

package/utf8.js

@@ -1,5 +1,4 @@
-import { typedView } from './array.js'
-import { assertU8, E_STRING, E_STRICT_UNICODE } from './fallback/_utils.js'
+import { assertU8, fromUint8, E_STRING, E_STRICT_UNICODE } from './fallback/_utils.js'
 import { nativeDecoder, nativeEncoder } from './fallback/platform.js'
 import * as js from './fallback/utf8.auto.js'
 
@@ -60,7 +59,7 @@ function decode(arr, loose = false) {
   return js.decodeFast(arr, loose)
 }
 
-export const utf8fromString = (str, format = 'uint8') => typedView(encode(str, false), format)
-export const utf8fromStringLoose = (str, format = 'uint8') => typedView(encode(str, true), format)
+export const utf8fromString = (str, format = 'uint8') => fromUint8(encode(str, false), format)
+export const utf8fromStringLoose = (str, format = 'uint8') => fromUint8(encode(str, true), format)
 export const utf8toString = (arr) => decode(arr, false)
 export const utf8toStringLoose = (arr) => decode(arr, true)

package/utf8.node.js

@@ -1,5 +1,4 @@
-import { typedView } from './array.js'
-import { assertU8, E_STRING, E_STRICT_UNICODE } from './fallback/_utils.js'
+import { assertU8, fromBuffer, E_STRING, E_STRICT_UNICODE } from './fallback/_utils.js'
 import { E_STRICT } from './fallback/utf8.js'
 import { isAscii } from 'node:buffer'
 
@@ -16,7 +15,7 @@ try {
   // Without ICU, Node.js doesn't support fatal option for utf-8
 }
 
-function encode(str, loose = false) {
+function encode(str, loose, format) {
   if (typeof str !== 'string') throw new TypeError(E_STRING)
   const strLength = str.length
   if (strLength === 0) return new Uint8Array() // faster than Uint8Array.of
@@ -24,18 +23,19 @@ function encode(str, loose = false) {
   if (strLength > 0x4_00 && !isDeno) {
     // Faster for large strings
     const byteLength = Buffer.byteLength(str)
-    res = Buffer.allocUnsafe(byteLength)
-    const ascii = byteLength === strLength
-    const written = ascii ? res.latin1Write(str) : res.utf8Write(str)
+    res = format === 'buffer' ? Buffer.allocUnsafe(byteLength) : Buffer.allocUnsafeSlow(byteLength)
+    const written = byteLength === strLength ? res.latin1Write(str) : res.utf8Write(str)
     if (written !== byteLength) throw new Error('Failed to write all bytes') // safeguard just in case
-    if (ascii || loose) return res // no further checks needed
   } else {
     res = Buffer.from(str)
-    if (res.length === strLength || loose) return res
   }
 
-  if (!isWellFormed.call(str)) throw new TypeError(E_STRICT_UNICODE)
-  return res
+  // Loose and ascii do not need the check
+  if (!loose && res.length !== strLength && !isWellFormed.call(str)) {
+    throw new TypeError(E_STRICT_UNICODE)
+  }
+
+  return fromBuffer(res, format)
 }
 
 function decode(arr, loose = false) {
@@ -61,7 +61,7 @@ function decode(arr, loose = false) {
   return str
 }
 
-export const utf8fromString = (str, format = 'uint8') => typedView(encode(str, false), format)
-export const utf8fromStringLoose = (str, format = 'uint8') => typedView(encode(str, true), format)
+export const utf8fromString = (str, format = 'uint8') => encode(str, false, format)
+export const utf8fromStringLoose = (str, format = 'uint8') => encode(str, true, format)
 export const utf8toString = (arr) => decode(arr, false)
 export const utf8toStringLoose = (arr) => decode(arr, true)