@atproto/lex-data 0.1.3 → 0.1.4

package/src/uint8array.test.ts

@@ -1,503 +0,0 @@
-import 'core-js/es/typed-array/from-base64.js'
-import 'core-js/es/typed-array/to-base64.js'
-
-import { describe, expect, it } from 'vitest'
-import {
-  asUint8Array,
-  fromBase64,
-  ifUint8Array,
-  toBase64,
-  ui8Concat,
-  ui8Equals,
-} from './uint8array.js'
-
-describe(toBase64, () => {
-  it('encodes empty Uint8Array', () => {
-    const encoded = toBase64(new Uint8Array(0))
-    expect(typeof encoded).toBe('string')
-    expect(encoded).toBe('')
-  })
-
-  it('encodes single byte', () => {
-    const encoded = toBase64(new Uint8Array([0x4d]))
-    expect(encoded).toBe('TQ')
-  })
-
-  it('encodes multiple bytes', () => {
-    const encoded = toBase64(new Uint8Array([0x4d, 0x61, 0x6e]))
-    expect(encoded).toBe('TWFu')
-  })
-
-  it('encodes with default alphabet (base64)', () => {
-    const bytes = new Uint8Array([0xfb, 0xff, 0xbf])
-    const encoded = toBase64(bytes)
-    expect(encoded).toContain('+')
-    expect(encoded).toContain('/')
-  })
-
-  it('encodes with base64url alphabet', () => {
-    const bytes = new Uint8Array([0xfb, 0xff, 0xbf])
-    const encoded = toBase64(bytes, 'base64url')
-    expect(encoded).toContain('-')
-    expect(encoded).toContain('_')
-  })
-
-  it('handles large data', () => {
-    const bytes = new Uint8Array(10000).fill(0xaa)
-    const encoded = toBase64(bytes)
-    expect(typeof encoded).toBe('string')
-    expect(encoded.length).toBeGreaterThan(0)
-  })
-})
-
-describe(fromBase64, () => {
-  it('decodes empty string', () => {
-    const decoded = fromBase64('')
-    expect(decoded).toBeInstanceOf(Uint8Array)
-    expect(decoded.length).toBe(0)
-  })
-
-  it('decodes single character', () => {
-    const decoded = fromBase64('TQ')
-    expect(decoded).toBeInstanceOf(Uint8Array)
-    expect(ui8Equals(decoded, new Uint8Array([0x4d]))).toBe(true)
-  })
-
-  it('decodes multiple characters', () => {
-    const decoded = fromBase64('TWFu')
-    expect(decoded).toBeInstanceOf(Uint8Array)
-    expect(ui8Equals(decoded, new Uint8Array([0x4d, 0x61, 0x6e]))).toBe(true)
-  })
-
-  it('decodes base64url alphabet', () => {
-    const decoded = fromBase64('-_-_', 'base64url')
-    expect(decoded).toBeInstanceOf(Uint8Array)
-    expect(ui8Equals(decoded, new Uint8Array([0xfb, 0xff, 0xbf]))).toBe(true)
-  })
-
-  it('decodes padded base64', () => {
-    const decoded = fromBase64('TQ==')
-    expect(decoded).toBeInstanceOf(Uint8Array)
-    expect(ui8Equals(decoded, new Uint8Array([0x4d]))).toBe(true)
-  })
-
-  it('decodes unpadded base64', () => {
-    const decoded = fromBase64('TQ')
-    expect(decoded).toBeInstanceOf(Uint8Array)
-    expect(ui8Equals(decoded, new Uint8Array([0x4d]))).toBe(true)
-  })
-
-  it('throws on invalid base64 string', () => {
-    expect(() => fromBase64('@@@@')).toThrow()
-  })
-
-  it('handles large data', () => {
-    const bytes = new Uint8Array(10000).fill(0xbb)
-    const encoded = toBase64(bytes)
-    const decoded = fromBase64(encoded)
-    expect(ui8Equals(decoded, bytes)).toBe(true)
-  })
-})
-
-describe('roundtrip toBase64 <-> fromBase64', () => {
-  it('roundtrips empty array', () => {
-    const original = new Uint8Array(0)
-    const encoded = toBase64(original)
-    const decoded = fromBase64(encoded)
-    expect(ui8Equals(decoded, original)).toBe(true)
-  })
-
-  it('roundtrips all byte values', () => {
-    const allBytes = new Uint8Array(256)
-    for (let i = 0; i < 256; i++) {
-      allBytes[i] = i
-    }
-    const encoded = toBase64(allBytes)
-    const decoded = fromBase64(encoded)
-    expect(ui8Equals(decoded, allBytes)).toBe(true)
-  })
-
-  it('roundtrips with base64url alphabet', () => {
-    const original = new Uint8Array([0xfb, 0xff, 0xbf, 0x00, 0xff])
-    const encoded = toBase64(original, 'base64url')
-    const decoded = fromBase64(encoded, 'base64url')
-    expect(ui8Equals(decoded, original)).toBe(true)
-  })
-
-  it('roundtrips random-like data', () => {
-    const data = new Uint8Array([
-      0x00, 0x01, 0x7f, 0x80, 0xfe, 0xff, 0x10, 0x20, 0x30, 0x40,
-    ])
-    const encoded = toBase64(data)
-    const decoded = fromBase64(encoded)
-    expect(ui8Equals(decoded, data)).toBe(true)
-  })
-})
-
-describe(asUint8Array, () => {
-  describe('Uint8Array input', () => {
-    it('returns same Uint8Array instance', () => {
-      const input = new Uint8Array([1, 2, 3])
-      const result = asUint8Array(input)
-      expect(result).toBe(input)
-    })
-
-    it('returns same empty Uint8Array instance', () => {
-      const input = new Uint8Array(0)
-      const result = asUint8Array(input)
-      expect(result).toBe(input)
-    })
-  })
-
-  describe('ArrayBuffer input', () => {
-    it('converts ArrayBuffer to Uint8Array', () => {
-      const buffer = new ArrayBuffer(4)
-      const view = new Uint8Array(buffer)
-      view.set([1, 2, 3, 4])
-      const result = asUint8Array(buffer)
-      expect(result).toBeInstanceOf(Uint8Array)
-      expect(ui8Equals(result!, new Uint8Array([1, 2, 3, 4]))).toBe(true)
-    })
-
-    it('converts empty ArrayBuffer to empty Uint8Array', () => {
-      const buffer = new ArrayBuffer(0)
-      const result = asUint8Array(buffer)
-      expect(result).toBeInstanceOf(Uint8Array)
-      expect(result!.length).toBe(0)
-    })
-  })
-
-  describe('TypedArray (ArrayBufferView) input', () => {
-    it('converts Int8Array to Uint8Array', () => {
-      const input = new Int8Array([1, 2, 3, 4])
-      const result = asUint8Array(input)
-      expect(result).toBeInstanceOf(Uint8Array)
-      expect(result!.length).toBe(4)
-    })
-
-    it('converts Int16Array to Uint8Array', () => {
-      const input = new Int16Array([1, 2])
-      const result = asUint8Array(input)
-      expect(result).toBeInstanceOf(Uint8Array)
-      // Int16Array has 2 bytes per element, so 2 elements = 4 bytes
-      expect(result!.length).toBe(4)
-    })
-
-    it('converts Int32Array to Uint8Array', () => {
-      const input = new Int32Array([1])
-      const result = asUint8Array(input)
-      expect(result).toBeInstanceOf(Uint8Array)
-      // Int32Array has 4 bytes per element, so 1 element = 4 bytes
-      expect(result!.length).toBe(4)
-    })
-
-    it('converts Float32Array to Uint8Array', () => {
-      const input = new Float32Array([1.5])
-      const result = asUint8Array(input)
-      expect(result).toBeInstanceOf(Uint8Array)
-      // Float32Array has 4 bytes per element
-      expect(result!.length).toBe(4)
-    })
-
-    it('converts Float64Array to Uint8Array', () => {
-      const input = new Float64Array([1.5])
-      const result = asUint8Array(input)
-      expect(result).toBeInstanceOf(Uint8Array)
-      // Float64Array has 8 bytes per element
-      expect(result!.length).toBe(8)
-    })
-
-    it('converts DataView to Uint8Array', () => {
-      const buffer = new ArrayBuffer(4)
-      const view = new DataView(buffer)
-      view.setUint8(0, 1)
-      view.setUint8(1, 2)
-      view.setUint8(2, 3)
-      view.setUint8(3, 4)
-      const result = asUint8Array(view)
-      expect(result).toBeInstanceOf(Uint8Array)
-      expect(ui8Equals(result!, new Uint8Array([1, 2, 3, 4]))).toBe(true)
-    })
-
-    it('handles TypedArray with byteOffset', () => {
-      const buffer = new ArrayBuffer(8)
-      const fullView = new Uint8Array(buffer)
-      fullView.set([0, 0, 1, 2, 3, 4, 0, 0])
-      // Create a view with offset
-      const offsetView = new Uint8Array(buffer, 2, 4)
-      const result = asUint8Array(offsetView)
-      expect(result).toBeInstanceOf(Uint8Array)
-      expect(result).toBe(offsetView) // Uint8Array returns same instance
-    })
-
-    it('handles Int16Array with byteOffset correctly', () => {
-      const buffer = new ArrayBuffer(8)
-      const fullView = new Uint8Array(buffer)
-      fullView.set([0, 0, 1, 0, 2, 0, 0, 0])
-      // Create Int16Array starting at byte 2, with 2 elements
-      const int16View = new Int16Array(buffer, 2, 2)
-      const result = asUint8Array(int16View)
-      expect(result).toBeInstanceOf(Uint8Array)
-      expect(result!.length).toBe(4) // 2 Int16 elements = 4 bytes
-    })
-  })
-
-  describe('invalid inputs', () => {
-    it('returns undefined for null', () => {
-      const result = asUint8Array(null)
-      expect(result).toBeUndefined()
-    })
-
-    it('returns undefined for undefined', () => {
-      const result = asUint8Array(undefined)
-      expect(result).toBeUndefined()
-    })
-
-    it('returns undefined for string', () => {
-      const result = asUint8Array('hello')
-      expect(result).toBeUndefined()
-    })
-
-    it('returns undefined for number', () => {
-      const result = asUint8Array(42)
-      expect(result).toBeUndefined()
-    })
-
-    it('returns undefined for boolean', () => {
-      const result = asUint8Array(true)
-      expect(result).toBeUndefined()
-    })
-
-    it('returns undefined for plain object', () => {
-      const result = asUint8Array({ foo: 'bar' })
-      expect(result).toBeUndefined()
-    })
-
-    it('returns undefined for array', () => {
-      const result = asUint8Array([1, 2, 3])
-      expect(result).toBeUndefined()
-    })
-
-    it('returns undefined for function', () => {
-      const result = asUint8Array(() => {})
-      expect(result).toBeUndefined()
-    })
-
-    it('returns undefined for symbol', () => {
-      const result = asUint8Array(Symbol('test'))
-      expect(result).toBeUndefined()
-    })
-
-    it('returns undefined for BigInt', () => {
-      const result = asUint8Array(BigInt(42))
-      expect(result).toBeUndefined()
-    })
-  })
-})
-
-describe(ui8Equals, () => {
-  describe('equal arrays', () => {
-    it('returns true for identical arrays', () => {
-      const a = new Uint8Array([1, 2, 3])
-      const b = new Uint8Array([1, 2, 3])
-      expect(ui8Equals(a, b)).toBe(true)
-    })
-
-    it('returns true for same instance', () => {
-      const a = new Uint8Array([1, 2, 3])
-      expect(ui8Equals(a, a)).toBe(true)
-    })
-
-    it('returns true for empty arrays', () => {
-      const a = new Uint8Array(0)
-      const b = new Uint8Array(0)
-      expect(ui8Equals(a, b)).toBe(true)
-    })
-
-    it('returns true for single element arrays', () => {
-      const a = new Uint8Array([255])
-      const b = new Uint8Array([255])
-      expect(ui8Equals(a, b)).toBe(true)
-    })
-
-    it('returns true for arrays with all zeros', () => {
-      const a = new Uint8Array([0, 0, 0])
-      const b = new Uint8Array([0, 0, 0])
-      expect(ui8Equals(a, b)).toBe(true)
-    })
-
-    it('returns true for arrays with all 255s', () => {
-      const a = new Uint8Array([255, 255, 255])
-      const b = new Uint8Array([255, 255, 255])
-      expect(ui8Equals(a, b)).toBe(true)
-    })
-  })
-
-  describe('unequal arrays - different lengths', () => {
-    it('returns false when first is longer', () => {
-      const a = new Uint8Array([1, 2, 3, 4])
-      const b = new Uint8Array([1, 2, 3])
-      expect(ui8Equals(a, b)).toBe(false)
-    })
-
-    it('returns false when second is longer', () => {
-      const a = new Uint8Array([1, 2, 3])
-      const b = new Uint8Array([1, 2, 3, 4])
-      expect(ui8Equals(a, b)).toBe(false)
-    })
-
-    it('returns false when one is empty', () => {
-      const a = new Uint8Array([1])
-      const b = new Uint8Array(0)
-      expect(ui8Equals(a, b)).toBe(false)
-    })
-
-    it('returns false when comparing empty to non-empty', () => {
-      const a = new Uint8Array(0)
-      const b = new Uint8Array([1])
-      expect(ui8Equals(a, b)).toBe(false)
-    })
-  })
-
-  describe('unequal arrays - different content', () => {
-    it('returns false when first byte differs', () => {
-      const a = new Uint8Array([1, 2, 3])
-      const b = new Uint8Array([0, 2, 3])
-      expect(ui8Equals(a, b)).toBe(false)
-    })
-
-    it('returns false when middle byte differs', () => {
-      const a = new Uint8Array([1, 2, 3])
-      const b = new Uint8Array([1, 0, 3])
-      expect(ui8Equals(a, b)).toBe(false)
-    })
-
-    it('returns false when last byte differs', () => {
-      const a = new Uint8Array([1, 2, 3])
-      const b = new Uint8Array([1, 2, 0])
-      expect(ui8Equals(a, b)).toBe(false)
-    })
-
-    it('returns false for completely different arrays', () => {
-      const a = new Uint8Array([0, 0, 0])
-      const b = new Uint8Array([255, 255, 255])
-      expect(ui8Equals(a, b)).toBe(false)
-    })
-
-    it('returns false when single values differ', () => {
-      const a = new Uint8Array([0])
-      const b = new Uint8Array([1])
-      expect(ui8Equals(a, b)).toBe(false)
-    })
-  })
-
-  describe('edge cases', () => {
-    it('handles boundary byte values', () => {
-      const a = new Uint8Array([0x00, 0x7f, 0x80, 0xff])
-      const b = new Uint8Array([0x00, 0x7f, 0x80, 0xff])
-      expect(ui8Equals(a, b)).toBe(true)
-    })
-
-    it('detects difference at boundary values', () => {
-      const a = new Uint8Array([0x7f])
-      const b = new Uint8Array([0x80])
-      expect(ui8Equals(a, b)).toBe(false)
-    })
-
-    it('handles large arrays efficiently', () => {
-      const size = 100000
-      const a = new Uint8Array(size).fill(0xaa)
-      const b = new Uint8Array(size).fill(0xaa)
-      expect(ui8Equals(a, b)).toBe(true)
-    })
-
-    it('detects single byte difference in large arrays', () => {
-      const size = 100000
-      const a = new Uint8Array(size).fill(0xaa)
-      const b = new Uint8Array(size).fill(0xaa)
-      b[size - 1] = 0xbb // Difference at the end
-      expect(ui8Equals(a, b)).toBe(false)
-    })
-
-    it('compares subarrays correctly', () => {
-      const full = new Uint8Array([0, 1, 2, 3, 4, 5])
-      const sub1 = full.subarray(1, 4) // [1, 2, 3]
-      const sub2 = new Uint8Array([1, 2, 3])
-      expect(ui8Equals(sub1, sub2)).toBe(true)
-    })
-
-    it('detects difference in subarrays', () => {
-      const full = new Uint8Array([0, 1, 2, 3, 4, 5])
-      const sub1 = full.subarray(1, 4) // [1, 2, 3]
-      const sub2 = new Uint8Array([1, 2, 4]) // Different last byte
-      expect(ui8Equals(sub1, sub2)).toBe(false)
-    })
-  })
-})
-
-describe(ifUint8Array, () => {
-  it('returns the input if it is a Uint8Array', () => {
-    const input = new Uint8Array([1, 2, 3])
-    const result = ifUint8Array(input)
-    expect(result).toBe(input)
-  })
-
-  it('returns undefined for non-Uint8Array inputs', () => {
-    expect(ifUint8Array(null)).toBeUndefined()
-    expect(ifUint8Array(undefined)).toBeUndefined()
-    expect(ifUint8Array({})).toBeUndefined()
-    expect(ifUint8Array([])).toBeUndefined()
-    expect(ifUint8Array('string')).toBeUndefined()
-    expect(ifUint8Array(123)).toBeUndefined()
-    expect(ifUint8Array(true)).toBeUndefined()
-  })
-})
-
-describe(ui8Concat, () => {
-  it('concatenates empty array', () => {
-    const result = ui8Concat([])
-    expect(result).toBeInstanceOf(Uint8Array)
-    expect(result.length).toBe(0)
-  })
-
-  it('concatenates single array', () => {
-    const input = new Uint8Array([1, 2, 3])
-    const result = ui8Concat([input])
-    expect(result).toBeInstanceOf(Uint8Array)
-    expect(ui8Equals(result, input)).toBe(true)
-  })
-
-  it('concatenates two arrays', () => {
-    const a = new Uint8Array([1, 2])
-    const b = new Uint8Array([3, 4])
-    const result = ui8Concat([a, b])
-    expect(result).toBeInstanceOf(Uint8Array)
-    expect(ui8Equals(result, new Uint8Array([1, 2, 3, 4]))).toBe(true)
-  })
-
-  it('concatenates multiple arrays', () => {
-    const arrays = [
-      new Uint8Array([1]),
-      new Uint8Array([2, 3]),
-      new Uint8Array([4, 5, 6]),
-    ]
-    const result = ui8Concat(arrays)
-    expect(result).toBeInstanceOf(Uint8Array)
-    expect(ui8Equals(result, new Uint8Array([1, 2, 3, 4, 5, 6]))).toBe(true)
-  })
-
-  it('handles empty arrays in input', () => {
-    const a = new Uint8Array(0)
-    const b = new Uint8Array([1, 2])
-    const c = new Uint8Array(0)
-    const result = ui8Concat([a, b, c])
-    expect(result).toBeInstanceOf(Uint8Array)
-    expect(ui8Equals(result, new Uint8Array([1, 2]))).toBe(true)
-  })
-
-  it('handles all empty arrays', () => {
-    const result = ui8Concat([new Uint8Array(0), new Uint8Array(0)])
-    expect(result).toBeInstanceOf(Uint8Array)
-    expect(result.length).toBe(0)
-  })
-})

