@exodus/bytes 1.0.0-rc.0 → 1.0.0-rc.10

package/fallback/utf16.js

@@ -0,0 +1,180 @@
+import { decodeLatin1, encodeCharcodes } from './latin1.js'
+import { isLE } from './_utils.js'
+
+export const E_STRICT = 'Input is not well-formed utf16'
+export const E_STRICT_UNICODE = 'Input is not well-formed Unicode'
+
+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 to16input(u8, le) {
+  // Assume even number of bytes
+  if (le === isLE) return to16(u8.byteOffset % 2 === 0 ? u8 : Uint8Array.from(u8))
+
+  const res = new Uint8Array(u8.length)
+
+  let i = 0
+  for (const last3 = u8.length - 3; i < last3; i += 4) {
+    const x0 = u8[i]
+    const x1 = u8[i + 1]
+    const x2 = u8[i + 2]
+    const x3 = u8[i + 3]
+    res[i] = x1
+    res[i + 1] = x0
+    res[i + 2] = x3
+    res[i + 3] = x2
+  }
+
+  for (const last = u8.length - 1; i < last; i += 2) {
+    const x0 = u8[i]
+    const x1 = u8[i + 1]
+    res[i] = x1
+    res[i + 1] = x0
+  }
+
+  return to16(res)
+}
+
+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 (!loose) throw new TypeError(E_STRICT)
+  return decodeLatin1(toWellFormed(Uint16Array.from(u16)), 0, u16.length) // cloned for replacement
+}
+
+export function encode(str, loose = false, checked = false, swapped = false) {
+  const arr = new Uint16Array(str.length)
+  if (checked) return swapped ? encodeCheckedSwapped(str, arr) : encodeChecked(str, arr)
+  return swapped ? encodeUncheckedSwapped(str, arr, loose) : encodeUnchecked(str, arr, loose)
+}
+
+// Splitting paths into small functions helps (at least on SpiderMonkey)
+/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
+
+const encodeChecked = (str, arr) => encodeCharcodes(str, arr) // Same as encodeLatin1, but with Uint16Array
+
+function encodeCheckedSwapped(str, arr) {
+  // TODO: faster path for Hermes? See encodeCharcodes
+  const length = str.length
+  for (let i = 0; i < length; i++) {
+    const x = str.charCodeAt(i)
+    arr[i] = ((x & 0xff) << 8) | (x >> 8)
+  }
+
+  return arr
+}
+
+// lead: d800 - dbff, trail: dc00 - dfff
+
+function encodeUnchecked(str, arr, loose = false) {
+  // TODO: faster path for Hermes? See encodeCharcodes
+  const length = str.length
+  for (let i = 0; i < length; i++) {
+    const code = str.charCodeAt(i)
+    arr[i] = code
+    if (code >= 0xd8_00 && code < 0xe0_00) {
+      // An unexpected trail or a lead at the very end of input
+      if (code > 0xdb_ff || i + 1 >= length) {
+        if (!loose) throw new TypeError(E_STRICT_UNICODE)
+        arr[i] = replacementCodepoint
+      } else {
+        const next = str.charCodeAt(i + 1) // Process valid pairs immediately
+        if (next < 0xdc_00 || next >= 0xe0_00) {
+          if (!loose) throw new TypeError(E_STRICT_UNICODE)
+          arr[i] = replacementCodepoint
+        } else {
+          i++ // consume next
+          arr[i] = next
+        }
+      }
+    }
+  }
+
+  return arr
+}
+
+function encodeUncheckedSwapped(str, arr, loose = false) {
+  // TODO: faster path for Hermes? See encodeCharcodes
+  const length = str.length
+  for (let i = 0; i < length; i++) {
+    const code = str.charCodeAt(i)
+    arr[i] = ((code & 0xff) << 8) | (code >> 8)
+    if (code >= 0xd8_00 && code < 0xe0_00) {
+      // An unexpected trail or a lead at the very end of input
+      if (code > 0xdb_ff || i + 1 >= length) {
+        if (!loose) throw new TypeError(E_STRICT_UNICODE)
+        arr[i] = replacementCodepointSwapped
+      } else {
+        const next = str.charCodeAt(i + 1) // Process valid pairs immediately
+        if (next < 0xdc_00 || next >= 0xe0_00) {
+          if (!loose) throw new TypeError(E_STRICT_UNICODE)
+          arr[i] = replacementCodepointSwapped
+        } else {
+          i++ // consume next
+          arr[i] = ((next & 0xff) << 8) | (next >> 8)
+        }
+      }
+    }
+  }
+
+  return arr
+}
+
+export function toWellFormed(u16) {
+  const length = u16.length
+  for (let i = 0; i < length; i++) {
+    const code = u16[i]
+    if (code >= 0xd8_00 && code < 0xe0_00) {
+      // An unexpected trail or a lead at the very end of input
+      if (code > 0xdb_ff || i + 1 >= length) {
+        u16[i] = replacementCodepoint
+      } else {
+        const next = u16[i + 1] // Process valid pairs immediately
+        if (next < 0xdc_00 || next >= 0xe0_00) {
+          u16[i] = replacementCodepoint
+        } else {
+          i++ // consume next
+        }
+      }
+    }
+  }
+
+  return u16
+}
+
+export function isWellFormed(u16) {
+  const length = u16.length
+  let i = 0
+
+  // Speedup with u32, by skipping to the first surrogate
+  // Only implemented for aligned input for now, but almost all input is aligned (pooled Buffer or 0 offset)
+  if (length > 32 && u16.byteOffset % 4 === 0) {
+    const u32length = (u16.byteLength / 4) | 0
+    const u32 = new Uint32Array(u16.buffer, u16.byteOffset, u32length)
+    for (const last3 = u32length - 3; ; i += 4) {
+      if (i >= last3) break // loop is fast enough for moving this here to be _very_ useful, likely due to array access checks
+      const a = u32[i]
+      const b = u32[i + 1]
+      const c = u32[i + 2]
+      const d = u32[i + 3]
+      if (a & 0x80_00_80_00 || b & 0x80_00_80_00 || c & 0x80_00_80_00 || d & 0x80_00_80_00) break
+    }
+
+    for (; i < u32length; i++) if (u32[i] & 0x80_00_80_00) break
+    i *= 2
+  }
+
+  for (; i < length; i++) {
+    const code = u16[i]
+    if (code >= 0xd8_00 && code < 0xe0_00) {
+      // An unexpected trail or a lead at the very end of input
+      if (code > 0xdb_ff || i + 1 >= length) return false
+      i++ // consume next
+      const next = u16[i] // Process valid pairs immediately
+      if (next < 0xdc_00 || next >= 0xe0_00) return false
+    }
+  }
+
+  return true
+}

