feat(multibase): initial commit

packages/utilities/multibase/README.md

···
+# @atcute/multibase
+
+multibase utilities, only supports a limited set of codecs.
+
+```ts
+import { toBase32 } from '@atcute/multibase';
+
+const utf8 = new TextEncoder();
+const base32 = toBase32(utf8.encode('lorem ipsum'));
+//    ^? "nrxxezlnebuxa43vnu"
+```

packages/utilities/multibase/lib/bases/base16.ts

···
+import { createRfc4648Decode, createRfc4648Encode } from '../utils.js';
+
+const HAS_UINT8_BASE16_SUPPORT = 'fromHex' in Uint8Array;
+
+const BASE16_CHARSET = '0123456789abcdef';
+const UPPER_RE = /[A-F]/;
+
+export const fromBase16 = !HAS_UINT8_BASE16_SUPPORT
+	? /*#__PURE__*/ createRfc4648Decode(BASE16_CHARSET, 4, false)
+	: (str: string): Uint8Array => {
+			if (UPPER_RE.test(str)) {
+				throw new SyntaxError(`unexpected uppercase characters in base16 string`);
+			}
+
+			return Uint8Array.fromHex(str);
+		};
+
+export const toBase16 = !HAS_UINT8_BASE16_SUPPORT
+	? /*#__PURE__*/ createRfc4648Encode(BASE16_CHARSET, 4, false)
+	: (bytes: Uint8Array): string => {
+			return bytes.toHex();
+		};

packages/utilities/multibase/lib/bases/base32.ts

···
+import { createRfc4648Decode, createRfc4648Encode } from '../utils.js';
+
+const BASE32_CHARSET = 'abcdefghijklmnopqrstuvwxyz234567';
+
+export const fromBase32 = /*#__PURE__*/ createRfc4648Decode(BASE32_CHARSET, 5, false);
+
+export const toBase32 = /*#__PURE__*/ createRfc4648Encode(BASE32_CHARSET, 5, false);

packages/utilities/multibase/lib/bases/base58.ts

···
+import { createRfc4648Decode, createRfc4648Encode } from '../utils.js';
+
+const BASE58BTC_CHARSET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+export const fromBase58Btc = /*#__PURE__*/ createRfc4648Decode(BASE58BTC_CHARSET, 5, false);
+
+export const toBase58Btc = /*#__PURE__*/ createRfc4648Encode(BASE58BTC_CHARSET, 5, false);

packages/utilities/multibase/lib/bases/base64.ts

···
+import { createRfc4648Decode, createRfc4648Encode } from '../utils.js';
+
+const HAS_UINT8_BASE64_SUPPORT = 'fromBase64' in Uint8Array;
+
+const BASE64_CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const BASE64URL_CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+export const fromBase64 = !HAS_UINT8_BASE64_SUPPORT
+	? /*#__PURE__*/ createRfc4648Decode(BASE64_CHARSET, 6, false)
+	: (str: string): Uint8Array => {
+			if (str[str.length - 1] === '=') {
+				throw new SyntaxError(`unexpected padding in base64 string`);
+			}
+
+			return Uint8Array.fromBase64(str, { alphabet: 'base64', lastChunkHandling: 'loose' });
+		};
+
+export const toBase64 = !HAS_UINT8_BASE64_SUPPORT
+	? /*#__PURE__*/ createRfc4648Encode(BASE64_CHARSET, 6, false)
+	: (bytes: Uint8Array): string => {
+			return bytes.toBase64({ alphabet: 'base64', omitPadding: true });
+		};
+
+export const fromBase64Pad = !HAS_UINT8_BASE64_SUPPORT
+	? /*#__PURE__*/ createRfc4648Decode(BASE64_CHARSET, 6, true)
+	: (str: string): Uint8Array => {
+			return Uint8Array.fromBase64(str, { alphabet: 'base64', lastChunkHandling: 'strict' });
+		};
+
+export const toBase64Pad = !HAS_UINT8_BASE64_SUPPORT
+	? /*#__PURE__*/ createRfc4648Encode(BASE64_CHARSET, 6, true)
+	: (bytes: Uint8Array): string => {
+			return bytes.toBase64({ alphabet: 'base64', omitPadding: false });
+		};
+
+export const fromBase64Url = !HAS_UINT8_BASE64_SUPPORT
+	? /*#__PURE__*/ createRfc4648Decode(BASE64URL_CHARSET, 6, false)
+	: (str: string): Uint8Array => {
+			if (str[str.length - 1] === '=') {
+				throw new SyntaxError(`unexpected padding in base64 string`);
+			}
+
+			return Uint8Array.fromBase64(str, { alphabet: 'base64url', lastChunkHandling: 'loose' });
+		};
+
+export const toBase64Url = !HAS_UINT8_BASE64_SUPPORT
+	? /*#__PURE__*/ createRfc4648Encode(BASE64URL_CHARSET, 6, false)
+	: (bytes: Uint8Array): string => {
+			return bytes.toBase64({ alphabet: 'base64url', omitPadding: true });
+		};
+
+export const fromBase64UrlPad = !HAS_UINT8_BASE64_SUPPORT
+	? /*#__PURE__*/ createRfc4648Decode(BASE64URL_CHARSET, 6, true)
+	: (str: string): Uint8Array => {
+			return Uint8Array.fromBase64(str, { alphabet: 'base64url', lastChunkHandling: 'strict' });
+		};
+
+export const toBase64UrlPad = !HAS_UINT8_BASE64_SUPPORT
+	? /*#__PURE__*/ createRfc4648Encode(BASE64URL_CHARSET, 6, true)
+	: (bytes: Uint8Array): string => {
+			return bytes.toBase64({ alphabet: 'base64url', omitPadding: false });
+		};

