bufferbase 1.0.3 → 1.0.5

package/dist/bufferbase.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="node" />
+/**
+ * A collection of common bases.
+ */
+export declare const Chars: {
+    Decimal: string;
+    Base16: string;
+    Base32: string;
+    Base32Crockford: string;
+    Base36: string;
+    Base58: string;
+    Base64_STD: string;
+    Base64_URL_SAFE: string;
+    Base64_XML_NMTOKEN: string;
+    Base64_XML_NAME: string;
+    Ascii85: string;
+    Base85: string;
+    Z85: string;
+};
+export declare class InvalidCharacterError extends Error {
+    message: string;
+}
+/**
+ * Encodes and decodes buffers to and from a base.
+ */
+export declare class BufferEncoder {
+    private baseChars;
+    constructor(baseChars: string);
+    /**
+     * Encodes a buffer to a string.
+     */
+    encode(buffer: Buffer): string;
+    /**
+     * Decodes a string to a buffer.
+     */
+    decode(encoded: string): Buffer;
+}
+/**
+ * Creates a converter function that can convert between two bases.
+ */
+export declare class Converter {
+    decoder: BufferEncoder;
+    encoder: BufferEncoder;
+    constructor(inputBase: string, outputBase: string);
+    /**
+     * Converts a string from the input base to the output base.
+     */
+    convert(input: string): string;
+}
+export declare class Validator {
+    decorder: BufferEncoder;
+    constructor(inputBase: string);
+    validate(input: string): boolean;
+}
+export declare const validate: (input: string, base: string) => boolean;

package/dist/bufferbase.js

@@ -0,0 +1,123 @@
+/**
+ * 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 {
+    baseChars;
+    constructor(baseChars) {
+        this.baseChars = baseChars;
+    }
+    /**
+     * Encodes a buffer to a string.
+     */
+    encode(buffer) {
+        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) {
+        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;
+    encoder;
+    constructor(inputBase, outputBase) {
+        this.decoder = new BufferEncoder(inputBase);
+        this.encoder = new BufferEncoder(outputBase);
+    }
+    /**
+     * Converts a string from the input base to the output base.
+     */
+    convert(input) {
+        return this.encoder.encode(this.decoder.decode(input));
+    }
+}
+export class Validator {
+    decorder;
+    constructor(inputBase) {
+        this.decorder = new BufferEncoder(inputBase);
+    }
+    validate(input) {
+        try {
+            this.decorder.decode(input);
+            return true;
+        }
+        catch (e) {
+            if (e instanceof InvalidCharacterError) {
+                return false;
+            }
+            throw e;
+        }
+    }
+}
+export const validate = (input, base) => {
+    return new Validator(base).validate(input);
+};

package/dist/bufferbase.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bufferbase.test.js

@@ -0,0 +1,42 @@
+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/dist/index.d.ts

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

package/dist/index.js

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

package/dist/sample.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sample.js

@@ -0,0 +1,36 @@
+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 isValidAsBase64 = 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,
+    isValidAsBase64,
+    decoded: decoded.toString("utf8"),
+});
+// ┌─────────────────┬─────────────────────────┐
+// │ (index)         │ Values                  │
+// ├─────────────────┼─────────────────────────┤
+// │ bytes           │ 'Hello, World!'         │
+// │ base32encoded   │ '4GSBCDHQJR82QDXS6RS11' │
+// │ base58encoded   │ '72k1xXWG59fYdzSNoA'    │
+// │ base64encoded   │ 'BIZWxsbywgV29ybGQh'    │
+// │ isValidAsBase64 │ true                    │
+// │ decoded         │ 'Hello, World!'         │
+// └─────────────────┴─────────────────────────┘

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bufferbase",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Buffer-to-BaseN Encoder, Decoder, Converter, and Validator",
   "type": "module",
   "sideEffects": false,
@@ -12,13 +12,17 @@
   },
   "devDependencies": {
     "@types/node": "^20.11.5",
+    "ts-loader": "^9.5.1",
     "tsx": "^4.7.0",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "webpack": "^5.89.0",
+    "webpack-cli": "^5.1.4"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/misebox/bufferbase.git"
   },
+  "files": ["dist", "src"],
   "keywords": [
     "number",
     "encode",

package/tsconfig.json

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