Hexer: Hexadecimal Dumper

1.5.0 · abandoned · verified Wed Apr 22

Hexer is a Node.js library for generating hexadecimal dumps of buffers and streams, offering synchronous, streaming, and CLI modes. Its primary function is to transform binary data into a human-readable hex format, similar to tools like `xxd`. The package provides various transform streams for different use cases, including spying on stream data, converting entire streams, or processing data in chunks. Key customization options include control over output formatting like line prefixes, column count, grouping, and custom decorators for byte representation. The current stable version is 1.5.0, which was last published over 7 years ago, indicating it is no longer actively maintained. This means it primarily supports older CommonJS (CJS) environments and Node.js versions (engines require `>= 0.10.x`) and lacks native ES module (ESM) support or recent updates to align with modern JavaScript practices. Alternatives like `hexy` exist that are more actively maintained and support modern Node.js and ESM.

Common errors

```
TypeError: hexer is not a function
```
cause Attempting to use `hexer` as a default export function after incorrectly importing it using `import hex from 'hexer';` in an ESM context, or incorrectly destructuring `require('hexer')`.

fix Ensure you are using `const hex = require('hexer');` for CommonJS environments. The main `hex` function is the direct export of the module, while `Spy` and `Transform` are properties on it.
```
ERR_REQUIRE_ESM: Must use import to load ES Module
```
cause Attempting to `require('hexer')` in a Node.js environment where the current file or project is configured as an ES module (e.g., `"type": "module"` in `package.json`).

fix Either convert your project or specific file to CommonJS, or use `const hex = await import('hexer').then(m => m.default || m);` for dynamic ESM import, though full compatibility isn't guaranteed. It's often better to use a modern, ESM-compatible hex dumping library.

Warnings

breaking Hexer is a CommonJS-only package and does not provide native ES module (ESM) support. Attempting to `import` it in an ESM project will result in a 'Module not found' or similar error.
Fix: For ESM projects, use dynamic `import()` or consider a modern alternative like `hexy` that supports ESM. If using Node.js with `type: "module"` in `package.json`, you might need to wrap `require('hexer')` in an async function or use a compatibility layer if available.
gotcha The package has not been updated in over 7 years, and its `engines.node` field specifies `>= 0.10.x`. While it might still function on newer Node.js versions, it is not officially tested or supported for them and may encounter unexpected compatibility issues or rely on deprecated Node.js APIs.
Fix: Evaluate compatibility through testing in your specific Node.js environment. For new projects or those requiring long-term stability and modern features, consider more actively maintained alternatives.

Install

npm install hexer npm
yarn add hexer yarn
pnpm add hexer pnpm

Imports

hex
wrong:
```
import hex from 'hexer';
```
correct:
```
const hex = require('hexer');
```
Hexer is a CommonJS-only package. Native ES module imports are not supported. The main export is a function for dumping buffers.
hex.Spy
wrong:
```
import { Spy } from 'hexer';
```
correct:
```
const hex = require('hexer');
// ...
hex.Spy(process.stdout);
```
Named exports like `Spy` are properties of the main CommonJS `hex` export, not separate ES modules.
hex.Transform
wrong:
```
import { Transform } from 'hexer';
```
correct:
```
const hex = require('hexer');
// ...
hex.Transform();
```
Like `Spy`, `Transform` is a property of the main CommonJS `hex` export. It functions as a duplex stream.

Quickstart

Demonstrates basic usage of `hexer` to dump a Buffer to a string and to process a Readable stream with custom formatting options.

const hex = require('hexer');
const { Readable, Writable } = require('stream');

// Example 1: Buffer to string
const someBuffer = Buffer.from('Hello, Hexer!');
console.log('Buffer dump:\n' + hex(someBuffer));

// Example 2: Streaming transform
const inputData = Buffer.from('This is a test stream with some data.\nAnother line here.');
const readableStream = new Readable({ read() {} });

console.log('\nStreaming transform:');
readableStream
    .pipe(hex.Transform({ cols: 8, group: 4, headSep: '| ' }))
    .pipe(new Writable({
        write(chunk, encoding, callback) {
            process.stdout.write(chunk.toString());
            callback();
        }
    }));

readableStream.push(inputData.slice(0, 20));
readableStream.push(inputData.slice(20, 40));
readableStream.push(null); // End the stream

view raw JSON →