@wtasnorg/node-lib 0.0.10 → 0.0.12

package/docs/type-aliases/Base58CharsetType.md

@@ -0,0 +1,13 @@
+[**@wtasnorg/node-lib**](../README.md)
+
+***
+
+[@wtasnorg/node-lib](../README.md) / Base58CharsetType
+
+# Type Alias: Base58CharsetType
+
+> **Base58CharsetType** = *typeof* [`Base58Charset`](../variables/Base58Charset.md)\[`number`\]
+
+Defined in: [base58.ts:18](https://github.com/wtasg/node-lib/blob/e8728afafd1c71a23332e0e226c750c68ec8ae80/src/base58.ts#L18)
+
+Base58 charset type.

package/docs/type-aliases/Base64CharsetType.md

@@ -8,6 +8,6 @@
 
 > **Base64CharsetType** = *typeof* [`Base64Charset`](../variables/Base64Charset.md)\[`number`\]
 
-Defined in: [base64.ts:18](https://github.com/wtasg/node-lib/blob/7baf8669b7042dca550ec8a4beb26526d3b538b4/src/base64.ts#L18)
+Defined in: [base64.ts:18](https://github.com/wtasg/node-lib/blob/e8728afafd1c71a23332e0e226c750c68ec8ae80/src/base64.ts#L18)
 
 Base64 charset type.

package/docs/type-aliases/Base85CharsetType.md

@@ -0,0 +1,13 @@
+[**@wtasnorg/node-lib**](../README.md)
+
+***
+
+[@wtasnorg/node-lib](../README.md) / Base85CharsetType
+
+# Type Alias: Base85CharsetType
+
+> **Base85CharsetType** = *typeof* [`Base85Charset`](../variables/Base85Charset.md)\[`number`\]
+
+Defined in: [base85.ts:18](https://github.com/wtasg/node-lib/blob/e8728afafd1c71a23332e0e226c750c68ec8ae80/src/base85.ts#L18)
+
+Base85 charset type.

package/docs/variables/Base32Charset.md

@@ -0,0 +1,16 @@
+[**@wtasnorg/node-lib**](../README.md)
+
+***
+
+[@wtasnorg/node-lib](../README.md) / Base32Charset
+
+# Variable: Base32Charset
+
+> `const` **Base32Charset**: readonly \[`"rfc4648"`, `"hex"`, `"crockford"`\]
+
+Defined in: [base32.ts:13](https://github.com/wtasg/node-lib/blob/e8728afafd1c71a23332e0e226c750c68ec8ae80/src/base32.ts#L13)
+
+Available Base32 charset variants.
+- `rfc4648`: Standard RFC 4648 alphabet (A-Z, 2-7)
+- `hex`: Extended hex alphabet (0-9, A-V)
+- `crockford`: Douglas Crockford's alphabet (excludes I, L, O, U)

package/docs/variables/Base58Charset.md

@@ -0,0 +1,16 @@
+[**@wtasnorg/node-lib**](../README.md)
+
+***
+
+[@wtasnorg/node-lib](../README.md) / Base58Charset
+
+# Variable: Base58Charset
+
+> `const` **Base58Charset**: readonly \[`"bitcoin"`, `"flickr"`, `"ripple"`\]
+
+Defined in: [base58.ts:13](https://github.com/wtasg/node-lib/blob/e8728afafd1c71a23332e0e226c750c68ec8ae80/src/base58.ts#L13)
+
+Available Base58 charset variants.
+- `bitcoin`: Bitcoin/IPFS alphabet (default)
+- `flickr`: Flickr short URLs (swaps case)
+- `ripple`: Ripple addresses

package/docs/variables/Base64Charset.md

@@ -8,7 +8,7 @@
 
 > `const` **Base64Charset**: readonly \[`"standard"`, `"urlsafe"`, `"imap"`, `"radix64"`\]
 
-Defined in: [base64.ts:13](https://github.com/wtasg/node-lib/blob/7baf8669b7042dca550ec8a4beb26526d3b538b4/src/base64.ts#L13)
+Defined in: [base64.ts:13](https://github.com/wtasg/node-lib/blob/e8728afafd1c71a23332e0e226c750c68ec8ae80/src/base64.ts#L13)
 
 Available Base64 charset variants.
 - `standard`: RFC 4648 standard alphabet (A-Z, a-z, 0-9, +, /)

package/docs/variables/Base85Charset.md

@@ -0,0 +1,16 @@
+[**@wtasnorg/node-lib**](../README.md)
+
+***
+
+[@wtasnorg/node-lib](../README.md) / Base85Charset
+
+# Variable: Base85Charset
+
+> `const` **Base85Charset**: readonly \[`"ascii85"`, `"z85"`, `"rfc1924"`\]
+
+Defined in: [base85.ts:13](https://github.com/wtasg/node-lib/blob/e8728afafd1c71a23332e0e226c750c68ec8ae80/src/base85.ts#L13)
+
+Available Base85 charset variants.
+- `ascii85`: Adobe Ascii85 (btoa format)
+- `z85`: ZeroMQ Base85 (no quotes or backslash)
+- `rfc1924`: RFC 1924 IPv6 encoding

package/package.json

@@ -1,8 +1,52 @@
 {
   "name": "@wtasnorg/node-lib",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "node library",
   "main": "src/index.js",
+  "module": "src/index.js",
+  "types": "src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./base64": {
+      "types": "./src/base64.d.ts",
+      "import": "./src/base64.js"
+    },
+    "./base58": {
+      "types": "./src/base58.d.ts",
+      "import": "./src/base58.js"
+    },
+    "./base85": {
+      "types": "./src/base85.d.ts",
+      "import": "./src/base85.js"
+    },
+    "./base32": {
+      "types": "./src/base32.d.ts",
+      "import": "./src/base32.js"
+    },
+    "./find": {
+      "types": "./src/find.d.ts",
+      "import": "./src/find.js"
+    },
+    "./user-agent": {
+      "types": "./src/user-agent.d.ts",
+      "import": "./src/user-agent.js"
+    },
+    "./pojo": {
+      "types": "./src/pojo.d.ts",
+      "import": "./src/pojo.js"
+    },
+    "./hello": {
+      "types": "./src/hello.d.ts",
+      "import": "./src/hello.js"
+    },
+    "./bits": {
+      "types": "./src/bits.d.ts",
+      "import": "./src/bits.js"
+    }
+  },
   "scripts": {
     "build": "./node_modules/.bin/tsc --project tsconfig.json",
     "docs": "./node_modules/.bin/typedoc",
@@ -29,15 +73,15 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
-    "@stylistic/eslint-plugin": "^5.6.1",
-    "@types/node": "^24.10.1",
-    "eslint": "^9.39.1",
+    "@stylistic/eslint-plugin": "^5.9.0",
+    "@types/node": "^24.10.13",
+    "eslint": "^9.39.3",
     "eslint-config-prettier": "^10.1.8",
     "globals": "^16.5.0",
-    "typedoc": "^0.28.15",
-    "typedoc-plugin-markdown": "^4.9.0",
+    "typedoc": "^0.28.17",
+    "typedoc-plugin-markdown": "^4.10.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.48.1"
+    "typescript-eslint": "^8.56.1"
   },
   "sideEffects": false
-}
+}

package/readme.txt

@@ -12,6 +12,10 @@ A library project for nodejs. #nodejs #typescript #library
 3. `createFindDirectories` as a factory for finding directories; think `find path -type d`.
 4. `parseUserAgent` for extracting information from user-agent strings.
 5. `encode` / `decode` for Base64 encoding/decoding with charset variants (`standard`, `urlsafe`, `imap`, `radix64`).
+6. `encode58` / `decode58` for Base58 encoding/decoding with charset variants (`bitcoin`, `flickr`, `ripple`).
+7. `encode85` / `decode85` for Base85 encoding/decoding with charset variants (`ascii85`, `z85`, `rfc1924`).
+8. `encode32` / `decode32` for Base32 encoding/decoding with charset variants (`rfc4648`, `hex`, `crockford`).
+9. `popcount32`, `popcount64`, `countOnes`, `countZeroesWithWidth`, `countZeroes` for integer bit counting helpers.
 
 ## Develop
 
@@ -30,14 +34,36 @@ We are using `node --test` for testing.
 npm install @wtasnorg/node-lib
 ```
 
+**Recommended:** Use subpath imports for maximum efficiency (enables tree shaking):
+
 ```typescript
-# check if you can run code
-import {hello} from "@wtasnorg/node-lib";
+import { encode, decode } from "@wtasnorg/node-lib/base64";
+import { encode58 } from "@wtasnorg/node-lib/base58";
+import { encode32 } from "@wtasnorg/node-lib/base32";
+import { parseUserAgent } from "@wtasnorg/node-lib/user-agent";
+import { popcount32, countZeroes } from "@wtasnorg/node-lib/bits";
+```
+
+Alternatively, import from the main entry point (includes all modules):
 
-await hello();
-// "hello from @wtasnorg/node-lib"
+```typescript
+import { hello, encode, encode58 } from "@wtasnorg/node-lib";
 ```
 
+## Available Subpath Imports
+
+| Module | Import Path |
+|--------|-------------|
+| Base64 | `@wtasnorg/node-lib/base64` |
+| Base58 | `@wtasnorg/node-lib/base58` |
+| Base85 | `@wtasnorg/node-lib/base85` |
+| Base32 | `@wtasnorg/node-lib/base32` |
+| User-Agent | `@wtasnorg/node-lib/user-agent` |
+| Find | `@wtasnorg/node-lib/find` |
+| POJO | `@wtasnorg/node-lib/pojo` |
+| Hello | `@wtasnorg/node-lib/hello` |
+| Bits | `@wtasnorg/node-lib/bits` |
+
 ## License: MIT
 
 [MIT License file](LICENSE)

package/src/base32.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Base32 encoding/decoding with multiple charset variants.
+ * Base32 is case-insensitive and useful for human-readable encoding (TOTP codes).
+ * @module base32
+ */
+/**
+ * Available Base32 charset variants.
+ * - `rfc4648`: Standard RFC 4648 alphabet (A-Z, 2-7)
+ * - `hex`: Extended hex alphabet (0-9, A-V)
+ * - `crockford`: Douglas Crockford's alphabet (excludes I, L, O, U)
+ */
+declare const Base32Charset: readonly ["rfc4648", "hex", "crockford"];
+/**
+ * Base32 charset type.
+ */
+type Base32CharsetType = (typeof Base32Charset)[number];
+/**
+ * Encode a string to Base32.
+ *
+ * @example
+ * ```typescript
+ * import { encode32 } from "./base32.js";
+ *
+ * encode32("Hello");
+ * // => "JBSWY3DP"
+ *
+ * encode32("test", "hex");
+ * // => "EHMP6SS="
+ * ```
+ *
+ * @param input - The string to encode.
+ * @param charset - The charset variant to use (default: "rfc4648").
+ * @returns The Base32 encoded string.
+ */
+declare function encode32(input: string, charset?: Base32CharsetType): string;
+/**
+ * Decode a Base32 string.
+ *
+ * @example
+ * ```typescript
+ * import { decode32 } from "./base32.js";
+ *
+ * decode32("JBSWY3DP");
+ * // => "Hello"
+ *
+ * decode32("EHMP6SS=", "hex");
+ * // => "test"
+ * ```
+ *
+ * @param input - The Base32 encoded string.
+ * @param charset - The charset variant to use (default: "rfc4648").
+ * @returns The decoded string.
+ * @throws Error if the input contains invalid characters.
+ */
+declare function decode32(input: string, charset?: Base32CharsetType): string;
+export { encode32, decode32, Base32Charset };
+export type { Base32CharsetType };
+//# sourceMappingURL=base32.d.ts.map

package/src/base32.js

@@ -0,0 +1,143 @@
+/**
+ * Base32 encoding/decoding with multiple charset variants.
+ * Base32 is case-insensitive and useful for human-readable encoding (TOTP codes).
+ * @module base32
+ */
+/**
+ * Available Base32 charset variants.
+ * - `rfc4648`: Standard RFC 4648 alphabet (A-Z, 2-7)
+ * - `hex`: Extended hex alphabet (0-9, A-V)
+ * - `crockford`: Douglas Crockford's alphabet (excludes I, L, O, U)
+ */
+const Base32Charset = ["rfc4648", "hex", "crockford"];
+/**
+ * Charset alphabets for Base32 variants.
+ */
+const CHARSETS = {
+    rfc4648: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+    hex: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+    crockford: "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+};
+/**
+ * Padding character for Base32 encoding.
+ */
+const PAD = "=";
+/**
+ * Build a reverse lookup table for decoding.
+ * @param alphabet - The 32-character alphabet string.
+ * @param caseInsensitive - Whether to add lowercase mappings.
+ * @returns Map of character to index.
+ */
+function buildDecodeTable(alphabet, caseInsensitive = true) {
+    const table = new Map();
+    for (let i = 0; i < alphabet.length; i++) {
+        const char = alphabet[i];
+        if (char !== undefined) {
+            table.set(char, i);
+            if (caseInsensitive) {
+                table.set(char.toLowerCase(), i);
+            }
+        }
+    }
+    return table;
+}
+/**
+ * Pre-built decode tables for each charset.
+ */
+const DECODE_TABLES = {
+    rfc4648: buildDecodeTable(CHARSETS.rfc4648),
+    hex: buildDecodeTable(CHARSETS.hex),
+    crockford: buildDecodeTable(CHARSETS.crockford)
+};
+/**
+ * Encode a string to Base32.
+ *
+ * @example
+ * ```typescript
+ * import { encode32 } from "./base32.js";
+ *
+ * encode32("Hello");
+ * // => "JBSWY3DP"
+ *
+ * encode32("test", "hex");
+ * // => "EHMP6SS="
+ * ```
+ *
+ * @param input - The string to encode.
+ * @param charset - The charset variant to use (default: "rfc4648").
+ * @returns The Base32 encoded string.
+ */
+function encode32(input, charset = "rfc4648") {
+    if (input === "") {
+        return "";
+    }
+    const alphabet = CHARSETS[charset];
+    const bytes = new TextEncoder().encode(input);
+    let result = "";
+    let buffer = 0;
+    let bitsInBuffer = 0;
+    for (const byte of bytes) {
+        buffer = (buffer << 8) | byte;
+        bitsInBuffer += 8;
+        while (bitsInBuffer >= 5) {
+            bitsInBuffer -= 5;
+            const index = (buffer >> bitsInBuffer) & 0x1f;
+            result += alphabet[index];
+        }
+    }
+    // Handle remaining bits
+    if (bitsInBuffer > 0) {
+        const index = (buffer << (5 - bitsInBuffer)) & 0x1f;
+        result += alphabet[index];
+    }
+    // Add padding to make length a multiple of 8
+    while (result.length % 8 !== 0) {
+        result += PAD;
+    }
+    return result;
+}
+/**
+ * Decode a Base32 string.
+ *
+ * @example
+ * ```typescript
+ * import { decode32 } from "./base32.js";
+ *
+ * decode32("JBSWY3DP");
+ * // => "Hello"
+ *
+ * decode32("EHMP6SS=", "hex");
+ * // => "test"
+ * ```
+ *
+ * @param input - The Base32 encoded string.
+ * @param charset - The charset variant to use (default: "rfc4648").
+ * @returns The decoded string.
+ * @throws Error if the input contains invalid characters.
+ */
+function decode32(input, charset = "rfc4648") {
+    if (input === "") {
+        return "";
+    }
+    const decodeTable = DECODE_TABLES[charset];
+    // Remove padding
+    const cleanInput = input.replace(/=+$/, "");
+    const bytes = [];
+    let buffer = 0;
+    let bitsInBuffer = 0;
+    for (const char of cleanInput) {
+        const value = decodeTable.get(char);
+        if (value === undefined) {
+            throw new Error(`Invalid Base32 character: ${char}`);
+        }
+        buffer = (buffer << 5) | value;
+        bitsInBuffer += 5;
+        if (bitsInBuffer >= 8) {
+            bitsInBuffer -= 8;
+            bytes.push((buffer >> bitsInBuffer) & 0xff);
+        }
+    }
+    return new TextDecoder().decode(new Uint8Array(bytes));
+}
+export { encode32, decode32, Base32Charset };
+//# sourceMappingURL=base32.js.map

package/src/base32.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=base32.test.d.ts.map

package/src/base32.test.js

@@ -0,0 +1,121 @@
+import { describe, it } from "node:test";
+import { strictEqual, throws } from "node:assert";
+import { encode32, decode32, Base32Charset } from "./base32.js";
+describe("Base32 encode32", () => {
+    it("encodes empty string", () => {
+        strictEqual(encode32(""), "");
+    });
+    it("encodes 'Hello' with rfc4648 charset", () => {
+        strictEqual(encode32("Hello"), "JBSWY3DP");
+    });
+    it("encodes single character", () => {
+        strictEqual(encode32("A"), "IE======");
+    });
+    it("encodes two characters", () => {
+        strictEqual(encode32("AB"), "IFBA====");
+    });
+    it("encodes 'test'", () => {
+        strictEqual(encode32("test"), "ORSXG5A=");
+    });
+    it("encodes with hex charset", () => {
+        const rfc4648 = encode32("test", "rfc4648");
+        const hex = encode32("test", "hex");
+        strictEqual(rfc4648 !== hex, true);
+    });
+    it("encodes with crockford charset", () => {
+        const rfc4648 = encode32("test", "rfc4648");
+        const crockford = encode32("test", "crockford");
+        strictEqual(rfc4648 !== crockford, true);
+    });
+    it("encodes UTF-8 characters", () => {
+        const input = "こんにちは";
+        const encoded = encode32(input);
+        const decoded = decode32(encoded);
+        strictEqual(decoded, input);
+    });
+});
+describe("Base32 decode32", () => {
+    it("decodes empty string", () => {
+        strictEqual(decode32(""), "");
+    });
+    it("decodes 'JBSWY3DP' to 'Hello'", () => {
+        strictEqual(decode32("JBSWY3DP"), "Hello");
+    });
+    it("decodes single character with padding", () => {
+        strictEqual(decode32("IE======"), "A");
+    });
+    it("decodes 'ORSXG5A=' to 'test'", () => {
+        strictEqual(decode32("ORSXG5A="), "test");
+    });
+    it("decodes without padding", () => {
+        strictEqual(decode32("JBSWY3DP"), "Hello");
+    });
+    it("decodes lowercase (case-insensitive)", () => {
+        strictEqual(decode32("jbswy3dp"), "Hello");
+    });
+    it("decodes mixed case", () => {
+        strictEqual(decode32("JbSwY3Dp"), "Hello");
+    });
+    it("throws on invalid character", () => {
+        throws(() => decode32("!!!"), /Invalid Base32 character/);
+    });
+});
+describe("Base32 round-trip", () => {
+    const testCases = [
+        "",
+        "a",
+        "ab",
+        "abc",
+        "abcd",
+        "abcde",
+        "Hello, World!",
+        "The quick brown fox jumps over the lazy dog",
+        "こんにちは世界",
+        "🎉🚀✨",
+        "1234567890"
+    ];
+    for (const charset of Base32Charset) {
+        describe(`charset: ${charset}`, () => {
+            for (const input of testCases) {
+                it(`round-trips: ${JSON.stringify(input)}`, () => {
+                    const encoded = encode32(input, charset);
+                    const decoded = decode32(encoded, charset);
+                    strictEqual(decoded, input);
+                });
+            }
+        });
+    }
+});
+describe("Base32Charset", () => {
+    it("exports array with three charsets", () => {
+        strictEqual(Base32Charset.length, 3);
+        strictEqual(Base32Charset[0], "rfc4648");
+        strictEqual(Base32Charset[1], "hex");
+        strictEqual(Base32Charset[2], "crockford");
+    });
+    it("charset type works correctly", () => {
+        const cs = "hex";
+        strictEqual(encode32("test", cs), encode32("test", "hex"));
+    });
+});
+describe("Base32 RFC 4648 test vectors", () => {
+    // Test vectors from RFC 4648
+    const vectors = [
+        ["", ""],
+        ["f", "MY======"],
+        ["fo", "MZXQ===="],
+        ["foo", "MZXW6==="],
+        ["foob", "MZXW6YQ="],
+        ["fooba", "MZXW6YTB"],
+        ["foobar", "MZXW6YTBOI======"]
+    ];
+    for (const [input, expected] of vectors) {
+        it(`encodes "${input}" to "${expected}"`, () => {
+            strictEqual(encode32(input), expected);
+        });
+        it(`decodes "${expected}" to "${input}"`, () => {
+            strictEqual(decode32(expected), input);
+        });
+    }
+});
+//# sourceMappingURL=base32.test.js.map