package/fallback/utf8.js

@@ -0,0 +1,245 @@
+export const E_STRICT = 'Input is not well-formed utf8'
+export const E_STRICT_UNICODE = 'Input is not well-formed Unicode'
+
+const replacementPoint = 0xff_fd
+
+// https://encoding.spec.whatwg.org/#utf-8-decoder
+// We are most likely in loose mode, for non-loose escape & decodeURIComponent solved everything
+export function decode(arr, loose, start = 0) {
+  start |= 0
+  const end = arr.length
+  let out = ''
+  const chunkSize = 0x2_00 // far below MAX_ARGUMENTS_LENGTH in npmjs.com/buffer, we use smaller chunks
+  const tmpSize = Math.min(end - start, chunkSize + 1) // need 1 extra slot for last codepoint, which can be 2 charcodes
+  const tmp = new Array(tmpSize).fill(0)
+  let ti = 0
+
+  for (let i = start; i < end; i++) {
+    if (ti >= chunkSize) {
+      tmp.length = ti // can be larger by 1 if last codepoint is two charcodes
+      out += String.fromCharCode.apply(String, tmp)
+      if (tmp.length <= chunkSize) tmp.push(0) // restore 1 extra slot for last codepoint
+      ti = 0
+    }
+
+    const byte = arr[i]
+    if (byte < 0x80) {
+      tmp[ti++] = byte
+      // ascii fast path is in ../utf8.js, this is called only on non-ascii input
+      // so we don't unroll this anymore
+    } else if (byte < 0xc2) {
+      if (!loose) throw new TypeError(E_STRICT)
+      tmp[ti++] = replacementPoint
+    } else if (byte < 0xe0) {
+      // need 1 more
+      if (i + 1 >= end) {
+        if (!loose) throw new TypeError(E_STRICT)
+        tmp[ti++] = replacementPoint
+        break
+      }
+
+      const byte1 = arr[i + 1]
+      if (byte1 < 0x80 || byte1 > 0xbf) {
+        if (!loose) throw new TypeError(E_STRICT)
+        tmp[ti++] = replacementPoint
+        continue
+      }
+
+      i++
+      tmp[ti++] = ((byte & 0x1f) << 6) | (byte1 & 0x3f)
+    } else if (byte < 0xf0) {
+      // need 2 more
+      if (i + 1 >= end) {
+        if (!loose) throw new TypeError(E_STRICT)
+        tmp[ti++] = replacementPoint
+        break
+      }
+
+      const lower = byte === 0xe0 ? 0xa0 : 0x80
+      const upper = byte === 0xed ? 0x9f : 0xbf
+      const byte1 = arr[i + 1]
+      if (byte1 < lower || byte1 > upper) {
+        if (!loose) throw new TypeError(E_STRICT)
+        tmp[ti++] = replacementPoint
+        continue
+      }
+
+      i++
+      if (i + 1 >= end) {
+        if (!loose) throw new TypeError(E_STRICT)
+        tmp[ti++] = replacementPoint
+        break
+      }
+
+      const byte2 = arr[i + 1]
+      if (byte2 < 0x80 || byte2 > 0xbf) {
+        if (!loose) throw new TypeError(E_STRICT)
+        tmp[ti++] = replacementPoint
+        continue
+      }
+
+      i++
+      tmp[ti++] = ((byte & 0xf) << 12) | ((byte1 & 0x3f) << 6) | (byte2 & 0x3f)
+    } else if (byte <= 0xf4) {
+      // need 3 more
+      if (i + 1 >= end) {
+        if (!loose) throw new TypeError(E_STRICT)
+        tmp[ti++] = replacementPoint
+        break
+      }
+
+      const lower = byte === 0xf0 ? 0x90 : 0x80
+      const upper = byte === 0xf4 ? 0x8f : 0xbf
+      const byte1 = arr[i + 1]
+      if (byte1 < lower || byte1 > upper) {
+        if (!loose) throw new TypeError(E_STRICT)
+        tmp[ti++] = replacementPoint
+        continue
+      }
+
+      i++
+      if (i + 1 >= end) {
+        if (!loose) throw new TypeError(E_STRICT)
+        tmp[ti++] = replacementPoint
+        break
+      }
+
+      const byte2 = arr[i + 1]
+      if (byte2 < 0x80 || byte2 > 0xbf) {
+        if (!loose) throw new TypeError(E_STRICT)
+        tmp[ti++] = replacementPoint
+        continue
+      }
+
+      i++
+      if (i + 1 >= end) {
+        if (!loose) throw new TypeError(E_STRICT)
+        tmp[ti++] = replacementPoint
+        break
+      }
+
+      const byte3 = arr[i + 1]
+      if (byte3 < 0x80 || byte3 > 0xbf) {
+        if (!loose) throw new TypeError(E_STRICT)
+        tmp[ti++] = replacementPoint
+        continue
+      }
+
+      i++
+      const codePoint =
+        ((byte & 0xf) << 18) | ((byte1 & 0x3f) << 12) | ((byte2 & 0x3f) << 6) | (byte3 & 0x3f)
+      if (codePoint > 0xff_ff) {
+        // split into char codes as String.fromCharCode is faster than String.fromCodePoint
+        const u = codePoint - 0x1_00_00
+        tmp[ti++] = 0xd8_00 + ((u >> 10) & 0x3_ff)
+        tmp[ti++] = 0xdc_00 + (u & 0x3_ff)
+      } else {
+        tmp[ti++] = codePoint
+      }
+      // eslint-disable-next-line sonarjs/no-duplicated-branches
+    } else {
+      if (!loose) throw new TypeError(E_STRICT)
+      tmp[ti++] = replacementPoint
+    }
+  }
+
+  if (ti === 0) return out
+  tmp.length = ti
+  return out + String.fromCharCode.apply(String, tmp)
+}
+
+export function encode(string, loose) {
+  const length = string.length
+  let small = true
+  let bytes = new Uint8Array(length) // assume ascii
+  let p = 0
+
+  for (let i = 0; i < length; i++) {
+    let code = string.charCodeAt(i)
+    if (code < 0x80) {
+      bytes[p++] = code
+      // Unroll the loop a bit for faster ops
+      while (true) {
+        i++
+        if (i >= length) break
+        code = string.charCodeAt(i)
+        if (code >= 0x80) break
+        bytes[p++] = code
+        i++
+        if (i >= length) break
+        code = string.charCodeAt(i)
+        if (code >= 0x80) break
+        bytes[p++] = code
+        i++
+        if (i >= length) break
+        code = string.charCodeAt(i)
+        if (code >= 0x80) break
+        bytes[p++] = code
+        i++
+        if (i >= length) break
+        code = string.charCodeAt(i)
+        if (code >= 0x80) break
+        bytes[p++] = code
+      }
+
+      if (i >= length) break
+      // now, code is present and >= 0x80
+    }
+
+    if (small) {
+      // TODO: use resizable array buffers? will have to return a non-resizeable one
+      if (p !== i) throw new Error('Unreachable') // Here, p === i (only when small is still true)
+      const bytesNew = new Uint8Array(p + (length - i) * 3) // maximium can be 3x of the string length in charcodes
+      bytesNew.set(bytes)
+      bytes = bytesNew
+      small = false
+    }
+
+    // surrogate, charcodes = [d800 + a & 3ff, dc00 + b & 3ff]; codePoint = 0x1_00_00 | (a << 10) | b
+    // lead: d800 - dbff
+    // trail: dc00 - dfff
+    if (code >= 0xd8_00 && code < 0xe0_00) {
+      // Can't be a valid trail as we already processed that below
+
+      if (code > 0xdb_ff || i + 1 >= length) {
+        // An unexpected trail or a lead at the very end of input
+        if (!loose) throw new TypeError(E_STRICT_UNICODE)
+        bytes[p++] = 0xef
+        bytes[p++] = 0xbf
+        bytes[p++] = 0xbd
+        continue
+      }
+
+      const next = string.charCodeAt(i + 1) // Process valid pairs immediately
+      if (next >= 0xdc_00 && next < 0xe0_00) {
+        // here, codePoint is always between 0x1_00_00 and 0x11_00_00, we encode as 4 bytes
+        const codePoint = (((code - 0xd8_00) << 10) | (next - 0xdc_00)) + 0x1_00_00
+        bytes[p++] = (codePoint >> 18) | 0xf0
+        bytes[p++] = ((codePoint >> 12) & 0x3f) | 0x80
+        bytes[p++] = ((codePoint >> 6) & 0x3f) | 0x80
+        bytes[p++] = (codePoint & 0x3f) | 0x80
+        i++ // consume next
+      } else {
+        // Next is not a trail, leave next unconsumed but process unmatched lead error
+        if (!loose) throw new TypeError(E_STRICT_UNICODE)
+        bytes[p++] = 0xef
+        bytes[p++] = 0xbf
+        bytes[p++] = 0xbd
+      }
+
+      continue
+    }
+
+    // We are left with a non-pair char code above ascii, it gets encoded to 2 or 3 bytes
+    if (code < 0x8_00) {
+      bytes[p++] = (code >> 6) | 0xc0
+      bytes[p++] = (code & 0x3f) | 0x80
+    } else {
+      bytes[p++] = (code >> 12) | 0xe0
+      bytes[p++] = ((code >> 6) & 0x3f) | 0x80
+      bytes[p++] = (code & 0x3f) | 0x80
+    }
+  }
+
+  return bytes.length === p ? bytes : bytes.slice(0, p)
+}

