@atproto/lex-data 0.1.3 → 0.1.4

package/src/object.ts

@@ -1,83 +0,0 @@
-/**
- * Checks whether the input is an object (not null).
- *
- * Returns true for any non-null value with typeof 'object', including
- * arrays, plain objects, class instances, etc.
- *
- * @param input - The value to check
- * @returns `true` if the input is an object (not null)
- *
- * @example
- * ```typescript
- * import { isObject } from '@atproto/lex-data'
- *
- * isObject({})           // true
- * isObject([1, 2, 3])    // true
- * isObject(new Date())   // true
- * isObject(null)         // false
- * isObject('string')     // false
- * ```
- */
-export function isObject(input: unknown): input is object {
-  return input != null && typeof input === 'object'
-}
-
-const ObjectProto = Object.prototype
-const ObjectToString = Object.prototype.toString
-
-/**
- * Checks whether the input is a plain object.
- *
- * A plain object is an object (not null) whose prototype is either null
- * or `Object.prototype`. This excludes arrays, class instances, and other
- * special objects.
- *
- * @param input - The value to check
- * @returns `true` if the input is a plain object
- *
- * @example
- * ```typescript
- * import { isPlainObject } from '@atproto/lex-data'
- *
- * isPlainObject({})                    // true
- * isPlainObject({ a: 1 })              // true
- * isPlainObject(Object.create(null))   // true
- * isPlainObject([1, 2, 3])             // false
- * isPlainObject(new Date())            // false
- * isPlainObject(null)                  // false
- * ```
- */
-export function isPlainObject(input: unknown) {
-  return isObject(input) && isPlainProto(input)
-}
-
-/**
- * Checks whether the prototype of an object is plain (null or Object.prototype).
- *
- * This is useful for checking if an object is a plain object without
- * checking that it's non-null first (the null check is already done).
- *
- * @param input - The object to check (must be non-null)
- * @returns `true` if the object's prototype is plain
- *
- * @example
- * ```typescript
- * import { isPlainProto } from '@atproto/lex-data'
- *
- * isPlainProto({})                    // true
- * isPlainProto(Object.create(null))   // true
- * isPlainProto([1, 2, 3])             // false (Array.prototype)
- * isPlainProto(new Date())            // false (Date.prototype)
- * ```
- */
-export function isPlainProto(input: object): input is Record<string, unknown> {
-  const proto = Object.getPrototypeOf(input)
-  if (proto === null) return true
-  return (
-    (proto === ObjectProto ||
-      // Needed to support NodeJS's `runInNewContext` which produces objects
-      // with a different prototype
-      Object.getPrototypeOf(proto) === null) &&
-    ObjectToString.call(input) === '[object Object]'
-  )
-}

package/src/uint8array-base64.ts

@@ -1,2 +0,0 @@
-/** @default 'base64' */
-export type Base64Alphabet = 'base64' | 'base64url'

package/src/uint8array-concat.test.ts

