@ctrl/torrent-file 3.0.0 → 4.1.0

package/README.md

@@ -2,7 +2,7 @@
 
 > Parse a torrent file and read encoded data. 
 
-This project is based on [parse-torrent](https://www.npmjs.com/package/parse-torrent) and [node-bencode](https://github.com/themasch/node-bencode) to parse the data of a torrent file. This library implements its own [bencode](http://www.bittorrent.org/beps/bep_0003.html) encoder and decoder and keeps dependencies to a minimum.
+This project is based on [parse-torrent](https://www.npmjs.com/package/parse-torrent) and [node-bencode](https://github.com/themasch/node-bencode) to parse the data of a torrent file. This library implements its own [bencode](http://www.bittorrent.org/beps/bep_0003.html) encoder and decoder that does not use `Buffer`.
 
 ### Install
 ```console
@@ -43,23 +43,6 @@ import { hash } from '@ctrl/torrent-file';
 })()
 ```
 
-### encode
-Use the built in bencode encoder
-```ts
-import fs from 'fs';
-import { encode } from '@ctrl/torrent-file';
-
-encode({ name: 'my string to encode' });
-```
-
-### decode
-Easily get the raw data inside a torrent file.
-```ts
-import fs from 'fs';
-import { decode } from '@ctrl/torrent-file';
-
-decode(fs.readFileSync('myfile'));
-```
 
 ### See Also
 [parse-torrent](https://www.npmjs.com/package/parse-torrent) - "@ctrl/torrent-file" torrent parsing based very heavily off this project  

package/dist/src/bencode/decode.d.ts

@@ -1,5 +1,2 @@
-/// <reference types="node" resolution-mode="require"/>
-/**
- * Decodes bencoded data
- */
-export declare function decode(data: Buffer | string | null, encoding?: string | null): Record<string, unknown> | any[] | Buffer | string | number | null;
+import type { bencodeValue } from './encode.js';
+export declare const decode: (payload: ArrayBufferView | ArrayBuffer | string) => bencodeValue;

package/dist/src/bencode/decode.js

@@ -1,117 +1,126 @@
-const INTEGER_START = 0x69; // 'i'
-const STRING_DELIM = 0x3a; // ':'
-const DICTIONARY_START = 0x64; // 'd'
-const LIST_START = 0x6c; // 'l'
-const END_OF_TYPE = 0x65; // 'e'
-/**
- * Replaces parseInt(buffer.toString('ascii', start, end)).
- * For strings with less then ~30 charachters, this is actually a lot faster.
- */
-function getIntFromBuffer(buffer, start, end) {
-    let sum = 0;
-    let sign = 1;
-    for (let i = start; i < end; i++) {
-        const num = buffer[i];
-        if (typeof num === 'undefined') {
-            continue;
+import { stringToUint8Array, uint8ArrayToString } from 'uint8array-extras';
+import { isValidUTF8 } from './utils.js';
+const td = new TextDecoder();
+class Decoder {
+    buf;
+    idx = 0;
+    constructor(buf) {
+        this.buf = buf;
+    }
+    readByte() {
+        if (this.idx >= this.buf.length) {
+            return null;
         }
-        if (num < 58 && num >= 48) {
-            sum = sum * 10 + (num - 48);
-            continue;
+        return String.fromCharCode(this.buf[this.idx++]);
+    }
+    readBytes(length) {
+        if (this.idx + length > this.buf.length) {
+            throw new Error(`could not read ${length} bytes, insufficient content`);
         }
-        if (i === start && num === 43) {
-            // +
-            continue;
+        const result = this.buf.slice(this.idx, this.idx + length);
+        this.idx += length;
+        return result;
+    }
+    readUntil(char) {
+        const targetIdx = this.buf.indexOf(char.charCodeAt(0), this.idx);
+        if (targetIdx === -1) {
+            throw new Error(`could not find terminated char: ${char}`);
         }
-        if (i === start && num === 45) {
-            // -
-            sign = -1;
-            continue;
+        const result = this.buf.slice(this.idx, targetIdx);
+        this.idx = targetIdx;
+        return result;
+    }
+    readNumber() {
+        const buf = this.readUntil(':');
+        return parseInt(uint8ArrayToString(buf), 10);
+    }
+    peekByte() {
+        if (this.idx >= this.buf.length) {
+            return '';
         }
-        if (num === 46) {
-            // .
-            // its a float. break here.
-            break;
+        const result = this.readByte();
+        if (result === null) {
+            return '';
         }
-        throw new Error(`not a number: buffer['${i}'] = ${num}`);
+        this.idx--;
+        return result;
     }
-    return sum * sign;
-}
-/**
- * Decodes bencoded data
- */
-export function decode(data, encoding = null) {
-    const state = {
-        bytes: 0,
-        position: 0,
-        data: null,
-        encoding,
-    };
-    if (data === null || data.length === 0) {
-        return null;
-    }
-    state.data = Buffer.isBuffer(data) ? data : Buffer.from(data);
-    state.bytes = state.data.length;
-    return next(state);
-}
-function next(state) {
-    switch (state.data[state.position]) {
-        case DICTIONARY_START:
-            return dictionary(state);
-        case LIST_START:
-            return list(state);
-        case INTEGER_START:
-            return integer(state);
-        default:
-            return buffer(state);
+    assertByte(expected) {
+        const b = this.readByte();
+        if (b !== expected) {
+            throw new Error(`expecte ${expected}, got ${b}`);
+        }
     }
-}
-function find(state, chr) {
-    let i = state.position;
-    const c = state.data.length;
-    const d = state.data;
-    while (i < c) {
-        if (d[i] === chr) {
-            return i;
+    next() {
+        switch (this.peekByte()) {
+            case 'd': {
+                return this.nextDictionary();
+            }
+            case 'l': {
+                return this.nextList();
+            }
+            case 'i': {
+                return this.nextNumber();
+            }
+            default: {
+                return this.nextBufOrString();
+            }
         }
-        i++;
     }
-    throw new Error('Invalid data: Missing delimiter "' +
-        String.fromCharCode(chr) +
-        '" [0x' +
-        chr.toString(16) +
-        ']');
-}
-function dictionary(state) {
-    state.position++;
-    const dict = {};
-    while (state.data[state.position] !== END_OF_TYPE) {
-        dict[buffer(state)] = next(state);
-    }
-    state.position++;
-    return dict;
-}
-function list(state) {
-    state.position++;
-    const lst = [];
-    while (state.data[state.position] !== END_OF_TYPE) {
-        lst.push(next(state));
-    }
-    state.position++;
-    return lst;
-}
-function integer(state) {
-    const end = find(state, END_OF_TYPE);
-    const number = getIntFromBuffer(state.data, state.position + 1, end);
-    state.position += end + 1 - state.position;
-    return number;
-}
-function buffer(state) {
-    let sep = find(state, STRING_DELIM);
-    const length = getIntFromBuffer(state.data, state.position, sep);
-    const end = ++sep + length;
-    state.position = end;
-    return state.encoding
-        ? state.data.toString(state.encoding, sep, end)
-        : state.data.slice(sep, end);
+    nextBufOrString() {
+        const length = this.readNumber();
+        this.assertByte(':');
+        const buf = this.readBytes(length);
+        return isValidUTF8(buf) ? td.decode(buf) : buf;
+    }
+    nextString() {
+        const length = this.readNumber();
+        this.assertByte(':');
+        return td.decode(this.readBytes(length));
+    }
+    nextNumber() {
+        this.assertByte('i');
+        const content = td.decode(this.readUntil('e'));
+        this.assertByte('e');
+        const result = Number(content);
+        if (isNaN(result)) {
+            throw new Error(`not a number: ${content}`);
+        }
+        return result;
+    }
+    nextList() {
+        this.assertByte('l');
+        const result = [];
+        while (this.peekByte() !== 'e') {
+            result.push(this.next());
+        }
+        this.assertByte('e');
+        return result;
+    }
+    nextDictionary() {
+        this.assertByte('d');
+        const result = {};
+        while (this.peekByte() !== 'e') {
+            result[this.nextString()] = this.next();
+        }
+        this.assertByte('e');
+        return result;
+    }
 }
+export const decode = (payload) => {
+    let buf;
+    if (typeof payload === 'string') {
+        buf = stringToUint8Array(payload);
+    }
+    else if (payload instanceof ArrayBuffer) {
+        buf = new Uint8Array(payload);
+    }
+    else if ('buffer' in payload) {
+        buf = new Uint8Array(payload.buffer);
+    }
+    else {
+        throw new Error(`invalid payload type`);
+    }
+    const decoder = new Decoder(buf);
+    return decoder.next();
+};

package/dist/src/bencode/encode.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-/**
- * Encodes data in bencode.
- */
-export declare function encode(data: Buffer | string | any[] | ArrayBuffer | number | boolean | Record<string, unknown> | object, buffer?: unknown, offset?: number, disableFloatConversionWarning?: boolean): Buffer;
+export type bencodeValue = string | Uint8Array | number | {
+    [key: string]: bencodeValue;
+} | bencodeValue[];
+export declare const encode: (data: bencodeValue | bencodeValue[]) => Uint8Array;
+export default encode;

package/dist/src/bencode/encode.js

@@ -1,121 +1,74 @@
-/* eslint-disable @typescript-eslint/ban-types */
-import { isArrayBuffer } from '../isArrayBuffer.js';
-/**
- * Encodes data in bencode.
- */
-export function encode(data, buffer, offset, disableFloatConversionWarning = false) {
-    const buffers = [];
-    const state = {
-        bytes: -1,
-        disableFloatConversionWarning,
-    };
-    _encode(state, buffers, data);
-    const result = Buffer.concat(buffers);
-    state.bytes = result.length;
-    if (Buffer.isBuffer(buffer)) {
-        result.copy(buffer, offset);
-        return buffer;
-    }
+import { concatUint8Arrays, stringToUint8Array } from 'uint8array-extras';
+import { cmpRawString } from './utils.js';
+const te = new TextEncoder();
+const encodeString = (str) => {
+    const lengthBytes = new TextEncoder().encode(str.length.toString());
+    const content = te.encode(str);
+    const result = new Uint8Array(lengthBytes.byteLength + 1 + content.byteLength);
+    result.set(lengthBytes);
+    result.set(te.encode(':'), lengthBytes.byteLength);
+    result.set(content, lengthBytes.byteLength + 1);
     return result;
-}
-function getType(value) {
-    if (Buffer.isBuffer(value)) {
-        return 'buffer';
-    }
-    if (Array.isArray(value)) {
-        return 'array';
-    }
-    if (ArrayBuffer.isView(value)) {
-        return 'arraybufferview';
-    }
-    if (value instanceof Number) {
-        return 'number';
-    }
-    if (value instanceof Boolean) {
-        return 'boolean';
-    }
-    if (isArrayBuffer(value)) {
-        return 'arraybuffer';
-    }
-    return typeof value;
-}
-function _encode(state, buffers, data) {
-    if (data === null) {
-        return;
-    }
-    switch (getType(data)) {
-        case 'buffer':
-            buffer(buffers, data);
-            break;
-        case 'object':
-            dict(state, buffers, data);
-            break;
-        case 'array':
-            list(state, buffers, data);
-            break;
-        case 'string':
-            string(buffers, data);
-            break;
-        case 'number':
-            number(state, buffers, data);
-            break;
-        case 'boolean':
-            number(state, buffers, data);
-            break;
-        case 'arraybufferview':
-            buffer(buffers, Buffer.from(data.buffer, data.byteOffset, data.byteLength));
-            break;
-        case 'arraybuffer':
-            buffer(buffers, Buffer.from(data));
-            break;
-        default:
-            break;
+};
+const encodeBuf = (buf) => {
+    const lengthBytes = new TextEncoder().encode(buf.byteLength.toString());
+    const result = new Uint8Array(lengthBytes.byteLength + 1 + buf.byteLength);
+    result.set(lengthBytes);
+    result.set(te.encode(':'), lengthBytes.byteLength);
+    result.set(buf, lengthBytes.byteLength + 1);
+    return result;
+};
+const encodeNumber = (num) => {
+    // NOTE: only support integers
+    const int = Math.floor(num);
+    if (int !== num) {
+        throw new Error(`bencode only support integers, got ${num}`);
     }
-}
-const buffE = Buffer.from('e');
-const buffD = Buffer.from('d');
-const buffL = Buffer.from('l');
-function buffer(buffers, data) {
-    buffers.push(Buffer.from(`${data.length}:`), data);
-}
-function string(buffers, data) {
-    buffers.push(Buffer.from(`${Buffer.byteLength(data)}:${data}`));
-}
-function number(state, buffers, data) {
-    const maxLo = 0x80000000;
-    const hi = (data / maxLo) << 0;
-    const lo = data % maxLo << 0;
-    const val = hi * maxLo + lo;
-    buffers.push(Buffer.from(`i${val}e`));
-    if (val !== data && !state.disableFloatConversionWarning) {
-        state.disableFloatConversionWarning = true;
-        console.warn(`WARNING: Possible data corruption detected with value "${data}":`, `Bencoding only defines support for integers, value was converted to "${val}"`);
-        console.trace();
+    return concatUint8Arrays([
+        stringToUint8Array('i'),
+        stringToUint8Array(int.toString()),
+        stringToUint8Array('e'),
+    ]);
+};
+const encodeDictionary = (obj) => {
+    const results = [];
+    Object.keys(obj)
+        .sort(cmpRawString)
+        .forEach(key => {
+        results.push(encodeString(key));
+        results.push(new Uint8Array(encode(obj[key])));
+    });
+    const d = stringToUint8Array('d');
+    const e = stringToUint8Array('e');
+    return concatUint8Arrays([d, ...results, e]);
+};
+const encodeArray = (arr) => {
+    const prefixSuffix = te.encode('le'); // Combined prefix and suffix
+    const encodedElements = arr.map(encode); // Encode each element
+    // Concatenate the encoded elements directly into a Uint8Array
+    const result = concatUint8Arrays([prefixSuffix, ...encodedElements.flat()]);
+    return result;
+};
+export const encode = (data) => {
+    if (Array.isArray(data)) {
+        return encodeArray(data);
     }
-}
-function dict(state, buffers, data) {
-    buffers.push(buffD);
-    // sorted dicts
-    const keys = Object.keys(data).sort();
-    for (const k of keys) {
-        // filter out null / undefined elements
-        if (data[k] === null || data[k] === undefined) {
-            continue;
+    switch (typeof data) {
+        case 'string': {
+            return encodeString(data);
         }
-        string(buffers, k);
-        _encode(state, buffers, data[k]);
-    }
-    buffers.push(buffE);
-}
-function list(state, buffers, data) {
-    let i = 0;
-    const c = data.length;
-    buffers.push(buffL);
-    for (; i < c; i++) {
-        if (data[i] === null) {
-            continue;
+        case 'number': {
+            return encodeNumber(data);
+        }
+        case 'object': {
+            if (data instanceof Uint8Array) {
+                return encodeBuf(data);
+            }
+            return encodeDictionary(data);
+        }
+        default: {
+            throw new Error(`unsupport data type: ${typeof data}`);
         }
-        _encode(state, buffers, data[i]);
     }
-    buffers.push(buffE);
-}
+};
+export default encode;

package/dist/src/bencode/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const cmpRawString: (str1: string, str2: string) => number;
+export declare const typedArraysAreEqual: <T extends Uint8Array>(a: T, b: T) => boolean;
+export declare const isValidUTF8: (buf: Uint8Array) => boolean;

package/dist/src/bencode/utils.js

@@ -0,0 +1,94 @@
+/* eslint-disable no-bitwise */
+// str1 > str2: 1
+// str1 === str2: 0
+// str1 < str2: -1
+export const cmpRawString = (str1, str2) => {
+    const te = new TextEncoder();
+    const v1 = te.encode(str1);
+    const v2 = te.encode(str2);
+    for (let i = 0; i < Math.min(v1.length, v2.length); i++) {
+        if (v1[i] < v2[i]) {
+            return -1;
+        }
+        if (v1[i] > v2[i]) {
+            return 1;
+        }
+    }
+    if (v1.length === v2.length) {
+        return 0;
+    }
+    return v1.length < v2.length ? -1 : 1;
+};
+export const typedArraysAreEqual = (a, b) => {
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    return a.every((val, i) => val === b[i]);
+};
+// Copied from https://github.com/hcodes/isutf8/blob/master/src/index.ts
+/*
+    https://tools.ietf.org/html/rfc3629
+    UTF8-char = UTF8-1 / UTF8-2 / UTF8-3 / UTF8-4
+    UTF8-1    = %x00-7F
+    UTF8-2    = %xC2-DF UTF8-tail
+    UTF8-3    = %xE0 %xA0-BF UTF8-tail
+                %xE1-EC 2( UTF8-tail )
+                %xED %x80-9F UTF8-tail
+                %xEE-EF 2( UTF8-tail )
+    UTF8-4    = %xF0 %x90-BF 2( UTF8-tail )
+                %xF1-F3 3( UTF8-tail )
+                %xF4 %x80-8F 2( UTF8-tail )
+    UTF8-tail = %x80-BF
+*/
+export const isValidUTF8 = (buf) => {
+    let i = 0;
+    const len = buf.length;
+    while (i < len) {
+        // UTF8-1 = %x00-7F
+        if (buf[i] <= 0x7f) {
+            i++;
+            continue;
+        }
+        // UTF8-2 = %xC2-DF UTF8-tail
+        if (buf[i] >= 0xc2 && buf[i] <= 0xdf) {
+            // if(buf[i + 1] >= 0x80 && buf[i + 1] <= 0xBF) {
+            if (buf[i + 1] >> 6 === 2) {
+                i += 2;
+                continue;
+                // biome-ignore lint/style/noUselessElse: false positive
+            }
+            else {
+                return false;
+            }
+        }
+        // UTF8-3 = %xE0 %xA0-BF UTF8-tail
+        // UTF8-3 = %xED %x80-9F UTF8-tail
+        if (((buf[i] === 0xe0 && buf[i + 1] >= 0xa0 && buf[i + 1] <= 0xbf) ||
+            (buf[i] === 0xed && buf[i + 1] >= 0x80 && buf[i + 1] <= 0x9f)) &&
+            buf[i + 2] >> 6 === 2) {
+            i += 3;
+            continue;
+        }
+        // UTF8-3 = %xE1-EC 2( UTF8-tail )
+        // UTF8-3 = %xEE-EF 2( UTF8-tail )
+        if (((buf[i] >= 0xe1 && buf[i] <= 0xec) || (buf[i] >= 0xee && buf[i] <= 0xef)) &&
+            buf[i + 1] >> 6 === 2 &&
+            buf[i + 2] >> 6 === 2) {
+            i += 3;
+            continue;
+        }
+        // UTF8-4 = %xF0 %x90-BF 2( UTF8-tail )
+        //          %xF1-F3 3( UTF8-tail )
+        //          %xF4 %x80-8F 2( UTF8-tail )
+        if (((buf[i] === 0xf0 && buf[i + 1] >= 0x90 && buf[i + 1] <= 0xbf) ||
+            (buf[i] >= 0xf1 && buf[i] <= 0xf3 && buf[i + 1] >> 6 === 2) ||
+            (buf[i] === 0xf4 && buf[i + 1] >= 0x80 && buf[i + 1] <= 0x8f)) &&
+            buf[i + 2] >> 6 === 2 &&
+            buf[i + 3] >> 6 === 2) {
+            i += 4;
+            continue;
+        }
+        return false;
+    }
+    return true;
+};

package/dist/src/index.d.ts

@@ -1,2 +1 @@
-export * from './bencode/index.js';
 export * from './torrentFile.js';

package/dist/src/index.js

@@ -1,2 +1 @@
-export * from './bencode/index.js';
 export * from './torrentFile.js';

package/dist/src/torrentFile.d.ts

@@ -1,8 +1,8 @@
-/// <reference types="node" resolution-mode="require"/>
+export declare const sha1: (input: Uint8Array) => string;
 /**
  * sha1 of torrent file info. This hash is commenly used by torrent clients as the ID of the torrent.
  */
-export declare function hash(file: Buffer): Promise<string>;
+export declare function hash(file: Uint8Array): string;
 export interface TorrentFileData {
     length: number;
     files: Array<{
@@ -27,7 +27,7 @@ export interface TorrentFileData {
 /**
  * data about the files the torrent contains
  */
-export declare function files(file: Buffer): TorrentFileData;
+export declare function files(file: Uint8Array): TorrentFileData;
 export interface TorrentInfo {
     name: string;
     /**
@@ -55,4 +55,4 @@ export interface TorrentInfo {
 /**
  * torrent file info
  */
-export declare function info(file: Buffer): TorrentInfo;
+export declare function info(file: Uint8Array): TorrentInfo;

package/dist/src/torrentFile.js

@@ -1,10 +1,17 @@
+import { createHash } from 'node:crypto';
 import { join, sep } from 'node:path';
-import { sha1 } from 'crypto-hash';
+import { isUint8Array, uint8ArrayToHex, uint8ArrayToString } from 'uint8array-extras';
 import { decode, encode } from './bencode/index.js';
+export const sha1 = (input) => {
+    const hash = createHash('sha1');
+    // Update the hash object with the data
+    hash.update(input);
+    return hash.digest('hex');
+};
 /**
  * sha1 of torrent file info. This hash is commenly used by torrent clients as the ID of the torrent.
  */
-export async function hash(file) {
+export function hash(file) {
     const torrent = decode(file);
     return sha1(encode(torrent.info));
 }
@@ -44,7 +51,7 @@ function sumLength(sum, file) {
 function splitPieces(buf) {
     const pieces = [];
     for (let i = 0; i < buf.length; i += 20) {
-        pieces.push(buf.slice(i, i + 20).toString('hex'));
+        pieces.push(uint8ArrayToHex(buf.slice(i, i + 20)));
     }
     return pieces;
 }
@@ -67,8 +74,8 @@ export function info(file) {
     if (torrent['created by']) {
         result.createdBy = torrent['created by'].toString();
     }
-    if (Buffer.isBuffer(torrent.comment)) {
-        result.comment = torrent.comment.toString();
+    if (isUint8Array(torrent.comment)) {
+        result.comment = uint8ArrayToString(torrent.comment);
     }
     // announce and announce-list will be missing if metadata fetched via ut_metadata
     if (Array.isArray(torrent['announce-list']) &&
@@ -87,7 +94,7 @@ export function info(file) {
         result.announce = Array.from(new Set(result.announce));
     }
     // web seeds
-    if (Buffer.isBuffer(torrent['url-list'])) {
+    if (isUint8Array(torrent['url-list'])) {
         // some clients set url-list to empty string
         torrent['url-list'] = torrent['url-list'].length > 0 ? [torrent['url-list']] : [];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctrl/torrent-file",
-  "version": "3.0.0",
+  "version": "4.1.0",
   "description": "Parse a torrent file (name, hash, files, pieces)",
   "author": "Scott Cooper <scttcper@gmail.com>",
   "license": "MIT",
@@ -14,8 +14,12 @@
   "sideEffects": false,
   "keywords": [],
   "scripts": {
-    "lint": "eslint --ext .ts .",
-    "lint:fix": "eslint --fix --ext .ts .",
+    "lint": "pnpm run '/^(lint:biome|lint:eslint)$/'",
+    "lint:biome": "biome check .",
+    "lint:eslint": "eslint .",
+    "lint:fix": "pnpm run '/^(lint:biome|lint:eslint):fix$/'",
+    "lint:eslint:fix": "eslint . --fix",
+    "lint:biome:fix": "biome check . --apply",
     "prepare": "npm run build",
     "build": "tsc",
     "test": "vitest run",
@@ -23,16 +27,17 @@
     "test:ci": "vitest run --coverage --reporter=default --reporter=junit --outputFile=./junit.xml"
   },
   "dependencies": {
-    "crypto-hash": "^2.0.1"
+    "uint8array-extras": "^1.4.0"
   },
   "devDependencies": {
-    "@ctrl/eslint-config": "4.0.6",
-    "@sindresorhus/tsconfig": "4.0.0",
-    "@types/node": "20.6.0",
-    "@vitest/coverage-v8": "0.34.4",
-    "parse-torrent": "11.0.14",
-    "typescript": "5.2.2",
-    "vitest": "0.34.4"
+    "@biomejs/biome": "1.8.3",
+    "@ctrl/eslint-config-biome": "4.2.1",
+    "@sindresorhus/tsconfig": "6.0.0",
+    "@types/node": "22.5.4",
+    "@vitest/coverage-v8": "2.0.5",
+    "parse-torrent": "11.0.17",
+    "typescript": "5.6.2",
+    "vitest": "2.0.5"
   },
   "publishConfig": {
     "access": "public",

package/dist/src/isArrayBuffer.d.ts

@@ -1,11 +0,0 @@
-/**
- * Check if the given value is an ArrayBuffer.
- * @param value - The value to check.
- * @returns `true` if the given value is an ArrayBuffer, else `false`.
- * @example
- * isArrayBuffer(new ArrayBuffer())
- * // => true
- * isArrayBuffer([])
- * // => false
- */
-export declare function isArrayBuffer(value: unknown): boolean;

package/dist/src/isArrayBuffer.js

@@ -1,16 +0,0 @@
-const hasArrayBuffer = typeof ArrayBuffer === 'function';
-const { toString } = Object.prototype;
-/**
- * Check if the given value is an ArrayBuffer.
- * @param value - The value to check.
- * @returns `true` if the given value is an ArrayBuffer, else `false`.
- * @example
- * isArrayBuffer(new ArrayBuffer())
- * // => true
- * isArrayBuffer([])
- * // => false
- */
-export function isArrayBuffer(value) {
-    return (hasArrayBuffer &&
-        (value instanceof ArrayBuffer || toString.call(value) === '[object ArrayBuffer]'));
-}