package/hex.js

@@ -1,78 +1,19 @@
-import { assertTypedArray, assert } from './assert.js'
-import { fromTypedArray } from './array.js'
+import { assertUint8 } from './assert.js'
+import { typedView } from './array.js'
+import { skipWeb } from './fallback/_utils.js'
+import * as js from './fallback/hex.js'
 
-const { Buffer } = globalThis // Buffer is optional, only used when native
-const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
 const { toHex: webHex } = Uint8Array.prototype // Modern engines have this
 
-let hexArray
-let dehexArray
-
 export function toHex(arr) {
-  assertTypedArray(arr)
-  if (!(arr instanceof Uint8Array)) arr = new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength)
-  if (webHex && arr.toHex === webHex) return arr.toHex()
-  if (haveNativeBuffer) {
-    if (arr.constructor === Buffer && Buffer.isBuffer(arr)) return arr.toString('hex')
-    return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).toString('hex')
-  }
-
-  if (!hexArray) hexArray = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'))
-  const length = arr.length // this helps Hermes
-
-  if (length > 3000) {
-    // Limit concatenation to avoid excessive GC
-    // Thresholds checked on Hermes
-    const concat = []
-    for (let i = 0; i < length; ) {
-      const step = i + 500
-      const end = step > length ? length : step
-      let chunk = ''
-      for (; i < end; i++) chunk += hexArray[arr[i]]
-      concat.push(chunk)
-    }
-
-    const res = concat.join('')
-    concat.length = 0
-    return res
-  }
-
-  let out = ''
-  for (let i = 0; i < length; i++) out += hexArray[arr[i]]
-  return out
+  assertUint8(arr)
+  if (arr.length === 0) return ''
+  if (!skipWeb && webHex && arr.toHex === webHex) return arr.toHex()
+  return js.toHex(arr)
 }
 
 // Unlike Buffer.from(), throws on invalid input