@@ -1,197 +0,0 @@
-import { assert, describe, expect, it } from 'vitest'
-import { ui8ConcatNode, ui8ConcatPonyfill } from './uint8array-concat.js'
-import { ui8Equals } from './uint8array.js'
-
-for (const ui8Concat of [ui8ConcatNode, ui8ConcatPonyfill] as const) {
-  // Tests should run in NodeJS where implementations are available.
-  assert(ui8Concat, 'ui8Concat implementation should not be undefined')
-
-  describe(ui8Concat.name, () => {
-    describe('empty array', () => {
-      it('returns empty Uint8Array when given empty array', () => {
-        const result = ui8Concat([])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(result.length).toBe(0)
-      })
-    })
-
-    describe('single array', () => {
-      it('returns copy of single Uint8Array', () => {
-        const input = new Uint8Array([1, 2, 3])
-        const result = ui8Concat([input])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(ui8Equals(result, input)).toBe(true)
-      })
-
-      it('returns copy of single empty Uint8Array', () => {
-        const input = new Uint8Array(0)
-        const result = ui8Concat([input])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(result.length).toBe(0)
-      })
-    })
-
-    describe('multiple arrays', () => {
-      it('concatenates two arrays', () => {
-        const a = new Uint8Array([1, 2, 3])
-        const b = new Uint8Array([4, 5, 6])
-        const result = ui8Concat([a, b])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(ui8Equals(result, new Uint8Array([1, 2, 3, 4, 5, 6]))).toBe(true)
-      })
-
-      it('concatenates three arrays', () => {
-        const a = new Uint8Array([1, 2])
-        const b = new Uint8Array([3, 4])
-        const c = new Uint8Array([5, 6])
-        const result = ui8Concat([a, b, c])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(ui8Equals(result, new Uint8Array([1, 2, 3, 4, 5, 6]))).toBe(true)
-      })
-
-      it('concatenates many arrays', () => {
-        const arrays = [
-          new Uint8Array([0x00]),
-          new Uint8Array([0x01, 0x02]),
-          new Uint8Array([0x03, 0x04, 0x05]),
-          new Uint8Array([0x06, 0x07, 0x08, 0x09]),
-          new Uint8Array([0x0a]),
-        ]
-        const result = ui8Concat(arrays)
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(
-          ui8Equals(
-            result,
-            new Uint8Array([
-              0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
-            ]),
-          ),
-        ).toBe(true)
-      })
-    })
-
-    describe('arrays with different lengths', () => {
-      it('concatenates arrays of varying lengths', () => {
-        const a = new Uint8Array([1])
-        const b = new Uint8Array([2, 3, 4, 5, 6])
-        const c = new Uint8Array([7, 8])
-        const result = ui8Concat([a, b, c])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(
-          ui8Equals(result, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8])),
-        ).toBe(true)
-      })
-
-      it('handles large arrays', () => {
-        const size = 10000
-        const a = new Uint8Array(size).fill(0xaa)
-        const b = new Uint8Array(size).fill(0xbb)
-        const result = ui8Concat([a, b])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(result.length).toBe(size * 2)
-        // Check first array portion
-        for (let i = 0; i < size; i++) {
-          expect(result[i]).toBe(0xaa)
-        }
-        // Check second array portion
-        for (let i = size; i < size * 2; i++) {
-          expect(result[i]).toBe(0xbb)
-        }
-      })
-    })
-
-    describe('empty Uint8Arrays in input', () => {
-      it('handles empty array at the beginning', () => {
-        const a = new Uint8Array(0)
-        const b = new Uint8Array([1, 2, 3])
-        const result = ui8Concat([a, b])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(ui8Equals(result, new Uint8Array([1, 2, 3]))).toBe(true)
-      })
-
-      it('handles empty array in the middle', () => {
-        const a = new Uint8Array([1, 2])
-        const b = new Uint8Array(0)
-        const c = new Uint8Array([3, 4])
-        const result = ui8Concat([a, b, c])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(ui8Equals(result, new Uint8Array([1, 2, 3, 4]))).toBe(true)
-      })
-
-      it('handles empty array at the end', () => {
-        const a = new Uint8Array([1, 2, 3])
-        const b = new Uint8Array(0)
-        const result = ui8Concat([a, b])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(ui8Equals(result, new Uint8Array([1, 2, 3]))).toBe(true)
-      })
-
-      it('handles multiple empty arrays', () => {
-        const a = new Uint8Array(0)
-        const b = new Uint8Array([1])
-        const c = new Uint8Array(0)
-        const d = new Uint8Array([2])
-        const e = new Uint8Array(0)
-        const result = ui8Concat([a, b, c, d, e])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(ui8Equals(result, new Uint8Array([1, 2]))).toBe(true)
-      })
-
-      it('handles all empty arrays', () => {
-        const a = new Uint8Array(0)
-        const b = new Uint8Array(0)
-        const c = new Uint8Array(0)
-        const result = ui8Concat([a, b, c])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(result.length).toBe(0)
-      })
-    })
-
-    describe('byte value preservation', () => {
-      it('preserves all byte values from 0x00 to 0xff', () => {
-        const allBytes = new Uint8Array(256)
-        for (let i = 0; i < 256; i++) {
-          allBytes[i] = i
-        }
-        const result = ui8Concat([allBytes])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(ui8Equals(result, allBytes)).toBe(true)
-      })
-
-      it('preserves boundary byte values in concatenation', () => {
-        const a = new Uint8Array([0x00, 0x01, 0x7f])
-        const b = new Uint8Array([0x80, 0xfe, 0xff])
-        const result = ui8Concat([a, b])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(
-          ui8Equals(
-            result,
-            new Uint8Array([0x00, 0x01, 0x7f, 0x80, 0xfe, 0xff]),
-          ),
-        ).toBe(true)
-      })
-    })
-
-    describe('subarray handling', () => {
-      it('correctly concatenates subarrays', () => {
-        const fullArray = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-        const sub1 = fullArray.subarray(0, 3) // [0, 1, 2]
-        const sub2 = fullArray.subarray(5, 8) // [5, 6, 7]
-        const result = ui8Concat([sub1, sub2])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(ui8Equals(result, new Uint8Array([0, 1, 2, 5, 6, 7]))).toBe(true)
-      })
-
-      it('correctly concatenates subarray with regular array', () => {
-        const fullArray = new Uint8Array([10, 20, 30, 40, 50])
-        const sub = fullArray.subarray(1, 4) // [20, 30, 40]
-        const regular = new Uint8Array([100, 200])
-        const result = ui8Concat([sub, regular])
-        expect(result).toBeInstanceOf(Uint8Array)
-        expect(ui8Equals(result, new Uint8Array([20, 30, 40, 100, 200]))).toBe(
-          true,
-        )
-      })
-    })
-  })
-}

