bufferbase 1.0.0

package/README.md

@@ -0,0 +1,32 @@
+# bufferbase
+
+Buffer-to-BaseN Encoding and Decoding for Node.js.
+
+bufferbase is a Node.js library that provides straightforward encoding and decoding of buffer objects into various BaseN formats. It's designed to be simple, efficient, and flexible for different application needs.
+
+## Features
+
+- Supports multiple base encoding formats.
+- Optimized for Node.js buffer handling.
+- Intuitive API for easy integration.
+- Suitable for various data types.
+- Consistent and reliable performance.
+
+## Installation
+
+Install bufferbase using npm:
+
+```bash
+npm install bufferbase
+```
+
+## Usage
+
+See [src/sample.ts](/src/sample.ts)
+
+## Contributing
+
+Contributions to bufferbase are welcome! Please read our contributing guidelines for more information.
+License
+
+bufferbase is ISC licensed.

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "bufferbase",
+  "version": "1.0.0",
+  "description": "Buffer-to-BaseN Encoder, Decoder, Converter, and Validator",
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./esm/index.d.ts",
+  "sideEffects": false,
+  "exports": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "node --loader tsx --test src/*.test.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.5",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/misebox/bufferbase.git"
+  },
+  "author": "misebox",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/misebox/bufferbase/issues"
+  },
+  "homepage": "https://github.com/misebox/bufferbase#readme"
+}

package/src/bufferbase.test.ts

@@ -0,0 +1,58 @@
+import { Chars, BufferEncoder } from "./bufferbase.js";
+import { Buffer } from "node:buffer";
+import test from "node:test"; // ①
+import assert from "node:assert";
+
+test("anybase", async (t) => {
+  await t.test(
+    "encodes and decodes a string correctly with base58chars",
+    () => {
+      const encoder = new BufferEncoder(Chars.Base58);
+      const buffer = Buffer.from("Hello, World!", "utf8");
+
+      const encoded = encoder.encode(buffer);
+      const decoded = encoder.decode(encoded);
+
+      assert.strictEqual(decoded.toString("utf8"), "Hello, World!");
+    }
+  );
+
+  await t.test("handles empty buffer correctly", () => {
+    const encoder = new BufferEncoder(Chars.Base58);
+    const buffer = Buffer.alloc(0);
+
+    const encoded = encoder.encode(buffer);
+    const decoded = encoder.decode(encoded);
+
+    assert.strictEqual(decoded.toString("utf8"), "");
+  });
+
+  await t.test("handles long buffer correctly", () => {
+    const encoder = new BufferEncoder(Chars.Base58);
+    const buffer = Buffer.from("Hello, World!".repeat(100), "utf8");
+
+    const encoded = encoder.encode(buffer);
+    const decoded = encoder.decode(encoded);
+
+    assert.strictEqual(decoded.toString("utf8"), "Hello, World!".repeat(100));
+  });
+
+  await t.test("encode and decode various chars correctly", () => {
+    for (const charTable of Object.values(Chars)) {
+      const encoder = new BufferEncoder(charTable);
+      const buffer = Buffer.from("Hello, World!", "utf8");
+
+      const encoded = encoder.encode(buffer);
+      const decoded = encoder.decode(encoded);
+
+      assert.strictEqual(decoded.toString("utf8"), "Hello, World!");
+    }
+  });
+
+  await t.test("throws error on invalid characters in decode", () => {
+    assert.throws(() => {
+      const encoder = new BufferEncoder(Chars.Base58);
+      encoder.decode("InvalidString!");
+    }, new Error("Invalid character found"));
+  });
+});

package/src/bufferbase.ts