-let fromHex
-if (Uint8Array.fromHex) {
-  fromHex = (str, format = 'uint8') => fromTypedArray(Uint8Array.fromHex(str), format)
-} else {
-  fromHex = (str, format = 'uint8') => {
-    if (typeof str !== 'string') throw new TypeError('Input is not a string')
-    assert(str.length % 2 === 0, 'Input is not a hex string')
-
-    // We don't use native Buffer impl, as rechecking input make it slower than pure js
-    // This path is used only on older engines though
-
-    if (!dehexArray) {
-      dehexArray = new Array(103) // f is 102
-      for (let i = 0; i < 16; i++) {
-        const s = i.toString(16)
-        dehexArray[s.charCodeAt(0)] = dehexArray[s.toUpperCase().charCodeAt(0)] = i
-      }
-    }
-
-    const arr = new Uint8Array(str.length / 2)
-    let j = 0
-    const length = arr.length // this helps Hermes
-    for (let i = 0; i < length; i++) {
-      const a = dehexArray[str.charCodeAt(j++)] * 16 + dehexArray[str.charCodeAt(j++)]
-      if (!a && Number.isNaN(a)) throw new Error('Input is not a hex string')
-      arr[i] = a
-    }
-
-    return fromTypedArray(arr, format)
-  }
-}
-
-export { fromHex }
+export const fromHex =
+  !skipWeb && Uint8Array.fromHex
+    ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
+    : (str, format = 'uint8') => typedView(js.fromHex(str), format)

