@atproto/lex-data 0.0.4 → 0.0.6

package/src/cid.test.ts

@@ -0,0 +1,126 @@
+import { CID } from 'multiformats/cid'
+import { sha256, sha512 } from 'multiformats/hashes/sha2'
+import { describe, expect, it } from 'vitest'
+import {
+  RAW_BIN_MULTICODEC,
+  createCid,
+  decodeCid,
+  ensureValidCidString,
+  isCid,
+  parseCid,
+  parseCidString,
+} from './cid.js'
+
+describe(isCid, () => {
+  describe('non-strict mode', () => {
+    it('returns true for parsed CIDs', () => {
+      const cid = parseCid(
+        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      )
+      expect(isCid(cid)).toBe(true)
+    })
+
+    it('returns true for CID v0 and v1', async () => {
+      const digest = await sha256.digest(Buffer.from('hello world'))
+      const cidV0 = CID.createV0(digest)
+      const cidV1 = CID.createV1(RAW_BIN_MULTICODEC, digest)
+      expect(isCid(cidV0)).toBe(true)
+      expect(isCid(cidV1)).toBe(true)
+    })
+
+    it('returns false for invalid CIDs', () => {
+      expect(isCid(new Date())).toBe(false)
+      expect(isCid({})).toBe(false)
+      expect(isCid('not a cid')).toBe(false)
+    })
+  })
+
+  describe('strict mode', () => {
+    it('returns true for valid CIDs in strict mode', async () => {
+      const digest = await sha256.digest(Buffer.from('hello world'))
+      const cid = CID.createV1(RAW_BIN_MULTICODEC, digest)
+      expect(isCid(cid, { strict: true })).toBe(true)
+    })
+
+    it('rejects CID v0 when strict option is set', async () => {
+      const digest = await sha256.digest(Buffer.from('hello world'))
+      const cid = CID.createV0(digest)
+      expect(isCid(cid, { strict: true })).toBe(false)
+    })
+
+    it('rejects CIDs with invalid hash algorithm', async () => {
+      const digest = await sha512.digest(Buffer.from('hello world'))
+      const cid = CID.createV1(RAW_BIN_MULTICODEC, digest)
+      expect(isCid(cid, { strict: true })).toBe(false)
+    })
+
+    it('rejects CIDs with invalid code', async () => {
+      const digest = await sha256.digest(Buffer.from('hello world'))
+      const cid = CID.createV1(3333, digest)
+      expect(isCid(cid, { strict: true })).toBe(false)
+    })
+  })
+})
+
+describe(createCid, () => {
+  it('creates a valid CID v1', async () => {
+    const digest = await sha256.digest(Buffer.from('hello world'))
+    const cid = createCid(RAW_BIN_MULTICODEC, digest)
+    expect(cid.version).toBe(1)
+    expect(cid.code).toBe(RAW_BIN_MULTICODEC)
+    expect(cid.multihash.code).toBe(sha256.code)
+    expect(cid.multihash.digest).toEqual(digest.digest)
+  })
+})
+
+describe(decodeCid, () => {
+  it('decodes CID from bytes', () => {
+    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
+    const cid = parseCid(cidStr)
+    const bytes = cid.bytes
+    const decodedCid = decodeCid(bytes)
+    expect(decodedCid.toString()).toBe(cidStr)
+  })
+})
+
+describe(parseCid, () => {
+  it('parses valid CIDs', () => {
+    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
+    const cid = parseCid(cidStr)
+    expect(cid.toString()).toBe(cidStr)
+  })
+
+  it('throws for invalid CIDs', () => {
+    const invalidCidStr = 'invalidcidstring'
+    expect(() => parseCid(invalidCidStr)).toThrow()
+  })
+})
+
+describe(parseCidString, () => {
+  it('parses valid CIDs', () => {
+    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
+    const cid = parseCidString(cidStr)
+    expect(cid).toBeDefined()
+    expect(cid!.toString()).toBe(cidStr)
+  })
+
+  it('returns undefined for invalid CIDs', () => {
+    const invalidCidStr = 'invalidcidstring'
+    const cid = parseCidString(invalidCidStr)
+    expect(cid).toBeUndefined()
+  })
+})
+
+describe(ensureValidCidString, () => {
+  it('does not throw for valid CIDs', () => {
+    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
+    expect(() => ensureValidCidString(cidStr)).not.toThrow()
+  })
+
+  it('throws for invalid CIDs', () => {
+    const invalidCidStr = 'invalidcidstring'
+    expect(() => ensureValidCidString(invalidCidStr)).toThrow(
+      'Invalid CID string',
+    )
+  })
+})