package/src/uint8array-concat.ts

@@ -1,25 +0,0 @@
-import { NodeJSBuffer } from './lib/nodejs-buffer.js'
-
-const Buffer = NodeJSBuffer
-
-export const ui8ConcatNode = Buffer
-  ? function ui8ConcatNode(
-      array: readonly Uint8Array[],
-    ): Uint8Array<ArrayBuffer> {
-      return Buffer.concat(array)
-    }
-  : /* v8 ignore next -- @preserve */ null
-
-export function ui8ConcatPonyfill(
-  array: readonly Uint8Array[],
-): Uint8Array<ArrayBuffer> {
-  let totalLength = 0
-  for (const arr of array) totalLength += arr.length
-  const result = new Uint8Array(totalLength)
-  let offset = 0
-  for (const arr of array) {
-    result.set(arr, offset)
-    offset += arr.length
-  }
-  return result
-}

package/src/uint8array-from-base64.test.ts

@@ -1,130 +0,0 @@
-import 'core-js/es/typed-array/from-base64.js'
-import 'core-js/es/typed-array/to-base64.js'
-
-import { assert, describe, expect, it } from 'vitest'
-import {
-  fromBase64Native,
-  fromBase64Node,
-  fromBase64Ponyfill,
-} from './uint8array-from-base64.js'
-import { ui8Equals } from './uint8array.js'
-
-// @NOTE This test suite relies on the NodeJS Buffer implementation to generate
-// valid base64 strings for testing.
-
-// @NOTE b64 needs a test suite because fromBase64 implementations differ in
-// their behavior when encountering invalid base64 strings. This is not the case
-// for toBase64, which is straightforward and has no edge cases.
-
-for (const fromBase64 of [
-  fromBase64Native,
-  fromBase64Node,
-  fromBase64Ponyfill,
-] as const) {
-  // Tests should run in NodeJS where implementations are either available or
-  // polyfilled (see core-js imports above).
-  assert(fromBase64 !== null, 'fromBase64 implementation should not be null')
-
-  describe(fromBase64.name, () => {
-    describe('valid base64 strings', () => {
-      it('decodes empty string', () => {
-        const decoded = fromBase64('')
-        expect(decoded).toBeInstanceOf(Uint8Array)
-        expect(decoded.length).toBe(0)
-      })
-
-      it('decodes 10MB', () => {
-        const bytes = Buffer.allocUnsafe(10_000_000).fill('🐩')
-        const encoded = bytes.toString('base64')
-        const decoded = fromBase64(encoded)
-        expect(decoded).toBeInstanceOf(Uint8Array)
-        expect(ui8Equals(decoded, bytes)).toBe(true)
-      })
-
-      for (const buffer of [
-        Buffer.from(''),
-        Buffer.from('\0\0'),
-        Buffer.from('\0\0\0'),
-        Buffer.from('\0\0\0\0'),
-        Buffer.from('__'),
-        Buffer.from('é'),
-        Buffer.from('àç'),
-        Buffer.from('\0éàç'),
-        Buffer.from('```'),
-        Buffer.from('aaa'),
-        Buffer.from('Hello, World!'),
-        Buffer.from('😀😃😄😁😆😅😂🤣😊😇'),
-        Buffer.from('👩‍💻👨‍💻👩‍🔬👨‍🔬👩‍🚀👨‍🚀'),
-        Buffer.from('🌍🌎🌏🌐🪐🌟✨⚡🔥💧'),
-        Buffer.from(new Uint8Array([0xfb, 0xff, 0xbf])),
-        Buffer.from(new Uint8Array([0xfb, 0xff, 0xbf])),
-        Buffer.from(new Uint8Array([0x4d])),
-        Buffer.from(new Uint8Array([0x4d, 0x61])),
-        Buffer.from(new Uint8Array([0x4d, 0x61, 0x6e])),
-        Buffer.from(new Uint8Array([0x4d])),
-        Buffer.from(new Uint8Array([0x4d, 0x61])),
-        Buffer.from(new Uint8Array([0x00, 0x4d, 0x61, 0x6e, 0x00])),
-      ]) {
-        const base64 = buffer.toString('base64')
-        const base64Unpadded = base64.replace(/=+$/, '')
-        const base64url = buffer.toString('base64url') // No padding in base64url
-
-        it(`decodes ${JSON.stringify(base64)}`, () => {
-          const decoded = fromBase64(base64)
-          expect(decoded).toBeInstanceOf(Uint8Array)
-          expect(ui8Equals(decoded, buffer)).toBe(true)
-        })
-
-        it(`decodes ${JSON.stringify(base64url)} (base64url)`, () => {
-          const decoded = fromBase64(base64url, 'base64url')
-          expect(decoded).toBeInstanceOf(Uint8Array)
-          expect(ui8Equals(decoded, buffer)).toBe(true)
-        })
-
-        if (base64 !== base64Unpadded) {
-          it(`decodes ${JSON.stringify(base64Unpadded)} (unpadded)`, () => {
-            const decoded = fromBase64(base64Unpadded)
-            expect(decoded).toBeInstanceOf(Uint8Array)
-            expect(ui8Equals(decoded, buffer)).toBe(true)
-          })
-        }
-      }
-    })
-
-    describe('invalid base64 strings', () => {
-      for (const invalidB64 of [
-        'çç',
-        'é',
-        'YWJjZGU$$$',
-        '@@@@',
-        'abcd!',
-        'ab=cd',
-        // "YWFh" is "aaa" in base64
-        'YWFh' + 'é',
-        'YWFh' + 'éé',
-        'YWFh' + 'ééé',
-        'YWFh' + 'éééé',
-        // Invalid padding
-        'YWFh' + '=',
-        'YWFh' + '==',
-        'YWFh' + '===',
-        'YWFh' + '====',
-        'YWFh' + '=====',
-        'YWFh' + '======',
-        'TWEé',
-        'TWE👍',
-        // More invalid padding
-        // 'TWE=', // 'Ma'
-        'TWE=' + '=',
-        'TWE=' + '==',
-        // 'TQ==', // 'M'
-        'TQ==' + '=',
-        'TQ==' + '==',
-      ] as const) {
-        it(`throws on invalid base64 string "${invalidB64}"`, () => {
-          expect(() => fromBase64(invalidB64)).toThrow()
-        })
-      }
-    })
-  })
-}

