Base32 Encoding for JavaScript

Common errors

• ReferenceError: require is not defined

  cause Attempting to use `require()` in an ES Module (`.mjs` file or `"type": "module"` in `package.json`).
  fix Use `import * as base32 from 'base32.js';` and ensure your bundler or Node.js environment is configured to handle CommonJS interop.

• TypeError: base32.Encoder is not a constructor

  cause Incorrect ES Module import of the CommonJS module. You might have tried `import base32 from 'base32.js';` which does not correctly capture the module's object export.
  fix Use `import * as base32 from 'base32.js';` to import the module object containing `Encoder` and `Decoder`.

• Error: Missing data at end of buffer

  cause Mismatch in padding settings between the encoder and decoder, or providing an invalid Base32 string to the decoder.
  fix Ensure both `Encoder` and `Decoder` are initialized with the same `type` and `padding` options. If the encoded string was padded, the decoder must be initialized with `{ padding: true }`. Verify the input string is valid Base32 according to the specified type.

Warnings

• breaking This package is at version 0.1.0 and appears to be unmaintained. There is no active development, explicit support for modern JavaScript features like ES Modules, or official TypeScript types. Users should be aware of potential compatibility issues with newer Node.js versions, build tools, or browser environments, and the absence of security patches.
  Fix: Consider migrating to a more actively maintained Base32 library that supports modern JavaScript environments and provides ongoing security updates. If continued use is necessary, carefully review the source code for vulnerabilities and ensure compatibility with your target environment.
• gotcha The library's API uses a streaming encoder/decoder pattern (`.write().finalize()`), which might be unfamiliar to users expecting direct `encode(input)` and `decode(input)` functions. This pattern requires calling `.write()` with the input data, then `.finalize()` to get the result.
  Fix: Always remember to call both `.write(data)` and `.finalize()` to process data and retrieve the output from `Encoder` and `Decoder` instances.
• gotcha The default Base32 variant is RFC 4648 *without* padding, which might differ from other Base32 implementations that commonly use padding by default. Incorrectly handling padding can lead to decoding errors or incompatible output with other systems.
  Fix: Explicitly configure the `type` and `padding` options in the `Encoder` and `Decoder` constructors to ensure compatibility with your target Base32 standard and padding requirements (e.g., `{ type: 'rfc4648', padding: true }`).

Install

• npm install base32.js npm
• yarn add base32.js yarn
• pnpm add base32.js pnpm

Imports

• base32 (module object)
  wrong:

  import base32 from "base32.js";

  correct:

  const base32 = require("base32.js");

  This package primarily targets CommonJS environments, exporting an object containing `Encoder` and `Decoder` classes. The `import base32 from 'base32.js'` syntax is incorrect for this type of CommonJS export in ESM.
• { Encoder, Decoder } (destructured CommonJS)
  wrong:

  const Encoder = require("base32.js").Encoder;

  correct:

  const { Encoder, Decoder } = require("base32.js");

  Direct destructuring is the idiomatic and clearer way to access the exported classes within CommonJS modules.
• base32 (ESM interop for CJS module)
  wrong:

  import base32 from 'base32.js';

  correct:

  import * as base32 from 'base32.js';

  When used in an ES Module environment, importing an older CommonJS module that exports an object typically requires a `* as` import to correctly access its named properties like `base32.Encoder`.

Quickstart

This quickstart demonstrates encoding and decoding binary data using Crockford Base32 and the default RFC4648 (no padding) variant, showcasing the streaming API.

const base32 = require("base32.js");

console.log("Encoding a buffer using Crockford Base32 (lowercase)...");
const buf = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // Extended buffer for a more realistic example
const encoder = new base32.Encoder({ type: "crockford", lc: true });
const encodedStr = encoder.write(buf).finalize();
console.log(`Original buffer: [${buf.join(', ')}]`);
console.log(`Encoded string: ${encodedStr}`);

console.log("\nDecoding the string back...");
const decoder = new base32.Decoder({ type: "crockford" });
const decodedBuf = decoder.write(encodedStr).finalize();
console.log(`Decoded buffer: [${decodedBuf.join(', ')}]`);

// Example with default RFC4648 without padding
console.log("\nEncoding with default RFC4648 (no padding)...");
const rfc4648Buf = Buffer.from("Hello World"); // Using Buffer for wider compatibility
const rfcEncoder = new base32.Encoder(); // Default is rfc4648, no padding
const rfcEncodedStr = rfcEncoder.write(rfc4648Buf).finalize();
console.log(`Original string: ${rfc4648Buf.toString()}`);
console.log(`Encoded RFC4648: ${rfcEncodedStr}`);

const rfcDecoder = new base32.Decoder();
const rfcDecodedBuf = rfcDecoder.write(rfcEncodedStr).finalize();
console.log(`Decoded RFC4648: ${rfcDecodedBuf.toString()});