package/src/index.ts

@@ -2,6 +2,7 @@ export * from './blob.js'
 export * from './cid.js'
 export * from './language.js'
 export * from './lex-equals.js'
+export * from './lex-error.js'
 export * from './lex.js'
 export * from './object.js'
 export * from './uint8array.js'

package/src/language.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { isLanguageString, parseLanguageString } from './language'
 
 describe('string', () => {

package/src/lex-equals.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { parseCid } from './cid.js'
 import { lexEquals } from './lex-equals.js'
 import { LexValue } from './lex.js'
@@ -38,6 +39,7 @@ describe('lexEquals', () => {
     expectLexEqual([1, 2, 3], [1, 2, 4], false)
     expectLexEqual([1, 2, 3], [1, 2], false)
     expectLexEqual([1, 2, 3], 'not an array', false)
+    expectLexEqual([1, 2, 3], { 0: 1, 1: 2, 2: 3 }, false)
   })
 
   it('compares Uint8Arrays', () => {
@@ -59,10 +61,23 @@ describe('lexEquals', () => {
     expectLexEqual(cid2, cid3, true)
 
     expectLexEqual(cid1, cid1.toString(), false)
+    expectLexEqual(cid1, { not: 'a cid' }, false)
+    expectLexEqual(cid1, [], false)
+    expectLexEqual(cid1, cid1.bytes, false)
   })
 
   it('compares objects', () => {
     expectLexEqual({ a: 1, b: 2 }, { a: 1, b: 2 }, true)
+    expectLexEqual(
+      { a: 1, b: 2, c: undefined },
+      { a: 1, b: 2, c: undefined },
+      true,
+    )
+    expectLexEqual(
+      { a: 1, b: 2, c: { e: 1, d: undefined } },
+      { a: 1, b: 2, c: { d: undefined, e: 1 } },
+      true,
+    )
     expectLexEqual(
       { a: 1, b: { unicode: 'a~öñ©⽘☎𓋓😀👨‍👩‍👧‍👧' } },
       { a: 1, b: { unicode: 'a~öñ©⽘☎𓋓😀👨‍👩‍👧‍👧' } },
@@ -75,6 +90,21 @@ describe('lexEquals', () => {
     expectLexEqual({ a: 1, b: 2 }, null, false)
   })
 
+  it('accounts for undefined (but present) properties in objects', () => {
+    expectLexEqual({ a: 1, b: undefined }, { a: 1 }, false)
+    expectLexEqual(
+      { a: 1, b: { c: undefined, d: 2 } },
+      { a: 1, b: { d: 2 } },
+      false,
+    )
+
+    expectLexEqual(
+      { a: 1, b: { c: undefined, d: 2 } },
+      { a: 1, b: { c: 3, d: 2 } },
+      false,
+    )
+  })
+
   it('compares nested structures', () => {
     const lex1 = {
       foo: [1, 2, { bar: new Uint8Array([3, 4, 5]) }],

package/src/lex-error.ts

@@ -0,0 +1,34 @@
+export type LexErrorCode = string
+
+export type LexErrorData<N extends LexErrorCode = LexErrorCode> = {
+  error: N
+  message?: string
+}
+
+export class LexError<N extends LexErrorCode = LexErrorCode> extends Error {
+  name = 'LexError'
+
+  constructor(
+    readonly error: N,
+    message?: string,
+    options?: ErrorOptions,
+  ) {
+    super(message, options)
+  }
+
+  toString(): string {
+    return `${this.name}: [${this.error}] ${this.message}`
+  }
+
+  toJSON(): LexErrorData<N> {
+    const { error, message } = this
+    return { error, message: message ?? undefined }
+  }
+
+  /**
+   * Translate into an HTTP response for downstream clients.
+   */
+  toResponse(): Response {
+    return Response.json(this.toJSON(), { status: 400 })
+  }
+}

package/src/lex.test.ts

@@ -1,4 +1,59 @@
-import { isLexValue, isTypedLexMap } from './lex'
+import { describe, expect, it } from 'vitest'
+import { parseCid } from './cid.js'
+import { isLexArray, isLexScalar, isLexValue, isTypedLexMap } from './lex.js'
+
+describe('isLexScalar', () => {
+  for (const { note, value, expected } of [
+    { note: 'string', value: 'hello', expected: true },
+    { note: 'boolean', value: true, expected: true },
+    { note: 'null', value: null, expected: true },
+    { note: 'Uint8Array', value: new Uint8Array([1, 2, 3]), expected: true },
+    {
+      note: 'Cid',
+      value: parseCid(
+        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      ),
+      expected: true,
+    },
+    { note: 'number (integer)', value: 42, expected: true },
+    { note: 'number (float)', value: 3.14, expected: false },
+    { note: 'object', value: { a: 1 }, expected: false },
+    { note: 'array', value: [1, 2, 3], expected: false },
+    { note: 'undefined', value: undefined, expected: false },
+    { note: 'function', value: () => {}, expected: false },
+  ]) {
+    it(note, () => {
+      const result = isLexScalar(value)
+      expect(result).toBe(expected)
+    })
+  }
+})
+
+describe('isLexArray', () => {
+  it('returns true for valid LexArray', () => {
+    const list = [123, 'blah', true, null, new Uint8Array([1, 2, 3]), { a: 1 }]
+    expect(isLexArray(list)).toBe(true)
+  })
+
+  it('returns false for non-arrays', () => {
+    const values = [
+      123,
+      'blah',
+      true,
+      null,
+      new Uint8Array([1, 2, 3]),
+      { a: 1 },
+    ]
+    for (const value of values) {
+      expect(isLexArray(value)).toBe(false)
+    }
+  })
+
+  it('returns false for arrays with non-Lex values', () => {
+    expect(isLexArray([123, 'blah', () => {}])).toBe(false)
+    expect(isLexArray([123, 'blah', undefined])).toBe(false)
+  })
+})
 
 describe('isLexValue', () => {
   describe('valid values', () => {
@@ -9,7 +64,9 @@ describe('isLexValue', () => {
       { note: 'Uint8Array', value: new Uint8Array([1, 2, 3]) },
       {
         note: 'Cid',
-        value: { code: 1, version: 1, multihash: new Uint8Array([18, 32]) },
+        value: parseCid(
+          'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+        ),
       },
       {
         note: 'record with Lex values',
@@ -51,17 +108,12 @@ describe('isLexValue', () => {
       { note: 'float', value: 123.456 },
       { note: 'undefined', value: undefined },
       { note: 'function', value: () => {} },
-      {
-        note: 'record with non-Lex value',
-        value: {
-          a: 123,
-          b: () => {},
-        },
-      },
-      {
-        note: 'list with non-Lex value',
-        value: [123, 'blah', () => {}],
-      },
+      { note: 'obj with fn', value: { a: 123, b: () => {} } },
+      { note: 'list with non-Lex value', value: [123, 'blah', () => {}] },
+      { note: 'Date object', value: new Date() },
+      { note: 'Map object', value: new Map() },
+      { note: 'Set object', value: new Set() },
+      { note: 'class instance', value: new (class A {})() },
     ]) {
       it(note, () => {
         expect(isLexValue(value)).toBe(false)

package/src/lib/nodejs-buffer.ts

@@ -12,6 +12,7 @@ interface NodeJSBufferConstructor {
     input: Uint8Array | ArrayBuffer | ArrayBufferView,
   ): NodeJSBuffer<ArrayBuffer>
   from(input: string, encoding?: Encoding): NodeJSBuffer<ArrayBuffer>
+  concat(list: readonly Uint8Array[], totalLength?: number): NodeJSBuffer
   byteLength(input: string, encoding?: Encoding): number
   prototype: NodeJSBuffer
 }
@@ -24,4 +25,4 @@ export const NodeJSBuffer: NodeJSBufferConstructor | null =
   (globalThis as any)?.[BUFFER]?.prototype instanceof Uint8Array &&
   'byteLength' in (globalThis as any)[BUFFER]
     ? ((globalThis as any)[BUFFER] as NodeJSBufferConstructor)
-    : null
+    : /* v8 ignore next -- @preserve */ null

package/src/object.test.ts

@@ -1,5 +1,7 @@
+import { describe, expect, it } from 'vitest'
 import { parseCid } from './cid.js'
 import { isObject, isPlainObject } from './object.js'
+
 describe('isObject', () => {
   it('returns true for plain objects', () => {
     expect(isObject({})).toBe(true)

package/src/uint8array-concat.test.ts

@@ -0,0 +1,197 @@
+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

@@ -0,0 +1,21 @@
+import { NodeJSBuffer } from './lib/nodejs-buffer.js'
+
+const Buffer = NodeJSBuffer
+
+export const ui8ConcatNode = Buffer
+  ? function ui8ConcatNode(array: readonly Uint8Array[]): Uint8Array {
+      return Buffer.concat(array)
+    }
+  : /* v8 ignore next -- @preserve */ null
+
+export function ui8ConcatPonyfill(array: readonly Uint8Array[]): Uint8Array {
+  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,6 +1,7 @@
 import 'core-js/modules/es.uint8-array.from-base64.js'
 import 'core-js/modules/es.uint8-array.to-base64.js'
-import assert from 'node:assert'
+
+import { assert, describe, expect, it } from 'vitest'
 import {
   fromBase64Native,
   fromBase64Node,
@@ -110,6 +111,8 @@ for (const fromBase64 of [
         'YWFh' + '====',
         'YWFh' + '=====',
         'YWFh' + '======',
+        'TWEé',
+        'TWE👍',
         // More invalid padding
         // 'TWE=', // 'Ma'
         'TWE=' + '=',

package/src/uint8array-from-base64.ts

@@ -31,7 +31,7 @@ export const fromBase64Native =
           lastChunkHandling: 'loose',
         })
       }
-    : null
+    : /* v8 ignore next -- @preserve */ null
 
 export const fromBase64Node = Buffer
   ? function fromBase64Node(
@@ -45,7 +45,7 @@ export const fromBase64Node = Buffer
       // results in unexpected behavior downstream (e.g. in tests)
       return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
     }
-  : null
+  : /* v8 ignore next -- @preserve */ null
 
 export function fromBase64Ponyfill(
   b64: string,

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

@@ -1,6 +1,6 @@
 import 'core-js/modules/es.uint8-array.from-base64.js'
 import 'core-js/modules/es.uint8-array.to-base64.js'
-import assert from 'node:assert'
+import { assert, describe, expect, it } from 'vitest'
 import {
   toBase64Native,
   toBase64Node,
@@ -14,9 +14,9 @@ for (const toBase64 of [
 ] as const) {
   // Tests should run in NodeJS where implementations are either available or
   // polyfilled (see core-js imports above).
-  assert(toBase64 !== null, 'toBase64 implementation should not be null')
+  assert(toBase64, 'toBase64 implementation should not be null')
 
-  describe(toBase64.name, () => {
+  describe(toBase64, () => {
     describe('basic encoding', () => {
       it('encodes empty Uint8Array', () => {
         const encoded = toBase64(new Uint8Array(0))

package/src/uint8array-to-base64.ts

@@ -25,7 +25,7 @@ export const toBase64Native =
       ): string {
         return bytes.toBase64!({ alphabet, omitPadding: true })
       }
-    : null
+    : /* v8 ignore next -- @preserve */ null
 
 export const toBase64Node = Buffer
   ? function toBase64Node(
@@ -45,7 +45,7 @@ export const toBase64Node = Buffer
           : b64.slice(0, -1) // '='
         : b64
     }
-  : null
+  : /* v8 ignore next -- @preserve */ null
 
 export function toBase64Ponyfill(
   bytes: Uint8Array,