@openclaw/matrix 2026.10.2 → 2026.10.5-beta.2

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisTagMapper.js

@@ -18,12 +18,14 @@ const vorbisTagMap = {
     ORIGINALYEAR: 'originalyear',
     RELEASEDATE: 'releasedate',
     COMMENT: 'comment',
+    DESCRIPTION: 'comment',
     TRACKNUMBER: 'track',
     DISCNUMBER: 'disk',
     GENRE: 'genre',
     METADATA_BLOCK_PICTURE: 'picture',
     COMPOSER: 'composer',
     LYRICS: 'lyrics',
+    UNSYNCEDLYRICS: 'lyrics',
     ALBUMSORT: 'albumsort',
     TITLESORT: 'titlesort',
     WORK: 'work',
@@ -41,6 +43,8 @@ const vorbisTagMap = {
     DJMIXER: 'djmixer',
     MIXER: 'mixer',
     LABEL: 'label',
+    ORGANIZATION: 'label',
+    PUBLISHER: 'label',
     GROUPING: 'grouping',
     SUBTITLE: 'subtitle',
     DISCSUBTITLE: 'discsubtitle',

package/node_modules/music-metadata/lib/riff/RiffChunk.d.ts

@@ -1,3 +1,4 @@
+import type { SupportedEncoding } from '@borewit/text-codec';
 import type { IGetToken } from 'strtok3';
 import type { IChunkHeader } from '../iff/index.js';
 export type { IChunkHeader } from '../iff/index.js';
@@ -9,8 +10,9 @@ export declare const Header: IGetToken<IChunkHeader>;
  * Token to parse RIFF-INFO tag value
  */
 export declare class ListInfoTagValue implements IGetToken<string> {
+    private readonly encoding;
     len: number;
     private tagHeader;
-    constructor(tagHeader: IChunkHeader);
+    constructor(tagHeader: IChunkHeader, encoding?: SupportedEncoding);
     get(buf: Uint8Array, off: number): string;
 }

package/node_modules/music-metadata/lib/riff/RiffChunk.js

@@ -17,12 +17,13 @@ export const Header = {
  * Token to parse RIFF-INFO tag value
  */
 export class ListInfoTagValue {
-    constructor(tagHeader) {
+    constructor(tagHeader, encoding = 'latin1') {
+        this.encoding = encoding;
         this.tagHeader = tagHeader;
         this.len = tagHeader.chunkSize;
         this.len += this.len & 1; // if it is an odd length, round up to even
     }
     get(buf, off) {
-        return new Token.StringType(this.tagHeader.chunkSize, 'utf8').get(buf, off);
+        return new Token.StringType(this.tagHeader.chunkSize, this.encoding).get(buf, off).split('\0', 1)[0];
     }
 }

package/node_modules/music-metadata/lib/riff/RiffInfoTagMap.d.ts

@@ -1,5 +1,5 @@
-import type { INativeTagMap } from '../common/GenericTagTypes.js';
 import { CommonTagMapper } from '../common/GenericTagMapper.js';
+import type { INativeTagMap } from '../common/GenericTagTypes.js';
 /**
  * RIFF Info Tags; part of the EXIF 2.3
  * Ref: http://owl.phy.queensu.ca/~phil/exiftool/TagNames/RIFF.html#Info

package/node_modules/music-metadata/lib/type.d.ts

@@ -1,9 +1,9 @@
-import type { TagType } from './common/GenericTagTypes.js';
 import type { IFooter } from './apev2/APEv2Token.js';
-import type { TrackType } from './matroska/types.js';
+import type { TagType } from './common/GenericTagTypes.js';
 import type { LyricsContentType, TimestampFormat } from './id3v2/ID3v2Token.js';
-export { TrackType, TrackTypeValueToKeyMap } from './matroska/types.js';
+import type { TrackType } from './matroska/types.js';
 export { LyricsContentType, TimestampFormat } from './id3v2/ID3v2Token.js';
+export { TrackType, TrackTypeValueToKeyMap } from './matroska/types.js';
 export type AnyTagValue = unknown;
 /**
  * Attached picture, typically used for cover art

package/node_modules/music-metadata/lib/type.js

@@ -1,2 +1,2 @@
-export { TrackType, TrackTypeValueToKeyMap } from './matroska/types.js';
 export { LyricsContentType, TimestampFormat } from './id3v2/ID3v2Token.js';
+export { TrackType, TrackTypeValueToKeyMap } from './matroska/types.js';

package/node_modules/music-metadata/lib/wav/WaveChunk.d.ts

@@ -37,7 +37,7 @@ export declare const WaveFormat: {
     MPEG: number;
     MPEGLAYER3: number;
 };
-export type WaveFormat = typeof WaveFormat[keyof typeof WaveFormat];
+export type WaveFormat = (typeof WaveFormat)[keyof typeof WaveFormat];
 export declare const WaveFormatNameMap: {
     [WaveFormat.PCM]: string;
     [WaveFormat.ADPCM]: string;

package/node_modules/music-metadata/lib/wav/WaveChunk.js

@@ -16,7 +16,7 @@ export const WaveFormat = {
     // MPEG-4 and AAC Audio Types
     MPEG_ADTS_AAC: 0x1600,
     MPEG_LOAS: 0x1602,
-    RAW_AAC1: 0x00FF,
+    RAW_AAC1: 0x00ff,
     // Dolby Audio Types
     DOLBY_AC3_SPDIF: 0x0092,
     DVM: 0x2000,
@@ -53,8 +53,9 @@ export const WaveFormatNameMap = {
  */
 export class Format {
     constructor(header) {
-        if (header.chunkSize < 16)
+        if (header.chunkSize < 16) {
             throw new WaveContentError('Invalid chunk size');
+        }
         this.len = header.chunkSize;
     }
     get(buf, off) {

package/node_modules/music-metadata/lib/wav/WaveParser.d.ts

@@ -1,5 +1,5 @@
-import * as riff from '../riff/RiffChunk.js';
 import { BasicParser } from '../common/BasicParser.js';
+import * as riff from '../riff/RiffChunk.js';
 /**
  * Resource Interchange File Format (RIFF) Parser
  *
@@ -12,6 +12,8 @@ import { BasicParser } from '../common/BasicParser.js';
  * ToDo: Split WAVE part from RIFF parser
  */
 export declare class WaveParser extends BasicParser {
+    private codePage;
+    private readonly pendingInfoTags;
     private fact;
     private blockAlign;
     private avgBytesPerSec;
@@ -21,5 +23,7 @@ export declare class WaveParser extends BasicParser {
     readWaveChunk(remaining: number): Promise<void>;
     parseListTag(listHeader: riff.IChunkHeader): Promise<void>;
     private parseRiffInfoTags;
-    private addTag;
+    private addInfoTag;
+    private flushInfoTags;
+    private getInfoEncoding;
 }

package/node_modules/music-metadata/lib/wav/WaveParser.js

@@ -1,13 +1,12 @@
+import initDebug from 'debug';
 import * as strtok3 from 'strtok3';
 import * as Token from 'token-types';
-import initDebug from 'debug';
-import * as riff from '../riff/RiffChunk.js';
-import * as WaveChunk from './WaveChunk.js';
-import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
-import * as util from '../common/Util.js';
-import { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
+import { FourCcToken } from '../common/FourCC.js';
+import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
+import * as riff from '../riff/RiffChunk.js';
 import { BroadcastAudioExtensionChunk } from './BwfChunk.js';
+import * as WaveChunk from './WaveChunk.js';
 import { WaveContentError } from './WaveChunk.js';
 const debug = initDebug('music-metadata:parser:RIFF');
 /**
@@ -24,20 +23,23 @@ const debug = initDebug('music-metadata:parser:RIFF');
 export class WaveParser extends BasicParser {
     constructor() {
         super(...arguments);
+        this.pendingInfoTags = [];
         this.blockAlign = 0;
         this.avgBytesPerSec = 0;
     }
     async parse() {
         const riffHeader = await this.tokenizer.readToken(riff.Header);
         debug(`pos=${this.tokenizer.position}, parse: chunkID=${riffHeader.chunkID}`);
-        if (riffHeader.chunkID !== 'RIFF')
+        if (riffHeader.chunkID !== 'RIFF') {
             return; // Not RIFF format
+        }
         this.metadata.setAudioOnly();
-        return this.parseRiffChunk(riffHeader.chunkSize).catch(err => {
+        await this.parseRiffChunk(riffHeader.chunkSize).catch(err => {
             if (!(err instanceof strtok3.EndOfStreamError)) {
                 throw err;
             }
         });
+        await this.flushInfoTags();
     }
     async parseRiffChunk(chunkSize) {
         const type = await this.tokenizer.readToken(FourCcToken);
@@ -59,6 +61,18 @@ export class WaveParser extends BasicParser {
             this.header = header;
             debug(`pos=${this.tokenizer.position}, readChunk: chunkID=RIFF/WAVE/${header.chunkID}`);
             switch (header.chunkID) {
+                case 'CSET': {
+                    if (header.chunkSize < 8) {
+                        throw new WaveContentError('CSET chunk must contain at least 8 bytes');
+                    }
+                    const cset = await this.tokenizer.readToken(new Token.Uint8ArrayType(header.chunkSize));
+                    this.codePage = Token.UINT16_LE.get(cset, 0);
+                    if (!this.getInfoEncoding()) {
+                        this.metadata.addWarning(`Unsupported RIFF CSET code page: ${this.codePage}; LIST/INFO tags will be omitted`);
+                    }
+                    await this.flushInfoTags();
+                    break;
+                }
                 case 'LIST':
                     await this.parseListTag(header);
                     break;
@@ -66,7 +80,8 @@ export class WaveParser extends BasicParser {
                     this.metadata.setFormat('lossless', false);
                     this.fact = await this.tokenizer.readToken(new WaveChunk.FactChunk(header));
                     break;
-                case 'fmt ': { // The Util Chunk, non-PCM Formats
+                case 'fmt ': {
+                    // The Util Chunk, non-PCM Formats
                     const fmt = await this.tokenizer.readToken(new WaveChunk.Format(header));
                     let subFormat = WaveChunk.WaveFormatNameMap[fmt.wFormatTag];
                     if (!subFormat) {
@@ -82,13 +97,15 @@ export class WaveParser extends BasicParser {
                     break;
                 }
                 case 'id3 ': // The way Picard, FooBar currently stores, ID3 meta-data
-                case 'ID3 ': { // The way Mp3Tags stores ID3 meta-data
+                case 'ID3 ': {
+                    // The way Mp3Tags stores ID3 meta-data
                     const id3_data = await this.tokenizer.readToken(new Token.Uint8ArrayType(header.chunkSize));
                     const rst = strtok3.fromBuffer(id3_data);
                     await new ID3v2Parser().parse(this.metadata, rst, this.options);
                     break;
                 }
-                case 'data': { // PCM-data
+                case 'data': {
+                    // PCM-data
                     if (this.metadata.format.lossless !== false) {
                         this.metadata.setFormat('lossless', true);
                     }
@@ -100,7 +117,11 @@ export class WaveParser extends BasicParser {
                             chunkSize = calcRemaining;
                         }
                     }
-                    const numberOfSamples = this.fact ? this.fact.dwSampleLength : (chunkSize === 0xffffffff ? undefined : chunkSize / this.blockAlign);
+                    const numberOfSamples = this.fact
+                        ? this.fact.dwSampleLength
+                        : chunkSize === 0xffffffff
+                            ? undefined
+                            : chunkSize / this.blockAlign;
                     if (numberOfSamples) {
                         this.metadata.setFormat('numberOfSamples', numberOfSamples);
                         if (this.metadata.format.sampleRate) {
@@ -111,16 +132,17 @@ export class WaveParser extends BasicParser {
                         this.metadata.setFormat('bitrate', this.avgBytesPerSec * 8);
                     }
                     else if (this.metadata.format.duration) {
-                        this.metadata.setFormat('bitrate', chunkSize * 8 / this.metadata.format.duration);
+                        this.metadata.setFormat('bitrate', (chunkSize * 8) / this.metadata.format.duration);
                     }
                     await this.tokenizer.ignore(header.chunkSize);
                     break;
                 }
-                case 'bext': { // Broadcast Audio Extension chunk	https://tech.ebu.ch/docs/tech/tech3285.pdf
+                case 'bext': {
+                    // Broadcast Audio Extension chunk	https://tech.ebu.ch/docs/tech/tech3285.pdf
                     const bext = await this.tokenizer.readToken(BroadcastAudioExtensionChunk);
-                    Object.keys(bext).forEach(key => {
-                        this.metadata.addTag('exif', `bext.${key}`, bext[key]);
-                    });
+                    for (const key of Object.keys(bext)) {
+                        await this.metadata.addTag('exif', `bext.${key}`, bext[key]);
+                    }
                     const bextRemaining = header.chunkSize - BroadcastAudioExtensionChunk.len;
                     await this.tokenizer.ignore(bextRemaining);
                     break;
@@ -157,15 +179,46 @@ export class WaveParser extends BasicParser {
         while (chunkSize >= 8) {
             const header = await this.tokenizer.readToken(riff.Header);
             const valueToken = new riff.ListInfoTagValue(header);
-            const value = await this.tokenizer.readToken(valueToken);
-            this.addTag(header.chunkID, util.stripNulls(value));
-            chunkSize -= (8 + valueToken.len);
+            const bytes = await this.tokenizer.readToken(new Token.Uint8ArrayType(valueToken.len));
+            if (this.codePage === undefined) {
+                this.metadata.registerTagType('exif');
+                this.pendingInfoTags.push({ header, bytes });
+            }
+            else {
+                await this.addInfoTag(header, bytes);
+            }
+            chunkSize -= 8 + valueToken.len;
         }
         if (chunkSize !== 0) {
             throw new WaveContentError(`Illegal remaining size: ${chunkSize}`);
         }
     }
-    addTag(id, value) {
-        this.metadata.addTag('exif', id, value);
+    async addInfoTag(header, bytes) {
+        const encoding = this.getInfoEncoding();
+        if (encoding) {
+            const value = new riff.ListInfoTagValue(header, encoding).get(bytes, 0);
+            await this.metadata.addTag('exif', header.chunkID, value);
+        }
+    }
+    async flushInfoTags() {
+        for (const { header, bytes } of this.pendingInfoTags.splice(0)) {
+            await this.addInfoTag(header, bytes);
+        }
+    }
+    getInfoEncoding() {
+        // RIFF CSET: absent/zero means ISO 8859-1, not Windows-1252.
+        // https://www.robotplanet.dk/audio/wav_meta_data/riff_mci.pdf#page=25
+        switch (this.codePage) {
+            case undefined:
+            case 0:
+            case 28591:
+                return 'latin1';
+            case 1252:
+                return 'windows-1252';
+            case 65001:
+                return 'utf-8';
+            default:
+                return undefined;
+        }
     }
 }

package/node_modules/music-metadata/lib/wavpack/WavPackParser.js

@@ -1,11 +1,11 @@
+import initDebug from 'debug';
 import * as Token from 'token-types';
+import { uint8ArrayToHex } from 'uint8array-extras';
 import { tryParseApeHeader } from '../apev2/APEv2Parser.js';
-import { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
-import { BlockHeaderToken, MetadataIdToken } from './WavPackToken.js';
-import initDebug from 'debug';
-import { uint8ArrayToHex } from 'uint8array-extras';
+import { FourCcToken } from '../common/FourCC.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { BlockHeaderToken, MetadataIdToken } from './WavPackToken.js';
 const debug = initDebug('music-metadata:parser:WavPack');
 export class WavPackContentError extends makeUnexpectedFileContentError('WavPack') {
 }
@@ -28,11 +28,13 @@ export class WavPackParser extends BasicParser {
     async parseWavPackBlocks() {
         do {
             const blockId = await this.tokenizer.peekToken(FourCcToken);
-            if (blockId !== 'wvpk')
+            if (blockId !== 'wvpk') {
                 break;
+            }
             const header = await this.tokenizer.readToken(BlockHeaderToken);
-            if (header.BlockID !== 'wvpk')
+            if (header.BlockID !== 'wvpk') {
                 throw new WavPackContentError('Invalid WavPack Block-ID');
+            }
             debug(`WavPack header blockIndex=${header.blockIndex}, len=${BlockHeaderToken.len}`);
             if (header.blockIndex === 0 && !this.metadata.format.container) {
                 this.metadata.setFormat('container', 'WavPack');
@@ -49,13 +51,16 @@ export class WavPackParser extends BasicParser {
                 this.metadata.setFormat('codec', header.flags.isDSD ? 'DSD' : 'PCM');
             }
             const ignoreBytes = header.blockSize - (BlockHeaderToken.len - 8);
-            await (header.blockIndex === 0 ? this.parseMetadataSubBlock(header, ignoreBytes) : this.tokenizer.ignore(ignoreBytes));
+            await (header.blockIndex === 0
+                ? this.parseMetadataSubBlock(header, ignoreBytes)
+                : this.tokenizer.ignore(ignoreBytes));
             if (header.blockSamples > 0) {
                 this.audioDataSize += header.blockSize; // Count audio data for bit-rate calculation
             }
-        } while (!this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= BlockHeaderToken.len);
+        } while (!this.tokenizer.fileInfo.size ||
+            this.tokenizer.fileInfo.size - this.tokenizer.position >= BlockHeaderToken.len);
         if (this.metadata.format.duration) {
-            this.metadata.setFormat('bitrate', this.audioDataSize * 8 / this.metadata.format.duration);
+            this.metadata.setFormat('bitrate', (this.audioDataSize * 8) / this.metadata.format.duration);
         }
     }
     /**
@@ -74,13 +79,15 @@ export class WavPackParser extends BasicParser {
             switch (id.functionId) {
                 case 0x0: // ID_DUMMY: could be used to pad WavPack blocks
                     break;
-                case 0xe: { // ID_DSD_BLOCK
+                case 0xe: {
+                    // ID_DSD_BLOCK
                     debug('ID_DSD_BLOCK');
                     // https://github.com/dbry/WavPack/issues/71#issuecomment-483094813
                     const mp = 1 << Token.UINT8.get(data, 0);
                     const samplingRate = header.flags.samplingRate * mp * 8; // ToDo: second factor should be read from DSD-metadata block https://github.com/dbry/WavPack/issues/71#issuecomment-483094813
-                    if (!header.flags.isDSD)
+                    if (!header.flags.isDSD) {
                         throw new WavPackContentError('Only expect DSD block if DSD-flag is set');
+                    }
                     this.metadata.setFormat('sampleRate', samplingRate);
                     this.metadata.setFormat('duration', header.totalSamples / samplingRate);
                     break;
@@ -100,10 +107,12 @@ export class WavPackParser extends BasicParser {
             }
             remaining -= MetadataIdToken.len + (id.largeBlock ? Token.UINT24_LE.len : Token.UINT8.len) + dataSizeInWords * 2;
             debug(`remainingLength=${remaining}`);
-            if (id.isOddSize)
+            if (id.isOddSize) {
                 this.tokenizer.ignore(1);
+            }
         }
-        if (remaining !== 0)
+        if (remaining !== 0) {
             throw new WavPackContentError('metadata-sub-block should fit it remaining length');
+        }
     }
 }

package/node_modules/music-metadata/lib/wavpack/WavPackToken.js

@@ -1,7 +1,8 @@
 import * as Token from 'token-types';
 import { FourCcToken } from '../common/FourCC.js';
-const SampleRates = [6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000, 32000, 44100,
-    48000, 64000, 88200, 96000, 192000, -1];
+const SampleRates = [
+    6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000, 192000, -1
+];
 /**
  * WavPack Block Header
  *

package/node_modules/music-metadata/package.json

@@ -1,7 +1,7 @@
 {
   "name": "music-metadata",
   "description": "Music metadata parser for Node.js, supporting virtual any audio and tag format.",
-  "version": "11.15.0",
+  "version": "11.16.1",
   "author": {
     "name": "Borewit",
     "url": "https://github.com/Borewit"
@@ -98,6 +98,7 @@
     "compile:dev": "yarn run compile-src:dev && yarn compile-test && yarn compile-doc",
     "compile:prod": "yarn run compile-src:prod && yarn compile-test && yarn compile-doc",
     "lint:ts": "biome check",
+    "lint:ts:fix": "biome check --write",
     "lint:md": "yarn run remark -u remark-preset-lint-consistent .",
     "lint": "yarn run lint:ts && yarn run lint:md",
     "test": "mocha",
@@ -152,5 +153,5 @@
   "bugs": {
     "url": "https://github.com/Borewit/music-metadata/issues"
   },
-  "packageManager": "yarn@4.9.2"
+  "packageManager": "yarn@4.18.0"
 }

package/node_modules/uint8array-extras/index.d.ts

@@ -92,7 +92,7 @@ console.log(concatUint8Arrays([a, b]));
 //=> Uint8Array [1, 2, 3, 4, 5, 6]
 ```
 */
-export function concatUint8Arrays(arrays: Uint8Array[], totalLength?: number): Uint8Array<ArrayBuffer>;
+export function concatUint8Arrays(arrays: Array<Uint8Array | ArrayBuffer>, totalLength?: number): Uint8Array<ArrayBuffer>;
 
 /**
 Check if two arrays are identical by verifying that they contain the same bytes in the same sequence.
@@ -114,7 +114,7 @@ console.log(areUint8ArraysEqual(a, c));
 //=> false
 ```
 */
-export function areUint8ArraysEqual(a: Uint8Array, b: Uint8Array): boolean;
+export function areUint8ArraysEqual(a: Uint8Array | ArrayBuffer, b: Uint8Array | ArrayBuffer): boolean;
 
 /**
 Compare two arrays and indicate their relative order or equality. Useful for sorting.
@@ -133,7 +133,7 @@ const array3 = new Uint8Array([7, 8, 9]);
 //=> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 ```
 */
-export function compareUint8Arrays(a: Uint8Array, b: Uint8Array): 0 | 1 | -1;
+export function compareUint8Arrays(a: Uint8Array | ArrayBuffer, b: Uint8Array | ArrayBuffer): 0 | 1 | -1;
 
 /**
 Convert a `Uint8Array` to a string.
@@ -193,7 +193,7 @@ console.log(uint8ArrayToBase64(byteArray));
 //=> 'SGVsbG8='
 ```
 */
-export function uint8ArrayToBase64(array: Uint8Array, options?: {urlSafe: boolean}): string;
+export function uint8ArrayToBase64(array: Uint8Array | ArrayBuffer, options?: {urlSafe: boolean}): string;
 
 /**
 Convert a Base64-encoded or [Base64URL](https://base64.guru/standards/base64url)-encoded string to a `Uint8Array`.
@@ -261,7 +261,7 @@ console.log(uint8ArrayToHex(byteArray));
 //=> '48656c6c6f'
 ```
 */
-export function uint8ArrayToHex(array: Uint8Array): string;
+export function uint8ArrayToHex(array: Uint8Array | ArrayBuffer): string;
 
 /**
 Convert a Hex string to a `Uint8Array`.
@@ -310,7 +310,7 @@ console.log(indexOf(byteArray, new Uint8Array([0x78, 0x90])));
 //=> 3
 ```
 */
-export function indexOf(array: Uint8Array, value: Uint8Array): number;
+export function indexOf(array: Uint8Array | ArrayBuffer, value: Uint8Array | ArrayBuffer): number;
 
 /**
 Checks if the given sequence of bytes (`value`) is within the given `Uint8Array` (`array`).
@@ -328,4 +328,4 @@ console.log(includes(byteArray, new Uint8Array([0x78, 0x90])));
 //=> true
 ```
 */
-export function includes(array: Uint8Array, value: Uint8Array): boolean;
+export function includes(array: Uint8Array | ArrayBuffer, value: Uint8Array | ArrayBuffer): boolean;

package/node_modules/uint8array-extras/index.js

@@ -26,6 +26,10 @@ function isUint8ArrayOrArrayBuffer(value) {
 	return isUint8Array(value) || isArrayBuffer(value);
 }
 
+function toUint8ArrayIfArrayBuffer(value) {
+	return isArrayBuffer(value) ? new Uint8Array(value) : value;
+}
+
 export function assertUint8Array(value) {
 	if (!isUint8Array(value)) {
 		throw new TypeError(`Expected \`Uint8Array\`, got \`${typeof value}\``);
@@ -55,13 +59,14 @@ export function concatUint8Arrays(arrays, totalLength) {
 		return new Uint8Array(0);
 	}
 
-	totalLength ??= arrays.reduce((accumulator, currentValue) => accumulator + currentValue.length, 0);
+	totalLength ??= arrays.reduce((accumulator, currentValue) => accumulator + currentValue.byteLength, 0);
 
 	const returnValue = new Uint8Array(totalLength);
 
 	let offset = 0;
-	for (const array of arrays) {
-		assertUint8Array(array);
+	for (let array of arrays) {
+		assertUint8ArrayOrArrayBuffer(array);
+		array = toUint8ArrayIfArrayBuffer(array);
 		returnValue.set(array, offset);
 		offset += array.length;
 	}
@@ -70,8 +75,10 @@ export function concatUint8Arrays(arrays, totalLength) {
 }
 
 export function areUint8ArraysEqual(a, b) {
-	assertUint8Array(a);
-	assertUint8Array(b);
+	assertUint8ArrayOrArrayBuffer(a);
+	assertUint8ArrayOrArrayBuffer(b);
+	a = toUint8ArrayIfArrayBuffer(a);
+	b = toUint8ArrayIfArrayBuffer(b);
 
 	if (a === b) {
 		return true;
@@ -92,8 +99,10 @@ export function areUint8ArraysEqual(a, b) {
 }
 
 export function compareUint8Arrays(a, b) {
-	assertUint8Array(a);
-	assertUint8Array(b);
+	assertUint8ArrayOrArrayBuffer(a);
+	assertUint8ArrayOrArrayBuffer(b);
+	a = toUint8ArrayIfArrayBuffer(a);
+	b = toUint8ArrayIfArrayBuffer(b);
 
 	const length = Math.min(a.length, b.length);
 
@@ -147,7 +156,8 @@ function base64UrlToBase64(base64url) {
 const MAX_BLOCK_SIZE = 65_535;
 
 export function uint8ArrayToBase64(array, {urlSafe = false} = {}) {
-	assertUint8Array(array);
+	assertUint8ArrayOrArrayBuffer(array);
+	array = toUint8ArrayIfArrayBuffer(array);
 
 	let base64 = '';
 
@@ -178,7 +188,8 @@ export function base64ToString(base64String) {
 const byteToHexLookupTable = Array.from({length: 256}, (_, index) => index.toString(16).padStart(2, '0'));
 
 export function uint8ArrayToHex(array) {
-	assertUint8Array(array);
+	assertUint8ArrayOrArrayBuffer(array);
+	array = toUint8ArrayIfArrayBuffer(array);
 
 	// Concatenating a string is faster than using an array.
 	let hexString = '';
@@ -273,11 +284,14 @@ export function getUintBE(view) {
 }
 
 /**
-@param {Uint8Array} array
-@param {Uint8Array} value
+@param {Uint8Array | ArrayBuffer} array
+@param {Uint8Array | ArrayBuffer} value
 @returns {number}
 */
 export function indexOf(array, value) {
+	array = toUint8ArrayIfArrayBuffer(array);
+	value = toUint8ArrayIfArrayBuffer(value);
+
 	const arrayLength = array.length;
 	const valueLength = value.length;
 
@@ -309,8 +323,8 @@ export function indexOf(array, value) {
 }
 
 /**
-@param {Uint8Array} array
-@param {Uint8Array} value
+@param {Uint8Array | ArrayBuffer} array
+@param {Uint8Array | ArrayBuffer} value
 @returns {boolean}
 */
 export function includes(array, value) {

package/node_modules/uint8array-extras/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "uint8array-extras",
-	"version": "1.5.0",
+	"version": "1.6.0",
 	"description": "Useful utilities for working with Uint8Array (and Buffer)",
 	"license": "MIT",
 	"repository": "sindresorhus/uint8array-extras",
@@ -20,7 +20,7 @@
 		"node": ">=18"
 	},
 	"scripts": {
-		"test": "xo && ava && tsc index.d.ts"
+		"test": "xo && ava && tsc --lib es2023 index.d.ts"
 	},
 	"files": [
 		"index.js",
@@ -46,9 +46,9 @@
 		"hexadecimal"
 	],
 	"devDependencies": {
-		"ava": "^6.0.1",
-		"typescript": "^5.3.3",
-		"xo": "^0.56.0",
-		"benchmark": "2.1.4"
+		"ava": "^6.4.1",
+		"benchmark": "2.1.4",
+		"typescript": "^5.9.3",
+		"xo": "^1.2.3"
 	}
 }