@yeasoft/wav 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,80 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.1.0] - 2026-04-12
+
+### Added
+
+- Added support for new options that allow an improved control of
+  the classes behaviour
+- Added TypeScript declarations with full inline documentation
+- Added example application for `WavFileWriter`
+
+### Changed
+
+- Made `WavReader` more robust allowing other chunks like "JUNK" to appear
+  before "fmt "
+- Refactoring of tests and examples
+- Full reimplementation of `WavReader` based on an internal state machine
+- Removed all external dependencies
+- Refactoring of the original `Reader`, `Writer` and `FileWriter` classes and
+  renaming to new unambigous names `WavReader`, `WavWriter` and `WavFileWriter`
+
+### Fixed
+
+- Moved rewriting of final header to `close` handler since under high pressure
+  sometimes the file is still not closed and rewriting fails
+
+## [1.0.2] - 2018-04-27
+
+- Upgrade linting
+- Avoid deprecated Buffer API
+- Writer options and FileWriter example in Readme
+
+## [1.0.1] - 2016-07-21
+
+- Bump dependencies and cleanup package.json
+- Add semistandard linting
+- Add missing fs.open call
+- Update CI Node.js versions
+- travis, appveyor: test node v0.12 instead of v0.11
+
+## [1.0.0] - 2015-05-01
+
+- add MIT license file
+- add appveyor.yml file for Windows testing
+- examples: fix comment
+- index: add link to RFC2361
+- reader: add clarifying comment
+- reader: add initial `float` WAV file support
+- reader: add a few more formats defined by the RFC
+- reader: add `formats` map and set `float`, `alaw` and `ulaw` on the "format" object
+- reader: use %o debug v1 formatters
+- reader, writer: always use "readable-stream" copy of Transform
+- package: remove "engines" field
+- package: update all dependency versions
+- README: use svg for Travis badge
+- travis: don't test node v0.7 and v0.9, test v0.11
+
+## [0.1.2] - 2014-01-11
+
+- package: update `readable-stream` dep to v1.1.10
+- travis: test node v0.10 and v0.11
+- Writer: bypassed `stream-parser` to avoid assertion error (#1, #5)
+
+## [0.1.1] - 2013-12-12
+
+- Fix package.json repository URL so npm link isn't broken (@cbebry)
+
+## [0.1.0] - 2013-03-07
+
+- reader: passthrough the audio data chunk until EOF
+- test: begin testing with Travis-ci
+- add experimental RIFX support
+- reader, writer: integrate the "stream-parser" mixin
+- test: add initial Reader tests
+
+## [0.0.1] - 2012-02-05
+
+- Initial release

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 YeaSoft Intl. - Leo Moll
+Copyright (c) 2012 Nathan Rajlich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,169 @@
+node-wav
+========
+
+This module offers streams to help work with Microsoft WAVE files. This module is basically
+a fork of the original module [node-wav](https://github.com/TooTallNate/node-wav), which has
+not been further developed for many years and whose codebase is outdated due to former
+compatibility requirements.
+
+The most important thing: **this module has no external dependencies**.
+
+Installation
+------------
+
+Install through npm:
+
+``` bash
+npm install @yeasoft/wav
+```
+
+Example
+-------
+
+Here's how you would play a standard PCM WAVE file out of the speakers using
+`node-wav` and `node-speaker`:
+
+```js
+const fs = require('node:fs');
+const Speaker = require('speaker');
+const { WavReader } = require('@yeasoft/wav');
+
+const file = fs.createReadStream('track01.wav');
+const reader = new WavReader();
+
+// the "format" event gets emitted at the end of the WAVE header
+reader.on('format', format => {
+
+  // the WAVE header is stripped from the output of the reader
+  reader.pipe(new Speaker(format));
+});
+
+// pipe the WAVE file to the Reader instance
+file.pipe(reader);
+```
+
+API
+---
+
+The module exports the follwing three classes that can be used to read and write WAVE
+files:
+
+- [WavReader(options)](#wavreaderoptions)
+- [WavWriter(options)](#wavwriteroptions)
+- [WavFileWriter()](#wavfilewriterpath-options)
+
+Additionally, the following deprecated compatibility aliases are also exported in order
+to provide a drop in replacement of [node-wav](https://github.com/TooTallNate/node-wav):
+
+- [Reader(options)](#wavreaderoptions)
+- [Writer(options)](#wavwriteroptions)
+- [FileWriter()](#wavfilewriterpath-options)
+
+### WavReader(options)
+
+The `WavReader` class accepts a WAV audio file written to it and outputs the raw
+audio data with the WAV header stripped (most of the time, PCM audio data will
+be output, depending on the `audioFormat` property).
+
+A `"format"` event gets emitted after the WAV header has been parsed.
+
+#### Options
+
+Currently there are no specific options of the `WavReader` class but the `options`
+object is also passed verbatim to the base `Transform` class allowing to influence
+the overall behaviour of the class.
+
+### WavWriter(options)
+
+The `WavWriter` class accepts raw audio data written to it (only PCM audio data is
+currently supported), and outputs a WAV file with a valid WAVE header at the
+beginning specifying the formatting information of the audio stream.
+
+Note that there's an interesting problem, because the WAVE header also
+specifies the total byte length of the audio data in the file, and there's no
+way that we can know this ahead of time. Therefore the WAVE header will contain
+a byte-length if `0` initially, which most WAVE decoders will know means to
+just read until `EOF`.
+
+Optionally, if you are in a situation where you can seek back to the beginning
+of the destination of the WAVE file (like writing to a regular file, for
+example), then you may listen for the `"header"` event which will be emitted
+_after_ all the data has been written, and you can go back and rewrite the new
+header with proper audio byte length into the beginning of the destination
+(though if your destination _is_ a regular file, you should use the the
+`WavFileWriter` class instead).
+
+#### Options
+
+The following options can be specified on creation of a `WavWriter` object:
+
+- `format`: Format of the audio data. See the [official WAVE format specification][1]
+(default: `0x0001`)
+- `channels`: Number of channels (default: `2`)
+- `sampleRate`: Sample rate (default: `44100`)
+- `bitDepth`: Bits per sample (default: `16`)
+- `bigEndian`: If `true`, a big endian wave file will be generated (default: `false`)
+- `dataLength`: The expected size of the "data" portion of the WAVE file (default: _maximum valid length for a WAVE file_)
+
+The `options` object is also passed verbatim to the base `Transform` class allowing
+to influence the overall behaviour of the class.
+
+### WavFileWriter(path, options)
+
+The `WavFileWriter` class is, essentially, a combination of `fs.createWriteStream()` and
+the above `WavWriter()` class, except it automatically corrects the header after the file
+is written. Options are passed to both `WavWriter()` and `fs.createWriteStream()`.
+
+Example usage with `mic`:
+
+```js
+const mic = require('mic'); // requires arecord or sox, see https://www.npmjs.com/package/mic
+const { WavFileWriter } = require('@yeasoft/wav');
+
+const micInstance = mic({
+  rate: '16000',
+  channels: '1',
+  debug: true
+});
+
+const micInputStream = micInstance.getAudioStream();
+
+const outputFileStream = new WavFileWriter('./test.wav', {
+  sampleRate: 16000,
+  channels: 1
+});
+
+micInputStream.pipe(outputFileStream);
+
+micInstance.start();
+
+setTimeout(function() {
+  micInstance.stop();
+}, 5000);
+```
+
+#### Options
+
+The following options can be specified on creation of a `WavFileWriter` object:
+
+- `fixHeaderOn`: Specifies when to fix the header of the WAVE file after having written the whole audio data:
+  - `none`: Do not fix the header. This can be done later using the `fixHeader` method
+  - `close`: Fix the header automatically on "_close_" event
+  - `header`: Fix the header automatically on "_header_" event (compatibility with `node-wav`)
+- `ignoreFixHeaderError`: If `true`, errors that occur when fixing the headers are silently
+  ignored and no "error" event is emitted (default: `false`)
+
+The `options` object is also passed verbatim to the base `WavWriter` class allowing
+to influence the overall behaviour of the class.
+
+References
+----------
+
+- [RFC 2361](http://tools.ietf.org/html/rfc2361)
+- [WAVE Specifications](https://www.mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html)
+- [Multimedia Programming Interface and Data Specifications 1.0](https://www.mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/riffmci.pdf)
+- [WAVE File Format](http://www.blitter.com/~russtopia/MIDI/~jglatt/tech/wave.htm)
+- [BEXT Metadata](https://2manyrobots.com/YateResources/InAppHelp/BEXTMetadata.html)
+- [Specification of the Broadcast Wave Format](https://tech.ebu.ch/docs/tech/tech3285.pdf)
+
+[1]: https://www.mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/riffmci.pdf

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+
+export * from "./wav-reader";
+export * from "./wav-writer";
+export * from "./wav-file-writer";

package/dist/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const { WavReader } = require( './wav-reader' );
+const { WavWriter } = require( './wav-writer' );
+const { WavFileWriter } = require( "./wav-file-writer" );
+
+module.exports = { WavReader, WavWriter, WavFileWriter, Reader: WavReader, Writer: WavWriter, FileWriter: WavFileWriter };

package/dist/wav-file-writer.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+
+import { WavWriter, WavWriterOptions } from "./wav-writer";
+
+/** Options of the {@link WavFileWriter} */
+export interface WavFileWriterOptions extends WavWriterOptions {
+	/**
+	 * Specifies when to fix the header of the WAVE file after having
+	 * written the whole audio data:
+	 *
+	 * - `none`: Do not fix the header. This can be done later using the {@link fixHeader} method
+	 * - `close`: Fix the header automatically on "close" event
+	 * - `header`: Fix the header automatically on "header" event (compatibility with `node-wav`)
+	 *
+	 * If not specified, the default setting is `close`
+	 */
+	fixHeaderOn?: 'header' | 'close' | 'none';
+
+	/**
+	 * If `true`, errors that occur when fixing the headers are silently
+	 * ignored and no "error" event is emitted (default: `false`)
+	 */
+	ignoreFixHeaderError?: boolean;
+}
+
+/**
+ * The `WavFileWriter` is a subclass of `WavWriter` that can automatically take
+ * care of writing the "header" event at the end of the stream to the beginning
+ * of the output file.
+ */
+export class WavFileWriter extends WavWriter {
+	/**
+	 * Constructs a {@link WavFileWriter} object.
+	 *
+	 * @param path The destination filename for the WAVE file
+	 * @param options The options of the {@link WavFileWriter}
+	 */
+	constructor( path: string, options?: WavFileWriterOptions );
+
+	/**
+	 * Helper function that can be invoked in order to fix the internal file sizes
+	 * in the file header after the whole audio data has been written. This method
+	 * must only be called, if `options.fixHeaderOn = 'none'` was set.
+	 *
+	 * @param callback A callback function that gets the result of the operation
+	 */
+	fixHeader( callback: ( error: Error ) => void ): void;
+}
+
+/**
+ * The `FileWriter` is a subclass of `WavWriter` that can automatically take
+ * care of writing the "header" event at the end of the stream to the beginning
+ * of the output file.
+ *
+ * This old name is only provided for compatibility reasons with the former
+ * `node-wav` module. Use {@link WavFileWriter} instead.
+ *
+ * @deprecated
+ */
+export class FileWriter extends WavFileWriter { }

package/dist/wav-file-writer.js

@@ -0,0 +1,57 @@
+// activate strict mode
+'use strict';
+
+// load modules
+const fs = require( 'node:fs' );
+const { WavWriter } = require( './wav-writer' );
+
+class WavFileWriter extends WavWriter {
+	constructor( pathName, options ) {
+		super( options );
+
+		this.path = pathName;
+		this.file = fs.createWriteStream( pathName, options );
+
+		const attachFixHeader = event => {
+			this.file.on( event, () => {
+				this.fixHeader( error => {
+					if ( error && this.options.ignoreFixHeaderError === false ) return this.emit( 'error', error );
+					this.emit( 'done' );
+				} );
+			} );
+		};
+
+		switch ( this.options.fixHeaderOn ) {
+			default:
+			case 'close':
+				attachFixHeader( 'close' );
+				break;
+			case 'header':
+				attachFixHeader( 'header' );
+				break;
+			case 'none':
+				break;
+		}
+
+		this.pipe( this.file );
+	}
+
+	fixHeader( callback ) {
+		fs.open( this.path, 'r+', ( error, fd ) => {
+			if ( error ) return callback( error );
+
+			fs.write( fd, this.header, 0, this.header.length, 0, ( error, bytesWritten ) => {
+
+				fs.close( fd, errorClose => {
+					if ( error ) return callback( error );
+					if ( bytesWritten !== this.header.length ) return callback( new Error( 'problem writing "header" data' ) );
+					if ( errorClose ) return callback( errorClose );
+
+					callback();
+				} );
+			} );
+		} );
+	}
+}
+
+exports.WavFileWriter = WavFileWriter;

package/dist/wav-reader.d.ts

@@ -0,0 +1,94 @@
+/// <reference types="node" />
+
+import { Transform, TransformOptions } from "node:stream";
+
+/** Options of the {@link WavReader} */
+export interface WavReaderOptions extends TransformOptions {
+}
+
+/** Format information of the read WAVE stream as emitted by the "format" event */
+export interface WavReaderFormat {
+	/** Format of the audio data */
+	audioFormat: number;
+	/** Endianess of the audio data: LE = little endian, BE = big endian */
+	endianness: 'LE' | 'BE';
+	/** Number of audio channels */
+	channels: number;
+	/** Sample rate in samples per second */
+	sampleRate: number;
+	/** Byte rate in bytes per second */
+	byteRate: number;
+	/** Block alignment in bytes */
+	blockAlign: number;
+	/** Bits per sample */
+	bitDepth: number;
+	/** `true` if data is signed, `false` if data is unsigned */
+	signed: boolean;
+	/** `true` if `audioFormat` is `WAVE_FORMAT_IEEE_FLOAT` */
+	float?: boolean;
+	/** `true` if `audioFormat` is `WAVE_FORMAT_ALAW` */
+	alaw?: boolean;
+	/** `true` if `audioFormat` is `WAVE_FORMAT_ULAW` */
+	ulaw?: boolean;
+}
+
+/** Unprocessed chunks information of the read WAVE stream as emitted by the "chunk" event */
+export interface WavReaderChunk {
+	/** ID of the chunk */
+	id: string;
+	/** size in bytes of the chunk */
+	size: number;
+	/** The chunk data */
+	data: Buffer;
+}
+
+/**
+ * The `WavReader` class accepts a WAVE audio file, emits a "format" event, and
+ * outputs the raw "data" from the WAVE file (usually raw PCM data, but if the
+ * WAVE file uses compression then the compressed data will be output, you are
+ * responsible for uncompressing in that case if necessary).
+ */
+export class WavReader extends Transform {
+	/** detected 'RIFF' id of the stream */
+	riffId: string;
+	/** detected 'WAVE' id of the stream */
+	waveId: string;
+	/** detected 'fmt ' id of the stream */
+	chunkId: string;
+	/** the size of the RIFF chunk */
+	chunkSize: number;
+	/** the sizes of all encoutnered chunks */
+	chunkSizes: Record<string, number>;
+	/** the size of the 'fmt ' chunk */
+	subchunk1Size: number;
+	/** the size of the 'data' chunk */
+	subchunk2Size: number;
+
+	/** Format of the audio data */
+	audioFormat: number;
+	/** Endianess of the audio data: LE = little endian, BE = big endian */
+	endianness: 'LE' | 'BE';
+	/** Number of audio channels */
+	channels: number;
+	/** Sample rate in samples per second */
+	sampleRate: number;
+	/** Byte rate in bytes per second */
+	byteRate: number;
+	/** Block alignment in bytes */
+	blockAlign: number;
+	/** Bits per sample */
+	bitDepth: number;
+}
+
+/**
+ * The `Reader` class accepts a WAVE audio file, emits a "format" event, and
+ * outputs the raw "data" from the WAVE file (usually raw PCM data, but if the
+ * WAVE file uses compression then the compressed data will be output, you are
+ * responsible for uncompressing in that case if necessary).
+ *
+ * This old name is only provided for compatibility reasons with the former
+ * `node-wav` module. Use {@link WavReader} instead.
+ *
+ * @deprecated
+ */
+export class Reader extends WavReader { }

package/dist/wav-reader.js

@@ -0,0 +1,258 @@
+
+// activate strict mode
+'use strict';
+
+// load modules
+const { Transform } = require( 'node:stream' );
+
+// Values for the `audioFormat` byte.
+const formats = {
+	WAVE_FORMAT_UNKNOWN: 0x0000, // Microsoft Unknown Wave Format
+	WAVE_FORMAT_PCM: 0x0001, // Microsoft PCM Format
+	WAVE_FORMAT_ADPCM: 0x0002, // Microsoft ADPCM Format
+	WAVE_FORMAT_IEEE_FLOAT: 0x0003, // IEEE float
+	WAVE_FORMAT_VSELP: 0x0004, // Compaq Computer's VSELP
+	WAVE_FORMAT_IBM_CVSD: 0x0005, // IBM CVSD
+	WAVE_FORMAT_ALAW: 0x0006, // 8-bit ITU-T G.711 A-law
+	WAVE_FORMAT_MULAW: 0x0007, // 8-bit ITU-T G.711 µ-law
+	WAVE_FORMAT_EXTENSIBLE: 0xFFFE // Determined by SubFormat
+};
+
+// States of the internal state machine
+const states = {
+	PROCESS_HEADER: 0,
+	PROCESS_DETECT_CHUNK: 1,
+	PROCESS_FORM: 2,
+	PROCESS_FACT: 3,
+	PROCESS_DATA: 50,
+	PROCESS_UNKNOWN: 99,
+};
+
+
+class WavReader extends Transform {
+	constructor( options ) {
+		super( options );
+
+		this.options = options instanceof Object ? options : {};
+		this.endianness = 'LE';
+		this.chunkSizes = {};
+
+		this._initState( states.PROCESS_HEADER, 12 );
+	}
+
+	_transform( chunk, encoding, callback ) {
+		switch ( this.state ) {
+			case states.PROCESS_HEADER:
+				this._processHeader( chunk, encoding, callback );
+				break;
+			case states.PROCESS_DETECT_CHUNK:
+				this._detectChunk( chunk, encoding, callback );
+				break;
+			case states.PROCESS_FORM:
+				this._processForm( chunk, encoding, callback );
+				break;
+			case states.PROCESS_FACT:
+				this._processFact( chunk, encoding, callback );
+				break;
+			case states.PROCESS_DATA:
+				this._processData( chunk, encoding, callback );
+				break;
+			case states.PROCESS_UNKNOWN:
+				this._processUnknown( chunk, encoding, callback );
+				break;
+			default:
+				// should never happen
+				callback();
+				break;
+		}
+	}
+
+	_initState( state, bytesExpected ) {
+		this.state = state;
+		this.bytesExpected = bytesExpected;
+		this.bytesRead = 0;
+		this.bytes = Buffer.alloc( 0 );
+		this.bytes.readUInt16 = this.endianness === 'LE' ? this.bytes.readUInt16LE : this.bytes.readUInt16BE;
+		this.bytes.readUInt32 = this.endianness === 'LE' ? this.bytes.readUInt32LE : this.bytes.readUInt32BE;
+	}
+
+	_accumulate( chunk ) {
+		this.bytes = Buffer.concat( [ this.bytes, chunk ] );
+		this.bytes.readUInt16 = this.endianness === 'LE' ? this.bytes.readUInt16LE : this.bytes.readUInt16BE;
+		this.bytes.readUInt32 = this.endianness === 'LE' ? this.bytes.readUInt32LE : this.bytes.readUInt32BE;
+		return ( this.bytes.length < this.bytesExpected );
+	}
+
+	_increaseChunkSize( bytesCount ) {
+		this.bytesExpected += bytesCount;
+		return ( this.bytes.length < this.bytesExpected );
+	}
+
+	_finishChunk( encoding, callback ) {
+		const chunkData = this.bytes.subarray( this.bytesExpected );
+		this._initState( states.PROCESS_DETECT_CHUNK, 8 );
+		this._transform( chunkData, encoding, callback );
+	}
+
+	_detectChunk( chunk, encoding, callback ) {
+		if ( this._accumulate( chunk ) ) return callback();
+
+		this.currentChunkId = this.bytes.subarray( 0, 4 ).toString( 'ascii' );
+		const chunkSize = this.bytes.readUInt32( 4 );
+		const chunkData = this.bytes.subarray( 8 );
+		this.chunkSizes[ this.currentChunkId ] = chunkSize;
+
+		switch ( this.currentChunkId ) {
+			case 'fmt ':
+				this.chunkId = this.currentChunkId;
+				this.subchunk1Size = chunkSize;
+				this._initState( states.PROCESS_FORM, chunkSize );
+				this._processForm( chunkData, encoding, callback );
+				break;
+			case 'fact':
+				this._initState( states.PROCESS_FACT, chunkSize );
+				this._processFact( chunkData, encoding, callback );
+				break;
+			case 'data':
+				// Some encoders write `0` for the byte length here in the case of a WAV file
+				// being generated on-the-fly. In that case, we're just gonna passthrough the
+				// remaining bytes assuming they're going to be audio data.
+				this.subchunk2Size = chunkSize;
+				this._initState( states.PROCESS_DATA, chunkSize === 0 ? Infinity : chunkSize );
+				this._processData( chunkData, encoding, callback );
+				break;
+			default:
+				this._initState( states.PROCESS_UNKNOWN, chunkSize );
+				this._processUnknown( chunkData, encoding, callback );
+				break;
+		}
+	}
+
+	_processHeader( chunk, encoding, callback ) {
+		if ( this._accumulate( chunk ) ) return callback();
+
+		this.riffId = this.bytes.subarray( 0, 4 ).toString( 'ascii' );
+		if ( this.riffId === 'RIFF' ) {
+			this.endianness = 'LE';
+			this.bytes.readUInt16 = this.bytes.readUInt16LE;
+			this.bytes.readUInt32 = this.bytes.readUInt32LE;
+		} else if ( this.riffId === 'RIFX' ) {
+			this.endianness = 'BE';
+			this.bytes.readUInt16 = this.bytes.readUInt16BE;
+			this.bytes.readUInt32 = this.bytes.readUInt32BE;
+		} else {
+			return callback( new Error( `bad "chunk id": expected "RIFF" or "RIFX", got ${this.riffId}` ) );
+		}
+
+		this.chunkSize = this.bytes.readUInt32( 4 );
+		this.waveId = this.bytes.subarray( 8, 12 ).toString( 'ascii' );
+		if ( this.waveId !== 'WAVE' ) {
+			return callback( new Error( `bad "format": expected "WAVE", got ${this.waveId}` ) );
+		}
+
+		this._finishChunk( encoding, callback );
+	}
+
+	_processForm( chunk, encoding, callback ) {
+		if ( this._accumulate( chunk ) ) return callback();
+
+		this.audioFormat = this.bytes.readUInt16( 0 );
+		this.channels = this.bytes.readUInt16( 2 );
+		this.sampleRate = this.bytes.readUInt32( 4 );
+		this.byteRate = this.bytes.readUInt32( 8 ); // useless...
+		this.blockAlign = this.bytes.readUInt16( 12 ); // useless...
+		this.bitDepth = this.bytes.readUInt16( 14 );
+		this.signed = this.bitDepth !== 8;
+
+		const format = {
+			audioFormat: this.audioFormat,
+			endianness: this.endianness,
+			channels: this.channels,
+			sampleRate: this.sampleRate,
+			byteRate: this.byteRate,
+			blockAlign: this.blockAlign,
+			bitDepth: this.bitDepth,
+			signed: this.signed
+		};
+
+		switch ( format.audioFormat ) {
+			case formats.WAVE_FORMAT_PCM:
+				// default, common case. don't need to do anything.
+				break;
+			case formats.WAVE_FORMAT_IEEE_FLOAT:
+				format.float = true;
+				break;
+			case formats.WAVE_FORMAT_ALAW:
+				format.alaw = true;
+				break;
+			case formats.WAVE_FORMAT_MULAW:
+				format.ulaw = true;
+				break;
+		}
+
+		this.emit( 'format', format );
+
+		this._finishChunk( encoding, callback );
+	}
+
+	_processData( chunk, encoding, callback ) {
+		if ( !( 'fmt ' in this.chunkSizes ) ) return callback( new Error( `bad "fmt id": expected "fmt ", got ${this.currentChunkId}` ) );
+
+		if ( this.bytesExpected === Infinity ) {
+			// pass through and go on forever
+			this.bytesRead += chunk.length;
+			this.push( chunk );
+			return callback();
+		}
+		else if ( this.bytesRead + chunk.length < this.bytesExpected ) {
+			// pass through
+			this.bytesRead += chunk.length;
+			this.push( chunk );
+			return callback();
+		}
+		else if ( this.bytesRead + chunk.length === this.bytesExpected ) {
+			// pass through and switch to chunk detection
+			this.bytesRead += chunk.length;
+			this.push( chunk );
+			this._initState( states.PROCESS_DETECT_CHUNK, 8 );
+			return callback();
+		}
+		else {
+			// pass through remaining bytes, switch to chunk detection of process first bytes of new chunk
+			const bytesRemaining = this.bytesExpected - this.bytesRead;
+			this.push( chunk.subarray( 0, bytesRemaining ) );
+			this._initState( states.PROCESS_DETECT_CHUNK, 8 );
+			this._transform( chunk.subarray( bytesRemaining ), encoding, callback );
+		}
+	}
+
+	_processFact( chunk, encoding, callback ) {
+		if ( this._accumulate( chunk ) ) return callback();
+
+		// There is currently only one field defined for the format dependant data.
+		// It is a single 4-byte value that specifies the number of samples in the
+		// waveform data chunk.
+		//
+		// The number of samples field is redundant for sampled data, since the Data
+		// chunk indicates the length of the data. The number of samples can be
+		// determined from the length of the data and the container size as determined
+		// from the Format chunk.
+		this.numSamples = this.bytes.readUInt32( 0 );
+
+		this._finishChunk( encoding, callback );
+	}
+
+	_processUnknown( chunk, encoding, callback ) {
+		if ( this._accumulate( chunk ) ) return callback();
+
+		this.emit( 'chunk', {
+			id: this.currentChunkId,
+			size: this.bytesExpected,
+			data: this.bytes.subarray( 0, this.bytesExpected )
+		} );
+
+		this._finishChunk( encoding, callback );
+	}
+}
+
+exports.WavReader = WavReader;

package/dist/wav-writer.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="node" />
+
+import { Transform, TransformOptions } from "node:stream";
+
+/** Options of the {@link WavWriter} */
+export interface WavWriterOptions extends TransformOptions {
+	/** Format of the audio data (default: 0x0001) */
+	format?: number;
+	/** Number of channels (default: 2) */
+	channels?: number;
+	/** Sample rate (default: 44100) */
+	sampleRate?: number;
+	/** Bits per sample (default: 16) */
+	bitDepth?: number;
+	/** If `true`, a big endian wave file will be generated (default: `false`) */
+	bigEndian?: boolean;
+	/** The expected size of the "data" portion of the WAVE file (default: <maximum valid length for a WAVE file>) */
+	dataLength?: number;
+}
+
+/**
+ * The `WavWriter` class outputs a valid WAVE file from the audio data written to
+ * it. You may set any of the "channels", "sampleRate" or "bitDepth"
+ * properties before writing the first chunk. You may also set the "dataLength" to
+ * the number of bytes expected in the "data" portion of the WAVE file. If
+ * "dataLength" is not set, then the maximum valid length for a WAVE file is
+ * written.
+ */
+export class WavWriter extends Transform {
+	/**
+	 * Constructs a {@link WavWriter} object.
+	 *
+	 * @param options The options of the {@link WavWriter}
+	 */
+	constructor( options: WavWriterOptions );
+}
+
+
+/**
+ * The `Writer` class outputs a valid WAVE file from the audio data written to
+ * it. You may set any of the "channels", "sampleRate" or "bitDepth"
+ * properties before writing the first chunk. You may also set the "dataLength" to
+ * the number of bytes expected in the "data" portion of the WAVE file. If
+ * "dataLength" is not set, then the maximum valid length for a WAVE file is
+ * written.
+ *
+ * This old name is only provided for compatibility reasons with the former
+ * `node-wav` module. Use {@link WavWriter} instead.
+ *
+ * @deprecated
+ */
+export class Writer extends WavWriter { }

package/dist/wav-writer.js

@@ -0,0 +1,155 @@
+// activate strict mode
+'use strict';
+
+// load modules
+const process = require( 'node:process' );
+const { Transform } = require( 'node:stream' );
+
+// RIFF Chunk IDs in Buffers.
+const RIFF = Buffer.from( 'RIFF' );
+const WAVE = Buffer.from( 'WAVE' );
+const fmt = Buffer.from( 'fmt ' );
+const data = Buffer.from( 'data' );
+
+/**
+ * The max size of the "data" chunk of a WAVE file. This is the max unsigned
+ * 32-bit int value, minus 100 bytes (overkill, 44 would be safe) for the header.
+ */
+const MAX_WAV = 4294967295 - 100;
+
+class WavWriter extends Transform {
+	constructor( options ) {
+		super( options );
+
+		this.options = options instanceof Object ? options : {};
+		this.endianness = this.options.bigEndian === true ? 'BE' : 'LE';
+		this.format = 1; // raw PCM
+		this.channels = 2;
+		this.sampleRate = 44100;
+		this.bitDepth = 16;
+		this.bytesProcessed = 0;
+
+		if ( options instanceof Object ) {
+			if ( !isNaN( options.format ) ) this.format = parseInt( options.format );
+			if ( !isNaN( options.channels ) ) this.channels = parseInt( options.channels );
+			if ( !isNaN( options.sampleRate ) ) this.sampleRate = parseInt( options.sampleRate );
+			if ( !isNaN( options.bitDepth ) ) this.bitDepth = parseInt( options.bitDepth );
+			if ( !isNaN( options.dataLength ) ) this.dataLength = parseInt( options.dataLength );
+		}
+
+		this._writeHeader();
+	}
+
+	_transform( chunk, encoding, callback ) {
+		this.push( chunk );
+		this.bytesProcessed += chunk.length;
+		callback();
+	}
+
+	_flush( callback ) {
+		this.dataLength = this.bytesProcessed;
+
+		// write the file length at the beginning of the header
+		this.header.writeUInt32( this.dataLength + this.headerLength - 8, 4 );
+
+		// write the data length at the end of the header
+		this.header.writeUInt32( this.dataLength, this.headerLength - 4 );
+
+		callback();
+
+		process.nextTick( () => {
+			this.emit( 'header', this.header );
+		} );
+	}
+
+	_writeHeader() {
+		// TODO: 44 is only for format 1 (PCM), any other
+		// format will have a variable size...
+		const headerLength = 44;
+
+		let dataLength = this.dataLength;
+		if ( isNaN( dataLength ) ) {
+			dataLength = MAX_WAV;
+		}
+		const fileSize = dataLength + headerLength;
+		const header = Buffer.allocUnsafe( headerLength );
+		// fastify
+		header.writeUInt16 = this.endianness === 'LE' ? header.writeUInt16LE : header.writeUInt16BE;
+		header.writeUInt32 = this.endianness === 'LE' ? header.writeUInt32LE : header.writeUInt32BE;
+
+		let offset = 0;
+
+		// write the "RIFF" identifier
+		RIFF.copy( header, offset );
+		offset += RIFF.length;
+
+		// write the file size minus the identifier and this 32-bit int
+		header.writeUInt32( fileSize - 8, offset );
+		offset += 4;
+
+		// write the "WAVE" identifier
+		WAVE.copy( header, offset );
+		offset += WAVE.length;
+
+		// write the "fmt " sub-chunk identifier
+		fmt.copy( header, offset );
+		offset += fmt.length;
+
+		// write the size of the "fmt " chunk
+		// XXX: value of 16 is hard-coded for raw PCM format. other formats have
+		// different size.
+		header.writeUInt32( 16, offset );
+		offset += 4;
+
+		// write the audio format code
+		header.writeUInt16( this.format, offset );
+		offset += 2;
+
+		// write the number of channels
+		header.writeUInt16( this.channels, offset );
+		offset += 2;
+
+		// write the sample rate
+		header.writeUInt32( this.sampleRate, offset );
+		offset += 4;
+
+		// write the byte rate
+		let byteRate = this.byteRate;
+		if ( isNaN( byteRate ) ) {
+			byteRate = this.sampleRate * this.channels * this.bitDepth / 8;
+		}
+		header.writeUInt32( byteRate, offset );
+		offset += 4;
+
+		// write the block align
+		let blockAlign = this.blockAlign;
+		if ( blockAlign == null ) {
+			blockAlign = this.channels * this.bitDepth / 8;
+		}
+		header.writeUInt16( blockAlign, offset );
+		offset += 2;
+
+		// write the bits per sample
+		header.writeUInt16( this.bitDepth, offset );
+		offset += 2;
+
+		// write the "data" sub-chunk ID
+		data.copy( header, offset );
+		offset += data.length;
+
+		// write the remaining length of the rest of the data
+		header.writeUInt32( dataLength, offset );
+		// offset += 4;
+
+		// save the "header" Buffer for the end, we emit the "header" event at the end
+		// with the "size" values properly filled out. if this stream is being piped to
+		// a file (or anything else seekable), then this correct header should be placed
+		// at the very beginning of the file.
+		this.header = header;
+		this.headerLength = headerLength;
+
+		this.push( header );
+	}
+}
+
+exports.WavWriter = WavWriter;

package/package.json

@@ -0,0 +1,52 @@
+{
+	"name": "@yeasoft/wav",
+	"version": "1.1.0",
+	"description": "Stream classes for Microsoft WAVE audio files",
+	"author": {
+		"name": "Leo Moll",
+		"email": "leo.moll@yeasoft.com"
+	},
+	"contributors": [ {
+		"name": "Nathan Friedly",
+		"email": "nathan@nfriedly.com"
+	}, {
+		"name": "Linus Unnebäck",
+		"email": "linus@folkdatorn.se"
+	}, {
+		"name": "Matt McKegg",
+		"email": "matt@wetsand.co.nz"
+	}, {
+		"name": "Christopher Bebry",
+		"email": "invalidsyntax@gmail.com"
+	}, {
+		"name": "Nathan Rajlich",
+		"email": "nathan@tootallnate.net"
+	} ],
+	"license": "MIT",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"bugs": "https://github.com/YeaSoft/node-wav/issues",
+	"scripts": {
+		"clean": "rm -rf node_modules",
+		"test": "eslint && mocha"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/YeaSoft/node-wav.git"
+	},
+	"engines": {
+		"node": ">=16"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"devDependencies": {
+		"@eslint/js": "^10.0.1",
+		"@types/node": "^22.9.3",
+		"eslint": "^10.0.3",
+		"globals": "^17.3.0",
+		"mic": "^2.1.2",
+		"mocha": "^11.7.5",
+		"speaker": "^0.5.5"
+	}
+}