Only expose the two methods

Author: blakeembrey

.github/workflows/ci.yml

@@ -11,9 +11,9 @@ jobs:
     strategy:
       matrix:
         node-version:
-          - 18
+          - 20
           - 25 # Node.js 25 support Uint8Array.fromBase64()
-          - 'lts/*'
+          - '*'
     steps:
       - uses: actions/checkout@v6
       - uses: actions/setup-node@v6

benchmarks/base64.bench.ts

@@ -79,17 +79,19 @@ for (const payload of payloads) {
 describe('decode base64 for basic-auth payloads', () => {
   for (const payload of payloads) {
     describe(payload.name, () => {
-      if (hasUint8ArrayFromBase64) {
-        bench('Uint8Array.fromBase64 + TextDecoder', () => {
+      bench.skipIf(!hasUint8ArrayFromBase64)(
+        'Uint8Array.fromBase64 + TextDecoder',
+        () => {
           decodeBase64WithUint8Array(payload.encoded);
-        });
-      }
+        },
+      );
 
-      if (hasNodeBuffer) {
-        bench('Buffer.from(base64).toString(utf-8)', () => {
+      bench.skipIf(!hasNodeBuffer)(
+        'Buffer.from(base64).toString(utf-8)',
+        () => {
           decodeBase64WithNodeBuffer(payload.encoded);
-        });
-      }
+        },
+      );
 
       bench('atob + Uint8Array.from + TextDecoder', () => {
         decodeBase64WithAtob(payload.encoded);

globals.d.ts

@@ -28,10 +28,11 @@
   "devDependencies": {
     "@borderless/ts-scripts": "^0.15.0",
     "@size-limit/preset-small-lib": "^12.1.0",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@types/node": "^25.7.0",
+    "@vitest/coverage-v8": "^4.1.6",
     "size-limit": "^12.1.0",
-    "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6"
   },
   "engines": {
     "node": ">=18"

package.json

@@ -0,0 +1,41 @@
+import { afterAll, assert, beforeAll, describe, it, vi } from 'vitest';
+
+const importBase64 = async () => {
+  vi.resetModules();
+
+  const { base64 } = await import('./base64.js');
+  return base64;
+};
+
+describe('base64', async () => {
+  let base64 = await importBase64();
+
+  afterAll(() => {
+    vi.unstubAllGlobals();
+  });
+
+  describe.skipIf(!Buffer)('Buffer', async () => {
+    it('should encode base64', () => {
+      assert.strictEqual(base64.encode('foo:bar'), 'Zm9vOmJhcg==');
+    });
+
+    it('should decode base64', () => {
+      assert.strictEqual(base64.decode('Zm9vOmJhcg=='), 'foo:bar');
+    });
+  });
+
+  describe.skipIf(!Uint8Array.prototype.toBase64)('Uint8Array', async () => {
+    beforeAll(async () => {
+      vi.stubGlobal('Buffer', undefined);
+      base64 = await importBase64();
+    });
+
+    it('should encode base64', () => {
+      assert.strictEqual(base64.encode('foo:bar'), 'Zm9vOmJhcg==');
+    });
+
+    it('should decode base64', () => {
+      assert.strictEqual(base64.decode('Zm9vOmJhcg=='), 'foo:bar');
+    });
+  });
+});

src/base64.spec.ts

@@ -1,75 +1,22 @@
-type Uint8ArrayWithBase64 = typeof Uint8Array & {
-  fromBase64?: (str: string) => Uint8Array;
-};
-
-type Uint8ArrayInstanceWithBase64 = Uint8Array & {
-  toBase64?: () => string;
-};
-
-type BufferLike = {
-  from(
-    input: string,
-    encoding: 'base64' | 'utf-8',
-  ): { toString(encoding: 'utf-8' | 'base64'): string };
-};
-
-const NodeBuffer = (globalThis as any).Buffer as BufferLike | undefined;
-const uint8ArrayPrototype =
-  Uint8Array.prototype as Uint8ArrayInstanceWithBase64;
-
-const textDecoder = new TextDecoder('utf-8');
-const textEncoder = new TextEncoder();
-
-/**
- * Decode base64 string.
- * @private
- */
-export const decodeBase64: (str: string) => string = (() => {
-  // 1) Node.js (fast path)
-  if (typeof NodeBuffer?.from === 'function') {
-    return (str: string) => NodeBuffer.from(str, 'base64').toString('utf-8');
-  }
-
-  // 2) Modern Web / some runtimes
-  if (typeof (Uint8Array as Uint8ArrayWithBase64).fromBase64 === 'function') {
-    return (str: string) =>
-      textDecoder.decode((Uint8Array as Uint8ArrayWithBase64).fromBase64!(str));
-  }
-
-  // 3) Browser fallback
-  return (str: string) => {
-    const binary = atob(str);
-    return textDecoder.decode(
-      Uint8Array.from(binary, (char) => char.charCodeAt(0)),
-    );
-  };
-})();
-
-/**
- * Encode string to base64.
- * @private
- */
-export const encodeBase64: (str: string) => string = (() => {
-  // 1) Node.js (fast path)
-  if (typeof NodeBuffer?.from === 'function') {
-    return (str: string) => NodeBuffer.from(str, 'utf-8').toString('base64');
+export const base64 = (() => {
+  if (typeof Buffer !== 'undefined') {
+    return {
+      encode: (str: string) => Buffer.from(str, 'utf-8').toString('base64'),
+      decode: (str: string) => Buffer.from(str, 'base64').toString('utf-8'),
+    };
   }
 
-  // 2) Modern Web / some runtimes
-  if (typeof uint8ArrayPrototype.toBase64 === 'function') {
-    return (str: string) =>
-      (textEncoder.encode(str) as Uint8ArrayInstanceWithBase64).toBase64!();
-  }
-
-  // 3) Browser fallback
-  return (str: string) => {
-    const bytes = textEncoder.encode(str);
-    let binary = '';
-
-    for (let i = 0; i < bytes.length; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-
-    return btoa(binary);
+  const textEncoder = new TextEncoder();
+  const textDecoder = new TextDecoder();
+
+  return {
+    encode: (str: string) => {
+      const bytes = textEncoder.encode(str);
+      return bytes.toBase64();
+    },
+    decode: (str: string) => {
+      const bytes = Uint8Array.fromBase64(str);
+      return textDecoder.decode(bytes);
+    },
   };
 })();

src/base64.ts

@@ -6,7 +6,7 @@
  * MIT Licensed
  */
 
-import { decodeBase64, encodeBase64 } from './base64.js';
+import { base64 } from './base64.js';
 
 /**
  * Object to represent user credentials.
@@ -34,7 +34,7 @@ export function parse(string: string): Credentials | undefined {
   if (!match) return undefined;
 
   // decode user pass
-  const userPass = decodeBase64(match[1]);
+  const userPass = base64.decode(match[1]);
   const colonIndex = userPass.indexOf(':');
   if (colonIndex === -1) return undefined;
 
@@ -84,7 +84,7 @@ export function format(credentials: Credentials): string {
     );
   }
 
-  return 'Basic ' + encodeBase64(credentials.name + ':' + credentials.pass);
+  return 'Basic ' + base64.encode(credentials.name + ':' + credentials.pass);
 }
 
 /**

src/index.ts

@@ -2,12 +2,12 @@
   "extends": "@borderless/ts-scripts/configs/tsconfig.json",
   "compilerOptions": {
     "target": "es2023",
-    "lib": ["es2023"],
+    "lib": ["ESNext"],
     "rootDir": "src",
     "outDir": "dist",
     "module": "nodenext",
     "moduleResolution": "nodenext",
-    "types": ["./globals.d.ts"]
+    "types": ["node"]
   },
   "include": ["src/**/*"]
 }