packages/utilities/multibase/lib/env.ts

···
+declare global {
+	interface Uint8Array {
+		toHex(): string;
+		toBase64(options?: { alphabet?: 'base64' | 'base64url'; omitPadding?: boolean }): string;
+	}
+
+	interface Uint8ArrayConstructor {
+		fromHex(base16: string): Uint8Array;
+		fromBase64(
+			base64: string,
+			options?: {
+				alphabet?: 'base64' | 'base64url';
+				lastChunkHandling?: 'loose' | 'strict' | 'stop-before-partial';
+			},
+		): Uint8Array;
+	}
+}

packages/utilities/multibase/lib/index.ts

···
+export * from './bases/base16.js';
+export * from './bases/base32.js';
+export * from './bases/base58.js';
+export * from './bases/base64.js';

packages/utilities/multibase/lib/utils.ts

···
+export const createRfc4648Encode = (alphabet: string, bitsPerChar: number, pad: boolean) => {
+	return (bytes: Uint8Array): string => {
+		const mask = (1 << bitsPerChar) - 1;
+		let str = '';
+
+		let bits = 0; // Number of bits currently in the buffer
+		let buffer = 0; // Bits waiting to be written out, MSB first
+		for (let i = 0; i < bytes.length; ++i) {
+			// Slurp data into the buffer:
+			buffer = (buffer << 8) | bytes[i];
+			bits += 8;
+
+			// Write out as much as we can:
+			while (bits > bitsPerChar) {
+				bits -= bitsPerChar;
+				str += alphabet[mask & (buffer >> bits)];
+			}
+		}
+
+		// Partial character:
+		if (bits !== 0) {
+			str += alphabet[mask & (buffer << (bitsPerChar - bits))];
+		}
+
+		// Add padding characters until we hit a byte boundary:
+		if (pad) {
+			while (((str.length * bitsPerChar) & 7) !== 0) {
+				str += '=';
+			}
+		}
+
+		return str;
+	};
+};
+
+export const createRfc4648Decode = (alphabet: string, bitsPerChar: number, pad: boolean) => {
+	// Build the character lookup table:
+	const codes: Record<string, number> = {};
+	for (let i = 0; i < alphabet.length; ++i) {
+		codes[alphabet[i]] = i;
+	}
+
+	return (str: string) => {
+		// Count the padding bytes:
+		let end = str.length;
+		while (pad && str[end - 1] === '=') {
+			--end;
+		}
+
+		// Allocate the output:
+		const bytes = new Uint8Array(((end * bitsPerChar) / 8) | 0);
+
+		// Parse the data:
+		let bits = 0; // Number of bits currently in the buffer
+		let buffer = 0; // Bits waiting to be written out, MSB first
+		let written = 0; // Next byte to write
+		for (let i = 0; i < end; ++i) {
+			// Read one character from the string:
+			const value = codes[str[i]];
+			if (value === undefined) {
+				throw new SyntaxError(`Non-${name} character`);
+			}
+
+			// Append the bits to the buffer:
+			buffer = (buffer << bitsPerChar) | value;
+			bits += bitsPerChar;
+
+			// Write out some bits if the buffer has a byte's worth:
+			if (bits >= 8) {
+				bits -= 8;
+				bytes[written++] = 0xff & (buffer >> bits);
+			}
+		}
+
+		// Verify that we have received just enough bits:
+		if (bits >= bitsPerChar || (0xff & (buffer << (8 - bits))) !== 0) {
+			throw new SyntaxError('Unexpected end of data');
+		}
+
+		return bytes;
+	};
+};

packages/utilities/multibase/package.json

···
+{
+	"type": "module",
+	"name": "@atcute/multibase",
+	"version": "1.0.0",
+	"description": "multibase utilities",
+	"license": "MIT",
+	"repository": {
+		"url": "https://github.com/mary-ext/atcute",
+		"directory": "packages/utilities/multibase"
+	},
+	"files": [
+		"dist/",
+		"lib/",
+		"!lib/**/*.bench.ts",
+		"!lib/**/*.test.ts"
+	],
+	"exports": {
+		".": "./dist/index.js"
+	},
+	"sideEffects": false,
+	"scripts": {
+		"build": "tsc --project tsconfig.build.json",
+		"test": "bun test --coverage",
+		"prepublish": "rm -rf dist; pnpm run build"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.1.12"
+	}
+}

packages/utilities/multibase/tsconfig.build.json

···
+{
+	"extends": "./tsconfig.json",
+	"exclude": ["**/*.test.ts"]
+}

packages/utilities/multibase/tsconfig.json

···
+{
+	"compilerOptions": {
+		"types": ["bun"],
+		"outDir": "dist/",
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"target": "ESNext",
+		"allowJs": true,
+		"resolveJsonModule": true,
+		"moduleDetection": "force",
+		"isolatedModules": true,
+		"verbatimModuleSyntax": true,
+		"strict": true,
+		"noImplicitOverride": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noFallthroughCasesInSwitch": true,
+		"module": "NodeNext",
+		"sourceMap": true,
+		"declaration": true,
+	},
+	"include": ["lib"],
+}

pnpm-lock.yaml

···
         specifier: ^1.1.12
         version: 1.1.12
 
+  packages/utilities/multibase:
+    devDependencies:
+      '@types/bun':
+        specifier: ^1.1.12
+        version: 1.1.12
+
   packages/utilities/tid:
     devDependencies:
       '@types/bun':