sindresorhus/is · error · TypeError

Expected value which is `Buffer`, received value of type `${

Error message

Expected value which is `Buffer`, received value of type `${is(value)}`.

What it means

Thrown by `assertBuffer()` when the value fails `isBuffer` (checks `value?.constructor?.isBuffer?.(value)`). It guards code that relies on Node Buffer-specific APIs. The library itself notes Buffer is legacy — prefer Uint8Array (see the JSDoc link at source/index.ts:1522).

Source

Thrown at source/index.ts:1526

export function assertBoolean(value: unknown, message?: string): asserts value is boolean {
	if (!isBoolean(value)) {
		throw new TypeError(message ?? typeErrorMessage('boolean', value));
	}
}

// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
export function assertBoundFunction(value: unknown, message?: string): asserts value is Function {
	if (!isBoundFunction(value)) {
		throw new TypeError(message ?? typeErrorMessage('bound Function', value));
	}
}

/**
Note: [Prefer using `Uint8Array` instead of `Buffer`.](https://sindresorhus.com/blog/goodbye-nodejs-buffer)
*/
export function assertBuffer(value: unknown, message?: string): asserts value is NodeBuffer {
	if (!isBuffer(value)) {
		throw new TypeError(message ?? typeErrorMessage('Buffer', value));
	}
}

export function assertClass<T>(value: unknown, message?: string): asserts value is Class<T> {
	if (!isClass(value)) {
		throw new TypeError(message ?? typeErrorMessage('Class', value));
	}
}

export function assertDataView(value: unknown, message?: string): asserts value is DataView {
	if (!isDataView(value)) {
		throw new TypeError(message ?? typeErrorMessage('DataView', value));
	}
}

export function assertDate(value: unknown, message?: string): asserts value is Date {
	if (!isDate(value)) {
		throw new TypeError(message ?? typeErrorMessage('Date', value));

View on GitHub ↗ (pinned to 7821031c66)

Solutions

Convert before asserting: `Buffer.from(uint8ArrayOrArrayBuffer)`.
Preferably migrate the code to accept Uint8Array (`assert.uint8Array`) instead of Buffer, per the library's own guidance.
In non-Node runtimes, remove the Buffer requirement or add an explicit Buffer polyfill only if truly needed.
Check whether a dependency upgrade changed its return type from Buffer to Uint8Array and adapt.

Example fix

// before
assert.buffer(await response.arrayBuffer());
// after
assert.buffer(Buffer.from(await response.arrayBuffer()));
// or better, per library guidance:
assert.uint8Array(new Uint8Array(await response.arrayBuffer()));

Defensive patterns

Strategy: type-guard

Validate before calling

if (!Buffer.isBuffer(value)) {
  value = Buffer.from(value); // explicit conversion from string/Uint8Array
}

Type guard

function isBuffer(value: unknown): value is Buffer {
  return typeof Buffer !== 'undefined' && Buffer.isBuffer(value);
}

Try / catch

try {
  assert.buffer(value);
} catch (error) {
  if (error instanceof TypeError) {
    // Uint8Array or string received — convert with Buffer.from() or fix the producer
  } else throw error;
}

Prevention

Use Buffer.isBuffer(), not instanceof, so cross-realm buffers are handled
Buffer is Node-only — in browser/edge runtimes prefer Uint8Array APIs or a polyfill, and know which one your bundler injects
A Uint8Array is not a Buffer even though Buffer extends it — convert with Buffer.from(uint8) (zero-copy via its buffer if needed)

When it happens

Trigger: Calling `assert.buffer(value)` with a Uint8Array, ArrayBuffer, string, Blob, or in a browser/edge runtime where `Buffer` doesn't exist so nothing can pass.

Common situations: Code moved from Node to browsers, Deno, Cloudflare Workers, or Vite-bundled frontends where Buffer is absent or shimmed; `fetch().arrayBuffer()` results passed where a Buffer was expected; libraries returning Uint8Array after migrating off Buffer (a common modern API change).

Related errors

AI-assisted analysis of sindresorhus/is@7821031c66 (2026-07-31). Data as JSON: /data/errors/868628877e5bae83.json. Report an issue: GitHub ↗.