package/src/uint8array.ts

@@ -1,197 +0,0 @@
-import { Base64Alphabet } from './uint8array-base64.js'
-import { ui8ConcatNode, ui8ConcatPonyfill } from './uint8array-concat.js'
-import {
-  fromBase64Native,
-  fromBase64Node,
-  fromBase64Ponyfill,
-} from './uint8array-from-base64.js'
-import {
-  toBase64Native,
-  toBase64Node,
-  toBase64Ponyfill,
-} from './uint8array-to-base64.js'
-
-export type { Base64Alphabet }
-
-// @TODO drop dependency on uint8arrays package once Uint8Array.fromBase64 /
-// Uint8Array.prototype.toBase64 is widely supported, and mark fromBase64 /
-// toBase64 as deprecated. We can also drop NodeJS specific implementations
-// once NodeJS <24 is no longer supported.
-
-/**
- * Encodes a Uint8Array into a base64 string.
- *
- * Uses native Uint8Array.prototype.toBase64 when available (Node.js 24+, modern browsers),
- * falling back to Node.js Buffer or a ponyfill implementation.
- *
- * @param bytes - The binary data to encode
- * @param alphabet - The base64 alphabet to use ('base64' or 'base64url'), defaults to 'base64'
- * @returns The base64 encoded string
- *
- * @example
- * ```typescript
- * import { toBase64 } from '@atproto/lex-data'
- *
- * const bytes = new Uint8Array([72, 101, 108, 108, 111])
- * toBase64(bytes)           // 'SGVsbG8='
- * toBase64(bytes, 'base64url')  // 'SGVsbG8' (URL-safe, no padding)
- * ```
- */
-export const toBase64: (
-  bytes: Uint8Array,
-  alphabet?: Base64Alphabet,
-) => string =
-  /* v8 ignore next -- @preserve */ toBase64Native ??
-  toBase64Node ??
-  toBase64Ponyfill
-
-/**
- * Decodes a base64 string into a Uint8Array.
- *
- * Supports both padded and unpadded base64 strings. Uses native
- * Uint8Array.fromBase64 when available, falling back to Node.js Buffer
- * or a ponyfill implementation.
- *
- * @param b64 - The base64 string to decode
- * @param alphabet - The base64 alphabet to use ('base64' or 'base64url'), defaults to 'base64'
- * @returns The decoded binary data
- * @throws If the input is not a valid base64 string
- *
- * @example
- * ```typescript
- * import { fromBase64 } from '@atproto/lex-data'
- *
- * fromBase64('SGVsbG8=')       // Uint8Array([72, 101, 108, 108, 111])
- * fromBase64('SGVsbG8', 'base64url')  // Same, URL-safe alphabet
- * ```
- */
-export const fromBase64: (
-  b64: string,
-  alphabet?: Base64Alphabet,
-) => Uint8Array =
-  /* v8 ignore next -- @preserve */ fromBase64Native ??
-  fromBase64Node ??
-  fromBase64Ponyfill
-
-/* v8 ignore next -- @preserve */
-if (toBase64 === toBase64Ponyfill || fromBase64 === fromBase64Ponyfill) {
-  /*#__PURE__*/
-  console.warn(
-    '[@atproto/lex-data]: Uint8Array.fromBase64 / Uint8Array.prototype.toBase64 not available in this environment. Falling back to ponyfill implementation.',
-  )
-}
-
-/**
- * Returns the input if it is a Uint8Array, otherwise returns undefined.
- *
- * @param input - The value to check
- * @returns The input if it's a Uint8Array, otherwise undefined
- *
- * @example
- * ```typescript
- * import { ifUint8Array } from '@atproto/lex-data'
- *
- * ifUint8Array(new Uint8Array([1, 2]))  // Uint8Array([1, 2])
- * ifUint8Array('not binary')            // undefined
- * ifUint8Array(new ArrayBuffer(4))      // undefined
- * ```
- */
-export function ifUint8Array(input: unknown): Uint8Array | undefined {
-  if (input instanceof Uint8Array) {
-    return input
-  }
-
-  return undefined
-}
-
-/**
- * Coerces various binary data representations into a Uint8Array.
- *
- * Handles the following input types:
- * - `Uint8Array` - Returned as-is
- * - `ArrayBufferView` (e.g., DataView, other TypedArrays) - Converted to Uint8Array
- * - `ArrayBuffer` - Wrapped in a Uint8Array
- *
- * @param input - The value to convert
- * @returns A Uint8Array, or `undefined` if the input could not be converted
- *
- * @example
- * ```typescript
- * import { asUint8Array } from '@atproto/lex-data'
- *
- * asUint8Array(new Uint8Array([1, 2]))     // Uint8Array([1, 2])
- * asUint8Array(new ArrayBuffer(4))         // Uint8Array of length 4
- * asUint8Array(new Int16Array([1, 2]))     // Uint8Array view of the buffer
- * asUint8Array('string')                   // undefined
- * ```
- */
-export function asUint8Array(input: unknown): Uint8Array | undefined {
-  if (input instanceof Uint8Array) {
-    return input
-  }
-
-  if (ArrayBuffer.isView(input)) {
-    return new Uint8Array(
-      input.buffer,
-      input.byteOffset,
-      input.byteLength / Uint8Array.BYTES_PER_ELEMENT,
-    )
-  }
-
-  if (input instanceof ArrayBuffer) {
-    return new Uint8Array(input)
-  }
-
-  return undefined
-}
-
-/**
- * Compares two Uint8Arrays for byte-by-byte equality.
- *
- * @param a - First Uint8Array to compare
- * @param b - Second Uint8Array to compare
- * @returns `true` if both arrays have the same length and identical bytes
- *
- * @example
- * ```typescript
- * import { ui8Equals } from '@atproto/lex-data'
- *
- * ui8Equals(new Uint8Array([1, 2]), new Uint8Array([1, 2]))  // true
- * ui8Equals(new Uint8Array([1, 2]), new Uint8Array([1, 3]))  // false
- * ui8Equals(new Uint8Array([1]), new Uint8Array([1, 2]))     // false
- * ```
- */
-export function ui8Equals(a: Uint8Array, b: Uint8Array): boolean {
-  if (a.byteLength !== b.byteLength) {
-    return false
-  }
-
-  for (let i = 0; i < a.byteLength; i++) {
-    if (a[i] !== b[i]) {
-      return false
-    }
-  }
-
-  return true
-}
-
-/**
- * Concatenates multiple Uint8Arrays into a single Uint8Array.
- *
- * Uses Node.js Buffer.concat when available for performance,
- * falling back to a ponyfill implementation.
- *
- * @param arrays - The Uint8Arrays to concatenate
- * @returns A new Uint8Array containing all input bytes in order
- *
- * @example
- * ```typescript
- * import { ui8Concat } from '@atproto/lex-data'
- *
- * const a = new Uint8Array([1, 2])
- * const b = new Uint8Array([3, 4])
- * ui8Concat([a, b])  // Uint8Array([1, 2, 3, 4])
- * ```
- */
-export const ui8Concat =
-  /* v8 ignore next -- @preserve */ ui8ConcatNode ?? ui8ConcatPonyfill