package/src/uint8array-from-base64.ts

@@ -1,98 +0,0 @@
-import { fromString } from 'uint8arrays/from-string'
-import { NodeJSBuffer } from './lib/nodejs-buffer.js'
-import { Base64Alphabet } from './uint8array-base64.js'
-
-const Buffer = NodeJSBuffer
-
-declare global {
-  interface Uint8ArrayConstructor {
-    /**
-     * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/fromBase64 Uint8Array.fromBase64()}
-     */
-    fromBase64?: (
-      b64: string,
-      options?: {
-        /** @default 'base64' */
-        alphabet?: 'base64' | 'base64url'
-        lastChunkHandling?: 'loose' | 'strict' | 'stop-before-partial'
-      },
-    ) => Uint8Array
-  }
-}
-
-export const fromBase64Native =
-  typeof Uint8Array.fromBase64 === 'function'
-    ? function fromBase64Native(
-        b64: string,
-        alphabet: Base64Alphabet = 'base64',
-      ): Uint8Array {
-        return Uint8Array.fromBase64!(b64, {
-          alphabet,
-          lastChunkHandling: 'loose',
-        })
-      }
-    : /* v8 ignore next -- @preserve */ null
-
-export const fromBase64Node = Buffer
-  ? function fromBase64Node(
-      b64: string,
-      alphabet: Base64Alphabet = 'base64',
-    ): Uint8Array {
-      const bytes = Buffer.from(b64, alphabet)
-      verifyBase64ForBytes(b64, bytes)
-      // Convert to Uint8Array because even though Buffer is a sub class of
-      // Uint8Array, it serializes differently to Uint8Array (e.g. in JSON) and
-      // results in unexpected behavior downstream (e.g. in tests)
-      return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
-    }
-  : /* v8 ignore next -- @preserve */ null
-
-export function fromBase64Ponyfill(
-  b64: string,
-  alphabet: Base64Alphabet = 'base64',
-): Uint8Array {
-  const bytes = fromString(b64, b64.endsWith('=') ? `${alphabet}pad` : alphabet)
-  verifyBase64ForBytes(b64, bytes)
-  return bytes
-}
-
-// @NOTE NodeJS will silently stop decoding at the first invalid character,
-// while "uint8arrays/from-string" will not validate that the padding is
-// correct. The following function performs basic validation to ensure that the
-// input was a valid base64 string. The availability of the "bytes" allows
-// to perform checks with O[1] complexity.
-function verifyBase64ForBytes(b64: string, bytes: Uint8Array): void {
-  const paddingCount = b64.endsWith('==') ? 2 : b64.endsWith('=') ? 1 : 0
-  const trimmedLength = b64.length - paddingCount
-  const expectedByteLength = Math.floor((trimmedLength * 3) / 4)
-  if (bytes.length !== expectedByteLength) {
-    throw new Error('Invalid base64 string')
-  }
-
-  const expectedB64Length = (bytes.length / 3) * 4
-  const expectedPaddingCount =
-    expectedB64Length % 4 === 0 ? 0 : 4 - (expectedB64Length % 4)
-  const expectedFullB64Length = expectedB64Length + expectedPaddingCount
-  if (b64.length > expectedFullB64Length) {
-    throw new Error('Invalid base64 string')
-  }
-
-  // The previous might still allow false positive if only the last few
-  // chars are invalid.
-  for (
-    let i = Math.ceil(expectedB64Length);
-    i < b64.length - paddingCount;
-    i++
-  ) {
-    const code = b64.charCodeAt(i)
-    if (
-      !(code >= 65 && code <= 90) && // A-Z
-      !(code >= 97 && code <= 122) && // a-z
-      !(code >= 48 && code <= 57) && // 0-9
-      code !== 43 && // +
-      code !== 47 // /
-    ) {
-      throw new Error('Invalid base64 string')
-    }
-  }
-}