@@ -0,0 +1,133 @@
+/**
+ * A collection of common bases.
+ */
+export const Chars = {
+  Decimal: "0123456789",
+  Base16: "0123456789ABCDEF",
+  Base32: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  Base32Crockford: "0123456789ABCDEFGHJKMNPQRSTVWXYZ",
+  Base36: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  Base58: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
+  Base64_STD:
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+  Base64_URL_SAFE:
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
+  Base64_XML_NMTOKEN:
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._",
+  Base64_XML_NAME:
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_:",
+  Ascii85:
+    "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstu",
+  Base85:
+    "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#$%&()*+-;<=>?@^_`{|}~",
+  Z85: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#",
+};
+
+export class InvalidCharacterError extends Error {
+  message = "Invalid character found";
+}
+/**
+ * Encodes and decodes buffers to and from a base.
+ */
+export class BufferEncoder {
+  constructor(private baseChars: string) {}
+
+  /**
+   * Encodes a buffer to a string.
+   */
+  encode(buffer: Buffer): string {
+    let result = [];
+    for (const byte of buffer) {
+      let carry = byte;
+      for (let j = 0; j < result.length; j++) {
+        carry += result[j] * 256;
+        result[j] = carry % this.baseChars.length;
+        carry = Math.floor(carry / this.baseChars.length);
+      }
+      while (carry > 0) {
+        result.push(carry % this.baseChars.length);
+        carry = Math.floor(carry / this.baseChars.length);
+      }
+    }
+    for (const byte of buffer) {
+      if (byte === 0) {
+        result.push(0);
+      } else {
+        break;
+      }
+    }
+    return result
+      .reverse()
+      .map((index) => this.baseChars[index])
+      .join("");
+  }
+
+  /**
+   * Decodes a string to a buffer.
+   */
+  decode(encoded: string): Buffer {
+    let result = Buffer.alloc(0);
+    for (const char of encoded) {
+      const value = this.baseChars.indexOf(char);
+      if (value === -1) throw new InvalidCharacterError();
+      let carry = value;
+      let tempResult = Buffer.alloc(result.length);
+      let i;
+      for (i = 0; i < result.length; i++) {
+        carry += result[i] * this.baseChars.length;
+        tempResult[i] = carry % 256;
+        carry = Math.floor(carry / 256);
+      }
+      while (carry > 0) {
+        tempResult = Buffer.concat([tempResult, Buffer.from([carry % 256])]);
+        carry = Math.floor(carry / 256);
+      }
+      result = tempResult;
+    }
+    return result.reverse();
+  }
+}
+
+/**
+ * Creates a converter function that can convert between two bases.
+ */
+export class Converter {
+  decoder: BufferEncoder;
+  encoder: BufferEncoder;
+
+  constructor(inputBase: string, outputBase: string) {
+    this.decoder = new BufferEncoder(inputBase);
+    this.encoder = new BufferEncoder(outputBase);
+  }
+
+  /**
+   * Converts a string from the input base to the output base.
+   */
+  convert(input: string): string {
+    return this.encoder.encode(this.decoder.decode(input));
+  }
+}
+
+export class Validator {
+  decorder: BufferEncoder;
+
+  constructor(inputBase: string) {
+    this.decorder = new BufferEncoder(inputBase);
+  }
+
+  validate(input: string): boolean {
+    try {
+      this.decorder.decode(input);
+      return true;
+    } catch (e) {
+      if (e instanceof InvalidCharacterError) {
+        return false;
+      }
+      throw e;
+    }
+  }
+}
+
+export const validate = (input: string, base: string): boolean => {
+  return new Validator(base).validate(input);
+};

package/src/index.ts

@@ -0,0 +1,7 @@
+export {
+  BufferEncoder,
+  Converter,
+  InvalidCharacterError,
+  Validator,
+  validate,
+} from "./bufferbase";

package/src/sample.ts

@@ -0,0 +1,43 @@
+import { Chars, BufferEncoder, Converter, Validator } from "./bufferbase";
+
+// Example buffer
+const bytes = Buffer.from("Hello, World!", "utf8");
+
+// Encoding buffer to Base32
+const encoder = new BufferEncoder(Chars.Base32Crockford);
+const base32encoded = encoder.encode(bytes);
+
+// Converting Base32 to Base58
+const converter_32to58 = new Converter(Chars.Base32Crockford, Chars.Base58);
+const base58encoded = converter_32to58.convert(base32encoded);
+
+// Converting Base32 to Base58
+const converter_58to64 = new Converter(Chars.Base58, Chars.Base64_URL_SAFE);
+const base64encoded = converter_58to64.convert(base58encoded);
+
+// Validating Base64
+const validatorB64 = new Validator(Chars.Base64_URL_SAFE);
+const isBase64 = validatorB64.validate(base64encoded);
+
+// Decoding Base64
+const decoder = new BufferEncoder(Chars.Base64_URL_SAFE);
+const decoded = decoder.decode(base64encoded);
+
+console.table({
+  bytes: bytes.toString("utf8"),
+  base32encoded,
+  base58encoded,
+  base64encoded,
+  isBase64,
+  decoded: decoded.toString("utf8"),
+});
+// ┌───────────────┬─────────────────────────┐
+// │    (index)    │         Values          │
+// ├───────────────┼─────────────────────────┤
+// │     bytes     │     'Hello, World!'     │
+// │ base32encoded │ '4GSBCDHQJR82QDXS6RS11' │
+// │ base58encoded │  '72k1xXWG59fYdzSNoA'   │
+// │ base64encoded │  'BIZWxsbywgV29ybGQh'   │
+// │    decoded    │     'Hello, World!'     │
+// │   isBase64    │          true           │
+// └───────────────┴─────────────────────────┘

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "target": "esnext",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "lib": ["esnext"],
+        "esModuleInterop": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "allowJs": false,
+        "types": [
+            "node",
+        ],
+        "declaration": true,
+        "pretty": true,
+        "newLine": "lf",
+        "outDir": "./dist",
+    },
+}