package/hex.node.js

@@ -0,0 +1,28 @@
+import { assertUint8 } from './assert.js'
+import { typedView } from './array.js'
+import { E_HEX } from './fallback/hex.js'
+
+if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
+
+const { toHex: webHex } = Uint8Array.prototype // Modern engines have this
+const denoBug = Buffer.from('ag', 'hex').length > 0
+
+export function toHex(arr) {
+  assertUint8(arr)
+  if (arr.length === 0) return ''
+  if (webHex && arr.toHex === webHex) return arr.toHex()
+  if (arr.constructor === Buffer && Buffer.isBuffer(arr)) return arr.hexSlice(0, arr.byteLength)
+  return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).hexSlice(0, arr.byteLength)
+}
+
+// Unlike Buffer.from(), throws on invalid input
+export const fromHex = Uint8Array.fromHex
+  ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
+  : (str, format = 'uint8') => {
+      if (typeof str !== 'string') throw new TypeError('Input is not a string')
+      if (str.length % 2 !== 0) throw new SyntaxError(E_HEX)
+      if (denoBug && /[^\dA-Fa-f]/.test(str)) throw new SyntaxError(E_HEX)
+      const buf = Buffer.from(str, 'hex') // will stop on first non-hex character, so we can just validate length
+      if (buf.length * 2 !== str.length) throw new SyntaxError(E_HEX)
+      return typedView(buf, format)
+    }

package/multi-byte.js

@@ -0,0 +1,13 @@
+import { assertUint8 } from './assert.js'
+import { multibyteDecoder } from './fallback/multi-byte.js'
+
+export function createMultibyteDecoder(encoding, loose = false) {
+  const jsDecoder = multibyteDecoder(encoding, loose) // asserts
+  let streaming = false
+  return (arr, stream = false) => {
+    assertUint8(arr)
+    if (!streaming && arr.byteLength === 0) return ''
+    streaming = stream
+    return jsDecoder(arr, stream)
+  }
+}

package/multi-byte.node.js

@@ -0,0 +1,25 @@
+import { assertUint8 } from './assert.js'
+import { isDeno } from './fallback/_utils.js'
+import { isAsciiSuperset, multibyteDecoder } from './fallback/multi-byte.js'
+import { isAscii } from 'node:buffer'
+
+const toBuf = (x) => Buffer.from(x.buffer, x.byteOffset, x.byteLength)
+
+export function createMultibyteDecoder(encoding, loose = false) {
+  const jsDecoder = multibyteDecoder(encoding, loose) // asserts
+  let streaming = false
+  const asciiSuperset = isAsciiSuperset(encoding)
+  return (arr, stream = false) => {
+    assertUint8(arr)
+    if (!streaming) {
+      if (arr.byteLength === 0) return ''
+      if (asciiSuperset && isAscii(arr)) {
+        if (isDeno) return toBuf(arr).toString()
+        return toBuf(arr).latin1Slice(0, arr.byteLength) // .latin1Slice is faster than .asciiSlice
+      }
+    }
+
+    streaming = stream
+    return jsDecoder(arr, stream)
+  }
+}