@quentinadam/base64 0.1.3

package/README.md

@@ -0,0 +1,26 @@
+# @quentinadam/base64
+
+[![JSR][jsr-image]][jsr-url] [![NPM][npm-image]][npm-url] [![CI][ci-image]][ci-url]
+
+A simple library to encode and decode base64 strings.
+
+Optionnaly supports specifying the alphabet to use.
+
+## Usage
+
+```ts
+import * as base64 from '@quentinadam/base64';
+
+base64.encode(new Uint8Array([102, 111, 111, 98])); // returns 'Zm9vYg=='
+
+base64.decode('Zm9vYg=='); // returns Uint8Array([102, 111, 111, 98])
+
+base64.encode(new Uint8Array([102, 111, 111, 98]), { padding: false }); // returns 'Zm9vYg'
+```
+
+[ci-image]: https://img.shields.io/github/actions/workflow/status/quentinadam/deno-base64/ci.yml?branch=main&logo=github&style=flat-square
+[ci-url]: https://github.com/quentinadam/deno-base64/actions/workflows/ci.yml
+[npm-image]: https://img.shields.io/npm/v/@quentinadam/base64.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/@quentinadam/base64
+[jsr-image]: https://jsr.io/badges/@quentinadam/base64?style=flat-square
+[jsr-url]: https://jsr.io/@quentinadam/base64

package/dist/base64.d.ts

@@ -0,0 +1,42 @@
+/** Options for {@linkcode encode}. */
+export interface EncodeOptions {
+    /**
+     * The alphabet to use.
+     * The alphabet must be a string of 64 unique characters (or 65 unique characters to specify the padding character to use).
+     *
+     * @default {'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='}
+     */
+    alphabet?: string;
+    /**
+     * Whether the encoded string should be padded.
+     *
+     * @default {true}
+     */
+    padding?: boolean;
+}
+/** Options for {@linkcode decode}. */
+export interface DecodeOptions {
+    /**
+     * The alphabet to use.
+     * The alphabet must be a string of 64 unique characters (or 65 unique characters to specify the padding character to use).
+     *
+     * @default {'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='}
+     */
+    alphabet?: string;
+}
+/**
+ * Encodes a Uint8Array buffer into a base64 string.
+ *
+ * @param buffer The buffer to encode.
+ * @param options The options to use for encoding.
+ * @returns The base64 encoded string.
+ */
+export declare function encode(buffer: Uint8Array, options?: EncodeOptions): string;
+/**
+ * Decodes a base64 encoded string into a Uint8Array buffer.
+ *
+ * @param string The base64 encoded string.
+ * @param options The options to use for decoding.
+ * @returns The decoded buffer.
+ */
+export declare function decode(string: string, options?: DecodeOptions): Uint8Array;

package/dist/base64.js

@@ -0,0 +1,65 @@
+import require from '@quentinadam/require';
+import assert from '@quentinadam/assert';
+function convert({ input, inputBase, outputBase, convertRemainingBits }) {
+    const output = new Array();
+    let accumulator = 0;
+    let bits = 0;
+    for (const digit of input) {
+        if (digit < (1 << inputBase)) {
+            accumulator = accumulator << inputBase | digit;
+            bits += inputBase;
+            while (bits >= outputBase) {
+                output.push(accumulator >> (bits - outputBase));
+                bits -= outputBase;
+                accumulator &= (1 << bits) - 1;
+            }
+        }
+    }
+    if (convertRemainingBits) {
+        if (bits > 0) {
+            output.push(accumulator << (outputBase - bits));
+        }
+    }
+    else {
+        assert(accumulator === 0, 'Remaining bits must be zero');
+    }
+    return output;
+}
+function getAlphabet(alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/') {
+    assert(alphabet.length === 64 || alphabet.length === 65, 'Alphabet must be 64 or 65 characters long');
+    if (alphabet.length === 64) {
+        alphabet += '=';
+    }
+    assert(new Set(alphabet).size === 65, 'Alphabet must not contain duplicate characters');
+    return alphabet;
+}
+/**
+ * Encodes a Uint8Array buffer into a base64 string.
+ *
+ * @param buffer The buffer to encode.
+ * @param options The options to use for encoding.
+ * @returns The base64 encoded string.
+ */
+export function encode(buffer, options) {
+    const alphabet = getAlphabet(options?.alphabet);
+    const output = convert({ input: buffer, inputBase: 8, outputBase: 6, convertRemainingBits: true });
+    if (options?.padding ?? true) {
+        while (output.length % 4 !== 0) {
+            output.push(64);
+        }
+    }
+    return output.map((digit) => require(alphabet[digit])).join('');
+}
+/**
+ * Decodes a base64 encoded string into a Uint8Array buffer.
+ *
+ * @param string The base64 encoded string.
+ * @param options The options to use for decoding.
+ * @returns The decoded buffer.
+ */
+export function decode(string, options) {
+    const alphabet = getAlphabet(options?.alphabet);
+    const map = new Map(Array.from(alphabet).map((character, index) => [character, index]));
+    const input = Array.from(string, (character) => require(map.get(character), `Invalid character ${character}`));
+    return new Uint8Array(convert({ input, inputBase: 6, outputBase: 8, convertRemainingBits: false }));
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@quentinadam/base64",
+  "version": "0.1.3",
+  "description": "A simple library to encode and decode base64 strings",
+  "license": "MIT",
+  "author": "Quentin Adam",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/quentinadam/deno-base64.git"
+  },
+  "type": "module",
+  "exports": "./dist/base64.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@quentinadam/assert": "^0.1.10",
+    "@quentinadam/require": "^0.1.4"
+  }
+}